diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..d567b311d9e3ce55d7c5bf0c9ee6b85c8783ee12 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+lib/python3.11/site-packages/llvmlite/binding/libllvmlite.dylib filter=lfs diff=lfs merge=lfs -text
+lib/python3.11/site-packages/mlx/core.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.11/site-packages/mlx/lib/libmlx.dylib filter=lfs diff=lfs merge=lfs -text
+lib/python3.11/site-packages/mlx/lib/mlx.metallib filter=lfs diff=lfs merge=lfs -text
diff --git a/bin/Activate.ps1 b/bin/Activate.ps1
new file mode 100644
index 0000000000000000000000000000000000000000..eeea3583fa130d4702a05012a2103152daf51487
--- /dev/null
+++ b/bin/Activate.ps1
@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"
diff --git a/bin/activate b/bin/activate
new file mode 100644
index 0000000000000000000000000000000000000000..36ac433d36f081790c667c7e0b0d85f98de2908f
--- /dev/null
+++ b/bin/activate
@@ -0,0 +1,69 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r 2> /dev/null
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(whisper_mlx) ${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT="(whisper_mlx) "
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2> /dev/null
+fi
diff --git a/bin/activate.csh b/bin/activate.csh
new file mode 100644
index 0000000000000000000000000000000000000000..158cd3ac1714756b1e990cd5051ec150933a4657
--- /dev/null
+++ b/bin/activate.csh
@@ -0,0 +1,26 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(whisper_mlx) $prompt"
+    setenv VIRTUAL_ENV_PROMPT "(whisper_mlx) "
+endif
+
+alias pydoc python -m pydoc
+
+rehash
diff --git a/bin/activate.fish b/bin/activate.fish
new file mode 100644
index 0000000000000000000000000000000000000000..0fdcd6a2930bd6ac5fa1beae13f614f805766e45
--- /dev/null
+++ b/bin/activate.fish
@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(whisper_mlx) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT "(whisper_mlx) "
+end
diff --git a/bin/convert-caffe2-to-onnx b/bin/convert-caffe2-to-onnx
new file mode 100644
index 0000000000000000000000000000000000000000..690c4957187338632f7a6c49124d2099fa727485
--- /dev/null
+++ b/bin/convert-caffe2-to-onnx
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import caffe2_to_onnx
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(caffe2_to_onnx())
diff --git a/bin/convert-onnx-to-caffe2 b/bin/convert-onnx-to-caffe2
new file mode 100644
index 0000000000000000000000000000000000000000..69d3391fab855e6210d493e063bb2e173b57a1d3
--- /dev/null
+++ b/bin/convert-onnx-to-caffe2
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import onnx_to_caffe2
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(onnx_to_caffe2())
diff --git a/bin/f2py b/bin/f2py
new file mode 100644
index 0000000000000000000000000000000000000000..bc791f48d6461541718280c4d93ec34ddad924af
--- /dev/null
+++ b/bin/f2py
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/bin/huggingface-cli b/bin/huggingface-cli
new file mode 100644
index 0000000000000000000000000000000000000000..37473b3e9ede2fd83972d4a63aa0bd356a8bde34
--- /dev/null
+++ b/bin/huggingface-cli
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.commands.huggingface_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/bin/isympy b/bin/isympy
new file mode 100644
index 0000000000000000000000000000000000000000..6b41380880e1083d5d8288e49624476ef0cc1ed7
--- /dev/null
+++ b/bin/isympy
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from isympy import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/bin/normalizer b/bin/normalizer
new file mode 100644
index 0000000000000000000000000000000000000000..3540733dd4ee041e82c19b4acf22d3cc91fa6224
--- /dev/null
+++ b/bin/normalizer
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from charset_normalizer.cli import cli_detect
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli_detect())
diff --git a/bin/numba b/bin/numba
new file mode 100644
index 0000000000000000000000000000000000000000..acec8457e1a80ca1198502dd81ed782e7e44d252
--- /dev/null
+++ b/bin/numba
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: UTF-8 -*-
+from __future__ import print_function, division, absolute_import
+
+from numba.misc.numba_entry import main
+
+if __name__ == "__main__":
+    main()
diff --git a/bin/pip b/bin/pip
new file mode 100644
index 0000000000000000000000000000000000000000..7b786bae4ec856fb94b45926bc1f483f37f5aa0c
--- /dev/null
+++ b/bin/pip
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/bin/pip3 b/bin/pip3
new file mode 100644
index 0000000000000000000000000000000000000000..7b786bae4ec856fb94b45926bc1f483f37f5aa0c
--- /dev/null
+++ b/bin/pip3
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/bin/pip3.11 b/bin/pip3.11
new file mode 100644
index 0000000000000000000000000000000000000000..7b786bae4ec856fb94b45926bc1f483f37f5aa0c
--- /dev/null
+++ b/bin/pip3.11
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/bin/python b/bin/python
new file mode 100644
index 0000000000000000000000000000000000000000..8cafbdb7310fdd9dd2c7524d923d2facf7e066b5
Binary files /dev/null and b/bin/python differ
diff --git a/bin/python3 b/bin/python3
new file mode 100644
index 0000000000000000000000000000000000000000..8cafbdb7310fdd9dd2c7524d923d2facf7e066b5
Binary files /dev/null and b/bin/python3 differ
diff --git a/bin/python3.11 b/bin/python3.11
new file mode 100644
index 0000000000000000000000000000000000000000..8cafbdb7310fdd9dd2c7524d923d2facf7e066b5
Binary files /dev/null and b/bin/python3.11 differ
diff --git a/bin/torchrun b/bin/torchrun
new file mode 100644
index 0000000000000000000000000000000000000000..74ee9946bd1ccd91d0823becbdfaa24935bc7d0c
--- /dev/null
+++ b/bin/torchrun
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from torch.distributed.run import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/bin/tqdm b/bin/tqdm
new file mode 100644
index 0000000000000000000000000000000000000000..d70ab1c3b7338cffcf1df1ffdcc7d9e0daf5cdca
--- /dev/null
+++ b/bin/tqdm
@@ -0,0 +1,8 @@
+#!/Users/vb/Documents/hf_projects/mlx-examples/whisper/whisper_mlx/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tqdm.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())
diff --git a/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/INSTALLER b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst
new file mode 100644
index 0000000000000000000000000000000000000000..c37cae49ec77ad6ebb25568c1605f1fee5313cfb
--- /dev/null
+++ b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
+Copyright 2007 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/METADATA b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..f54bb5ca1a59f2696ed5273a531aff9088754da0
--- /dev/null
+++ b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/METADATA
@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: Jinja2
+Version: 3.1.2
+Summary: A very fast and expressive template engine.
+Home-page: https://palletsprojects.com/p/jinja/
+Author: Armin Ronacher
+Author-email: armin.ronacher@active-4.com
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://jinja.palletsprojects.com/
+Project-URL: Changes, https://jinja.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/jinja/
+Project-URL: Issue Tracker, https://github.com/pallets/jinja/issues/
+Project-URL: Twitter, https://twitter.com/PalletsTeam
+Project-URL: Chat, https://discord.gg/pallets
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: MarkupSafe (>=2.0)
+Provides-Extra: i18n
+Requires-Dist: Babel (>=2.7) ; extra == 'i18n'
+
+Jinja
+=====
+
+Jinja is a fast, expressive, extensible templating engine. Special
+placeholders in the template allow writing code similar to Python
+syntax. Then the template is passed data to render the final document.
+
+It includes:
+
+-   Template inheritance and inclusion.
+-   Define and import macros within templates.
+-   HTML templates can use autoescaping to prevent XSS from untrusted
+    user input.
+-   A sandboxed environment can safely render untrusted templates.
+-   AsyncIO support for generating templates and calling async
+    functions.
+-   I18N support with Babel.
+-   Templates are compiled to optimized Python code just-in-time and
+    cached, or can be compiled ahead-of-time.
+-   Exceptions point to the correct line in templates to make debugging
+    easier.
+-   Extensible filters, tests, functions, and even syntax.
+
+Jinja's philosophy is that while application logic belongs in Python if
+possible, it shouldn't make the template designer's job difficult by
+restricting functionality too much.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    $ pip install -U Jinja2
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+In A Nutshell
+-------------
+
+.. code-block:: jinja
+
+    {% extends "base.html" %}
+    {% block title %}Members{% endblock %}
+    {% block content %}
+      <ul>
+      {% for user in users %}
+        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
+      {% endfor %}
+      </ul>
+    {% endblock %}
+
+
+Donate
+------
+
+The Pallets organization develops and supports Jinja and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, `please
+donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://jinja.palletsprojects.com/
+-   Changes: https://jinja.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/Jinja2/
+-   Source Code: https://github.com/pallets/jinja/
+-   Issue Tracker: https://github.com/pallets/jinja/issues/
+-   Website: https://palletsprojects.com/p/jinja/
+-   Twitter: https://twitter.com/PalletsTeam
+-   Chat: https://discord.gg/pallets
+
+
diff --git a/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/RECORD b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..878712a0efd0265d465f4a39147999a9236506d5
--- /dev/null
+++ b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/RECORD
@@ -0,0 +1,58 @@
+Jinja2-3.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Jinja2-3.1.2.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
+Jinja2-3.1.2.dist-info/METADATA,sha256=PZ6v2SIidMNixR7MRUX9f7ZWsPwtXanknqiZUmRbh4U,3539
+Jinja2-3.1.2.dist-info/RECORD,,
+Jinja2-3.1.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+Jinja2-3.1.2.dist-info/entry_points.txt,sha256=zRd62fbqIyfUpsRtU7EVIFyiu1tPwfgO7EvPErnxgTE,59
+Jinja2-3.1.2.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
+jinja2/__init__.py,sha256=8vGduD8ytwgD6GDSqpYc2m3aU-T7PKOAddvVXgGr_Fs,1927
+jinja2/__pycache__/__init__.cpython-311.pyc,,
+jinja2/__pycache__/_identifier.cpython-311.pyc,,
+jinja2/__pycache__/async_utils.cpython-311.pyc,,
+jinja2/__pycache__/bccache.cpython-311.pyc,,
+jinja2/__pycache__/compiler.cpython-311.pyc,,
+jinja2/__pycache__/constants.cpython-311.pyc,,
+jinja2/__pycache__/debug.cpython-311.pyc,,
+jinja2/__pycache__/defaults.cpython-311.pyc,,
+jinja2/__pycache__/environment.cpython-311.pyc,,
+jinja2/__pycache__/exceptions.cpython-311.pyc,,
+jinja2/__pycache__/ext.cpython-311.pyc,,
+jinja2/__pycache__/filters.cpython-311.pyc,,
+jinja2/__pycache__/idtracking.cpython-311.pyc,,
+jinja2/__pycache__/lexer.cpython-311.pyc,,
+jinja2/__pycache__/loaders.cpython-311.pyc,,
+jinja2/__pycache__/meta.cpython-311.pyc,,
+jinja2/__pycache__/nativetypes.cpython-311.pyc,,
+jinja2/__pycache__/nodes.cpython-311.pyc,,
+jinja2/__pycache__/optimizer.cpython-311.pyc,,
+jinja2/__pycache__/parser.cpython-311.pyc,,
+jinja2/__pycache__/runtime.cpython-311.pyc,,
+jinja2/__pycache__/sandbox.cpython-311.pyc,,
+jinja2/__pycache__/tests.cpython-311.pyc,,
+jinja2/__pycache__/utils.cpython-311.pyc,,
+jinja2/__pycache__/visitor.cpython-311.pyc,,
+jinja2/_identifier.py,sha256=_zYctNKzRqlk_murTNlzrju1FFJL7Va_Ijqqd7ii2lU,1958
+jinja2/async_utils.py,sha256=dHlbTeaxFPtAOQEYOGYh_PHcDT0rsDaUJAFDl_0XtTg,2472
+jinja2/bccache.py,sha256=mhz5xtLxCcHRAa56azOhphIAe19u1we0ojifNMClDio,14061
+jinja2/compiler.py,sha256=Gs-N8ThJ7OWK4-reKoO8Wh1ZXz95MVphBKNVf75qBr8,72172
+jinja2/constants.py,sha256=GMoFydBF_kdpaRKPoM5cl5MviquVRLVyZtfp5-16jg0,1433
+jinja2/debug.py,sha256=iWJ432RadxJNnaMOPrjIDInz50UEgni3_HKuFXi2vuQ,6299
+jinja2/defaults.py,sha256=boBcSw78h-lp20YbaXSJsqkAI2uN_mD_TtCydpeq5wU,1267
+jinja2/environment.py,sha256=6uHIcc7ZblqOMdx_uYNKqRnnwAF0_nzbyeMP9FFtuh4,61349
+jinja2/exceptions.py,sha256=ioHeHrWwCWNaXX1inHmHVblvc4haO7AXsjCp3GfWvx0,5071
+jinja2/ext.py,sha256=ivr3P7LKbddiXDVez20EflcO3q2aHQwz9P_PgWGHVqE,31502
+jinja2/filters.py,sha256=9js1V-h2RlyW90IhLiBGLM2U-k6SCy2F4BUUMgB3K9Q,53509
+jinja2/idtracking.py,sha256=GfNmadir4oDALVxzn3DL9YInhJDr69ebXeA2ygfuCGA,10704
+jinja2/lexer.py,sha256=DW2nX9zk-6MWp65YR2bqqj0xqCvLtD-u9NWT8AnFRxQ,29726
+jinja2/loaders.py,sha256=BfptfvTVpClUd-leMkHczdyPNYFzp_n7PKOJ98iyHOg,23207
+jinja2/meta.py,sha256=GNPEvifmSaU3CMxlbheBOZjeZ277HThOPUTf1RkppKQ,4396
+jinja2/nativetypes.py,sha256=DXgORDPRmVWgy034H0xL8eF7qYoK3DrMxs-935d0Fzk,4226
+jinja2/nodes.py,sha256=i34GPRAZexXMT6bwuf5SEyvdmS-bRCy9KMjwN5O6pjk,34550
+jinja2/optimizer.py,sha256=tHkMwXxfZkbfA1KmLcqmBMSaz7RLIvvItrJcPoXTyD8,1650
+jinja2/parser.py,sha256=nHd-DFHbiygvfaPtm9rcQXJChZG7DPsWfiEsqfwKerY,39595
+jinja2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jinja2/runtime.py,sha256=5CmD5BjbEJxSiDNTFBeKCaq8qU4aYD2v6q2EluyExms,33476
+jinja2/sandbox.py,sha256=Y0xZeXQnH6EX5VjaV2YixESxoepnRbW_3UeQosaBU3M,14584
+jinja2/tests.py,sha256=Am5Z6Lmfr2XaH_npIfJJ8MdXtWsbLjMULZJulTAj30E,5905
+jinja2/utils.py,sha256=u9jXESxGn8ATZNVolwmkjUVu4SA-tLgV0W7PcSfPfdQ,23965
+jinja2/visitor.py,sha256=MH14C6yq24G_KVtWzjwaI7Wg14PCJIYlWW1kpkxYak0,3568
diff --git a/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/WHEEL b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..becc9a66ea739ba941d48a749e248761cc6e658a
--- /dev/null
+++ b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7b9666c8ea311ea0f0cfe7bed861aaa5469f92bb
--- /dev/null
+++ b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[babel.extractors]
+jinja2 = jinja2.ext:babel_extract[i18n]
diff --git a/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/top_level.txt b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7f7afbf3bf54b346092be6a72070fcbd305ead1e
--- /dev/null
+++ b/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+jinja2
diff --git a/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/INSTALLER b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/LICENSE.rst b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/LICENSE.rst
new file mode 100644
index 0000000000000000000000000000000000000000..9d227a0cc43c3268d15722b763bd94ad298645a1
--- /dev/null
+++ b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
+Copyright 2010 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/METADATA b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..bced1652399a6ca9a5285d9e12bcecc91a987fec
--- /dev/null
+++ b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/METADATA
@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 2.1.3
+Summary: Safely add untrusted strings to HTML/XML markup.
+Home-page: https://palletsprojects.com/p/markupsafe/
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/markupsafe/
+Project-URL: Issue Tracker, https://github.com/pallets/markupsafe/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+
+MarkupSafe
+==========
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    pip install -U MarkupSafe
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+Examples
+--------
+
+.. code-block:: pycon
+
+    >>> from markupsafe import Markup, escape
+
+    >>> # escape replaces special characters and wraps in Markup
+    >>> escape("<script>alert(document.cookie);</script>")
+    Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+
+    >>> # wrap in Markup to mark text "safe" and prevent escaping
+    >>> Markup("<strong>Hello</strong>")
+    Markup('<strong>hello</strong>')
+
+    >>> escape(Markup("<strong>Hello</strong>"))
+    Markup('<strong>hello</strong>')
+
+    >>> # Markup is a str subclass
+    >>> # methods and operators escape their arguments
+    >>> template = Markup("Hello <em>{name}</em>")
+    >>> template.format(name='"World"')
+    Markup('Hello <em>&#34;World&#34;</em>')
+
+
+Donate
+------
+
+The Pallets organization develops and supports MarkupSafe and other
+popular packages. In order to grow the community of contributors and
+users, and allow the maintainers to devote more time to the projects,
+`please donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://markupsafe.palletsprojects.com/
+-   Changes: https://markupsafe.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/MarkupSafe/
+-   Source Code: https://github.com/pallets/markupsafe/
+-   Issue Tracker: https://github.com/pallets/markupsafe/issues/
+-   Chat: https://discord.gg/pallets
diff --git a/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/RECORD b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..7ffd70dbe44d5824bd23423f48701bd41491b85d
--- /dev/null
+++ b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/RECORD
@@ -0,0 +1,14 @@
+MarkupSafe-2.1.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+MarkupSafe-2.1.3.dist-info/LICENSE.rst,sha256=SJqOEQhQntmKN7uYPhHg9-HTHwvY-Zp5yESOf_N9B-o,1475
+MarkupSafe-2.1.3.dist-info/METADATA,sha256=Wvvh4Tz-YtW24YagYdqrrrBdm9m-DjTdqJWhxlbU6-0,3003
+MarkupSafe-2.1.3.dist-info/RECORD,,
+MarkupSafe-2.1.3.dist-info/WHEEL,sha256=1gGdl8c7V4tzGrOfjA4xbXg5uJOisfAwei4hK84YpXE,115
+MarkupSafe-2.1.3.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
+markupsafe/__init__.py,sha256=xIItqrn1Bwi7FxPJO9rCVQBG0Evewue1Tl4BV0l9xEs,10338
+markupsafe/__pycache__/__init__.cpython-311.pyc,,
+markupsafe/__pycache__/_native.cpython-311.pyc,,
+markupsafe/_native.py,sha256=GR86Qvo_GcgKmKreA1WmYN9ud17OFwkww8E-fiW-57s,1713
+markupsafe/_speedups.c,sha256=X2XvQVtIdcK4Usz70BvkzoOfjTCmQlDkkjYSn-swE0g,7083
+markupsafe/_speedups.cpython-311-darwin.so,sha256=tzy2iIP3YqrDJlsEvshIKNMf7FwfWLcVq1OeD7W7HnM,117484
+markupsafe/_speedups.pyi,sha256=vfMCsOgbAXRNLUXkyuyonG8uEWKYU4PDqNuMaDELAYw,229
+markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/WHEEL b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..ebece4cd56f07605101ffafd86d4a1d3e794f2e8
--- /dev/null
+++ b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_10_9_universal2
+
diff --git a/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/top_level.txt b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..75bf729258f9daef77370b6df1a57940f90fc23f
--- /dev/null
+++ b/lib/python3.11/site-packages/MarkupSafe-2.1.3.dist-info/top_level.txt
@@ -0,0 +1 @@
+markupsafe
diff --git a/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/INSTALLER b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/LICENSE b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..2f1b8e15e5627d92f0521605c9870bc8e5505cb4
--- /dev/null
+++ b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2017-2021 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/METADATA b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..c8905983e369893f68879f4cdfb7290d54d5f822
--- /dev/null
+++ b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/METADATA
@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0.1
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Download-URL: https://pypi.org/project/PyYAML/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.6
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.
diff --git a/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/RECORD b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..1c1df95efe864a2f7428c51a13d178e51172674c
--- /dev/null
+++ b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/RECORD
@@ -0,0 +1,43 @@
+PyYAML-6.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyYAML-6.0.1.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-6.0.1.dist-info/METADATA,sha256=UNNF8-SzzwOKXVo-kV5lXUGH2_wDWMBmGxqISpp5HQk,2058
+PyYAML-6.0.1.dist-info/RECORD,,
+PyYAML-6.0.1.dist-info/WHEEL,sha256=GYWT1Q_60SI2bAUaGrkLwkEA5yYDmphib6XcY6K30ZQ,110
+PyYAML-6.0.1.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+_yaml/__pycache__/__init__.cpython-311.pyc,,
+yaml/__init__.py,sha256=bhl05qSeO-1ZxlSRjGrvl2m9nrXb1n9-GQatTN0Mrqc,12311
+yaml/__pycache__/__init__.cpython-311.pyc,,
+yaml/__pycache__/composer.cpython-311.pyc,,
+yaml/__pycache__/constructor.cpython-311.pyc,,
+yaml/__pycache__/cyaml.cpython-311.pyc,,
+yaml/__pycache__/dumper.cpython-311.pyc,,
+yaml/__pycache__/emitter.cpython-311.pyc,,
+yaml/__pycache__/error.cpython-311.pyc,,
+yaml/__pycache__/events.cpython-311.pyc,,
+yaml/__pycache__/loader.cpython-311.pyc,,
+yaml/__pycache__/nodes.cpython-311.pyc,,
+yaml/__pycache__/parser.cpython-311.pyc,,
+yaml/__pycache__/reader.cpython-311.pyc,,
+yaml/__pycache__/representer.cpython-311.pyc,,
+yaml/__pycache__/resolver.cpython-311.pyc,,
+yaml/__pycache__/scanner.cpython-311.pyc,,
+yaml/__pycache__/serializer.cpython-311.pyc,,
+yaml/__pycache__/tokens.cpython-311.pyc,,
+yaml/_yaml.cpython-311-darwin.so,sha256=YiF55JiadfOvw_mUH-lONNnsiMHj6C6o1SBfTCvvW54,362008
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/representer.py,sha256=IuWP-cAW9sHKEnS0gCqSa894k1Bg4cgTxaDwIcbRQ-Y,14190
+yaml/resolver.py,sha256=9L-VYfm4mWHxUD1Vg4X7rjDRK_7VZd6b92wzq7Y2IKY,9004
+yaml/scanner.py,sha256=YEM3iLZSaQwXcQRg2l2R4MdT0zGP2F9eHkKGKnHyWQY,51279
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573
diff --git a/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/WHEEL b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..2a4682fa95c716f0b1b89ab65a26c5abb81a9483
--- /dev/null
+++ b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64
+
diff --git a/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/top_level.txt b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e6475e911f628412049bc4090d86f23ac403adde
--- /dev/null
+++ b/lib/python3.11/site-packages/PyYAML-6.0.1.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+_yaml
+yaml
diff --git a/lib/python3.11/site-packages/__pycache__/isympy.cpython-311.pyc b/lib/python3.11/site-packages/__pycache__/isympy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2aec2253d08e652d438528301331d69feb6bc286
Binary files /dev/null and b/lib/python3.11/site-packages/__pycache__/isympy.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/__pycache__/typing_extensions.cpython-311.pyc b/lib/python3.11/site-packages/__pycache__/typing_extensions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..415c6722f29968c746b9468bc225cb3a21837c86
Binary files /dev/null and b/lib/python3.11/site-packages/__pycache__/typing_extensions.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/_distutils_hack/__init__.py b/lib/python3.11/site-packages/_distutils_hack/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b951c2defd0b447a6974de79cd7353255b613f6a
--- /dev/null
+++ b/lib/python3.11/site-packages/_distutils_hack/__init__.py
@@ -0,0 +1,227 @@
+# don't import any costly modules
+import sys
+import os
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns):
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self):
+        insert_shim()
+
+    def __exit__(self, exc, value, tb):
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim
diff --git a/lib/python3.11/site-packages/_distutils_hack/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/_distutils_hack/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e4e7e0dc9b12c00b745b17934b7181dce8d9ea57
Binary files /dev/null and b/lib/python3.11/site-packages/_distutils_hack/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/_distutils_hack/__pycache__/override.cpython-311.pyc b/lib/python3.11/site-packages/_distutils_hack/__pycache__/override.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..37df2273e5cc6ddd8d886f3a1acaa84bb0cda520
Binary files /dev/null and b/lib/python3.11/site-packages/_distutils_hack/__pycache__/override.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/_distutils_hack/override.py b/lib/python3.11/site-packages/_distutils_hack/override.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cc433a4a55e3b41fa31089918fb62096092f89f
--- /dev/null
+++ b/lib/python3.11/site-packages/_distutils_hack/override.py
@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()
diff --git a/lib/python3.11/site-packages/_yaml/__init__.py b/lib/python3.11/site-packages/_yaml/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7baa8c4b68127d5cdf0be9a799429e61347c2694
--- /dev/null
+++ b/lib/python3.11/site-packages/_yaml/__init__.py
@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''
diff --git a/lib/python3.11/site-packages/_yaml/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/_yaml/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ed0b023b4c06e92a86e5871397e57b516411e03
Binary files /dev/null and b/lib/python3.11/site-packages/_yaml/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/INSTALLER b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/LICENSE b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..62b076cdee58ec8f34034141ba0befd9015b0c7e
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/LICENSE
@@ -0,0 +1,20 @@
+This package contains a modified version of ca-bundle.crt:
+
+ca-bundle.crt -- Bundle of CA Root Certificates
+
+This is a bundle of X.509 certificates of public Certificate Authorities
+(CA). These were automatically extracted from Mozilla's root certificates
+file (certdata.txt).  This file can be found in the mozilla source tree:
+https://hg.mozilla.org/mozilla-central/file/tip/security/nss/lib/ckfw/builtins/certdata.txt
+It contains the certificates in PEM format and therefore
+can be directly used with curl / libcurl / php_curl, or with
+an Apache+mod_ssl webserver for SSL client authentication.
+Just configure this file as the SSLCACertificateFile.#
+
+***** BEGIN LICENSE BLOCK *****
+This Source Code Form is subject to the terms of the Mozilla Public License,
+v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
+one at http://mozilla.org/MPL/2.0/.
+
+***** END LICENSE BLOCK *****
+@(#) $RCSfile: certdata.txt,v $ $Revision: 1.80 $ $Date: 2011/11/03 15:11:58 $
diff --git a/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/METADATA b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..7dd1791d94d92b3e3e92552ac8b99e55db3613c4
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/METADATA
@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: certifi
+Version: 2023.11.17
+Summary: Python package for providing Mozilla's CA Bundle.
+Home-page: https://github.com/certifi/python-certifi
+Author: Kenneth Reitz
+Author-email: me@kennethreitz.com
+License: MPL-2.0
+Project-URL: Source, https://github.com/certifi/python-certifi
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.6
+License-File: LICENSE
+
+Certifi: Python SSL Certificates
+================================
+
+Certifi provides Mozilla's carefully curated collection of Root Certificates for
+validating the trustworthiness of SSL certificates while verifying the identity
+of TLS hosts. It has been extracted from the `Requests`_ project.
+
+Installation
+------------
+
+``certifi`` is available on PyPI. Simply install it with ``pip``::
+
+    $ pip install certifi
+
+Usage
+-----
+
+To reference the installed certificate authority (CA) bundle, you can use the
+built-in function::
+
+    >>> import certifi
+
+    >>> certifi.where()
+    '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem'
+
+Or from the command line::
+
+    $ python -m certifi
+    /usr/local/lib/python3.7/site-packages/certifi/cacert.pem
+
+Enjoy!
+
+.. _`Requests`: https://requests.readthedocs.io/en/master/
+
+Addition/Removal of Certificates
+--------------------------------
+
+Certifi does not support any addition/removal or other modification of the
+CA trust store content. This project is intended to provide a reliable and
+highly portable root of trust to python deployments. Look to upstream projects
+for methods to use alternate trust.
diff --git a/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/RECORD b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..e84fdefd4b7bcc8b10211138105cdc8f602b62f0
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/RECORD
@@ -0,0 +1,14 @@
+certifi-2023.11.17.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+certifi-2023.11.17.dist-info/LICENSE,sha256=6TcW2mucDVpKHfYP5pWzcPBpVgPSH2-D8FPkLPwQyvc,989
+certifi-2023.11.17.dist-info/METADATA,sha256=P7BMxvbKUZTP20mLy_wc2atkEPFNVqElEzV6Mhaj3Zc,2172
+certifi-2023.11.17.dist-info/RECORD,,
+certifi-2023.11.17.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+certifi-2023.11.17.dist-info/top_level.txt,sha256=KMu4vUCfsjLrkPbSNdgdekS-pVJzBAJFO__nI8NF6-U,8
+certifi/__init__.py,sha256=oYZVbNEJ66LQQamFRyuICe6FoYDmkY4j4fKEyO9D96c,94
+certifi/__main__.py,sha256=xBBoj905TUWBLRGANOcf7oi6e-3dMP4cEoG9OyMs11g,243
+certifi/__pycache__/__init__.cpython-311.pyc,,
+certifi/__pycache__/__main__.cpython-311.pyc,,
+certifi/__pycache__/core.cpython-311.pyc,,
+certifi/cacert.pem,sha256=z503-oFAev4R3MDXD-YCVhQiqiNEcIwyTkUE24xsV0g,290282
+certifi/core.py,sha256=lhewz0zFb2b4ULsQurElmloYwQoecjWzPqY67P8T7iM,4219
+certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/WHEEL b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..ba48cbcf9275ac6d88fe25821695e14d0a822e79
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/top_level.txt b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..963eac530b9bc28d704d1bc410299c68e3216d4d
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi-2023.11.17.dist-info/top_level.txt
@@ -0,0 +1 @@
+certifi
diff --git a/lib/python3.11/site-packages/certifi/__init__.py b/lib/python3.11/site-packages/certifi/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b93bb49b01f31b7059fea8d6b6f3149ac9acd35b
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi/__init__.py
@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2023.11.17"
diff --git a/lib/python3.11/site-packages/certifi/__main__.py b/lib/python3.11/site-packages/certifi/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8945b5da857f4a7dec2b84f1225f012f6098418c
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi/__main__.py
@@ -0,0 +1,12 @@
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())
diff --git a/lib/python3.11/site-packages/certifi/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/certifi/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba3d001f26594e568a77afbfe591da63cef7c832
Binary files /dev/null and b/lib/python3.11/site-packages/certifi/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/certifi/__pycache__/__main__.cpython-311.pyc b/lib/python3.11/site-packages/certifi/__pycache__/__main__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06f3d75e64fa592eb60e5b44de7ad0bf5e0b52e6
Binary files /dev/null and b/lib/python3.11/site-packages/certifi/__pycache__/__main__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/certifi/__pycache__/core.cpython-311.pyc b/lib/python3.11/site-packages/certifi/__pycache__/core.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8483dd6e5ee47357cc1c11d09273f60950e20826
Binary files /dev/null and b/lib/python3.11/site-packages/certifi/__pycache__/core.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/certifi/cacert.pem b/lib/python3.11/site-packages/certifi/cacert.pem
new file mode 100644
index 0000000000000000000000000000000000000000..f309400503a8e986a9f6bf0034b1aea089e1526a
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi/cacert.pem
@@ -0,0 +1,4778 @@
+
+# Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Label: "GlobalSign Root CA"
+# Serial: 4835703278459707669005204
+# MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a
+# SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c
+# SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99
+-----BEGIN CERTIFICATE-----
+MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
+A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
+b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
+MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
+YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
+aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
+jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
+xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
+1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
+snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
+U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
+9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
+AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
+yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
+38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
+AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
+DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
+HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Label: "Entrust.net Premium 2048 Secure Server CA"
+# Serial: 946069240
+# MD5 Fingerprint: ee:29:31:bc:32:7e:9a:e6:e8:b5:f7:51:b4:34:71:90
+# SHA1 Fingerprint: 50:30:06:09:1d:97:d4:f5:ae:39:f7:cb:e7:92:7d:7d:65:2d:34:31
+# SHA256 Fingerprint: 6d:c4:71:72:e0:1c:bc:b0:bf:62:58:0d:89:5f:e2:b8:ac:9a:d4:f8:73:80:1e:0c:10:b9:c8:37:d2:1e:b1:77
+-----BEGIN CERTIFICATE-----
+MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML
+RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp
+bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5
+IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3
+MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
+LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
+YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
+A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq
+K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe
+sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX
+MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT
+XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/
+HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH
+4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub
+j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo
+U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf
+zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b
+u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+
+bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er
+fF6adulZkMV8gzURZVE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Label: "Baltimore CyberTrust Root"
+# Serial: 33554617
+# MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4
+# SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74
+# SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ
+RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD
+VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX
+DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y
+ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy
+VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr
+mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr
+IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK
+mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu
+XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy
+dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye
+jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1
+BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3
+DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92
+9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx
+jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0
+Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz
+ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
+R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Label: "Entrust Root Certification Authority"
+# Serial: 1164660820
+# MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4
+# SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9
+# SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c
+-----BEGIN CERTIFICATE-----
+MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0
+Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW
+KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl
+cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw
+NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw
+NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy
+ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV
+BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ
+KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo
+Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4
+4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9
+KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI
+rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi
+94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB
+sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi
+gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo
+kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE
+vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA
+A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t
+O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua
+AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP
+9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/
+eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m
+0vdXcDazv/wor3ElhVsT/h5/WrQ8
+-----END CERTIFICATE-----
+
+# Issuer: CN=AAA Certificate Services O=Comodo CA Limited
+# Subject: CN=AAA Certificate Services O=Comodo CA Limited
+# Label: "Comodo AAA Services root"
+# Serial: 1
+# MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0
+# SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49
+# SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4
+-----BEGIN CERTIFICATE-----
+MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj
+YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM
+GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua
+BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe
+3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4
+YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR
+rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm
+ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU
+oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF
+MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v
+QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t
+b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF
+AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q
+GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz
+Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2
+G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi
+l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3
+smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2"
+# Serial: 1289
+# MD5 Fingerprint: 5e:39:7b:dd:f8:ba:ec:82:e9:ac:62:ba:0c:54:00:2b
+# SHA1 Fingerprint: ca:3a:fb:cf:12:40:36:4b:44:b2:16:20:88:80:48:39:19:93:7c:f7
+# SHA256 Fingerprint: 85:a0:dd:7d:d7:20:ad:b7:ff:05:f8:3d:54:2b:20:9d:c7:ff:45:28:f7:d6:77:b1:83:89:fe:a5:e5:c4:9e:86
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3"
+# Serial: 1478
+# MD5 Fingerprint: 31:85:3c:62:94:97:63:b9:aa:fd:89:4e:af:6f:e0:cf
+# SHA1 Fingerprint: 1f:49:14:f7:d8:74:95:1d:dd:ae:02:c0:be:fd:3a:2d:82:75:51:85
+# SHA256 Fingerprint: 18:f1:fc:7f:20:5d:f8:ad:dd:eb:7f:e0:07:dd:57:e3:af:37:5a:9c:4d:8d:73:54:6b:f4:f1:fe:d1:e1:8d:35
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=SECOM Trust.net OU=Security Communication RootCA1
+# Subject: O=SECOM Trust.net OU=Security Communication RootCA1
+# Label: "Security Communication Root CA"
+# Serial: 0
+# MD5 Fingerprint: f1:bc:63:6a:54:e0:b5:27:f5:cd:e7:1a:e3:4d:6e:4a
+# SHA1 Fingerprint: 36:b1:2b:49:f9:81:9e:d7:4c:9e:bc:38:0f:c6:56:8f:5d:ac:b2:f7
+# SHA256 Fingerprint: e7:5e:72:ed:9f:56:0e:ec:6e:b4:80:00:73:a4:3f:c3:ad:19:19:5a:39:22:82:01:78:95:97:4a:99:02:6b:6c
+-----BEGIN CERTIFICATE-----
+MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY
+MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t
+dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5
+WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD
+VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8
+9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ
+DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9
+Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N
+QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ
+xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G
+A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T
+AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG
+kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr
+Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5
+Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU
+JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot
+RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Label: "XRamp Global CA Root"
+# Serial: 107108908803651509692980124233745014957
+# MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1
+# SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6
+# SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2
+-----BEGIN CERTIFICATE-----
+MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB
+gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk
+MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY
+UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx
+NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3
+dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy
+dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6
+38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP
+KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q
+DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4
+qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa
+JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi
+PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P
+BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs
+jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0
+eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD
+ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR
+vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt
+qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa
+IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy
+i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ
+O+7ETPTsJ3xCwnR8gooJybQDJbw=
+-----END CERTIFICATE-----
+
+# Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Label: "Go Daddy Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67
+# SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4
+# SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4
+-----BEGIN CERTIFICATE-----
+MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
+MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
+YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
+MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
+ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
+MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
+ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
+PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
+wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
+EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
+avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
+YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
+sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
+/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
+IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
+ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
+OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
+TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
+HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
+dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
+ReYNnyicsbkqWletNw+vHX/bvZ8=
+-----END CERTIFICATE-----
+
+# Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Label: "Starfield Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24
+# SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a
+# SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58
+-----BEGIN CERTIFICATE-----
+MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
+MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
+U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
+NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
+ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
+ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
+DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
+8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
+X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
+K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
+1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
+A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
+zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
+YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
+bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
+DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
+L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
+eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
+xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
+VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
+WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root CA"
+# Serial: 17154717934120587862167794914071425081
+# MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72
+# SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43
+# SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c
+-----BEGIN CERTIFICATE-----
+MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c
+JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP
+mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+
+wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4
+VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/
+AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB
+AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun
+pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC
+dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf
+fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm
+NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx
+H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root CA"
+# Serial: 10944719598952040374951832963794454346
+# MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e
+# SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36
+# SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61
+-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
+QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
+CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
+nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
+43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
+T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
+gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
+BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
+TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
+DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
+hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
+06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
+PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
+YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
+CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert High Assurance EV Root CA"
+# Serial: 3553400076410547919724730734378100087
+# MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a
+# SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25
+# SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j
+ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL
+MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3
+LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug
+RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm
++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW
+PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM
+xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB
+Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3
+hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg
+EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA
+FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec
+nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z
+eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF
+hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2
+Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
+vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
++OkuE6N36B9K
+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Label: "SwissSign Gold CA - G2"
+# Serial: 13492815561806991280
+# MD5 Fingerprint: 24:77:d9:a8:91:d1:3b:fa:88:2d:c2:ff:f8:cd:33:93
+# SHA1 Fingerprint: d8:c5:38:8a:b7:30:1b:1b:6e:d4:7a:e6:45:25:3a:6f:9f:1a:27:61
+# SHA256 Fingerprint: 62:dd:0b:e9:b9:f5:0a:16:3e:a0:f8:e7:5c:05:3b:1e:ca:57:ea:55:c8:68:8f:64:7c:68:81:f2:c8:35:7b:95
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Label: "SwissSign Silver CA - G2"
+# Serial: 5700383053117599563
+# MD5 Fingerprint: e0:06:a1:c9:7d:cf:c9:fc:0d:c0:56:75:96:d8:62:13
+# SHA1 Fingerprint: 9b:aa:e5:9f:56:ee:21:cb:43:5a:be:25:93:df:a7:f0:40:d1:1d:cb
+# SHA256 Fingerprint: be:6c:4d:a2:bb:b9:ba:59:b6:f3:93:97:68:37:42:46:c3:c0:05:99:3f:a9:8f:02:0d:1d:ed:be:d4:8a:81:d5
+-----BEGIN CERTIFICATE-----
+MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UE
+BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWdu
+IFNpbHZlciBDQSAtIEcyMB4XDTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0Nlow
+RzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMY
+U3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A
+MIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644N0Mv
+Fz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7br
+YT7QbNHm+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieF
+nbAVlDLaYQ1HTWBCrpJH6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH
+6ATK72oxh9TAtvmUcXtnZLi2kUpCe2UuMGoM9ZDulebyzYLs2aFK7PayS+VFheZt
+eJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5hqAaEuSh6XzjZG6k4sIN/
+c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5FZGkECwJ
+MoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRH
+HTBsROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTf
+jNFusB3hB48IHpmccelM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb6
+5i/4z3GcRm25xBWNOHkDRUjvxF3XCO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOB
+rDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU
+F6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRBtjpbO8tFnb0c
+wpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0
+cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIB
+AHPGgeAn0i0P4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShp
+WJHckRE1qTodvBqlYJ7YH39FkWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9
+xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L3XWgwF15kIwb4FDm3jH+mHtwX6WQ
+2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx/uNncqCxv1yL5PqZ
+IseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFaDGi8
+aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2X
+em1ZqSqPe97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQR
+dAtq/gsD/KNVV4n+SsuuWxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/
+OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJDIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+
+hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ubDgEj8Z+7fNzcbBGXJbLy
+tGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u
+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureTrust CA O=SecureTrust Corporation
+# Subject: CN=SecureTrust CA O=SecureTrust Corporation
+# Label: "SecureTrust CA"
+# Serial: 17199774589125277788362757014266862032
+# MD5 Fingerprint: dc:32:c3:a7:6d:25:57:c7:68:09:9d:ea:2d:a9:a2:d1
+# SHA1 Fingerprint: 87:82:c6:c3:04:35:3b:cf:d2:96:92:d2:59:3e:7d:44:d9:34:ff:11
+# SHA256 Fingerprint: f1:c1:b5:0a:e5:a2:0d:d8:03:0e:c9:f6:bc:24:82:3d:d3:67:b5:25:57:59:b4:e7:1b:61:fc:e9:f7:37:5d:73
+-----BEGIN CERTIFICATE-----
+MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz
+MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv
+cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz
+Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO
+0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao
+wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj
+7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS
+8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT
+BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg
+JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3
+6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/
+3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm
+D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS
+CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR
+3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Secure Global CA O=SecureTrust Corporation
+# Subject: CN=Secure Global CA O=SecureTrust Corporation
+# Label: "Secure Global CA"
+# Serial: 9751836167731051554232119481456978597
+# MD5 Fingerprint: cf:f4:27:0d:d4:ed:dc:65:16:49:6d:3d:da:bf:6e:de
+# SHA1 Fingerprint: 3a:44:73:5a:e5:81:90:1f:24:86:61:46:1e:3b:9c:c4:5f:f5:3a:1b
+# SHA256 Fingerprint: 42:00:f5:04:3a:c8:59:0e:bb:52:7d:20:9e:d1:50:30:29:fb:cb:d4:1c:a1:b5:06:ec:27:f1:5a:de:7d:ac:69
+-----BEGIN CERTIFICATE-----
+MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx
+MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg
+Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ
+iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa
+/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ
+jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI
+HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7
+sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w
+gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw
+KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG
+AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L
+URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO
+H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm
+I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY
+iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc
+f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO Certification Authority O=COMODO CA Limited
+# Label: "COMODO Certification Authority"
+# Serial: 104350513648249232941998508985834464573
+# MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75
+# SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b
+# SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66
+-----BEGIN CERTIFICATE-----
+MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB
+gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
+A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV
+BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw
+MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl
+YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P
+RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0
+aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3
+UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI
+2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8
+Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp
++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+
+DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O
+nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW
+/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g
+PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u
+QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY
+SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv
+IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/
+RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4
+zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd
+BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB
+ZQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Label: "COMODO ECC Certification Authority"
+# Serial: 41578283867086692638256921589707938090
+# MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23
+# SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11
+# SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7
+-----BEGIN CERTIFICATE-----
+MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT
+IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw
+MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy
+ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N
+T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv
+biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR
+FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J
+cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW
+BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm
+fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv
+GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna O=Dhimyotis
+# Subject: CN=Certigna O=Dhimyotis
+# Label: "Certigna"
+# Serial: 18364802974209362175
+# MD5 Fingerprint: ab:57:a6:5b:7d:42:82:19:b5:d8:58:26:28:5e:fd:ff
+# SHA1 Fingerprint: b1:2e:13:63:45:86:a4:6f:1a:b2:60:68:37:58:2d:c4:ac:fd:94:97
+# SHA256 Fingerprint: e3:b6:a2:db:2e:d7:ce:48:84:2f:7a:c5:32:41:c7:b7:1d:54:14:4b:fb:40:c1:1f:3f:1d:0b:42:f5:ee:a1:2d
+-----BEGIN CERTIFICATE-----
+MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV
+BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X
+DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ
+BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4
+QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny
+gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw
+zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q
+130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2
+JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw
+DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw
+ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT
+AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj
+AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG
+9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h
+bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc
+fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu
+HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w
+t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw
+WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg==
+-----END CERTIFICATE-----
+
+# Issuer: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Subject: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Label: "ePKI Root Certification Authority"
+# Serial: 28956088682735189655030529057352760477
+# MD5 Fingerprint: 1b:2e:00:ca:26:06:90:3d:ad:fe:6f:15:68:d3:6b:b3
+# SHA1 Fingerprint: 67:65:0d:f1:7e:8e:7e:5b:82:40:a4:f4:56:4b:cf:e2:3d:69:c6:f0
+# SHA256 Fingerprint: c0:a6:f4:dc:63:a2:4b:fd:cf:54:ef:2a:6a:08:2a:0a:72:de:35:80:3e:2f:f5:ff:52:7a:e5:d8:72:06:df:d5
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=certSIGN OU=certSIGN ROOT CA
+# Subject: O=certSIGN OU=certSIGN ROOT CA
+# Label: "certSIGN ROOT CA"
+# Serial: 35210227249154
+# MD5 Fingerprint: 18:98:c0:d6:e9:3a:fc:f9:b0:f5:0c:f7:4b:01:44:17
+# SHA1 Fingerprint: fa:b7:ee:36:97:26:62:fb:2d:b0:2a:f6:bf:03:fd:e8:7c:4b:2f:9b
+# SHA256 Fingerprint: ea:a9:62:c4:fa:4a:6b:af:eb:e4:15:19:6d:35:1c:cd:88:8d:4f:53:f3:fa:8a:e6:d7:c4:66:a9:4e:60:42:bb
+-----BEGIN CERTIFICATE-----
+MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT
+AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD
+QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP
+MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do
+0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ
+UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d
+RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ
+OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv
+JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C
+AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O
+BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ
+LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY
+MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ
+44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I
+Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw
+i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN
+9u6wWk5JRFRYX0KD
+-----END CERTIFICATE-----
+
+# Issuer: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Subject: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Label: "NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny"
+# Serial: 80544274841616
+# MD5 Fingerprint: c5:a1:b7:ff:73:dd:d6:d7:34:32:18:df:fc:3c:ad:88
+# SHA1 Fingerprint: 06:08:3f:59:3f:15:a1:04:a0:69:a4:6b:a9:03:d0:06:b7:97:09:91
+# SHA256 Fingerprint: 6c:61:da:c3:a2:de:f0:31:50:6b:e0:36:d2:a6:fe:40:19:94:fb:d1:3d:f9:c8:d4:66:59:92:74:c4:46:ec:98
+-----BEGIN CERTIFICATE-----
+MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG
+EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3
+MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl
+cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR
+dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB
+pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM
+b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm
+aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz
+IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT
+lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz
+AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5
+VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG
+ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2
+BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG
+AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M
+U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh
+bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C
++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC
+bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F
+uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2
+XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Subject: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Label: "SecureSign RootCA11"
+# Serial: 1
+# MD5 Fingerprint: b7:52:74:e2:92:b4:80:93:f2:75:e4:cc:d7:f2:ea:26
+# SHA1 Fingerprint: 3b:c4:9f:48:f8:f3:73:a0:9c:1e:bd:f8:5b:b1:c3:65:c7:d8:11:b3
+# SHA256 Fingerprint: bf:0f:ee:fb:9e:3a:58:1a:d5:f9:e9:db:75:89:98:57:43:d2:61:08:5c:4d:31:4f:6f:5d:72:59:aa:42:16:12
+-----BEGIN CERTIFICATE-----
+MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr
+MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG
+A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0
+MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp
+Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD
+QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz
+i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8
+h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV
+MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9
+UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni
+8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC
+h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD
+VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB
+AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm
+KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ
+X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr
+QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5
+pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN
+QSdJQO7e5iNEOdyhIta6A/I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Subject: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Label: "Microsec e-Szigno Root CA 2009"
+# Serial: 14014712776195784473
+# MD5 Fingerprint: f8:49:f4:03:bc:44:2d:83:be:48:69:7d:29:64:fc:b1
+# SHA1 Fingerprint: 89:df:74:fe:5c:f4:0f:4a:80:f9:e3:37:7d:54:da:91:e1:01:31:8e
+# SHA256 Fingerprint: 3c:5f:81:fe:a5:fa:b8:2c:64:bf:a2:ea:ec:af:cd:e8:e0:77:fc:86:20:a7:ca:e5:37:16:3d:f3:6e:db:f3:78
+-----BEGIN CERTIFICATE-----
+MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD
+VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0
+ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G
+CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y
+OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx
+FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp
+Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o
+dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP
+kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc
+cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U
+fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7
+N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC
+xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1
++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM
+Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG
+SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h
+mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk
+ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775
+tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c
+2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t
+HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Label: "GlobalSign Root CA - R3"
+# Serial: 4835703278459759426209954
+# MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28
+# SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad
+# SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b
+-----BEGIN CERTIFICATE-----
+MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G
+A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp
+Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4
+MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG
+A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8
+RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT
+gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm
+KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd
+QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ
+XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw
+DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o
+LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU
+RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp
+jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK
+6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX
+mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs
+Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH
+WD9f
+-----END CERTIFICATE-----
+
+# Issuer: CN=Izenpe.com O=IZENPE S.A.
+# Subject: CN=Izenpe.com O=IZENPE S.A.
+# Label: "Izenpe.com"
+# Serial: 917563065490389241595536686991402621
+# MD5 Fingerprint: a6:b0:cd:85:80:da:5c:50:34:a3:39:90:2f:55:67:73
+# SHA1 Fingerprint: 2f:78:3d:25:52:18:a7:4a:65:39:71:b5:2c:a2:9c:45:15:6f:e9:19
+# SHA256 Fingerprint: 25:30:cc:8e:98:32:15:02:ba:d9:6f:9b:1f:ba:1b:09:9e:2d:29:9e:0f:45:48:bb:91:4f:36:3b:c0:d4:53:1f
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Label: "Go Daddy Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01
+# SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b
+# SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
+EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
+ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz
+NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
+EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE
+AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD
+E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH
+/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy
+DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh
+GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR
+tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA
+AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
+FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX
+WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu
+9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr
+gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo
+2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO
+LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI
+4uJEvlz36hz1
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96
+# SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e
+# SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5
+-----BEGIN CERTIFICATE-----
+MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs
+ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw
+MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6
+b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj
+aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp
+Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg
+nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1
+HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N
+Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN
+dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0
+HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
+BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G
+CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU
+sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3
+4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg
+8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K
+pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1
+mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Services Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2
+# SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f
+# SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5
+-----BEGIN CERTIFICATE-----
+MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs
+ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5
+MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD
+VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
+ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy
+dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p
+OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2
+8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K
+Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe
+hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk
+6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw
+DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q
+AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI
+bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB
+ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z
+qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd
+iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn
+0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN
+sSi6
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Commercial O=AffirmTrust
+# Subject: CN=AffirmTrust Commercial O=AffirmTrust
+# Label: "AffirmTrust Commercial"
+# Serial: 8608355977964138876
+# MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7
+# SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7
+# SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP
+Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr
+ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL
+MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1
+yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr
+VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/
+nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG
+XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj
+vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt
+Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g
+N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC
+nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Networking O=AffirmTrust
+# Subject: CN=AffirmTrust Networking O=AffirmTrust
+# Label: "AffirmTrust Networking"
+# Serial: 8957382827206547757
+# MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f
+# SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f
+# SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y
+YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua
+kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL
+QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp
+6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG
+yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i
+QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO
+tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu
+QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ
+Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u
+olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48
+x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium O=AffirmTrust
+# Subject: CN=AffirmTrust Premium O=AffirmTrust
+# Label: "AffirmTrust Premium"
+# Serial: 7893706540734352110
+# MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57
+# SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27
+# SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz
+dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG
+A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U
+cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf
+qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ
+JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ
++jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS
+s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5
+HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7
+70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG
+V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S
+qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S
+5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia
+C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX
+OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE
+FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2
+KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg
+Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B
+8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ
+MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc
+0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ
+u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF
+u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH
+YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8
+GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO
+RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e
+KeC2uAloGRwYQw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Subject: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Label: "AffirmTrust Premium ECC"
+# Serial: 8401224907861490260
+# MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d
+# SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb
+# SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23
+-----BEGIN CERTIFICATE-----
+MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC
+VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ
+cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ
+BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt
+VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D
+0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9
+ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G
+A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs
+aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I
+flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA"
+# Serial: 279744
+# MD5 Fingerprint: d5:e9:81:40:c5:18:69:fc:46:2c:89:75:62:0f:aa:78
+# SHA1 Fingerprint: 07:e0:32:e0:20:b7:2c:3f:19:2f:06:28:a2:59:3a:19:a7:0f:06:9e
+# SHA256 Fingerprint: 5c:58:46:8d:55:f5:8e:49:7e:74:39:82:d2:b5:00:10:b6:d1:65:37:4a:cf:83:a7:d4:a3:2d:b7:68:c4:40:8e
+-----BEGIN CERTIFICATE-----
+MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM
+MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D
+ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU
+cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3
+WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg
+Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw
+IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH
+UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM
+TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU
+BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM
+kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x
+AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV
+HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y
+sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL
+I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8
+J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY
+VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI
+03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Root Certification Authority"
+# Serial: 1
+# MD5 Fingerprint: aa:08:8f:f6:f9:7b:b7:f2:b1:a7:1e:9b:ea:ea:bd:79
+# SHA1 Fingerprint: cf:9e:87:6d:d3:eb:fc:42:26:97:a3:b5:a3:7a:a0:76:a9:06:23:48
+# SHA256 Fingerprint: bf:d8:8f:e1:10:1c:41:ae:3e:80:1b:f8:be:56:35:0e:e9:ba:d1:a6:b9:bd:51:5e:dc:5c:6d:5b:87:11:ac:44
+-----BEGIN CERTIFICATE-----
+MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES
+MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU
+V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz
+WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO
+LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE
+AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH
+K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX
+RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z
+rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx
+3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq
+hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC
+MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls
+XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D
+lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn
+aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ
+YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw==
+-----END CERTIFICATE-----
+
+# Issuer: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Subject: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Label: "Security Communication RootCA2"
+# Serial: 0
+# MD5 Fingerprint: 6c:39:7d:a4:0e:55:59:b2:3f:d6:41:b1:12:50:de:43
+# SHA1 Fingerprint: 5f:3b:8c:f2:f8:10:b3:7d:78:b4:ce:ec:19:19:c3:73:34:b9:c7:74
+# SHA256 Fingerprint: 51:3b:2c:ec:b8:10:d4:cd:e5:dd:85:39:1a:df:c6:c2:dd:60:d8:7b:b7:36:d2:b5:21:48:4a:a4:7a:0e:be:f6
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl
+MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe
+U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX
+DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy
+dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj
+YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV
+OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr
+zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM
+VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ
+hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO
+ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw
+awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs
+OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3
+DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF
+coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc
+okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8
+t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy
+1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/
+SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03
+-----END CERTIFICATE-----
+
+# Issuer: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Subject: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Label: "Actalis Authentication Root CA"
+# Serial: 6271844772424770508
+# MD5 Fingerprint: 69:c1:0d:4f:07:a3:1b:c3:fe:56:3d:04:bc:11:f6:a6
+# SHA1 Fingerprint: f3:73:b3:87:06:5a:28:84:8a:f2:f3:4a:ce:19:2b:dd:c7:8e:9c:ac
+# SHA256 Fingerprint: 55:92:60:84:ec:96:3a:64:b9:6e:2a:be:01:ce:0b:a8:6a:64:fb:fe:bc:c7:aa:b5:af:c1:55:b3:7f:d7:60:66
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 2 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 46:a7:d2:fe:45:fb:64:5a:a8:59:90:9b:78:44:9b:29
+# SHA1 Fingerprint: 49:0a:75:74:de:87:0a:47:fe:58:ee:f6:c7:6b:eb:c6:0b:12:40:99
+# SHA256 Fingerprint: 9a:11:40:25:19:7c:5b:b9:5d:94:e6:3d:55:cd:43:79:08:47:b6:46:b2:3c:df:11:ad:a4:a0:0e:ff:15:fb:48
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr
+6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV
+L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91
+1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx
+MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ
+QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB
+arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr
+Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi
+FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS
+P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN
+9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz
+uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h
+9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s
+A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t
+OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo
++fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7
+KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2
+DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us
+H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ
+I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7
+5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h
+3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz
+Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 3 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 3d:3b:18:9e:2c:64:5a:e8:d5:88:ce:0e:f9:37:c2:ec
+# SHA1 Fingerprint: da:fa:f7:fa:66:84:ec:06:8f:14:50:bd:c7:c2:81:a5:bc:a9:64:57
+# SHA256 Fingerprint: ed:f7:eb:bc:a2:7a:2a:38:4d:38:7b:7d:40:10:c6:66:e2:ed:b4:84:3e:4c:29:b4:ae:1d:5b:93:32:e6:b2:4d
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y
+ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E
+N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9
+tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX
+0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c
+/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X
+KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY
+zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS
+O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D
+34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP
+K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv
+Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj
+QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV
+cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS
+IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2
+HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa
+O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv
+033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u
+dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE
+kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41
+3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD
+u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq
+4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 3"
+# Serial: 1
+# MD5 Fingerprint: ca:fb:40:a8:4e:39:92:8a:1d:fe:8e:2f:c4:27:ea:ef
+# SHA1 Fingerprint: 55:a6:72:3e:cb:f2:ec:cd:c3:23:74:70:19:9d:2a:be:11:e3:81:d1
+# SHA256 Fingerprint: fd:73:da:d3:1c:64:4f:f1:b4:3b:ef:0c:cd:da:96:71:0b:9c:d9:87:5e:ca:7e:31:70:7a:f3:e9:6d:52:2b:bd
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN
+8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/
+RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4
+hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5
+ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM
+EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1
+A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy
+WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ
+1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30
+6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT
+91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml
+e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p
+TpPDpFQUWw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 2009"
+# Serial: 623603
+# MD5 Fingerprint: cd:e0:25:69:8d:47:ac:9c:89:35:90:f7:fd:51:3d:2f
+# SHA1 Fingerprint: 58:e8:ab:b0:36:15:33:fb:80:f7:9b:1b:6d:29:d3:ff:8d:5f:00:f0
+# SHA256 Fingerprint: 49:e7:a4:42:ac:f0:ea:62:87:05:00:54:b5:25:64:b6:50:e4:f4:9e:42:e3:48:d6:aa:38:e0:39:e9:57:b1:c1
+-----BEGIN CERTIFICATE-----
+MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha
+ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM
+HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03
+UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42
+tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R
+ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM
+lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp
+/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G
+A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G
+A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj
+dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy
+MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl
+cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js
+L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL
+BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni
+acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0
+o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K
+zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8
+PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y
+Johw1+qRzT65ysCQblrGXnRl11z+o+I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 EV 2009"
+# Serial: 623604
+# MD5 Fingerprint: aa:c6:43:2c:5e:2d:cd:c4:34:c0:50:4f:11:02:4f:b6
+# SHA1 Fingerprint: 96:c9:1b:0b:95:b4:10:98:42:fa:d0:d8:22:79:fe:60:fa:b9:16:83
+# SHA256 Fingerprint: ee:c5:49:6b:98:8c:e9:86:25:b9:34:09:2e:ec:29:08:be:d0:b0:f3:16:c2:d4:73:0c:84:ea:f1:f3:d3:48:81
+-----BEGIN CERTIFICATE-----
+MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw
+NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV
+BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn
+ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0
+3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z
+qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR
+p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8
+HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw
+ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea
+HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw
+Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh
+c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E
+RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt
+dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku
+Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp
+3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05
+nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF
+CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na
+xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX
+KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1
+-----END CERTIFICATE-----
+
+# Issuer: CN=CA Disig Root R2 O=Disig a.s.
+# Subject: CN=CA Disig Root R2 O=Disig a.s.
+# Label: "CA Disig Root R2"
+# Serial: 10572350602393338211
+# MD5 Fingerprint: 26:01:fb:d8:27:a7:17:9a:45:54:38:1a:43:01:3b:03
+# SHA1 Fingerprint: b5:61:eb:ea:a4:de:e4:25:4b:69:1a:98:a5:57:47:c2:34:c7:d9:71
+# SHA256 Fingerprint: e2:3d:4a:03:6d:7b:70:e9:f5:95:b1:42:20:79:d2:b9:1e:df:bb:1f:b6:51:a0:63:3e:aa:8a:9d:c5:f8:07:03
+-----BEGIN CERTIFICATE-----
+MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV
+BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu
+MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy
+MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx
+EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw
+ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe
+NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH
+PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I
+x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe
+QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR
+yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO
+QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912
+H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ
+QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD
+i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs
+nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1
+rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud
+DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI
+hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM
+tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf
+GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb
+lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka
++elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal
+TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i
+nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3
+gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr
+G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os
+zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x
+L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL
+-----END CERTIFICATE-----
+
+# Issuer: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Subject: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Label: "ACCVRAIZ1"
+# Serial: 6828503384748696800
+# MD5 Fingerprint: d0:a0:5a:ee:05:b6:09:94:21:a1:7d:f1:b2:29:82:02
+# SHA1 Fingerprint: 93:05:7a:88:15:c6:4f:ce:88:2f:fa:91:16:52:28:78:bc:53:64:17
+# SHA256 Fingerprint: 9a:6e:c0:12:e1:a7:da:9d:be:34:19:4d:47:8a:d7:c0:db:18:22:fb:07:1d:f1:29:81:49:6e:d1:04:38:41:13
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Global Root CA"
+# Serial: 3262
+# MD5 Fingerprint: f9:03:7e:cf:e6:9e:3c:73:7a:2a:90:07:69:ff:2b:96
+# SHA1 Fingerprint: 9c:bb:48:53:f6:a4:f6:d3:52:a4:e8:32:52:55:60:13:f5:ad:af:65
+# SHA256 Fingerprint: 59:76:90:07:f7:68:5d:0f:cd:50:87:2f:9f:95:d5:75:5a:5b:2b:45:7d:81:f3:69:2b:61:0a:98:67:2f:0e:1b
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx
+EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT
+VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5
+NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT
+B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF
+10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz
+0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh
+MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH
+zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc
+46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2
+yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi
+laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP
+oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA
+BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE
+qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm
+4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL
+1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn
+LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF
+H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo
+RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+
+nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh
+15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW
+6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW
+nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j
+wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz
+aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy
+KwbQBM0=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Subject: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Label: "TeliaSonera Root CA v1"
+# Serial: 199041966741090107964904287217786801558
+# MD5 Fingerprint: 37:41:49:1b:18:56:9a:26:f5:ad:c2:66:fb:40:a5:4c
+# SHA1 Fingerprint: 43:13:bb:96:f1:d5:86:9b:c1:4e:6a:92:f6:cf:f6:34:69:87:82:37
+# SHA256 Fingerprint: dd:69:36:fe:21:f8:f0:77:c1:23:a1:a5:21:c1:22:24:f7:22:55:b7:3e:03:a7:26:06:93:e8:a2:4b:0f:a3:89
+-----BEGIN CERTIFICATE-----
+MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw
+NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv
+b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD
+VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F
+VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1
+7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X
+Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+
+/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs
+81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm
+dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe
+Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu
+sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4
+pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs
+slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ
+arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD
+VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG
+9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl
+dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx
+0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj
+TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed
+Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7
+Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI
+OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7
+vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW
+t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn
+HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx
+SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 2"
+# Serial: 1
+# MD5 Fingerprint: 2b:9b:9e:e4:7b:6c:1f:00:72:1a:cc:c1:77:79:df:6a
+# SHA1 Fingerprint: 59:0d:2d:7d:88:4f:40:2e:61:7e:a5:62:32:17:65:cf:17:d8:94:e9
+# SHA256 Fingerprint: 91:e2:f5:78:8d:58:10:eb:a7:ba:58:73:7d:e1:54:8a:8e:ca:cd:01:45:98:bc:0b:14:3e:04:1b:17:05:25:52
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd
+AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC
+FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi
+1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq
+jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ
+wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/
+WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy
+NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC
+uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw
+IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6
+g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN
+9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP
+BSeOE6Fuwg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot 2011 O=Atos
+# Subject: CN=Atos TrustedRoot 2011 O=Atos
+# Label: "Atos TrustedRoot 2011"
+# Serial: 6643877497813316402
+# MD5 Fingerprint: ae:b9:c4:32:4b:ac:7f:5d:66:cc:77:94:bb:2a:77:56
+# SHA1 Fingerprint: 2b:b1:f5:3e:55:0c:1d:c5:f1:d4:e6:b7:6a:46:4b:55:06:02:ac:21
+# SHA256 Fingerprint: f3:56:be:a2:44:b7:a9:1e:b3:5d:53:ca:9a:d7:86:4a:ce:01:8e:2d:35:d5:f8:f9:6d:df:68:a6:f4:1a:a4:74
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE
+AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG
+EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM
+FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC
+REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp
+Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM
+VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+
+SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ
+4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L
+cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi
+eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV
+HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG
+A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3
+DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j
+vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP
+DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc
+maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D
+lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv
+KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 1 G3"
+# Serial: 687049649626669250736271037606554624078720034195
+# MD5 Fingerprint: a4:bc:5b:3f:fe:37:9a:fa:64:f0:e2:fa:05:3d:0b:ab
+# SHA1 Fingerprint: 1b:8e:ea:57:96:29:1a:c9:39:ea:b8:0a:81:1a:73:73:c0:93:79:67
+# SHA256 Fingerprint: 8a:86:6f:d1:b2:76:b5:7e:57:8e:92:1c:65:82:8a:2b:ed:58:e9:f2:f2:88:05:41:34:b7:f1:f4:bf:c9:cc:74
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00
+MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV
+wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe
+rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341
+68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh
+4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp
+UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o
+abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc
+3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G
+KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt
+hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO
+Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt
+zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD
+ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC
+MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2
+cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN
+qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5
+YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv
+b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2
+8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k
+NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj
+ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp
+q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt
+nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2 G3"
+# Serial: 390156079458959257446133169266079962026824725800
+# MD5 Fingerprint: af:0c:86:6e:bf:40:2d:7f:0b:3e:12:50:ba:12:3d:06
+# SHA1 Fingerprint: 09:3c:61:f3:8b:8b:dc:7d:55:df:75:38:02:05:00:e1:25:f5:c8:36
+# SHA256 Fingerprint: 8f:e4:fb:0a:f9:3a:4d:0d:67:db:0b:eb:b2:3e:37:c7:1b:f3:25:dc:bc:dd:24:0e:a0:4d:af:58:b4:7e:18:40
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00
+MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf
+qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW
+n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym
+c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+
+O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1
+o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j
+IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq
+IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz
+8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh
+vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l
+7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG
+cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD
+ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66
+AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC
+roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga
+W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n
+lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE
++V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV
+csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd
+dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg
+KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM
+HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4
+WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3 G3"
+# Serial: 268090761170461462463995952157327242137089239581
+# MD5 Fingerprint: df:7d:b9:ad:54:6f:68:a1:df:89:57:03:97:43:b0:d7
+# SHA1 Fingerprint: 48:12:bd:92:3c:a8:c4:39:06:e7:30:6d:27:96:e6:a4:cf:22:2e:7d
+# SHA256 Fingerprint: 88:ef:81:de:20:2e:b0:18:45:2e:43:f8:64:72:5c:ea:5f:bd:1f:c2:d9:d2:05:73:07:09:c5:d8:b8:69:0f:46
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00
+MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR
+/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu
+FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR
+U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c
+ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR
+FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k
+A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw
+eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl
+sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp
+VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q
+A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+
+ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD
+ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px
+KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI
+FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv
+oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg
+u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP
+0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf
+3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl
+8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+
+DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN
+PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/
+ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G2"
+# Serial: 15385348160840213938643033620894905419
+# MD5 Fingerprint: 92:38:b9:f8:63:24:82:65:2c:57:33:e6:fe:81:8f:9d
+# SHA1 Fingerprint: a1:4b:48:d9:43:ee:0a:0e:40:90:4f:3c:e0:a4:c0:91:93:51:5d:3f
+# SHA256 Fingerprint: 7d:05:eb:b6:82:33:9f:8c:94:51:ee:09:4e:eb:fe:fa:79:53:a1:14:ed:b2:f4:49:49:45:2f:ab:7d:2f:c1:85
+-----BEGIN CERTIFICATE-----
+MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA
+n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc
+biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp
+EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA
+bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu
+YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB
+AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW
+BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI
+QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I
+0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni
+lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9
+B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv
+ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo
+IhNzbM8m9Yop5w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G3"
+# Serial: 15459312981008553731928384953135426796
+# MD5 Fingerprint: 7c:7f:65:31:0c:81:df:8d:ba:3e:99:e2:5c:ad:6e:fb
+# SHA1 Fingerprint: f5:17:a2:4f:9a:48:c6:c9:f8:a2:00:26:9f:dc:0f:48:2c:ab:30:89
+# SHA256 Fingerprint: 7e:37:cb:8b:4c:47:09:0c:ab:36:55:1b:a6:f4:5d:b8:40:68:0f:ba:16:6a:95:2d:b1:00:71:7f:43:05:3f:c2
+-----BEGIN CERTIFICATE-----
+MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg
+RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf
+Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q
+RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD
+AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY
+JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv
+6pZjamVFkpUBtA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G2"
+# Serial: 4293743540046975378534879503202253541
+# MD5 Fingerprint: e4:a6:8a:c8:54:ac:52:42:46:0a:fd:72:48:1b:2a:44
+# SHA1 Fingerprint: df:3c:24:f9:bf:d6:66:76:1b:26:80:73:fe:06:d1:cc:8d:4f:82:a4
+# SHA256 Fingerprint: cb:3c:cb:b7:60:31:e5:e0:13:8f:8d:d3:9a:23:f9:de:47:ff:c3:5e:43:c1:14:4c:ea:27:d4:6a:5a:b1:cb:5f
+-----BEGIN CERTIFICATE-----
+MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
+MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI
+2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx
+1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ
+q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz
+tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ
+vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP
+BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV
+5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY
+1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4
+NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG
+Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91
+8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe
+pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl
+MrY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G3"
+# Serial: 7089244469030293291760083333884364146
+# MD5 Fingerprint: f5:5d:a4:50:a5:fb:28:7e:1e:0f:0d:cc:96:57:56:ca
+# SHA1 Fingerprint: 7e:04:de:89:6a:3e:66:6d:00:e6:87:d3:3f:fa:d9:3b:e8:3d:34:9e
+# SHA256 Fingerprint: 31:ad:66:48:f8:10:41:38:c7:38:f3:9e:a4:32:01:33:39:3e:3a:18:cc:02:29:6e:f9:7c:2a:c9:ef:67:31:d0
+-----BEGIN CERTIFICATE-----
+MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe
+Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw
+EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x
+IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF
+K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG
+fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO
+Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd
+BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx
+AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/
+oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8
+sycX
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Trusted Root G4"
+# Serial: 7451500558977370777930084869016614236
+# MD5 Fingerprint: 78:f2:fc:aa:60:1f:2f:b4:eb:c9:37:ba:53:2e:75:49
+# SHA1 Fingerprint: dd:fb:16:cd:49:31:c9:73:a2:03:7d:3f:c8:3a:4d:7d:77:5d:05:e4
+# SHA256 Fingerprint: 55:2f:7b:dc:f1:a7:af:9e:6c:e6:72:01:7f:4f:12:ab:f7:72:40:c7:8e:76:1a:c2:03:d1:d9:d2:0a:c8:99:88
+-----BEGIN CERTIFICATE-----
+MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg
+RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y
+ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If
+xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV
+ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO
+DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ
+jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/
+CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi
+EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM
+fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY
+uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK
+chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t
+9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD
+ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2
+SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd
++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc
+fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa
+sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N
+cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N
+0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie
+4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI
+r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1
+/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm
+gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Label: "COMODO RSA Certification Authority"
+# Serial: 101909084537582093308941363524873193117
+# MD5 Fingerprint: 1b:31:b0:71:40:36:cc:14:36:91:ad:c4:3e:fd:ec:18
+# SHA1 Fingerprint: af:e5:d2:44:a8:d1:19:42:30:ff:47:9f:e2:f8:97:bb:cd:7a:8c:b4
+# SHA256 Fingerprint: 52:f0:e1:c4:e5:8e:c6:29:29:1b:60:31:7f:07:46:71:b8:5d:7e:a8:0d:5b:07:27:34:63:53:4b:32:b4:02:34
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Label: "USERTrust RSA Certification Authority"
+# Serial: 2645093764781058787591871645665788717
+# MD5 Fingerprint: 1b:fe:69:d1:91:b7:19:33:a3:72:a8:0f:e1:55:e5:b5
+# SHA1 Fingerprint: 2b:8f:1b:57:33:0d:bb:a2:d0:7a:6c:51:f7:0e:e9:0d:da:b9:ad:8e
+# SHA256 Fingerprint: e7:93:c9:b0:2f:d8:aa:13:e2:1c:31:22:8a:cc:b0:81:19:64:3b:74:9c:89:89:64:b1:74:6d:46:c3:d4:cb:d2
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Label: "USERTrust ECC Certification Authority"
+# Serial: 123013823720199481456569720443997572134
+# MD5 Fingerprint: fa:68:bc:d9:b5:7f:ad:fd:c9:1d:06:83:28:cc:24:c1
+# SHA1 Fingerprint: d1:cb:ca:5d:b2:d5:2a:7f:69:3b:67:4d:e5:f0:5a:1d:0c:95:7d:f0
+# SHA256 Fingerprint: 4f:f4:60:d5:4b:9c:86:da:bf:bc:fc:57:12:e0:40:0d:2b:ed:3f:bc:4d:4f:bd:aa:86:e0:6a:dc:d2:a9:ad:7a
+-----BEGIN CERTIFICATE-----
+MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL
+MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl
+eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT
+JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx
+MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT
+Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg
+VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo
+I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng
+o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G
+A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB
+zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW
+RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Label: "GlobalSign ECC Root CA - R5"
+# Serial: 32785792099990507226680698011560947931244
+# MD5 Fingerprint: 9f:ad:3b:1c:02:1e:8a:ba:17:74:38:81:0c:a2:bc:08
+# SHA1 Fingerprint: 1f:24:c6:30:cd:a4:18:ef:20:69:ff:ad:4f:dd:5f:46:3a:1b:69:aa
+# SHA256 Fingerprint: 17:9f:bc:14:8a:3d:d0:0f:d2:4e:a1:34:58:cc:43:bf:a7:f5:9c:81:82:d7:83:a5:13:f6:eb:ec:10:0c:89:24
+-----BEGIN CERTIFICATE-----
+MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk
+MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH
+bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX
+DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD
+QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu
+MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc
+8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke
+hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI
+KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg
+515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO
+xwy8p2Fp8fc74SrL+SvzZpA3
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Label: "IdenTrust Commercial Root CA 1"
+# Serial: 13298821034946342390520003877796839426
+# MD5 Fingerprint: b3:3e:77:73:75:ee:a0:d3:e3:7e:49:63:49:59:bb:c7
+# SHA1 Fingerprint: df:71:7e:aa:4a:d9:4e:c9:55:84:99:60:2d:48:de:5f:bc:f0:3a:25
+# SHA256 Fingerprint: 5d:56:49:9b:e4:d2:e0:8b:cf:ca:d0:8a:3e:38:72:3d:50:50:3b:de:70:69:48:e4:2f:55:60:30:19:e5:28:ae
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu
+VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw
+MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw
+JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT
+3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU
++ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp
+S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1
+bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi
+T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL
+vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK
+Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK
+dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT
+c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv
+l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N
+iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD
+ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH
+6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt
+LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93
+nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3
++wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK
+W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT
+AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq
+l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG
+4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ
+mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A
+7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Label: "IdenTrust Public Sector Root CA 1"
+# Serial: 13298821034946342390521976156843933698
+# MD5 Fingerprint: 37:06:a5:b0:fc:89:9d:ba:f4:6b:8c:1a:64:cd:d5:ba
+# SHA1 Fingerprint: ba:29:41:60:77:98:3f:f4:f3:ef:f2:31:05:3b:2e:ea:6d:4d:45:fd
+# SHA256 Fingerprint: 30:d0:89:5a:9a:44:8a:26:20:91:63:55:22:d1:f5:20:10:b5:86:7a:ca:e1:2c:78:ef:95:8f:d4:f4:38:9f:2f
+-----BEGIN CERTIFICATE-----
+MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu
+VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN
+MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0
+MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7
+ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy
+RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS
+bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF
+/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R
+3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw
+EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy
+9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V
+GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ
+2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV
+WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD
+W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN
+AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj
+t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV
+DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9
+TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G
+lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW
+mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df
+WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5
++bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ
+tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA
+GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv
+8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G2"
+# Serial: 1246989352
+# MD5 Fingerprint: 4b:e2:c9:91:96:65:0c:f4:0e:5a:93:92:a0:0a:fe:b2
+# SHA1 Fingerprint: 8c:f4:27:fd:79:0c:3a:d1:66:06:8d:e8:1e:57:ef:bb:93:22:72:d4
+# SHA256 Fingerprint: 43:df:57:74:b0:3e:7f:ef:5f:e4:0d:93:1a:7b:ed:f1:bb:2e:6b:42:73:8c:4e:6d:38:41:10:3d:3a:a7:f3:39
+-----BEGIN CERTIFICATE-----
+MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50
+cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs
+IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz
+dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy
+NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu
+dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt
+dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0
+aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T
+RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN
+cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW
+wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1
+U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0
+jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP
+BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN
+BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/
+jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ
+Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v
+1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R
+nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH
+VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - EC1"
+# Serial: 51543124481930649114116133369
+# MD5 Fingerprint: b6:7e:1d:f0:58:c5:49:6c:24:3b:3d:ed:98:18:ed:bc
+# SHA1 Fingerprint: 20:d8:06:40:df:9b:25:f5:12:25:3a:11:ea:f7:59:8a:eb:14:b5:47
+# SHA256 Fingerprint: 02:ed:0e:b2:8c:14:da:45:16:5c:56:67:91:70:0d:64:51:d7:fb:56:f0:b2:ab:1d:3b:8e:b0:70:e5:6e:df:f5
+-----BEGIN CERTIFICATE-----
+MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG
+A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3
+d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu
+dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq
+RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy
+MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD
+VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0
+L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g
+Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD
+ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi
+A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt
+ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH
+Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O
+BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC
+R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX
+hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G
+-----END CERTIFICATE-----
+
+# Issuer: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Subject: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Label: "CFCA EV ROOT"
+# Serial: 407555286
+# MD5 Fingerprint: 74:e1:b6:ed:26:7a:7a:44:30:33:94:ab:7b:27:81:30
+# SHA1 Fingerprint: e2:b8:29:4b:55:84:ab:6b:58:c2:90:46:6c:ac:3f:b8:39:8f:84:83
+# SHA256 Fingerprint: 5c:c3:d7:8e:4e:1d:5e:45:54:7a:04:e6:87:3e:64:f9:0c:f9:53:6d:1c:cc:2e:f8:00:f3:55:c4:c5:fd:70:fd
+-----BEGIN CERTIFICATE-----
+MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD
+TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y
+aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx
+MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j
+aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP
+T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03
+sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL
+TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5
+/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp
+7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz
+EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt
+hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP
+a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot
+aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg
+TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV
+PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv
+cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL
+tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd
+BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB
+ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT
+ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL
+jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS
+ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy
+P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19
+xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d
+Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN
+5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe
+/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z
+AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ
+5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GB CA"
+# Serial: 157768595616588414422159278966750757568
+# MD5 Fingerprint: a4:eb:b9:61:28:2e:b7:2f:98:b0:35:26:90:99:51:1d
+# SHA1 Fingerprint: 0f:f9:40:76:18:d3:d7:6a:4b:98:f0:a8:35:9e:0c:fd:27:ac:cc:ed
+# SHA256 Fingerprint: 6b:9c:08:e8:6e:b0:f7:67:cf:ad:65:cd:98:b6:21:49:e5:49:4a:67:f5:84:5e:7b:d1:ed:01:9f:27:b8:6b:d6
+-----BEGIN CERTIFICATE-----
+MIIDtTCCAp2gAwIBAgIQdrEgUnTwhYdGs/gjGvbCwDANBgkqhkiG9w0BAQsFADBt
+MQswCQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUg
+Rm91bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9i
+YWwgUm9vdCBHQiBDQTAeFw0xNDEyMDExNTAwMzJaFw0zOTEyMDExNTEwMzFaMG0x
+CzAJBgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBG
+b3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2Jh
+bCBSb290IEdCIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Be3
+HEokKtaXscriHvt9OO+Y9bI5mE4nuBFde9IllIiCFSZqGzG7qFshISvYD06fWvGx
+WuR51jIjK+FTzJlFXHtPrby/h0oLS5daqPZI7H17Dc0hBt+eFf1Biki3IPShehtX
+1F1Q/7pn2COZH8g/497/b1t3sWtuuMlk9+HKQUYOKXHQuSP8yYFfTvdv37+ErXNk
+u7dCjmn21HYdfp2nuFeKUWdy19SouJVUQHMD9ur06/4oQnc/nSMbsrY9gBQHTC5P
+99UKFg29ZkM3fiNDecNAhvVMKdqOmq0NpQSHiB6F4+lT1ZvIiwNjeOvgGUpuuy9r
+M2RYk61pv48b74JIxwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUNQ/INmNe4qPs+TtmFc5RUuORmj0wEAYJKwYBBAGCNxUB
+BAMCAQAwDQYJKoZIhvcNAQELBQADggEBAEBM+4eymYGQfp3FsLAmzYh7KzKNbrgh
+cViXfa43FK8+5/ea4n32cZiZBKpDdHij40lhPnOMTZTg+XHEthYOU3gf1qKHLwI5
+gSk8rxWYITD+KJAAjNHhy/peyP34EEY7onhCkRd0VQreUGdNZtGn//3ZwLWoo4rO
+ZvUPQ82nK1d7Y0Zqqi5S2PTt4W2tKZB4SLrhI6qjiey1q5bAtEuiHZeeevJuQHHf
+aPFlTc58Bd9TZaml8LGXBHAVRgOY1NK/VLSgWH1Sb9pWJmLU2NuJMW8c8CLC02Ic
+Nc1MaRVUGpCY3useX8p3x8uOPUNpnJpY0CQ73xtAln41rYHHTnG6iBM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Subject: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Label: "SZAFIR ROOT CA2"
+# Serial: 357043034767186914217277344587386743377558296292
+# MD5 Fingerprint: 11:64:c1:89:b0:24:b1:8c:b1:07:7e:89:9e:51:9e:99
+# SHA1 Fingerprint: e2:52:fa:95:3f:ed:db:24:60:bd:6e:28:f3:9c:cc:cf:5e:b3:3f:de
+# SHA256 Fingerprint: a1:33:9d:33:28:1a:0b:56:e5:57:d3:d3:2b:1c:e7:f9:36:7e:b0:94:bd:5f:a7:2a:7e:50:04:c8:de:d7:ca:fe
+-----BEGIN CERTIFICATE-----
+MIIDcjCCAlqgAwIBAgIUPopdB+xV0jLVt+O2XwHrLdzk1uQwDQYJKoZIhvcNAQEL
+BQAwUTELMAkGA1UEBhMCUEwxKDAmBgNVBAoMH0tyYWpvd2EgSXpiYSBSb3psaWN6
+ZW5pb3dhIFMuQS4xGDAWBgNVBAMMD1NaQUZJUiBST09UIENBMjAeFw0xNTEwMTkw
+NzQzMzBaFw0zNTEwMTkwNzQzMzBaMFExCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9L
+cmFqb3dhIEl6YmEgUm96bGljemVuaW93YSBTLkEuMRgwFgYDVQQDDA9TWkFGSVIg
+Uk9PVCBDQTIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC3vD5QqEvN
+QLXOYeeWyrSh2gwisPq1e3YAd4wLz32ohswmUeQgPYUM1ljj5/QqGJ3a0a4m7utT
+3PSQ1hNKDJA8w/Ta0o4NkjrcsbH/ON7Dui1fgLkCvUqdGw+0w8LBZwPd3BucPbOw
+3gAeqDRHu5rr/gsUvTaE2g0gv/pby6kWIK05YO4vdbbnl5z5Pv1+TW9NL++IDWr6
+3fE9biCloBK0TXC5ztdyO4mTp4CEHCdJckm1/zuVnsHMyAHs6A6KCpbns6aH5db5
+BSsNl0BwPLqsdVqc1U2dAgrSS5tmS0YHF2Wtn2yIANwiieDhZNRnvDF5YTy7ykHN
+XGoAyDw4jlivAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMB0GA1UdDgQWBBQuFqlKGLXLzPVvUPMjX/hd56zwyDANBgkqhkiG9w0BAQsF
+AAOCAQEAtXP4A9xZWx126aMqe5Aosk3AM0+qmrHUuOQn/6mWmc5G4G18TKI4pAZw
+8PRBEew/R40/cof5O/2kbytTAOD/OblqBw7rHRz2onKQy4I9EYKL0rufKq8h5mOG
+nXkZ7/e7DDWQw4rtTw/1zBLZpD67oPwglV9PJi8RI4NOdQcPv5vRtB3pEAT+ymCP
+oky4rc/hkA/NrgrHXXu3UNLUYfrVFdvXn4dRVOul4+vJhaAlIDf7js4MNIThPIGy
+d05DpYhfhmehPea0XGG2Ptv+tyjFogeutcrKjSoS75ftwjCkySp6+/NNIxuZMzSg
+LvWpCz/UXeHPhJ/iGcJfitYgHuNztw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA 2"
+# Serial: 44979900017204383099463764357512596969
+# MD5 Fingerprint: 6d:46:9e:d9:25:6d:08:23:5b:5e:74:7d:1e:27:db:f2
+# SHA1 Fingerprint: d3:dd:48:3e:2b:bf:4c:05:e8:af:10:f5:fa:76:26:cf:d3:dc:30:92
+# SHA256 Fingerprint: b6:76:f2:ed:da:e8:77:5c:d3:6c:b0:f6:3c:d1:d4:60:39:61:f4:9e:62:65:ba:01:3a:2f:03:07:b6:d0:b8:04
+-----BEGIN CERTIFICATE-----
+MIIF0jCCA7qgAwIBAgIQIdbQSk8lD8kyN/yqXhKN6TANBgkqhkiG9w0BAQ0FADCB
+gDELMAkGA1UEBhMCUEwxIjAgBgNVBAoTGVVuaXpldG8gVGVjaG5vbG9naWVzIFMu
+QS4xJzAlBgNVBAsTHkNlcnR1bSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEkMCIG
+A1UEAxMbQ2VydHVtIFRydXN0ZWQgTmV0d29yayBDQSAyMCIYDzIwMTExMDA2MDgz
+OTU2WhgPMjA0NjEwMDYwODM5NTZaMIGAMQswCQYDVQQGEwJQTDEiMCAGA1UEChMZ
+VW5pemV0byBUZWNobm9sb2dpZXMgUy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5MSQwIgYDVQQDExtDZXJ0dW0gVHJ1c3RlZCBOZXR3
+b3JrIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC9+Xj45tWA
+DGSdhhuWZGc/IjoedQF97/tcZ4zJzFxrqZHmuULlIEub2pt7uZld2ZuAS9eEQCsn
+0+i6MLs+CRqnSZXvK0AkwpfHp+6bJe+oCgCXhVqqndwpyeI1B+twTUrWwbNWuKFB
+OJvR+zF/j+Bf4bE/D44WSWDXBo0Y+aomEKsq09DRZ40bRr5HMNUuctHFY9rnY3lE
+fktjJImGLjQ/KUxSiyqnwOKRKIm5wFv5HdnnJ63/mgKXwcZQkpsCLL2puTRZCr+E
+Sv/f/rOf69me4Jgj7KZrdxYq28ytOxykh9xGc14ZYmhFV+SQgkK7QtbwYeDBoz1m
+o130GO6IyY0XRSmZMnUCMe4pJshrAua1YkV/NxVaI2iJ1D7eTiew8EAMvE0Xy02i
+sx7QBlrd9pPPV3WZ9fqGGmd4s7+W/jTcvedSVuWz5XV710GRBdxdaeOVDUO5/IOW
+OZV7bIBaTxNyxtd9KXpEulKkKtVBRgkg/iKgtlswjbyJDNXXcPiHUv3a76xRLgez
+Tv7QCdpw75j6VuZt27VXS9zlLCUVyJ4ueE742pyehizKV/Ma5ciSixqClnrDvFAS
+adgOWkaLOusm+iPJtrCBvkIApPjW/jAux9JG9uWOdf3yzLnQh1vMBhBgu4M1t15n
+3kfsmUjxpKEV/q2MYo45VU85FrmxY53/twIDAQABo0IwQDAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBS2oVQ5AsOgP46KvPrU+Bym0ToO/TAOBgNVHQ8BAf8EBAMC
+AQYwDQYJKoZIhvcNAQENBQADggIBAHGlDs7k6b8/ONWJWsQCYftMxRQXLYtPU2sQ
+F/xlhMcQSZDe28cmk4gmb3DWAl45oPePq5a1pRNcgRRtDoGCERuKTsZPpd1iHkTf
+CVn0W3cLN+mLIMb4Ck4uWBzrM9DPhmDJ2vuAL55MYIR4PSFk1vtBHxgP58l1cb29
+XN40hz5BsA72udY/CROWFC/emh1auVbONTqwX3BNXuMp8SMoclm2q8KMZiYcdywm
+djWLKKdpoPk79SPdhRB0yZADVpHnr7pH1BKXESLjokmUbOe3lEu6LaTaM4tMpkT/
+WjzGHWTYtTHkpjx6qFcL2+1hGsvxznN3Y6SHb0xRONbkX8eftoEq5IVIeVheO/jb
+AoJnwTnbw3RLPTYe+SmTiGhbqEQZIfCn6IENLOiTNrQ3ssqwGyZ6miUfmpqAnksq
+P/ujmv5zMnHCnsZy4YpoJ/HkD7TETKVhk/iXEAcqMCWpuchxuO9ozC1+9eB+D4Ko
+b7a6bINDd82Kkhehnlt4Fj1F4jNy3eFmypnTycUm/Q1oBEauttmbjL4ZvrHG8hnj
+XALKLNhvSgfZyTXaQHXyxKcZb55CEJh15pWLYLztxRLXis7VmFxWlgPF7ncGNf/P
+5O4/E2Hu29othfDNrp2yGAlFw5Khchf8R7agCyzxxN5DaAhqXzvwdmP7zAYspsbi
+DrW5viSP
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: ca:ff:e2:db:03:d9:cb:4b:e9:0f:ad:84:fd:7b:18:ce
+# SHA1 Fingerprint: 01:0c:06:95:a6:98:19:14:ff:bf:5f:c6:b0:b6:95:ea:29:e9:12:a6
+# SHA256 Fingerprint: a0:40:92:9a:02:ce:53:b4:ac:f4:f2:ff:c6:98:1c:e4:49:6f:75:5e:6d:45:fe:0b:2a:69:2b:cd:52:52:3f:36
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions ECC RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: 81:e5:b4:17:eb:c2:f5:e1:4b:0d:41:7b:49:92:fe:ef
+# SHA1 Fingerprint: 9f:f1:71:8d:92:d5:9a:f3:7d:74:97:b4:bc:6f:84:68:0b:ba:b6:66
+# SHA256 Fingerprint: 44:b5:45:aa:8a:25:e6:5a:73:ca:15:dc:27:fc:36:d2:4c:1c:b9:95:3a:06:65:39:b1:15:82:dc:48:7b:48:33
+-----BEGIN CERTIFICATE-----
+MIICwzCCAkqgAwIBAgIBADAKBggqhkjOPQQDAjCBqjELMAkGA1UEBhMCR1IxDzAN
+BgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxRDBCBgNVBAMTO0hl
+bGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgRUNDIFJv
+b3RDQSAyMDE1MB4XDTE1MDcwNzEwMzcxMloXDTQwMDYzMDEwMzcxMlowgaoxCzAJ
+BgNVBAYTAkdSMQ8wDQYDVQQHEwZBdGhlbnMxRDBCBgNVBAoTO0hlbGxlbmljIEFj
+YWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgQ2VydC4gQXV0aG9yaXR5
+MUQwQgYDVQQDEztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0
+dXRpb25zIEVDQyBSb290Q0EgMjAxNTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJKg
+QehLgoRc4vgxEZmGZE4JJS+dQS8KrjVPdJWyUWRrjWvmP3CV8AVER6ZyOFB2lQJa
+jq4onvktTpnvLEhvTCUp6NFxW98dwXU3tNf6e3pCnGoKVlp8aQuqgAkkbH7BRqNC
+MEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFLQi
+C4KZJAEOnLvkDv2/+5cgk5kqMAoGCCqGSM49BAMCA2cAMGQCMGfOFmI4oqxiRaep
+lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof
+TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR
+-----END CERTIFICATE-----
+
+# Issuer: CN=ISRG Root X1 O=Internet Security Research Group
+# Subject: CN=ISRG Root X1 O=Internet Security Research Group
+# Label: "ISRG Root X1"
+# Serial: 172886928669790476064670243504169061120
+# MD5 Fingerprint: 0c:d2:f9:e0:da:17:73:e9:ed:86:4d:a5:e3:70:e7:4e
+# SHA1 Fingerprint: ca:bd:2a:79:a1:07:6a:31:f2:1d:25:36:35:cb:03:9d:43:29:a5:e8
+# SHA256 Fingerprint: 96:bc:ec:06:26:49:76:f3:74:60:77:9a:cf:28:c5:a7:cf:e8:a3:c0:aa:e1:1a:8f:fc:ee:05:c0:bd:df:08:c6
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----
+
+# Issuer: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Subject: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Label: "AC RAIZ FNMT-RCM"
+# Serial: 485876308206448804701554682760554759
+# MD5 Fingerprint: e2:09:04:b4:d3:bd:d1:a0:14:fd:1a:d2:47:c4:57:1d
+# SHA1 Fingerprint: ec:50:35:07:b2:15:c4:95:62:19:e2:a8:9a:5b:42:99:2c:4c:2c:20
+# SHA256 Fingerprint: eb:c5:57:0c:29:01:8c:4d:67:b1:aa:12:7b:af:12:f7:03:b4:61:1e:bc:17:b7:da:b5:57:38:94:17:9b:93:fa
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIPXZONMGc2yAYdGsdUhGkHMA0GCSqGSIb3DQEBCwUAMDsx
+CzAJBgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJ
+WiBGTk1ULVJDTTAeFw0wODEwMjkxNTU5NTZaFw0zMDAxMDEwMDAwMDBaMDsxCzAJ
+BgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJWiBG
+Tk1ULVJDTTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALpxgHpMhm5/
+yBNtwMZ9HACXjywMI7sQmkCpGreHiPibVmr75nuOi5KOpyVdWRHbNi63URcfqQgf
+BBckWKo3Shjf5TnUV/3XwSyRAZHiItQDwFj8d0fsjz50Q7qsNI1NOHZnjrDIbzAz
+WHFctPVrbtQBULgTfmxKo0nRIBnuvMApGGWn3v7v3QqQIecaZ5JCEJhfTzC8PhxF
+tBDXaEAUwED653cXeuYLj2VbPNmaUtu1vZ5Gzz3rkQUCwJaydkxNEJY7kvqcfw+Z
+374jNUUeAlz+taibmSXaXvMiwzn15Cou08YfxGyqxRxqAQVKL9LFwag0Jl1mpdIC
+IfkYtwb1TplvqKtMUejPUBjFd8g5CSxJkjKZqLsXF3mwWsXmo8RZZUc1g16p6DUL
+mbvkzSDGm0oGObVo/CK67lWMK07q87Hj/LaZmtVC+nFNCM+HHmpxffnTtOmlcYF7
+wk5HlqX2doWjKI/pgG6BU6VtX7hI+cL5NqYuSf+4lsKMB7ObiFj86xsc3i1w4peS
+MKGJ47xVqCfWS+2QrYv6YyVZLag13cqXM7zlzced0ezvXg5KkAYmY6252TUtB7p2
+ZSysV4999AeU14ECll2jB0nVetBX+RvnU0Z1qrB5QstocQjpYL05ac70r8NWQMet
+UqIJ5G+GR4of6ygnXYMgrwTJbFaai0b1AgMBAAGjgYMwgYAwDwYDVR0TAQH/BAUw
+AwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFPd9xf3E6Jobd2Sn9R2gzL+H
+YJptMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vd3d3
+LmNlcnQuZm5tdC5lcy9kcGNzLzANBgkqhkiG9w0BAQsFAAOCAgEAB5BK3/MjTvDD
+nFFlm5wioooMhfNzKWtN/gHiqQxjAb8EZ6WdmF/9ARP67Jpi6Yb+tmLSbkyU+8B1
+RXxlDPiyN8+sD8+Nb/kZ94/sHvJwnvDKuO+3/3Y3dlv2bojzr2IyIpMNOmqOFGYM
+LVN0V2Ue1bLdI4E7pWYjJ2cJj+F3qkPNZVEI7VFY/uY5+ctHhKQV8Xa7pO6kO8Rf
+77IzlhEYt8llvhjho6Tc+hj507wTmzl6NLrTQfv6MooqtyuGC2mDOL7Nii4LcK2N
+JpLuHvUBKwrZ1pebbuCoGRw6IYsMHkCtA+fdZn71uSANA+iW+YJF1DngoABd15jm
+fZ5nc8OaKveri6E6FO80vFIOiZiaBECEHX5FaZNXzuvO+FB8TxxuBEOb+dY7Ixjp
+6o7RTUaN8Tvkasq6+yO3m/qZASlaWFot4/nUbQ4mrcFuNLwy+AwF+mWj2zs3gyLp
+1txyM/1d8iC9djwj2ij3+RvrWWTV3F9yfiD8zYm1kGdNYno/Tq0dwzn+evQoFt9B
+9kiABdcPUXmsEKvU7ANm5mqwujGSQkBqvjrTcuFqN1W8rB2Vt2lh8kORdOag0wok
+RqEIr9baRRmW1FMdW4R58MD3R++Lj8UGrp1MYp3/RgT408m2ECVAdf4WqslKYIYv
+uu8wd+RU4riEmViAqhOLUTpPSPaLtrM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 1 O=Amazon
+# Subject: CN=Amazon Root CA 1 O=Amazon
+# Label: "Amazon Root CA 1"
+# Serial: 143266978916655856878034712317230054538369994
+# MD5 Fingerprint: 43:c6:bf:ae:ec:fe:ad:2f:18:c6:88:68:30:fc:c8:e6
+# SHA1 Fingerprint: 8d:a7:f9:65:ec:5e:fc:37:91:0f:1c:6e:59:fd:c1:cc:6a:6e:de:16
+# SHA256 Fingerprint: 8e:cd:e6:88:4f:3d:87:b1:12:5b:a3:1a:c3:fc:b1:3d:70:16:de:7f:57:cc:90:4f:e1:cb:97:c6:ae:98:19:6e
+-----BEGIN CERTIFICATE-----
+MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
+ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
+9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
+IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
+VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
+93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
+jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
+A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
+U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
+N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
+o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
+5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
+rqXRfboQnoZsG4q5WTP468SQvvG5
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 2 O=Amazon
+# Subject: CN=Amazon Root CA 2 O=Amazon
+# Label: "Amazon Root CA 2"
+# Serial: 143266982885963551818349160658925006970653239
+# MD5 Fingerprint: c8:e5:8d:ce:a8:42:e2:7a:c0:2a:5c:7c:9e:26:bf:66
+# SHA1 Fingerprint: 5a:8c:ef:45:d7:a6:98:59:76:7a:8c:8b:44:96:b5:78:cf:47:4b:1a
+# SHA256 Fingerprint: 1b:a5:b2:aa:8c:65:40:1a:82:96:01:18:f8:0b:ec:4f:62:30:4d:83:ce:c4:71:3a:19:c3:9c:01:1e:a4:6d:b4
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK
+gXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ
+W0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg
+1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K
+8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r
+2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me
+z/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR
+8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj
+mUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz
+7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6
++XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI
+0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB
+Af8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm
+UjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2
+LIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY
++gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS
+k5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl
+7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm
+btmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl
+urR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+
+fUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63
+n749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE
+76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H
+9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT
+4PsJYGw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 3 O=Amazon
+# Subject: CN=Amazon Root CA 3 O=Amazon
+# Label: "Amazon Root CA 3"
+# Serial: 143266986699090766294700635381230934788665930
+# MD5 Fingerprint: a0:d4:ef:0b:f7:b5:d8:49:95:2a:ec:f5:c4:fc:81:87
+# SHA1 Fingerprint: 0d:44:dd:8c:3c:8c:1a:1a:58:75:64:81:e9:0f:2e:2a:ff:b3:d2:6e
+# SHA256 Fingerprint: 18:ce:6c:fe:7b:f1:4e:60:b2:e3:47:b8:df:e8:68:cb:31:d0:2e:bb:3a:da:27:15:69:f5:03:43:b4:6d:b3:a4
+-----BEGIN CERTIFICATE-----
+MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl
+ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr
+ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr
+BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM
+YyRIHN8wfdVoOw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 4 O=Amazon
+# Subject: CN=Amazon Root CA 4 O=Amazon
+# Label: "Amazon Root CA 4"
+# Serial: 143266989758080763974105200630763877849284878
+# MD5 Fingerprint: 89:bc:27:d5:eb:17:8d:06:6a:69:d5:fd:89:47:b4:cd
+# SHA1 Fingerprint: f6:10:84:07:d6:f8:bb:67:98:0c:c2:e2:44:c2:eb:ae:1c:ef:63:be
+# SHA256 Fingerprint: e3:5d:28:41:9e:d0:20:25:cf:a6:90:38:cd:62:39:62:45:8d:a5:c6:95:fb:de:a3:c2:2b:0b:fb:25:89:70:92
+-----BEGIN CERTIFICATE-----
+MIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi
+9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk
+M6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB
+/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB
+MAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw
+CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW
+1KyLa2tJElMzrdfkviT8tQp21KW8EA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Subject: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Label: "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1"
+# Serial: 1
+# MD5 Fingerprint: dc:00:81:dc:69:2f:3e:2f:b0:3b:f6:3d:5a:91:8e:49
+# SHA1 Fingerprint: 31:43:64:9b:ec:ce:27:ec:ed:3a:3f:0b:8f:0d:e4:e8:91:dd:ee:ca
+# SHA256 Fingerprint: 46:ed:c3:68:90:46:d5:3a:45:3f:b3:10:4a:b8:0d:ca:ec:65:8b:26:60:ea:16:29:dd:7e:86:79:90:64:87:16
+-----BEGIN CERTIFICATE-----
+MIIEYzCCA0ugAwIBAgIBATANBgkqhkiG9w0BAQsFADCB0jELMAkGA1UEBhMCVFIx
+GDAWBgNVBAcTD0dlYnplIC0gS29jYWVsaTFCMEAGA1UEChM5VHVya2l5ZSBCaWxp
+bXNlbCB2ZSBUZWtub2xvamlrIEFyYXN0aXJtYSBLdXJ1bXUgLSBUVUJJVEFLMS0w
+KwYDVQQLEyRLYW11IFNlcnRpZmlrYXN5b24gTWVya2V6aSAtIEthbXUgU00xNjA0
+BgNVBAMTLVRVQklUQUsgS2FtdSBTTSBTU0wgS29rIFNlcnRpZmlrYXNpIC0gU3Vy
+dW0gMTAeFw0xMzExMjUwODI1NTVaFw00MzEwMjUwODI1NTVaMIHSMQswCQYDVQQG
+EwJUUjEYMBYGA1UEBxMPR2ViemUgLSBLb2NhZWxpMUIwQAYDVQQKEzlUdXJraXll
+IEJpbGltc2VsIHZlIFRla25vbG9qaWsgQXJhc3Rpcm1hIEt1cnVtdSAtIFRVQklU
+QUsxLTArBgNVBAsTJEthbXUgU2VydGlmaWthc3lvbiBNZXJrZXppIC0gS2FtdSBT
+TTE2MDQGA1UEAxMtVFVCSVRBSyBLYW11IFNNIFNTTCBLb2sgU2VydGlmaWthc2kg
+LSBTdXJ1bSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr3UwM6q7
+a9OZLBI3hNmNe5eA027n/5tQlT6QlVZC1xl8JoSNkvoBHToP4mQ4t4y86Ij5iySr
+LqP1N+RAjhgleYN1Hzv/bKjFxlb4tO2KRKOrbEz8HdDc72i9z+SqzvBV96I01INr
+N3wcwv61A+xXzry0tcXtAA9TNypN9E8Mg/uGz8v+jE69h/mniyFXnHrfA2eJLJ2X
+YacQuFWQfw4tJzh03+f92k4S400VIgLI4OD8D62K18lUUMw7D8oWgITQUVbDjlZ/
+iSIzL+aFCr2lqBs23tPcLG07xxO9WSMs5uWk99gL7eqQQESolbuT1dCANLZGeA4f
+AJNG4e7p+exPFwIDAQABo0IwQDAdBgNVHQ4EFgQUZT/HiobGPN08VFw1+DrtUgxH
+V8gwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBACo/4fEyjq7hmFxLXs9rHmoJ0iKpEsdeV31zVmSAhHqT5Am5EM2fKifh
+AHe+SMg1qIGf5LgsyX8OsNJLN13qudULXjS99HMpw+0mFZx+CFOKWI3QSyjfwbPf
+IPP54+M638yclNhOT8NrF7f3cuitZjO1JVOr4PhMqZ398g26rrnZqsZr+ZO7rqu4
+lzwDGrpDxpa5RXI4s6ehlj2Re37AIVNMh+3yC1SVUZPVIqUNivGTDj5UDrDYyU7c
+8jEyVupk+eq1nRZmQnLzf9OxMUP8pI4X8W0jq5Rm+K37DwhuJi1/FwcJsoz7UMCf
+lo3Ptv0AnVoUmr8CRPXBwp8iXqIPoeM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Subject: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Label: "GDCA TrustAUTH R5 ROOT"
+# Serial: 9009899650740120186
+# MD5 Fingerprint: 63:cc:d9:3d:34:35:5c:6f:53:a3:e2:08:70:48:1f:b4
+# SHA1 Fingerprint: 0f:36:38:5b:81:1a:25:c3:9b:31:4e:83:ca:e9:34:66:70:cc:74:b4
+# SHA256 Fingerprint: bf:ff:8f:d0:44:33:48:7d:6a:8a:a6:0c:1a:29:76:7a:9f:c2:bb:b0:5e:42:0f:71:3a:13:b9:92:89:1d:38:93
+-----BEGIN CERTIFICATE-----
+MIIFiDCCA3CgAwIBAgIIfQmX/vBH6nowDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE
+BhMCQ04xMjAwBgNVBAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZ
+IENPLixMVEQuMR8wHQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMB4XDTE0
+MTEyNjA1MTMxNVoXDTQwMTIzMTE1NTk1OVowYjELMAkGA1UEBhMCQ04xMjAwBgNV
+BAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZIENPLixMVEQuMR8w
+HQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMIICIjANBgkqhkiG9w0BAQEF
+AAOCAg8AMIICCgKCAgEA2aMW8Mh0dHeb7zMNOwZ+Vfy1YI92hhJCfVZmPoiC7XJj
+Dp6L3TQsAlFRwxn9WVSEyfFrs0yw6ehGXTjGoqcuEVe6ghWinI9tsJlKCvLriXBj
+TnnEt1u9ol2x8kECK62pOqPseQrsXzrj/e+APK00mxqriCZ7VqKChh/rNYmDf1+u
+KU49tm7srsHwJ5uu4/Ts765/94Y9cnrrpftZTqfrlYwiOXnhLQiPzLyRuEH3FMEj
+qcOtmkVEs7LXLM3GKeJQEK5cy4KOFxg2fZfmiJqwTTQJ9Cy5WmYqsBebnh52nUpm
+MUHfP/vFBu8btn4aRjb3ZGM74zkYI+dndRTVdVeSN72+ahsmUPI2JgaQxXABZG12
+ZuGR224HwGGALrIuL4xwp9E7PLOR5G62xDtw8mySlwnNR30YwPO7ng/Wi64HtloP
+zgsMR6flPri9fcebNaBhlzpBdRfMK5Z3KpIhHtmVdiBnaM8Nvd/WHwlqmuLMc3Gk
+L30SgLdTMEZeS1SZD2fJpcjyIMGC7J0R38IC+xo70e0gmu9lZJIQDSri3nDxGGeC
+jGHeuLzRL5z7D9Ar7Rt2ueQ5Vfj4oR24qoAATILnsn8JuLwwoC8N9VKejveSswoA
+HQBUlwbgsQfZxw9cZX08bVlX5O2ljelAU58VS6Bx9hoh49pwBiFYFIeFd3mqgnkC
+AwEAAaNCMEAwHQYDVR0OBBYEFOLJQJ9NzuiaoXzPDj9lxSmIahlRMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQDRSVfg
+p8xoWLoBDysZzY2wYUWsEe1jUGn4H3++Fo/9nesLqjJHdtJnJO29fDMylyrHBYZm
+DRd9FBUb1Ov9H5r2XpdptxolpAqzkT9fNqyL7FeoPueBihhXOYV0GkLH6VsTX4/5
+COmSdI31R9KrO9b7eGZONn356ZLpBN79SWP8bfsUcZNnL0dKt7n/HipzcEYwv1ry
+L3ml4Y0M2fmyYzeMN2WFcGpcWwlyua1jPLHd+PwyvzeG5LuOmCd+uh8W4XAR8gPf
+JWIyJyYYMoSf/wA6E7qaTfRPuBRwIrHKK5DOKcFw9C+df/KQHtZa37dG/OaG+svg
+IHZ6uqbL9XzeYqWxi+7egmaKTjowHz+Ay60nugxe19CxVsp3cbK1daFQqUBDF8Io
+2c9Si1vIY9RCPqAzekYu9wogRlR+ak8x8YF+QnQ4ZXMn7sZ8uI7XpTrXmKGcjBBV
+09tL7ECQ8s1uV9JiDnxXk7Gnbc2dg7sq5+W2O3FYrf3RRbxake5TFW/TRQl1brqQ
+XR4EzzffHqhmsYzmIGrv/EhOdJhCrylvLmrH+33RZjEizIYAfmaDDEL0vTSSwxrq
+T8p+ck0LcIymSLumoRT2+1hEmRSuqguTaaApJUqlyyvdimYHFngVV3Eb7PVHhPOe
+MTd61X8kreS8/f3MboPoDKi3QWwH3b08hpcv0g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Label: "SSL.com Root Certification Authority RSA"
+# Serial: 8875640296558310041
+# MD5 Fingerprint: 86:69:12:c0:70:f1:ec:ac:ac:c2:d5:bc:a5:5b:a1:29
+# SHA1 Fingerprint: b7:ab:33:08:d1:ea:44:77:ba:14:80:12:5a:6f:bd:a9:36:49:0c:bb
+# SHA256 Fingerprint: 85:66:6a:56:2e:e0:be:5c:e9:25:c1:d8:89:0a:6f:76:a8:7e:c1:6d:4d:7d:5f:29:ea:74:19:cf:20:12:3b:69
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com Root Certification Authority ECC"
+# Serial: 8495723813297216424
+# MD5 Fingerprint: 2e:da:e4:39:7f:9c:8f:37:d1:70:9f:26:17:51:3a:8e
+# SHA1 Fingerprint: c3:19:7c:39:24:e6:54:af:1b:c4:ab:20:95:7a:e2:c3:0e:13:02:6a
+# SHA256 Fingerprint: 34:17:bb:06:cc:60:07:da:1b:96:1c:92:0b:8a:b4:ce:3f:ad:82:0e:4a:a3:0b:9a:cb:c4:a7:4e:bd:ce:bc:65
+-----BEGIN CERTIFICATE-----
+MIICjTCCAhSgAwIBAgIIdebfy8FoW6gwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZpY2F0
+aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNDAzWhcNNDEwMjEyMTgxNDAz
+WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0
+b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNvbSBS
+b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABEVuqVDEpiM2nl8ojRfLliJkP9x6jh3MCLOicSS6jkm5BBtHllirLZXI
+7Z4INcgn64mMU1jrYor+8FsPazFSY0E7ic3s7LaNGdM0B9y7xgZ/wkWV7Mt/qCPg
+CemB+vNH06NjMGEwHQYDVR0OBBYEFILRhXMw5zUE044CkvvlpNHEIejNMA8GA1Ud
+EwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUgtGFczDnNQTTjgKS++Wk0cQh6M0wDgYD
+VR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2cAMGQCMG/n61kRpGDPYbCWe+0F+S8T
+kdzt5fxQaxFGRrMcIQBiu77D5+jNB5n5DQtdcj7EqgIwH7y6C+IwJPt8bYBVCpk+
+gA0z5Wajs6O7pdWLjwkspl1+4vAHCGht0nxpbl/f5Wpl
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority RSA R2"
+# Serial: 6248227494352943350
+# MD5 Fingerprint: e1:1e:31:58:1a:ae:54:53:02:f6:17:6a:11:7b:4d:95
+# SHA1 Fingerprint: 74:3a:f0:52:9b:d0:32:a0:f4:4a:83:cd:d4:ba:a9:7b:7c:2e:c4:9a
+# SHA256 Fingerprint: 2e:7b:f1:6c:c2:24:85:a7:bb:e2:aa:86:96:75:07:61:b0:ae:39:be:3b:2f:e9:d0:cc:6d:4e:f7:34:91:42:5c
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority ECC"
+# Serial: 3182246526754555285
+# MD5 Fingerprint: 59:53:22:65:83:42:01:54:c0:ce:42:b9:5a:7c:f2:90
+# SHA1 Fingerprint: 4c:dd:51:a3:d1:f5:20:32:14:b0:c6:c5:32:23:03:91:c7:46:42:6d
+# SHA256 Fingerprint: 22:a2:c1:f7:bd:ed:70:4c:c1:e7:01:b5:f4:08:c3:10:88:0f:e9:56:b5:de:2a:4a:44:f9:9c:87:3a:25:a7:c8
+-----BEGIN CERTIFICATE-----
+MIIClDCCAhqgAwIBAgIILCmcWxbtBZUwCgYIKoZIzj0EAwIwfzELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xNDAyBgNVBAMMK1NTTC5jb20gRVYgUm9vdCBDZXJ0aWZp
+Y2F0aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNTIzWhcNNDEwMjEyMTgx
+NTIzWjB/MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv
+dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjE0MDIGA1UEAwwrU1NMLmNv
+bSBFViBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49
+AgEGBSuBBAAiA2IABKoSR5CYG/vvw0AHgyBO8TCCogbR8pKGYfL2IWjKAMTH6kMA
+VIbc/R/fALhBYlzccBYy3h+Z1MzFB8gIH2EWB1E9fVwHU+M1OIzfzZ/ZLg1Kthku
+WnBaBu2+8KGwytAJKaNjMGEwHQYDVR0OBBYEFFvKXuXe0oGqzagtZFG22XKbl+ZP
+MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX
+5k8wDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2gAMGUCMQCK5kCJN+vp1RPZ
+ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg
+h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Label: "GlobalSign Root CA - R6"
+# Serial: 1417766617973444989252670301619537
+# MD5 Fingerprint: 4f:dd:07:e4:d4:22:64:39:1e:0c:37:42:ea:d1:c6:ae
+# SHA1 Fingerprint: 80:94:64:0e:b5:a7:a1:ca:11:9c:1f:dd:d5:9f:81:02:63:a7:fb:d1
+# SHA256 Fingerprint: 2c:ab:ea:fe:37:d0:6c:a2:2a:ba:73:91:c0:03:3d:25:98:29:52:c4:53:64:73:49:76:3a:3a:b5:ad:6c:cf:69
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
+MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
+MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
+MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
+KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
+xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
+ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
+aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
+LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
+1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
+k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
+SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
+bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
+WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
+rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
+MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
+bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
+nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
+Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
+55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
+vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
+cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
+oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
+nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
+pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
+JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
+8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
+5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GC CA"
+# Serial: 44084345621038548146064804565436152554
+# MD5 Fingerprint: a9:d6:b9:2d:2f:93:64:f8:a5:69:ca:91:e9:68:07:23
+# SHA1 Fingerprint: e0:11:84:5e:34:de:be:88:81:b9:9c:f6:16:26:d1:96:1f:c3:b9:31
+# SHA256 Fingerprint: 85:60:f9:1c:36:24:da:ba:95:70:b5:fe:a0:db:e3:6f:f1:1a:83:23:be:94:86:85:4f:b3:f3:4a:55:71:19:8d
+-----BEGIN CERTIFICATE-----
+MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw
+CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91
+bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg
+Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ
+BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu
+ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS
+b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni
+eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W
+p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T
+rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV
+57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg
+Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Global G2 Root O=UniTrust
+# Subject: CN=UCA Global G2 Root O=UniTrust
+# Label: "UCA Global G2 Root"
+# Serial: 124779693093741543919145257850076631279
+# MD5 Fingerprint: 80:fe:f0:c4:4a:f0:5c:62:32:9f:1c:ba:78:a9:50:f8
+# SHA1 Fingerprint: 28:f9:78:16:19:7a:ff:18:25:18:aa:44:fe:c1:a0:ce:5c:b6:4c:8a
+# SHA256 Fingerprint: 9b:ea:11:c9:76:fe:01:47:64:c1:be:56:a6:f9:14:b5:a5:60:31:7a:bd:99:88:39:33:82:e5:16:1a:a0:49:3c
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIQXd+x2lqj7V2+WmUgZQOQ7zANBgkqhkiG9w0BAQsFADA9
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxGzAZBgNVBAMMElVDQSBH
+bG9iYWwgRzIgUm9vdDAeFw0xNjAzMTEwMDAwMDBaFw00MDEyMzEwMDAwMDBaMD0x
+CzAJBgNVBAYTAkNOMREwDwYDVQQKDAhVbmlUcnVzdDEbMBkGA1UEAwwSVUNBIEds
+b2JhbCBHMiBSb290MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeYr
+b3zvJgUno4Ek2m/LAfmZmqkywiKHYUGRO8vDaBsGxUypK8FnFyIdK+35KYmToni9
+kmugow2ifsqTs6bRjDXVdfkX9s9FxeV67HeToI8jrg4aA3++1NDtLnurRiNb/yzm
+VHqUwCoV8MmNsHo7JOHXaOIxPAYzRrZUEaalLyJUKlgNAQLx+hVRZ2zA+te2G3/R
+VogvGjqNO7uCEeBHANBSh6v7hn4PJGtAnTRnvI3HLYZveT6OqTwXS3+wmeOwcWDc
+C/Vkw85DvG1xudLeJ1uK6NjGruFZfc8oLTW4lVYa8bJYS7cSN8h8s+1LgOGN+jIj
+tm+3SJUIsUROhYw6AlQgL9+/V087OpAh18EmNVQg7Mc/R+zvWr9LesGtOxdQXGLY
+D0tK3Cv6brxzks3sx1DoQZbXqX5t2Okdj4q1uViSukqSKwxW/YDrCPBeKW4bHAyv
+j5OJrdu9o54hyokZ7N+1wxrrFv54NkzWbtA+FxyQF2smuvt6L78RHBgOLXMDj6Dl
+NaBa4kx1HXHhOThTeEDMg5PXCp6dW4+K5OXgSORIskfNTip1KnvyIvbJvgmRlld6
+iIis7nCs+dwp4wwcOxJORNanTrAmyPPZGpeRaOrvjUYG0lZFWJo8DA+DuAUlwznP
+O6Q0ibd5Ei9Hxeepl2n8pndntd978XplFeRhVmUCAwEAAaNCMEAwDgYDVR0PAQH/
+BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIHEjMz15DD/pQwIX4wV
+ZyF0Ad/fMA0GCSqGSIb3DQEBCwUAA4ICAQATZSL1jiutROTL/7lo5sOASD0Ee/oj
+L3rtNtqyzm325p7lX1iPyzcyochltq44PTUbPrw7tgTQvPlJ9Zv3hcU2tsu8+Mg5
+1eRfB70VVJd0ysrtT7q6ZHafgbiERUlMjW+i67HM0cOU2kTC5uLqGOiiHycFutfl
+1qnN3e92mI0ADs0b+gO3joBYDic/UvuUospeZcnWhNq5NXHzJsBPd+aBJ9J3O5oU
+b3n09tDh05S60FdRvScFDcH9yBIw7m+NESsIndTUv4BFFJqIRNow6rSn4+7vW4LV
+PtateJLbXDzz2K36uGt/xDYotgIVilQsnLAXc47QN6MUPJiVAAwpBVueSUmxX8fj
+y88nZY41F7dXyDDZQVu5FLbowg+UMaeUmMxq67XhJ/UQqAHojhJi6IjMtX9Gl8Cb
+EGY4GjZGXyJoPd/JxhMnq1MGrKI8hgZlb7F+sSlEmqO6SWkoaY/X5V+tBIZkbxqg
+DMUIYs6Ao9Dz7GjevjPHF1t/gMRMTLGmhIrDO7gJzRSBuhjjVFc2/tsvfEehOjPI
++Vg7RE+xygKJBJYoaMVLuCaJu9YzL1DV/pqJuhgyklTGW+Cd+V7lDSKb9triyCGy
+YiGqhkCyLmTTX8jjfhFnRR8F/uOi77Oos/N9j/gMHyIfLXC0uAE0djAA5SN4p1bX
+UB+K+wb1whnw0A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Extended Validation Root O=UniTrust
+# Subject: CN=UCA Extended Validation Root O=UniTrust
+# Label: "UCA Extended Validation Root"
+# Serial: 106100277556486529736699587978573607008
+# MD5 Fingerprint: a1:f3:5f:43:c6:34:9b:da:bf:8c:7e:05:53:ad:96:e2
+# SHA1 Fingerprint: a3:a1:b0:6f:24:61:23:4a:e3:36:a5:c2:37:fc:a6:ff:dd:f0:d7:3a
+# SHA256 Fingerprint: d4:3a:f9:b3:54:73:75:5c:96:84:fc:06:d7:d8:cb:70:ee:5c:28:e7:73:fb:29:4e:b4:1e:e7:17:22:92:4d:24
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQT9Irj/VkyDOeTzRYZiNwYDANBgkqhkiG9w0BAQsFADBH
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNVBAMMHFVDQSBF
+eHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwHhcNMTUwMzEzMDAwMDAwWhcNMzgxMjMx
+MDAwMDAwWjBHMQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNV
+BAMMHFVDQSBFeHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCpCQcoEwKwmeBkqh5DFnpzsZGgdT6o+uM4AHrsiWog
+D4vFsJszA1qGxliG1cGFu0/GnEBNyr7uaZa4rYEwmnySBesFK5pI0Lh2PpbIILvS
+sPGP2KxFRv+qZ2C0d35qHzwaUnoEPQc8hQ2E0B92CvdqFN9y4zR8V05WAT558aop
+O2z6+I9tTcg1367r3CTueUWnhbYFiN6IXSV8l2RnCdm/WhUFhvMJHuxYMjMR83dk
+sHYf5BA1FxvyDrFspCqjc/wJHx4yGVMR59mzLC52LqGj3n5qiAno8geK+LLNEOfi
+c0CTuwjRP+H8C5SzJe98ptfRr5//lpr1kXuYC3fUfugH0mK1lTnj8/FtDw5lhIpj
+VMWAtuCeS31HJqcBCF3RiJ7XwzJE+oJKCmhUfzhTA8ykADNkUVkLo4KRel7sFsLz
+KuZi2irbWWIQJUoqgQtHB0MGcIfS+pMRKXpITeuUx3BNr2fVUbGAIAEBtHoIppB/
+TuDvB0GHr2qlXov7z1CymlSvw4m6WC31MJixNnI5fkkE/SmnTHnkBVfblLkWU41G
+sx2VYVdWf6/wFlthWG82UBEL2KwrlRYaDh8IzTY0ZRBiZtWAXxQgXy0MoHgKaNYs
+1+lvK9JKBZP8nm9rZ/+I8U6laUpSNwXqxhaN0sSZ0YIrO7o1dfdRUVjzyAfd5LQD
+fwIDAQABo0IwQDAdBgNVHQ4EFgQU2XQ65DA9DfcS3H5aBZ8eNJr34RQwDwYDVR0T
+AQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQADggIBADaN
+l8xCFWQpN5smLNb7rhVpLGsaGvdftvkHTFnq88nIua7Mui563MD1sC3AO6+fcAUR
+ap8lTwEpcOPlDOHqWnzcSbvBHiqB9RZLcpHIojG5qtr8nR/zXUACE/xOHAbKsxSQ
+VBcZEhrxH9cMaVr2cXj0lH2RC47skFSOvG+hTKv8dGT9cZr4QQehzZHkPJrgmzI5
+c6sq1WnIeJEmMX3ixzDx/BR4dxIOE/TdFpS/S2d7cFOFyrC78zhNLJA5wA3CXWvp
+4uXViI3WLL+rG761KIcSF3Ru/H38j9CHJrAb+7lsq+KePRXBOy5nAliRn+/4Qh8s
+t2j1da3Ptfb/EX3C8CSlrdP6oDyp+l3cpaDvRKS+1ujl5BOWF3sGPjLtx7dCvHaj
+2GU4Kzg1USEODm8uNBNA4StnDG1KQTAYI1oyVZnJF+A83vbsea0rWBmirSwiGpWO
+vpaQXUJXxPkUAzUrHC1RVwinOt4/5Mi0A3PCwSaAuwtCH60NryZy2sy+s6ODWA2C
+xR9GUeOcGMyNm43sSet1UNWMKFnKdDTajAshqx7qG+XH/RU+wBeq+yNuJkbL+vmx
+cmtpzyKEC2IPrNkZAJSidjzULZrtBJ4tBmIQN1IchXIbJ+XMxjHsN+xjWZsLHXbM
+fjKaiJUINlK73nZfdklJrX+9ZSCyycErdhh2n1ax
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Subject: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Label: "Certigna Root CA"
+# Serial: 269714418870597844693661054334862075617
+# MD5 Fingerprint: 0e:5c:30:62:27:eb:5b:bc:d7:ae:62:ba:e9:d5:df:77
+# SHA1 Fingerprint: 2d:0d:52:14:ff:9e:ad:99:24:01:74:20:47:6e:6c:85:27:27:f5:43
+# SHA256 Fingerprint: d4:8d:3d:23:ee:db:50:a4:59:e5:51:97:60:1c:27:77:4b:9d:7b:18:c9:4d:5a:05:95:11:a1:02:50:b9:31:68
+-----BEGIN CERTIFICATE-----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=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign Root CA - G1"
+# Serial: 235931866688319308814040
+# MD5 Fingerprint: 9c:42:84:57:dd:cb:0b:a7:2e:95:ad:b6:f3:da:bc:ac
+# SHA1 Fingerprint: 8a:c7:ad:8f:73:ac:4e:c1:b5:75:4d:a5:40:f4:fc:cf:7c:b5:8e:8c
+# SHA256 Fingerprint: 40:f6:af:03:46:a9:9a:a1:cd:1d:55:5a:4e:9c:ce:62:c7:f9:63:46:03:ee:40:66:15:83:3d:c8:c8:d0:03:67
+-----BEGIN CERTIFICATE-----
+MIIDlDCCAnygAwIBAgIKMfXkYgxsWO3W2DANBgkqhkiG9w0BAQsFADBnMQswCQYD
+VQQGEwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBU
+ZWNobm9sb2dpZXMgTGltaXRlZDEcMBoGA1UEAxMTZW1TaWduIFJvb3QgQ0EgLSBH
+MTAeFw0xODAyMTgxODMwMDBaFw00MzAyMTgxODMwMDBaMGcxCzAJBgNVBAYTAklO
+MRMwEQYDVQQLEwplbVNpZ24gUEtJMSUwIwYDVQQKExxlTXVkaHJhIFRlY2hub2xv
+Z2llcyBMaW1pdGVkMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEcxMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAk0u76WaK7p1b1TST0Bsew+eeuGQz
+f2N4aLTNLnF115sgxk0pvLZoYIr3IZpWNVrzdr3YzZr/k1ZLpVkGoZM0Kd0WNHVO
+8oG0x5ZOrRkVUkr+PHB1cM2vK6sVmjM8qrOLqs1D/fXqcP/tzxE7lM5OMhbTI0Aq
+d7OvPAEsbO2ZLIvZTmmYsvePQbAyeGHWDV/D+qJAkh1cF+ZwPjXnorfCYuKrpDhM
+tTk1b+oDafo6VGiFbdbyL0NVHpENDtjVaqSW0RM8LHhQ6DqS0hdW5TUaQBw+jSzt
+Od9C4INBdN+jzcKGYEho42kLVACL5HZpIQ15TjQIXhTCzLG3rdd8cIrHhQIDAQAB
+o0IwQDAdBgNVHQ4EFgQU++8Nhp6w492pufEhF38+/PB3KxowDgYDVR0PAQH/BAQD
+AgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAFn/8oz1h31x
+PaOfG1vR2vjTnGs2vZupYeveFix0PZ7mddrXuqe8QhfnPZHr5X3dPpzxz5KsbEjM
+wiI/aTvFthUvozXGaCocV685743QNcMYDHsAVhzNixl03r4PEuDQqqE/AjSxcM6d
+GNYIAwlG7mDgfrbESQRRfXBgvKqy/3lyeqYdPV8q+Mri/Tm3R7nrft8EI6/6nAYH
+6ftjk4BAtcZsCjEozgyfz7MjNYBBjWzEN3uBL4ChQEKF6dk4jeihU80Bv2noWgby
+RQuQ+q7hv53yrlc8pa6yVvSLZUDp/TGBLPQ5Cdjua6e0ph0VpZj3AYHYhX3zUVxx
+iN66zB+Afko=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign ECC Root CA - G3"
+# Serial: 287880440101571086945156
+# MD5 Fingerprint: ce:0b:72:d1:9f:88:8e:d0:50:03:e8:e3:b8:8b:67:40
+# SHA1 Fingerprint: 30:43:fa:4f:f2:57:dc:a0:c3:80:ee:2e:58:ea:78:b2:3f:e6:bb:c1
+# SHA256 Fingerprint: 86:a1:ec:ba:08:9c:4a:8d:3b:be:27:34:c6:12:ba:34:1d:81:3e:04:3c:f9:e8:a8:62:cd:5c:57:a3:6b:be:6b
+-----BEGIN CERTIFICATE-----
+MIICTjCCAdOgAwIBAgIKPPYHqWhwDtqLhDAKBggqhkjOPQQDAzBrMQswCQYDVQQG
+EwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNo
+bm9sb2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0g
+RzMwHhcNMTgwMjE4MTgzMDAwWhcNNDMwMjE4MTgzMDAwWjBrMQswCQYDVQQGEwJJ
+TjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNobm9s
+b2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0gRzMw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAAQjpQy4LRL1KPOxst3iAhKAnjlfSU2fySU0
+WXTsuwYc58Byr+iuL+FBVIcUqEqy6HyC5ltqtdyzdc6LBtCGI79G1Y4PPwT01xyS
+fvalY8L1X44uT6EYGQIrMgqCZH0Wk9GjQjBAMB0GA1UdDgQWBBR8XQKEE9TMipuB
+zhccLikenEhjQjAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggq
+hkjOPQQDAwNpADBmAjEAvvNhzwIQHWSVB7gYboiFBS+DCBeQyh+KTOgNG3qxrdWB
+CUfvO6wIBHxcmbHtRwfSAjEAnbpV/KlK6O3t5nYBQnvI+GDZjVGLVTv7jHvrZQnD
++JbNR6iC8hZVdyR+EhCVBCyj
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign Root CA - C1"
+# Serial: 825510296613316004955058
+# MD5 Fingerprint: d8:e3:5d:01:21:fa:78:5a:b0:df:ba:d2:ee:2a:5f:68
+# SHA1 Fingerprint: e7:2e:f1:df:fc:b2:09:28:cf:5d:d4:d5:67:37:b1:51:cb:86:4f:01
+# SHA256 Fingerprint: 12:56:09:aa:30:1d:a0:a2:49:b9:7a:82:39:cb:6a:34:21:6f:44:dc:ac:9f:39:54:b1:42:92:f2:e8:c8:60:8f
+-----BEGIN CERTIFICATE-----
+MIIDczCCAlugAwIBAgILAK7PALrEzzL4Q7IwDQYJKoZIhvcNAQELBQAwVjELMAkG
+A1UEBhMCVVMxEzARBgNVBAsTCmVtU2lnbiBQS0kxFDASBgNVBAoTC2VNdWRocmEg
+SW5jMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEMxMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowVjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMRwwGgYDVQQDExNlbVNpZ24gUm9v
+dCBDQSAtIEMxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+upufGZ
+BczYKCFK83M0UYRWEPWgTywS4/oTmifQz/l5GnRfHXk5/Fv4cI7gklL35CX5VIPZ
+HdPIWoU/Xse2B+4+wM6ar6xWQio5JXDWv7V7Nq2s9nPczdcdioOl+yuQFTdrHCZH
+3DspVpNqs8FqOp099cGXOFgFixwR4+S0uF2FHYP+eF8LRWgYSKVGczQ7/g/IdrvH
+GPMF0Ybzhe3nudkyrVWIzqa2kbBPrH4VI5b2P/AgNBbeCsbEBEV5f6f9vtKppa+c
+xSMq9zwhbL2vj07FOrLzNBL834AaSaTUqZX3noleoomslMuoaJuvimUnzYnu3Yy1
+aylwQ6BpC+S5DwIDAQABo0IwQDAdBgNVHQ4EFgQU/qHgcB4qAzlSWkK+XJGFehiq
+TbUwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBAMJKVvoVIXsoounlHfv4LcQ5lkFMOycsxGwYFYDGrK9HWS8mC+M2sO87
+/kOXSTKZEhVb3xEp/6tT+LvBeA+snFOvV71ojD1pM/CjoCNjO2RnIkSt1XHLVip4
+kqNPEjE2NuLe/gDEo2APJ62gsIq1NnpSob0n9CAnYuhNlCQT5AoE6TyrLshDCUrG
+YQTlSTR+08TI9Q/Aqum6VF7zYytPT1DU/rl7mYw9wC68AivTxEDkigcxHpvOJpkT
++xHqmiIMERnHXhuBUDDIlhJu58tBf5E7oke3VIAb3ADMmpDqw8NQBmIMMMAVSKeo
+WXzhriKi4gp6D/piq1JM4fHfyr6DDUI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign ECC Root CA - C3"
+# Serial: 582948710642506000014504
+# MD5 Fingerprint: 3e:53:b3:a3:81:ee:d7:10:f8:d3:b0:1d:17:92:f5:d5
+# SHA1 Fingerprint: b6:af:43:c2:9b:81:53:7d:f6:ef:6b:c3:1f:1f:60:15:0c:ee:48:66
+# SHA256 Fingerprint: bc:4d:80:9b:15:18:9d:78:db:3e:1d:8c:f4:f9:72:6a:79:5d:a1:64:3c:a5:f1:35:8e:1d:db:0e:dc:0d:7e:b3
+-----BEGIN CERTIFICATE-----
+MIICKzCCAbGgAwIBAgIKe3G2gla4EnycqDAKBggqhkjOPQQDAzBaMQswCQYDVQQG
+EwJVUzETMBEGA1UECxMKZW1TaWduIFBLSTEUMBIGA1UEChMLZU11ZGhyYSBJbmMx
+IDAeBgNVBAMTF2VtU2lnbiBFQ0MgUm9vdCBDQSAtIEMzMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowWjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMSAwHgYDVQQDExdlbVNpZ24gRUND
+IFJvb3QgQ0EgLSBDMzB2MBAGByqGSM49AgEGBSuBBAAiA2IABP2lYa57JhAd6bci
+MK4G9IGzsUJxlTm801Ljr6/58pc1kjZGDoeVjbk5Wum739D+yAdBPLtVb4Ojavti
+sIGJAnB9SMVK4+kiVCJNk7tCDK93nCOmfddhEc5lx/h//vXyqaNCMEAwHQYDVR0O
+BBYEFPtaSNCAIEDyqOkAB2kZd6fmw/TPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB
+Af8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMQC02C8Cif22TGK6Q04ThHK1rt0c
+3ta13FaPWEBaLd4gTCKDypOofu4SQMfWh0/434UCMBwUZOR8loMRnLDRWmFLpg9J
+0wD8ofzkpf9/rdcw0Md3f76BB1UwUCAU9Vc4CqgxUQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Subject: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Label: "Hongkong Post Root CA 3"
+# Serial: 46170865288971385588281144162979347873371282084
+# MD5 Fingerprint: 11:fc:9f:bd:73:30:02:8a:fd:3f:f3:58:b9:cb:20:f0
+# SHA1 Fingerprint: 58:a2:d0:ec:20:52:81:5b:c1:f3:f8:64:02:24:4e:c2:8e:02:4b:02
+# SHA256 Fingerprint: 5a:2f:c0:3f:0c:83:b0:90:bb:fa:40:60:4b:09:88:44:6c:76:36:18:3d:f9:84:6e:17:10:1a:44:7f:b8:ef:d6
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G4"
+# Serial: 289383649854506086828220374796556676440
+# MD5 Fingerprint: 89:53:f1:83:23:b7:7c:8e:05:f1:8c:71:38:4e:1f:88
+# SHA1 Fingerprint: 14:88:4e:86:26:37:b0:26:af:59:62:5c:40:77:ec:35:29:ba:96:01
+# SHA256 Fingerprint: db:35:17:d1:f6:73:2a:2d:5a:b9:7c:53:3e:c7:07:79:ee:32:70:a6:2f:b4:ac:42:38:37:24:60:e6:f0:1e:88
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft ECC Root Certificate Authority 2017"
+# Serial: 136839042543790627607696632466672567020
+# MD5 Fingerprint: dd:a1:03:e6:4a:93:10:d1:bf:f0:19:42:cb:fe:ed:67
+# SHA1 Fingerprint: 99:9a:64:c3:7f:f4:7d:9f:ab:95:f1:47:69:89:14:60:ee:c4:c3:c5
+# SHA256 Fingerprint: 35:8d:f3:9d:76:4a:f9:e1:b7:66:e9:c9:72:df:35:2e:e1:5c:fa:c2:27:af:6a:d1:d7:0e:8e:4a:6e:dc:ba:02
+-----BEGIN CERTIFICATE-----
+MIICWTCCAd+gAwIBAgIQZvI9r4fei7FK6gxXMQHC7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYD
+VQQDEy1NaWNyb3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIw
+MTcwHhcNMTkxMjE4MjMwNjQ1WhcNNDIwNzE4MjMxNjA0WjBlMQswCQYDVQQGEwJV
+UzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1NaWNy
+b3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAATUvD0CQnVBEyPNgASGAlEvaqiBYgtlzPbKnR5vSmZR
+ogPZnZH6thaxjG7efM3beaYvzrvOcS/lpaso7GMEZpn4+vKTEAXhgShC48Zo9OYb
+hGBKia/teQ87zvH2RPUBeMCjVDBSMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBTIy5lycFIM+Oa+sgRXKSrPQhDtNTAQBgkrBgEEAYI3
+FQEEAwIBADAKBggqhkjOPQQDAwNoADBlAjBY8k3qDPlfXu5gKcs68tvWMoQZP3zV
+L8KxzJOuULsJMsbG7X7JNpQS5GiFBqIb0C8CMQCZ6Ra0DvpWSNSkMBaReNtUjGUB
+iudQZsIxtzm6uBoiB078a1QWIP8rtedMDE2mT3M=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft RSA Root Certificate Authority 2017"
+# Serial: 40975477897264996090493496164228220339
+# MD5 Fingerprint: 10:ff:00:ff:cf:c9:f8:c7:7a:c0:ee:35:8e:c9:0f:47
+# SHA1 Fingerprint: 73:a5:e6:4a:3b:ff:83:16:ff:0e:dc:cc:61:8a:90:6e:4e:ae:4d:74
+# SHA256 Fingerprint: c7:41:f7:0f:4b:2a:8d:88:bf:2e:71:c1:41:22:ef:53:ef:10:eb:a0:cf:a5:e6:4c:fa:20:f4:18:85:30:73:e0
+-----BEGIN CERTIFICATE-----
+MIIFqDCCA5CgAwIBAgIQHtOXCV/YtLNHcB6qvn9FszANBgkqhkiG9w0BAQwFADBl
+MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYw
+NAYDVQQDEy1NaWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
+IDIwMTcwHhcNMTkxMjE4MjI1MTIyWhcNNDIwNzE4MjMwMDIzWjBlMQswCQYDVQQG
+EwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1N
+aWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKW76UM4wplZEWCpW9R2LBifOZ
+Nt9GkMml7Xhqb0eRaPgnZ1AzHaGm++DlQ6OEAlcBXZxIQIJTELy/xztokLaCLeX0
+ZdDMbRnMlfl7rEqUrQ7eS0MdhweSE5CAg2Q1OQT85elss7YfUJQ4ZVBcF0a5toW1
+HLUX6NZFndiyJrDKxHBKrmCk3bPZ7Pw71VdyvD/IybLeS2v4I2wDwAW9lcfNcztm
+gGTjGqwu+UcF8ga2m3P1eDNbx6H7JyqhtJqRjJHTOoI+dkC0zVJhUXAoP8XFWvLJ
+jEm7FFtNyP9nTUwSlq31/niol4fX/V4ggNyhSyL71Imtus5Hl0dVe49FyGcohJUc
+aDDv70ngNXtk55iwlNpNhTs+VcQor1fznhPbRiefHqJeRIOkpcrVE7NLP8TjwuaG
+YaRSMLl6IE9vDzhTyzMMEyuP1pq9KsgtsRx9S1HKR9FIJ3Jdh+vVReZIZZ2vUpC6
+W6IYZVcSn2i51BVrlMRpIpj0M+Dt+VGOQVDJNE92kKz8OMHY4Xu54+OU4UZpyw4K
+UGsTuqwPN1q3ErWQgR5WrlcihtnJ0tHXUeOrO8ZV/R4O03QK0dqq6mm4lyiPSMQH
++FJDOvTKVTUssKZqwJz58oHhEmrARdlns87/I6KJClTUFLkqqNfs+avNJVgyeY+Q
+W5g5xAgGwax/Dj0ApQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQUCctZf4aycI8awznjwNnpv7tNsiMwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEMBQADggIBAKyvPl3CEZaJjqPnktaXFbgToqZC
+LgLNFgVZJ8og6Lq46BrsTaiXVq5lQ7GPAJtSzVXNUzltYkyLDVt8LkS/gxCP81OC
+gMNPOsduET/m4xaRhPtthH80dK2Jp86519efhGSSvpWhrQlTM93uCupKUY5vVau6
+tZRGrox/2KJQJWVggEbbMwSubLWYdFQl3JPk+ONVFT24bcMKpBLBaYVu32TxU5nh
+SnUgnZUP5NbcA/FZGOhHibJXWpS2qdgXKxdJ5XbLwVaZOjex/2kskZGT4d9Mozd2
+TaGf+G0eHdP67Pv0RR0Tbc/3WeUiJ3IrhvNXuzDtJE3cfVa7o7P4NHmJweDyAmH3
+pvwPuxwXC65B2Xy9J6P9LjrRk5Sxcx0ki69bIImtt2dmefU6xqaWM/5TkshGsRGR
+xpl/j8nWZjEgQRCHLQzWwa80mMpkg/sTV9HB8Dx6jKXB/ZUhoHHBk2dxEuqPiApp
+GWSZI1b7rCoucL5mxAyE7+WL85MB+GqQk2dLsmijtWKP6T+MejteD+eMuMZ87zf9
+dOLITzNy4ZQ5bb0Sr74MTnB8G2+NszKTc0QWbej09+CVgI+WXTik9KveCjCHk9hN
+AHFiRSdLOkKEW39lt2c0Ui2cFmuqqNh7o0JMcccMyj6D5KbvtwEwXlGjefVwaaZB
+RA+GsCyRxj3qrg+E
+-----END CERTIFICATE-----
+
+# Issuer: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Subject: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Label: "e-Szigno Root CA 2017"
+# Serial: 411379200276854331539784714
+# MD5 Fingerprint: de:1f:f6:9e:84:ae:a7:b4:21:ce:1e:58:7d:d1:84:98
+# SHA1 Fingerprint: 89:d4:83:03:4f:9e:9a:48:80:5f:72:37:d4:a9:a6:ef:cb:7c:1f:d1
+# SHA256 Fingerprint: be:b0:0b:30:83:9b:9b:c3:2c:32:e4:44:79:05:95:06:41:f2:64:21:b1:5e:d0:89:19:8b:51:8a:e2:ea:1b:99
+-----BEGIN CERTIFICATE-----
+MIICQDCCAeWgAwIBAgIMAVRI7yH9l1kN9QQKMAoGCCqGSM49BAMCMHExCzAJBgNV
+BAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRk
+LjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25vIFJv
+b3QgQ0EgMjAxNzAeFw0xNzA4MjIxMjA3MDZaFw00MjA4MjIxMjA3MDZaMHExCzAJ
+BgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMg
+THRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25v
+IFJvb3QgQ0EgMjAxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJbcPYrYsHtv
+xie+RJCxs1YVe45DJH0ahFnuY2iyxl6H0BVIHqiQrb1TotreOpCmYF9oMrWGQd+H
+Wyx7xf58etqjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBSHERUI0arBeAyxr87GyZDvvzAEwDAfBgNVHSMEGDAWgBSHERUI0arB
+eAyxr87GyZDvvzAEwDAKBggqhkjOPQQDAgNJADBGAiEAtVfd14pVCzbhhkT61Nlo
+jbjcI4qKDdQvfepz7L9NbKgCIQDLpbQS+ue16M9+k/zzNY9vTlp8tLxOsvxyqltZ
++efcMQ==
+-----END CERTIFICATE-----
+
+# Issuer: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Subject: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Label: "certSIGN Root CA G2"
+# Serial: 313609486401300475190
+# MD5 Fingerprint: 8c:f1:75:8a:c6:19:cf:94:b7:f7:65:20:87:c3:97:c7
+# SHA1 Fingerprint: 26:f9:93:b4:ed:3d:28:27:b0:b9:4b:a7:e9:15:1d:a3:8d:92:e5:32
+# SHA256 Fingerprint: 65:7c:fe:2f:a7:3f:aa:38:46:25:71:f3:32:a2:36:3a:46:fc:e7:02:09:51:71:07:02:cd:fb:b6:ee:da:33:05
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIJEQA0tk7GNi02MA0GCSqGSIb3DQEBCwUAMEExCzAJBgNV
+BAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJR04g
+Uk9PVCBDQSBHMjAeFw0xNzAyMDYwOTI3MzVaFw00MjAyMDYwOTI3MzVaMEExCzAJ
+BgNVBAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJ
+R04gUk9PVCBDQSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMDF
+dRmRfUR0dIf+DjuW3NgBFszuY5HnC2/OOwppGnzC46+CjobXXo9X69MhWf05N0Iw
+vlDqtg+piNguLWkh59E3GE59kdUWX2tbAMI5Qw02hVK5U2UPHULlj88F0+7cDBrZ
+uIt4ImfkabBoxTzkbFpG583H+u/E7Eu9aqSs/cwoUe+StCmrqzWaTOTECMYmzPhp
+n+Sc8CnTXPnGFiWeI8MgwT0PPzhAsP6CRDiqWhqKa2NYOLQV07YRaXseVO6MGiKs
+cpc/I1mbySKEwQdPzH/iV8oScLumZfNpdWO9lfsbl83kqK/20U6o2YpxJM02PbyW
+xPFsqa7lzw1uKA2wDrXKUXt4FMMgL3/7FFXhEZn91QqhngLjYl/rNUssuHLoPj1P
+rCy7Lobio3aP5ZMqz6WryFyNSwb/EkaseMsUBzXgqd+L6a8VTxaJW732jcZZroiF
+DsGJ6x9nxUWO/203Nit4ZoORUSs9/1F3dmKh7Gc+PoGD4FapUB8fepmrY7+EF3fx
+DTvf95xhszWYijqy7DwaNz9+j5LP2RIUZNoQAhVB/0/E6xyjyfqZ90bp4RjZsbgy
+LcsUDFDYg2WD7rlcz8sFWkz6GZdr1l0T08JcVLwyc6B49fFtHsufpaafItzRUZ6C
+eWRgKRM+o/1Pcmqr4tTluCRVLERLiohEnMqE0yo7AgMBAAGjQjBAMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSCIS1mxteg4BXrzkwJ
+d8RgnlRuAzANBgkqhkiG9w0BAQsFAAOCAgEAYN4auOfyYILVAzOBywaK8SJJ6ejq
+kX/GM15oGQOGO0MBzwdw5AgeZYWR5hEit/UCI46uuR59H35s5r0l1ZUa8gWmr4UC
+b6741jH/JclKyMeKqdmfS0mbEVeZkkMR3rYzpMzXjWR91M08KCy0mpbqTfXERMQl
+qiCA2ClV9+BB/AYm/7k29UMUA2Z44RGx2iBfRgB4ACGlHgAoYXhvqAEBj500mv/0
+OJD7uNGzcgbJceaBxXntC6Z58hMLnPddDnskk7RI24Zf3lCGeOdA5jGokHZwYa+c
+NywRtYK3qq4kNFtyDGkNzVmf9nGvnAvRCjj5BiKDUyUM/FHE5r7iOZULJK2v0ZXk
+ltd0ZGtxTgI8qoXzIKNDOXZbbFD+mpwUHmUUihW9o4JFWklWatKcsWMy5WHgUyIO
+pwpJ6st+H6jiYoD2EEVSmAYY3qXNL3+q1Ok+CHLsIwMCPKaq2LxndD0UF/tUSxfj
+03k9bWtJySgOLnRQvwzZRjoQhsmnP+mg7H/rpXdYaXHmgwo38oZJar55CJD2AhZk
+PuXaTH4MNMn5X7azKFGnpyuqSfqNZSlO42sTp5SjLVFteAxEy9/eCG/Oo2Sr05WE
+1LlSVHJ7liXMvGnjSG4N0MedJ5qq+BOS3R7fY581qRY27Iy4g/Q9iY/NtBde17MX
+QRBdJ3NghVdJIgc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global Certification Authority"
+# Serial: 1846098327275375458322922162
+# MD5 Fingerprint: f8:1c:18:2d:2f:ba:5f:6d:a1:6c:bc:c7:ab:91:c7:0e
+# SHA1 Fingerprint: 2f:8f:36:4f:e1:58:97:44:21:59:87:a5:2a:9a:d0:69:95:26:7f:b5
+# SHA256 Fingerprint: 97:55:20:15:f5:dd:fc:3c:87:88:c0:06:94:45:55:40:88:94:45:00:84:f1:00:86:70:86:bc:1a:2b:b5:8d:c8
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global ECC P256 Certification Authority"
+# Serial: 4151900041497450638097112925
+# MD5 Fingerprint: 5b:44:e3:8d:5d:36:86:26:e8:0d:05:d2:59:a7:83:54
+# SHA1 Fingerprint: b4:90:82:dd:45:0c:be:8b:5b:b1:66:d3:e2:a4:08:26:cd:ed:42:cf
+# SHA256 Fingerprint: 94:5b:bc:82:5e:a5:54:f4:89:d1:fd:51:a7:3d:df:2e:a6:24:ac:70:19:a0:52:05:22:5c:22:a7:8c:cf:a8:b4
+-----BEGIN CERTIFICATE-----
+MIICYDCCAgegAwIBAgIMDWpfCD8oXD5Rld9dMAoGCCqGSM49BAMCMIGRMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
+BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
+YXZlIEdsb2JhbCBFQ0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
+NzA4MjMxOTM1MTBaFw00MjA4MjMxOTM1MTBaMIGRMQswCQYDVQQGEwJVUzERMA8G
+A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
+d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
+Q0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTBZMBMGByqGSM49AgEGCCqG
+SM49AwEHA0IABH77bOYj43MyCMpg5lOcunSNGLB4kFKA3TjASh3RqMyTpJcGOMoN
+FWLGjgEqZZ2q3zSRLoHB5DOSMcT9CTqmP62jQzBBMA8GA1UdEwEB/wQFMAMBAf8w
+DwYDVR0PAQH/BAUDAwcGADAdBgNVHQ4EFgQUo0EGrJBt0UrrdaVKEJmzsaGLSvcw
+CgYIKoZIzj0EAwIDRwAwRAIgB+ZU2g6gWrKuEZ+Hxbb/ad4lvvigtwjzRM4q3wgh
+DDcCIC0mA6AFvWvR9lz4ZcyGbbOcNEhjhAnFjXca4syc4XR7
+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global ECC P384 Certification Authority"
+# Serial: 2704997926503831671788816187
+# MD5 Fingerprint: ea:cf:60:c4:3b:b9:15:29:40:a1:97:ed:78:27:93:d6
+# SHA1 Fingerprint: e7:f3:a3:c8:cf:6f:c3:04:2e:6d:0e:67:32:c5:9e:68:95:0d:5e:d2
+# SHA256 Fingerprint: 55:90:38:59:c8:c0:c3:eb:b8:75:9e:ce:4e:25:57:22:5f:f5:75:8b:bd:38:eb:d4:82:76:60:1e:1b:d5:80:97
+-----BEGIN CERTIFICATE-----
+MIICnTCCAiSgAwIBAgIMCL2Fl2yZJ6SAaEc7MAoGCCqGSM49BAMDMIGRMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
+BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
+YXZlIEdsb2JhbCBFQ0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
+NzA4MjMxOTM2NDNaFw00MjA4MjMxOTM2NDNaMIGRMQswCQYDVQQGEwJVUzERMA8G
+A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
+d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
+Q0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABGvaDXU1CDFHBa5FmVXxERMuSvgQMSOjfoPTfygIOiYaOs+Xgh+AtycJ
+j9GOMMQKmw6sWASr9zZ9lCOkmwqKi6vr/TklZvFe/oyujUF5nQlgziip04pt89ZF
+1PKYhDhloKNDMEEwDwYDVR0TAQH/BAUwAwEB/zAPBgNVHQ8BAf8EBQMDBwYAMB0G
+A1UdDgQWBBRVqYSJ0sEyvRjLbKYHTsjnnb6CkDAKBggqhkjOPQQDAwNnADBkAjA3
+AZKXRRJ+oPM+rRk6ct30UJMDEr5E0k9BpIycnR+j9sKS50gU/k6bpZFXrsY3crsC
+MGclCrEMXu6pY5Jv5ZAL/mYiykf9ijH3g/56vxC+GCsej/YpHpRZ744hN8tRmKVu
+Sw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
+# Subject: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
+# Label: "NAVER Global Root Certification Authority"
+# Serial: 9013692873798656336226253319739695165984492813
+# MD5 Fingerprint: c8:7e:41:f6:25:3b:f5:09:b3:17:e8:46:3d:bf:d0:9b
+# SHA1 Fingerprint: 8f:6b:f2:a9:27:4a:da:14:a0:c4:f4:8e:61:27:f9:c0:1e:78:5d:d1
+# SHA256 Fingerprint: 88:f4:38:dc:f8:ff:d1:fa:8f:42:91:15:ff:e5:f8:2a:e1:e0:6e:0c:70:c3:75:fa:ad:71:7b:34:a4:9e:72:65
+-----BEGIN CERTIFICATE-----
+MIIFojCCA4qgAwIBAgIUAZQwHqIL3fXFMyqxQ0Rx+NZQTQ0wDQYJKoZIhvcNAQEM
+BQAwaTELMAkGA1UEBhMCS1IxJjAkBgNVBAoMHU5BVkVSIEJVU0lORVNTIFBMQVRG
+T1JNIENvcnAuMTIwMAYDVQQDDClOQVZFUiBHbG9iYWwgUm9vdCBDZXJ0aWZpY2F0
+aW9uIEF1dGhvcml0eTAeFw0xNzA4MTgwODU4NDJaFw0zNzA4MTgyMzU5NTlaMGkx
+CzAJBgNVBAYTAktSMSYwJAYDVQQKDB1OQVZFUiBCVVNJTkVTUyBQTEFURk9STSBD
+b3JwLjEyMDAGA1UEAwwpTkFWRVIgR2xvYmFsIFJvb3QgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC21PGTXLVA
+iQqrDZBbUGOukJR0F0Vy1ntlWilLp1agS7gvQnXp2XskWjFlqxcX0TM62RHcQDaH
+38dq6SZeWYp34+hInDEW+j6RscrJo+KfziFTowI2MMtSAuXaMl3Dxeb57hHHi8lE
+HoSTGEq0n+USZGnQJoViAbbJAh2+g1G7XNr4rRVqmfeSVPc0W+m/6imBEtRTkZaz
+kVrd/pBzKPswRrXKCAfHcXLJZtM0l/aM9BhK4dA9WkW2aacp+yPOiNgSnABIqKYP
+szuSjXEOdMWLyEz59JuOuDxp7W87UC9Y7cSw0BwbagzivESq2M0UXZR4Yb8Obtoq
+vC8MC3GmsxY/nOb5zJ9TNeIDoKAYv7vxvvTWjIcNQvcGufFt7QSUqP620wbGQGHf
+nZ3zVHbOUzoBppJB7ASjjw2i1QnK1sua8e9DXcCrpUHPXFNwcMmIpi3Ua2FzUCaG
+YQ5fG8Ir4ozVu53BA0K6lNpfqbDKzE0K70dpAy8i+/Eozr9dUGWokG2zdLAIx6yo
+0es+nPxdGoMuK8u180SdOqcXYZaicdNwlhVNt0xz7hlcxVs+Qf6sdWA7G2POAN3a
+CJBitOUt7kinaxeZVL6HSuOpXgRM6xBtVNbv8ejyYhbLgGvtPe31HzClrkvJE+2K
+AQHJuFFYwGY6sWZLxNUxAmLpdIQM201GLQIDAQABo0IwQDAdBgNVHQ4EFgQU0p+I
+36HNLL3s9TsBAZMzJ7LrYEswDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMB
+Af8wDQYJKoZIhvcNAQEMBQADggIBADLKgLOdPVQG3dLSLvCkASELZ0jKbY7gyKoN
+qo0hV4/GPnrK21HUUrPUloSlWGB/5QuOH/XcChWB5Tu2tyIvCZwTFrFsDDUIbatj
+cu3cvuzHV+YwIHHW1xDBE1UBjCpD5EHxzzp6U5LOogMFDTjfArsQLtk70pt6wKGm
++LUx5vR1yblTmXVHIloUFcd4G7ad6Qz4G3bxhYTeodoS76TiEJd6eN4MUZeoIUCL
+hr0N8F5OSza7OyAfikJW4Qsav3vQIkMsRIz75Sq0bBwcupTgE34h5prCy8VCZLQe
+lHsIJchxzIdFV4XTnyliIoNRlwAYl3dqmJLJfGBs32x9SuRwTMKeuB330DTHD8z7
+p/8Dvq1wkNoL3chtl1+afwkyQf3NosxabUzyqkn+Zvjp2DXrDige7kgvOtB5CTh8
+piKCk5XQA76+AqAF3SAi428diDRgxuYKuQl1C/AH6GmWNcf7I4GOODm4RStDeKLR
+LBT/DShycpWbXgnbiUSYqqFJu3FS8r/2/yehNq+4tneI3TqkbZs0kNwUXTC/t+sX
+5Ie3cdCh13cV1ELX8vMxmV2b3RZtP+oGI/hGoiLtk/bdmuYqh7GYVPEi92tF4+KO
+dh2ajcQGjTa3FPOdVGm3jjzVpG2Tgbet9r1ke8LJaDmgkpzNNIaRkPpkUZ3+/uul
+9XXeifdy
+-----END CERTIFICATE-----
+
+# Issuer: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
+# Subject: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
+# Label: "AC RAIZ FNMT-RCM SERVIDORES SEGUROS"
+# Serial: 131542671362353147877283741781055151509
+# MD5 Fingerprint: 19:36:9c:52:03:2f:d2:d1:bb:23:cc:dd:1e:12:55:bb
+# SHA1 Fingerprint: 62:ff:d9:9e:c0:65:0d:03:ce:75:93:d2:ed:3f:2d:32:c9:e3:e5:4a
+# SHA256 Fingerprint: 55:41:53:b1:3d:2c:f9:dd:b7:53:bf:be:1a:4e:0a:e0:8d:0a:a4:18:70:58:fe:60:a2:b8:62:b2:e4:b8:7b:cb
+-----BEGIN CERTIFICATE-----
+MIICbjCCAfOgAwIBAgIQYvYybOXE42hcG2LdnC6dlTAKBggqhkjOPQQDAzB4MQsw
+CQYDVQQGEwJFUzERMA8GA1UECgwIRk5NVC1SQ00xDjAMBgNVBAsMBUNlcmVzMRgw
+FgYDVQRhDA9WQVRFUy1RMjgyNjAwNEoxLDAqBgNVBAMMI0FDIFJBSVogRk5NVC1S
+Q00gU0VSVklET1JFUyBTRUdVUk9TMB4XDTE4MTIyMDA5MzczM1oXDTQzMTIyMDA5
+MzczM1oweDELMAkGA1UEBhMCRVMxETAPBgNVBAoMCEZOTVQtUkNNMQ4wDAYDVQQL
+DAVDZXJlczEYMBYGA1UEYQwPVkFURVMtUTI4MjYwMDRKMSwwKgYDVQQDDCNBQyBS
+QUlaIEZOTVQtUkNNIFNFUlZJRE9SRVMgU0VHVVJPUzB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABPa6V1PIyqvfNkpSIeSX0oNnnvBlUdBeh8dHsVnyV0ebAAKTRBdp20LH
+sbI6GA60XYyzZl2hNPk2LEnb80b8s0RpRBNm/dfF/a82Tc4DTQdxz69qBdKiQ1oK
+Um8BA06Oi6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
+VR0OBBYEFAG5L++/EYZg8k/QQW6rcx/n0m5JMAoGCCqGSM49BAMDA2kAMGYCMQCu
+SuMrQMN0EfKVrRYj3k4MGuZdpSRea0R7/DjiT8ucRRcRTBQnJlU5dUoDzBOQn5IC
+MQD6SmxgiHPz7riYYqnOK8LZiqZwMR2vsJRM60/G49HzYqc8/5MuB1xJAWdpEgJy
+v+c=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign Root R46 O=GlobalSign nv-sa
+# Subject: CN=GlobalSign Root R46 O=GlobalSign nv-sa
+# Label: "GlobalSign Root R46"
+# Serial: 1552617688466950547958867513931858518042577
+# MD5 Fingerprint: c4:14:30:e4:fa:66:43:94:2a:6a:1b:24:5f:19:d0:ef
+# SHA1 Fingerprint: 53:a2:b0:4b:ca:6b:d6:45:e6:39:8a:8e:c4:0d:d2:bf:77:c3:a2:90
+# SHA256 Fingerprint: 4f:a3:12:6d:8d:3a:11:d1:c4:85:5a:4f:80:7c:ba:d6:cf:91:9d:3a:5a:88:b0:3b:ea:2c:63:72:d9:3c:40:c9
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgISEdK7udcjGJ5AXwqdLdDfJWfRMA0GCSqGSIb3DQEBDAUA
+MEYxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYD
+VQQDExNHbG9iYWxTaWduIFJvb3QgUjQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMy
+MDAwMDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYt
+c2ExHDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBSNDYwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCsrHQy6LNl5brtQyYdpokNRbopiLKkHWPd08EsCVeJ
+OaFV6Wc0dwxu5FUdUiXSE2te4R2pt32JMl8Nnp8semNgQB+msLZ4j5lUlghYruQG
+vGIFAha/r6gjA7aUD7xubMLL1aa7DOn2wQL7Id5m3RerdELv8HQvJfTqa1VbkNud
+316HCkD7rRlr+/fKYIje2sGP1q7Vf9Q8g+7XFkyDRTNrJ9CG0Bwta/OrffGFqfUo
+0q3v84RLHIf8E6M6cqJaESvWJ3En7YEtbWaBkoe0G1h6zD8K+kZPTXhc+CtI4wSE
+y132tGqzZfxCnlEmIyDLPRT5ge1lFgBPGmSXZgjPjHvjK8Cd+RTyG/FWaha/LIWF
+zXg4mutCagI0GIMXTpRW+LaCtfOW3T3zvn8gdz57GSNrLNRyc0NXfeD412lPFzYE
++cCQYDdF3uYM2HSNrpyibXRdQr4G9dlkbgIQrImwTDsHTUB+JMWKmIJ5jqSngiCN
+I/onccnfxkF0oE32kRbcRoxfKWMxWXEM2G/CtjJ9++ZdU6Z+Ffy7dXxd7Pj2Fxzs
+x2sZy/N78CsHpdlseVR2bJ0cpm4O6XkMqCNqo98bMDGfsVR7/mrLZqrcZdCinkqa
+ByFrgY/bxFn63iLABJzjqls2k+g9vXqhnQt2sQvHnf3PmKgGwvgqo6GDoLclcqUC
+4wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUA1yrc4GHqMywptWU4jaWSf8FmSwwDQYJKoZIhvcNAQEMBQADggIBAHx4
+7PYCLLtbfpIrXTncvtgdokIzTfnvpCo7RGkerNlFo048p9gkUbJUHJNOxO97k4Vg
+JuoJSOD1u8fpaNK7ajFxzHmuEajwmf3lH7wvqMxX63bEIaZHU1VNaL8FpO7XJqti
+2kM3S+LGteWygxk6x9PbTZ4IevPuzz5i+6zoYMzRx6Fcg0XERczzF2sUyQQCPtIk
+pnnpHs6i58FZFZ8d4kuaPp92CC1r2LpXFNqD6v6MVenQTqnMdzGxRBF6XLE+0xRF
+FRhiJBPSy03OXIPBNvIQtQ6IbbjhVp+J3pZmOUdkLG5NrmJ7v2B0GbhWrJKsFjLt
+rWhV/pi60zTe9Mlhww6G9kuEYO4Ne7UyWHmRVSyBQ7N0H3qqJZ4d16GLuc1CLgSk
+ZoNNiTW2bKg2SnkheCLQQrzRQDGQob4Ez8pn7fXwgNNgyYMqIgXQBztSvwyeqiv5
+u+YfjyW6hY0XHgL+XVAEV8/+LbzvXMAaq7afJMbfc2hIkCwU9D9SGuTSyxTDYWnP
+4vkYxboznxSjBF25cfe1lNj2M8FawTSLfJvdkzrnE6JwYZ+vj+vYxXX4M2bUdGc6
+N3ec592kD3ZDZopD8p/7DEJ4Y9HiD2971KE9dJeFt0g5QdYg/NA6s/rob8SKunE3
+vouXsXgxT7PntgMTzlSdriVZzH81Xwj3QEUxeCp6
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign Root E46 O=GlobalSign nv-sa
+# Subject: CN=GlobalSign Root E46 O=GlobalSign nv-sa
+# Label: "GlobalSign Root E46"
+# Serial: 1552617690338932563915843282459653771421763
+# MD5 Fingerprint: b5:b8:66:ed:de:08:83:e3:c9:e2:01:34:06:ac:51:6f
+# SHA1 Fingerprint: 39:b4:6c:d5:fe:80:06:eb:e2:2f:4a:bb:08:33:a0:af:db:b9:dd:84
+# SHA256 Fingerprint: cb:b9:c4:4d:84:b8:04:3e:10:50:ea:31:a6:9f:51:49:55:d7:bf:d2:e2:c6:b4:93:01:01:9a:d6:1d:9f:50:58
+-----BEGIN CERTIFICATE-----
+MIICCzCCAZGgAwIBAgISEdK7ujNu1LzmJGjFDYQdmOhDMAoGCCqGSM49BAMDMEYx
+CzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYDVQQD
+ExNHbG9iYWxTaWduIFJvb3QgRTQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMyMDAw
+MDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2Ex
+HDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBFNDYwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAAScDrHPt+ieUnd1NPqlRqetMhkytAepJ8qUuwzSChDH2omwlwxwEwkBjtjq
+R+q+soArzfwoDdusvKSGN+1wCAB16pMLey5SnCNoIwZD7JIvU4Tb+0cUB+hflGdd
+yXqBPCCjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBQxCpCPtsad0kRLgLWi5h+xEk8blTAKBggqhkjOPQQDAwNoADBlAjEA31SQ
+7Zvvi5QCkxeCmb6zniz2C5GMn0oUsfZkvLtoURMMA/cVi4RguYv/Uo7njLwcAjA8
++RHUjE7AwWHCFUyqqx0LMV87HOIAl0Qx5v5zli/altP+CAezNIm8BZ/3Hobui3A=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GLOBALTRUST 2020 O=e-commerce monitoring GmbH
+# Subject: CN=GLOBALTRUST 2020 O=e-commerce monitoring GmbH
+# Label: "GLOBALTRUST 2020"
+# Serial: 109160994242082918454945253
+# MD5 Fingerprint: 8a:c7:6f:cb:6d:e3:cc:a2:f1:7c:83:fa:0e:78:d7:e8
+# SHA1 Fingerprint: d0:67:c1:13:51:01:0c:aa:d0:c7:6a:65:37:31:16:26:4f:53:71:a2
+# SHA256 Fingerprint: 9a:29:6a:51:82:d1:d4:51:a2:e3:7f:43:9b:74:da:af:a2:67:52:33:29:f9:0f:9a:0d:20:07:c3:34:e2:3c:9a
+-----BEGIN CERTIFICATE-----
+MIIFgjCCA2qgAwIBAgILWku9WvtPilv6ZeUwDQYJKoZIhvcNAQELBQAwTTELMAkG
+A1UEBhMCQVQxIzAhBgNVBAoTGmUtY29tbWVyY2UgbW9uaXRvcmluZyBHbWJIMRkw
+FwYDVQQDExBHTE9CQUxUUlVTVCAyMDIwMB4XDTIwMDIxMDAwMDAwMFoXDTQwMDYx
+MDAwMDAwMFowTTELMAkGA1UEBhMCQVQxIzAhBgNVBAoTGmUtY29tbWVyY2UgbW9u
+aXRvcmluZyBHbWJIMRkwFwYDVQQDExBHTE9CQUxUUlVTVCAyMDIwMIICIjANBgkq
+hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAri5WrRsc7/aVj6B3GyvTY4+ETUWiD59b
+RatZe1E0+eyLinjF3WuvvcTfk0Uev5E4C64OFudBc/jbu9G4UeDLgztzOG53ig9Z
+YybNpyrOVPu44sB8R85gfD+yc/LAGbaKkoc1DZAoouQVBGM+uq/ufF7MpotQsjj3
+QWPKzv9pj2gOlTblzLmMCcpL3TGQlsjMH/1WljTbjhzqLL6FLmPdqqmV0/0plRPw
+yJiT2S0WR5ARg6I6IqIoV6Lr/sCMKKCmfecqQjuCgGOlYx8ZzHyyZqjC0203b+J+
+BlHZRYQfEs4kUmSFC0iAToexIiIwquuuvuAC4EDosEKAA1GqtH6qRNdDYfOiaxaJ
+SaSjpCuKAsR49GiKweR6NrFvG5Ybd0mN1MkGco/PU+PcF4UgStyYJ9ORJitHHmkH
+r96i5OTUawuzXnzUJIBHKWk7buis/UDr2O1xcSvy6Fgd60GXIsUf1DnQJ4+H4xj0
+4KlGDfV0OoIu0G4skaMxXDtG6nsEEFZegB31pWXogvziB4xiRfUg3kZwhqG8k9Me
+dKZssCz3AwyIDMvUclOGvGBG85hqwvG/Q/lwIHfKN0F5VVJjjVsSn8VoxIidrPIw
+q7ejMZdnrY8XD2zHc+0klGvIg5rQmjdJBKuxFshsSUktq6HQjJLyQUp5ISXbY9e2
+nKd+Qmn7OmMCAwEAAaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AQYwHQYDVR0OBBYEFNwuH9FhN3nkq9XVsxJxaD1qaJwiMB8GA1UdIwQYMBaAFNwu
+H9FhN3nkq9XVsxJxaD1qaJwiMA0GCSqGSIb3DQEBCwUAA4ICAQCR8EICaEDuw2jA
+VC/f7GLDw56KoDEoqoOOpFaWEhCGVrqXctJUMHytGdUdaG/7FELYjQ7ztdGl4wJC
+XtzoRlgHNQIw4Lx0SsFDKv/bGtCwr2zD/cuz9X9tAy5ZVp0tLTWMstZDFyySCstd
+6IwPS3BD0IL/qMy/pJTAvoe9iuOTe8aPmxadJ2W8esVCgmxcB9CpwYhgROmYhRZf
++I/KARDOJcP5YBugxZfD0yyIMaK9MOzQ0MAS8cE54+X1+NZK3TTN+2/BT+MAi1bi
+kvcoskJ3ciNnxz8RFbLEAwW+uxF7Cr+obuf/WEPPm2eggAe2HcqtbepBEX4tdJP7
+wry+UUTF72glJ4DjyKDUEuzZpTcdN3y0kcra1LGWge9oXHYQSa9+pTeAsRxSvTOB
+TI/53WXZFM2KJVj04sWDpQmQ1GwUY7VA3+vA/MRYfg0UFodUJ25W5HCEuGwyEn6C
+MUO+1918oa2u1qsgEu8KwxCMSZY13At1XrFP1U80DhEgB3VDRemjEdqso5nCtnkn
+4rnvyOL2NSl6dPrFf4IFYqYK6miyeUcGbvJXqBUzxvd4Sj1Ce2t+/vdG6tHrju+I
+aFvowdlxfv1k7/9nR4hYJS8+hge9+6jlgqispdNpQ80xiEmEU5LAsTkbOYMBMMTy
+qfrQA71yN2BWHzZ8vTmR9W0Nv3vXkg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
+# Subject: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
+# Label: "ANF Secure Server Root CA"
+# Serial: 996390341000653745
+# MD5 Fingerprint: 26:a6:44:5a:d9:af:4e:2f:b2:1d:b6:65:b0:4e:e8:96
+# SHA1 Fingerprint: 5b:6e:68:d0:cc:15:b6:a0:5f:1e:c1:5f:ae:02:fc:6b:2f:5d:6f:74
+# SHA256 Fingerprint: fb:8f:ec:75:91:69:b9:10:6b:1e:51:16:44:c6:18:c5:13:04:37:3f:6c:06:43:08:8d:8b:ef:fd:1b:99:75:99
+-----BEGIN CERTIFICATE-----
+MIIF7zCCA9egAwIBAgIIDdPjvGz5a7EwDQYJKoZIhvcNAQELBQAwgYQxEjAQBgNV
+BAUTCUc2MzI4NzUxMDELMAkGA1UEBhMCRVMxJzAlBgNVBAoTHkFORiBBdXRvcmlk
+YWQgZGUgQ2VydGlmaWNhY2lvbjEUMBIGA1UECxMLQU5GIENBIFJhaXoxIjAgBgNV
+BAMTGUFORiBTZWN1cmUgU2VydmVyIFJvb3QgQ0EwHhcNMTkwOTA0MTAwMDM4WhcN
+MzkwODMwMTAwMDM4WjCBhDESMBAGA1UEBRMJRzYzMjg3NTEwMQswCQYDVQQGEwJF
+UzEnMCUGA1UEChMeQU5GIEF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uMRQwEgYD
+VQQLEwtBTkYgQ0EgUmFpejEiMCAGA1UEAxMZQU5GIFNlY3VyZSBTZXJ2ZXIgUm9v
+dCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANvrayvmZFSVgpCj
+cqQZAZ2cC4Ffc0m6p6zzBE57lgvsEeBbphzOG9INgxwruJ4dfkUyYA8H6XdYfp9q
+yGFOtibBTI3/TO80sh9l2Ll49a2pcbnvT1gdpd50IJeh7WhM3pIXS7yr/2WanvtH
+2Vdy8wmhrnZEE26cLUQ5vPnHO6RYPUG9tMJJo8gN0pcvB2VSAKduyK9o7PQUlrZX
+H1bDOZ8rbeTzPvY1ZNoMHKGESy9LS+IsJJ1tk0DrtSOOMspvRdOoiXsezx76W0OL
+zc2oD2rKDF65nkeP8Nm2CgtYZRczuSPkdxl9y0oukntPLxB3sY0vaJxizOBQ+OyR
+p1RMVwnVdmPF6GUe7m1qzwmd+nxPrWAI/VaZDxUse6mAq4xhj0oHdkLePfTdsiQz
+W7i1o0TJrH93PB0j7IKppuLIBkwC/qxcmZkLLxCKpvR/1Yd0DVlJRfbwcVw5Kda/
+SiOL9V8BY9KHcyi1Swr1+KuCLH5zJTIdC2MKF4EA/7Z2Xue0sUDKIbvVgFHlSFJn
+LNJhiQcND85Cd8BEc5xEUKDbEAotlRyBr+Qc5RQe8TZBAQIvfXOn3kLMTOmJDVb3
+n5HUA8ZsyY/b2BzgQJhdZpmYgG4t/wHFzstGH6wCxkPmrqKEPMVOHj1tyRRM4y5B
+u8o5vzY8KhmqQYdOpc5LMnndkEl/AgMBAAGjYzBhMB8GA1UdIwQYMBaAFJxf0Gxj
+o1+TypOYCK2Mh6UsXME3MB0GA1UdDgQWBBScX9BsY6Nfk8qTmAitjIelLFzBNzAO
+BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOC
+AgEATh65isagmD9uw2nAalxJUqzLK114OMHVVISfk/CHGT0sZonrDUL8zPB1hT+L
+9IBdeeUXZ701guLyPI59WzbLWoAAKfLOKyzxj6ptBZNscsdW699QIyjlRRA96Gej
+rw5VD5AJYu9LWaL2U/HANeQvwSS9eS9OICI7/RogsKQOLHDtdD+4E5UGUcjohybK
+pFtqFiGS3XNgnhAY3jyB6ugYw3yJ8otQPr0R4hUDqDZ9MwFsSBXXiJCZBMXM5gf0
+vPSQ7RPi6ovDj6MzD8EpTBNO2hVWcXNyglD2mjN8orGoGjR0ZVzO0eurU+AagNjq
+OknkJjCb5RyKqKkVMoaZkgoQI1YS4PbOTOK7vtuNknMBZi9iPrJyJ0U27U1W45eZ
+/zo1PqVUSlJZS2Db7v54EX9K3BR5YLZrZAPbFYPhor72I5dQ8AkzNqdxliXzuUJ9
+2zg/LFis6ELhDtjTO0wugumDLmsx2d1Hhk9tl5EuT+IocTUW0fJz/iUrB0ckYyfI
++PbZa/wSMVYIwFNCr5zQM378BvAxRAMU8Vjq8moNqRGyg77FGr8H6lnco4g175x2
+MjxNBiLOFeXdntiP2t7SxDnlF4HPOEfrf4htWRvfn0IUrn7PqLBmZdo3r5+qPeoo
+tt7VMVgWglvquxl1AnMaykgaIZOQCo6ThKd9OyMYkomgjaw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Subject: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Label: "Certum EC-384 CA"
+# Serial: 160250656287871593594747141429395092468
+# MD5 Fingerprint: b6:65:b3:96:60:97:12:a1:ec:4e:e1:3d:a3:c6:c9:f1
+# SHA1 Fingerprint: f3:3e:78:3c:ac:df:f4:a2:cc:ac:67:55:69:56:d7:e5:16:3c:e1:ed
+# SHA256 Fingerprint: 6b:32:80:85:62:53:18:aa:50:d1:73:c9:8d:8b:da:09:d5:7e:27:41:3d:11:4c:f7:87:a0:f5:d0:6c:03:0c:f6
+-----BEGIN CERTIFICATE-----
+MIICZTCCAeugAwIBAgIQeI8nXIESUiClBNAt3bpz9DAKBggqhkjOPQQDAzB0MQsw
+CQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEuMScw
+JQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAXBgNVBAMT
+EENlcnR1bSBFQy0zODQgQ0EwHhcNMTgwMzI2MDcyNDU0WhcNNDMwMzI2MDcyNDU0
+WjB0MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBT
+LkEuMScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAX
+BgNVBAMTEENlcnR1bSBFQy0zODQgQ0EwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATE
+KI6rGFtqvm5kN2PkzeyrOvfMobgOgknXhimfoZTy42B4mIF4Bk3y7JoOV2CDn7Tm
+Fy8as10CW4kjPMIRBSqniBMY81CE1700LCeJVf/OTOffph8oxPBUw7l8t1Ot68Kj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI0GZnQkdjrzife81r1HfS+8
+EF9LMA4GA1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNoADBlAjADVS2m5hjEfO/J
+UG7BJw+ch69u1RsIGL2SKcHvlJF40jocVYli5RsJHrpka/F2tNQCMQC0QoSZ/6vn
+nvuRlydd3LBbMHHOXjgaatkl5+r3YZJW+OraNsKHZZYuciUvf9/DE8k=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Root CA"
+# Serial: 40870380103424195783807378461123655149
+# MD5 Fingerprint: 51:e1:c2:e7:fe:4c:84:af:59:0e:2f:f4:54:6f:ea:29
+# SHA1 Fingerprint: c8:83:44:c0:18:ae:9f:cc:f1:87:b7:8f:22:d1:c5:d7:45:84:ba:e5
+# SHA256 Fingerprint: fe:76:96:57:38:55:77:3e:37:a9:5e:7a:d4:d9:cc:96:c3:01:57:c1:5d:31:76:5b:a9:b1:57:04:e1:ae:78:fd
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TunTrust Root CA O=Agence Nationale de Certification Electronique
+# Subject: CN=TunTrust Root CA O=Agence Nationale de Certification Electronique
+# Label: "TunTrust Root CA"
+# Serial: 108534058042236574382096126452369648152337120275
+# MD5 Fingerprint: 85:13:b9:90:5b:36:5c:b6:5e:b8:5a:f8:e0:31:57:b4
+# SHA1 Fingerprint: cf:e9:70:84:0f:e0:73:0f:9d:f6:0c:7f:2c:4b:ee:20:46:34:9c:bb
+# SHA256 Fingerprint: 2e:44:10:2a:b5:8c:b8:54:19:45:1c:8e:19:d9:ac:f3:66:2c:af:bc:61:4b:6a:53:96:0a:30:f7:d0:e2:eb:41
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=HARICA TLS RSA Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Subject: CN=HARICA TLS RSA Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Label: "HARICA TLS RSA Root CA 2021"
+# Serial: 76817823531813593706434026085292783742
+# MD5 Fingerprint: 65:47:9b:58:86:dd:2c:f0:fc:a2:84:1f:1e:96:c4:91
+# SHA1 Fingerprint: 02:2d:05:82:fa:88:ce:14:0c:06:79:de:7f:14:10:e9:45:d7:a5:6d
+# SHA256 Fingerprint: d9:5d:0e:8e:da:79:52:5b:f9:be:b1:1b:14:d2:10:0d:32:94:98:5f:0c:62:d9:fa:bd:9c:d9:99:ec:cb:7b:1d
+-----BEGIN CERTIFICATE-----
+MIIFpDCCA4ygAwIBAgIQOcqTHO9D88aOk8f0ZIk4fjANBgkqhkiG9w0BAQsFADBs
+MQswCQYDVQQGEwJHUjE3MDUGA1UECgwuSGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBDQTEkMCIGA1UEAwwbSEFSSUNBIFRMUyBSU0Eg
+Um9vdCBDQSAyMDIxMB4XDTIxMDIxOTEwNTUzOFoXDTQ1MDIxMzEwNTUzN1owbDEL
+MAkGA1UEBhMCR1IxNzA1BgNVBAoMLkhlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNl
+YXJjaCBJbnN0aXR1dGlvbnMgQ0ExJDAiBgNVBAMMG0hBUklDQSBUTFMgUlNBIFJv
+b3QgQ0EgMjAyMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIvC569l
+mwVnlskNJLnQDmT8zuIkGCyEf3dRywQRNrhe7Wlxp57kJQmXZ8FHws+RFjZiPTgE
+4VGC/6zStGndLuwRo0Xua2s7TL+MjaQenRG56Tj5eg4MmOIjHdFOY9TnuEFE+2uv
+a9of08WRiFukiZLRgeaMOVig1mlDqa2YUlhu2wr7a89o+uOkXjpFc5gH6l8Cct4M
+pbOfrqkdtx2z/IpZ525yZa31MJQjB/OCFks1mJxTuy/K5FrZx40d/JiZ+yykgmvw
+Kh+OC19xXFyuQnspiYHLA6OZyoieC0AJQTPb5lh6/a6ZcMBaD9YThnEvdmn8kN3b
+LW7R8pv1GmuebxWMevBLKKAiOIAkbDakO/IwkfN4E8/BPzWr8R0RI7VDIp4BkrcY
+AuUR0YLbFQDMYTfBKnya4dC6s1BG7oKsnTH4+yPiAwBIcKMJJnkVU2DzOFytOOqB
+AGMUuTNe3QvboEUHGjMJ+E20pwKmafTCWQWIZYVWrkvL4N48fS0ayOn7H6NhStYq
+E613TBoYm5EPWNgGVMWX+Ko/IIqmhaZ39qb8HOLubpQzKoNQhArlT4b4UEV4AIHr
+W2jjJo3Me1xR9BQsQL4aYB16cmEdH2MtiKrOokWQCPxrvrNQKlr9qEgYRtaQQJKQ
+CoReaDH46+0N0x3GfZkYVVYnZS6NRcUk7M7jAgMBAAGjQjBAMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFApII6ZgpJIKM+qTW8VX6iVNvRLuMA4GA1UdDwEB/wQE
+AwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAPpBIqm5iFSVmewzVjIuJndftTgfvnNAU
+X15QvWiWkKQUEapobQk1OUAJ2vQJLDSle1mESSmXdMgHHkdt8s4cUCbjnj1AUz/3
+f5Z2EMVGpdAgS1D0NTsY9FVqQRtHBmg8uwkIYtlfVUKqrFOFrJVWNlar5AWMxaja
+H6NpvVMPxP/cyuN+8kyIhkdGGvMA9YCRotxDQpSbIPDRzbLrLFPCU3hKTwSUQZqP
+JzLB5UkZv/HywouoCjkxKLR9YjYsTewfM7Z+d21+UPCfDtcRj88YxeMn/ibvBZ3P
+zzfF0HvaO7AWhAw6k9a+F9sPPg4ZeAnHqQJyIkv3N3a6dcSFA1pj1bF1BcK5vZSt
+jBWZp5N99sXzqnTPBIWUmAD04vnKJGW/4GKvyMX6ssmeVkjaef2WdhW+o45WxLM0
+/L5H9MG0qPzVMIho7suuyWPEdr6sOBjhXlzPrjoiUevRi7PzKzMHVIf6tLITe7pT
+BGIBnfHAT+7hOtSLIBD6Alfm78ELt5BGnBkpjNxvoEppaZS3JGWg/6w/zgH7IS79
+aPib8qXPMThcFarmlwDB31qlpzmq6YR/PFGoOtmUW4y/Twhx5duoXNTSpv4Ao8YW
+xw/ogM4cKGR0GQjTQuPOAF1/sdwTsOEFy9EgqoZ0njnnkf3/W9b3raYvAwtt41dU
+63ZTGI0RmLo=
+-----END CERTIFICATE-----
+
+# Issuer: CN=HARICA TLS ECC Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Subject: CN=HARICA TLS ECC Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Label: "HARICA TLS ECC Root CA 2021"
+# Serial: 137515985548005187474074462014555733966
+# MD5 Fingerprint: ae:f7:4c:e5:66:35:d1:b7:9b:8c:22:93:74:d3:4b:b0
+# SHA1 Fingerprint: bc:b0:c1:9d:e9:98:92:70:19:38:57:e9:8d:a7:b4:5d:6e:ee:01:48
+# SHA256 Fingerprint: 3f:99:cc:47:4a:cf:ce:4d:fe:d5:87:94:66:5e:47:8d:15:47:73:9f:2e:78:0f:1b:b4:ca:9b:13:30:97:d4:01
+-----BEGIN CERTIFICATE-----
+MIICVDCCAdugAwIBAgIQZ3SdjXfYO2rbIvT/WeK/zjAKBggqhkjOPQQDAzBsMQsw
+CQYDVQQGEwJHUjE3MDUGA1UECgwuSGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJlc2Vh
+cmNoIEluc3RpdHV0aW9ucyBDQTEkMCIGA1UEAwwbSEFSSUNBIFRMUyBFQ0MgUm9v
+dCBDQSAyMDIxMB4XDTIxMDIxOTExMDExMFoXDTQ1MDIxMzExMDEwOVowbDELMAkG
+A1UEBhMCR1IxNzA1BgNVBAoMLkhlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJj
+aCBJbnN0aXR1dGlvbnMgQ0ExJDAiBgNVBAMMG0hBUklDQSBUTFMgRUNDIFJvb3Qg
+Q0EgMjAyMTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDgI/rGgltJ6rK9JOtDA4MM7
+KKrxcm1lAEeIhPyaJmuqS7psBAqIXhfyVYf8MLA04jRYVxqEU+kw2anylnTDUR9Y
+STHMmE5gEYd103KUkE+bECUqqHgtvpBBWJAVcqeht6NCMEAwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUyRtTgRL+BNUW0aq8mm+3oJUZbsowDgYDVR0PAQH/BAQD
+AgGGMAoGCCqGSM49BAMDA2cAMGQCMBHervjcToiwqfAircJRQO9gcS3ujwLEXQNw
+SaSS6sUUiHCm0w2wqsosQJz76YJumgIwK0eaB8bRwoF8yguWGEEbo/QwCZ61IygN
+nxS2PFOiTAZpffpskcYqSUXm7LcT4Tps
+-----END CERTIFICATE-----
+
+# Issuer: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Subject: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Label: "Autoridad de Certificacion Firmaprofesional CIF A62634068"
+# Serial: 1977337328857672817
+# MD5 Fingerprint: 4e:6e:9b:54:4c:ca:b7:fa:48:e4:90:b1:15:4b:1c:a3
+# SHA1 Fingerprint: 0b:be:c2:27:22:49:cb:39:aa:db:35:5c:53:e3:8c:ae:78:ff:b6:fe
+# SHA256 Fingerprint: 57:de:05:83:ef:d2:b2:6e:03:61:da:99:da:9d:f4:64:8d:ef:7e:e8:44:1c:3b:72:8a:fa:9b:cd:e0:f9:b2:6a
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=vTrus ECC Root CA O=iTrusChina Co.,Ltd.
+# Subject: CN=vTrus ECC Root CA O=iTrusChina Co.,Ltd.
+# Label: "vTrus ECC Root CA"
+# Serial: 630369271402956006249506845124680065938238527194
+# MD5 Fingerprint: de:4b:c1:f5:52:8c:9b:43:e1:3e:8f:55:54:17:8d:85
+# SHA1 Fingerprint: f6:9c:db:b0:fc:f6:02:13:b6:52:32:a6:a3:91:3f:16:70:da:c3:e1
+# SHA256 Fingerprint: 30:fb:ba:2c:32:23:8e:2a:98:54:7a:f9:79:31:e5:50:42:8b:9b:3f:1c:8e:eb:66:33:dc:fa:86:c5:b2:7d:d3
+-----BEGIN CERTIFICATE-----
+MIICDzCCAZWgAwIBAgIUbmq8WapTvpg5Z6LSa6Q75m0c1towCgYIKoZIzj0EAwMw
+RzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28uLEx0ZC4xGjAY
+BgNVBAMTEXZUcnVzIEVDQyBSb290IENBMB4XDTE4MDczMTA3MjY0NFoXDTQzMDcz
+MTA3MjY0NFowRzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28u
+LEx0ZC4xGjAYBgNVBAMTEXZUcnVzIEVDQyBSb290IENBMHYwEAYHKoZIzj0CAQYF
+K4EEACIDYgAEZVBKrox5lkqqHAjDo6LN/llWQXf9JpRCux3NCNtzslt188+cToL0
+v/hhJoVs1oVbcnDS/dtitN9Ti72xRFhiQgnH+n9bEOf+QP3A2MMrMudwpremIFUd
+e4BdS49nTPEQo0IwQDAdBgNVHQ4EFgQUmDnNvtiyjPeyq+GtJK97fKHbH88wDwYD
+VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0EAwMDaAAwZQIw
+V53dVvHH4+m4SVBrm2nDb+zDfSXkV5UTQJtS0zvzQBm8JsctBp61ezaf9SXUY2sA
+AjEA6dPGnlaaKsyh2j/IZivTWJwghfqrkYpwcBE4YGQLYgmRWAD5Tfs0aNoJrSEG
+GJTO
+-----END CERTIFICATE-----
+
+# Issuer: CN=vTrus Root CA O=iTrusChina Co.,Ltd.
+# Subject: CN=vTrus Root CA O=iTrusChina Co.,Ltd.
+# Label: "vTrus Root CA"
+# Serial: 387574501246983434957692974888460947164905180485
+# MD5 Fingerprint: b8:c9:37:df:fa:6b:31:84:64:c5:ea:11:6a:1b:75:fc
+# SHA1 Fingerprint: 84:1a:69:fb:f5:cd:1a:25:34:13:3d:e3:f8:fc:b8:99:d0:c9:14:b7
+# SHA256 Fingerprint: 8a:71:de:65:59:33:6f:42:6c:26:e5:38:80:d0:0d:88:a1:8d:a4:c6:a9:1f:0d:cb:61:94:e2:06:c5:c9:63:87
+-----BEGIN CERTIFICATE-----
+MIIFVjCCAz6gAwIBAgIUQ+NxE9izWRRdt86M/TX9b7wFjUUwDQYJKoZIhvcNAQEL
+BQAwQzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28uLEx0ZC4x
+FjAUBgNVBAMTDXZUcnVzIFJvb3QgQ0EwHhcNMTgwNzMxMDcyNDA1WhcNNDMwNzMx
+MDcyNDA1WjBDMQswCQYDVQQGEwJDTjEcMBoGA1UEChMTaVRydXNDaGluYSBDby4s
+THRkLjEWMBQGA1UEAxMNdlRydXMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEBBQAD
+ggIPADCCAgoCggIBAL1VfGHTuB0EYgWgrmy3cLRB6ksDXhA/kFocizuwZotsSKYc
+IrrVQJLuM7IjWcmOvFjai57QGfIvWcaMY1q6n6MLsLOaXLoRuBLpDLvPbmyAhykU
+AyyNJJrIZIO1aqwTLDPxn9wsYTwaP3BVm60AUn/PBLn+NvqcwBauYv6WTEN+VRS+
+GrPSbcKvdmaVayqwlHeFXgQPYh1jdfdr58tbmnDsPmcF8P4HCIDPKNsFxhQnL4Z9
+8Cfe/+Z+M0jnCx5Y0ScrUw5XSmXX+6KAYPxMvDVTAWqXcoKv8R1w6Jz1717CbMdH
+flqUhSZNO7rrTOiwCcJlwp2dCZtOtZcFrPUGoPc2BX70kLJrxLT5ZOrpGgrIDajt
+J8nU57O5q4IikCc9Kuh8kO+8T/3iCiSn3mUkpF3qwHYw03dQ+A0Em5Q2AXPKBlim
+0zvc+gRGE1WKyURHuFE5Gi7oNOJ5y1lKCn+8pu8fA2dqWSslYpPZUxlmPCdiKYZN
+pGvu/9ROutW04o5IWgAZCfEF2c6Rsffr6TlP9m8EQ5pV9T4FFL2/s1m02I4zhKOQ
+UqqzApVg+QxMaPnu1RcN+HFXtSXkKe5lXa/R7jwXC1pDxaWG6iSe4gUH3DRCEpHW
+OXSuTEGC2/KmSNGzm/MzqvOmwMVO9fSddmPmAsYiS8GVP1BkLFTltvA8Kc9XAgMB
+AAGjQjBAMB0GA1UdDgQWBBRUYnBj8XWEQ1iO0RYgscasGrz2iTAPBgNVHRMBAf8E
+BTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAKbqSSaet
+8PFww+SX8J+pJdVrnjT+5hpk9jprUrIQeBqfTNqK2uwcN1LgQkv7bHbKJAs5EhWd
+nxEt/Hlk3ODg9d3gV8mlsnZwUKT+twpw1aA08XXXTUm6EdGz2OyC/+sOxL9kLX1j
+bhd47F18iMjrjld22VkE+rxSH0Ws8HqA7Oxvdq6R2xCOBNyS36D25q5J08FsEhvM
+Kar5CKXiNxTKsbhm7xqC5PD48acWabfbqWE8n/Uxy+QARsIvdLGx14HuqCaVvIiv
+TDUHKgLKeBRtRytAVunLKmChZwOgzoy8sHJnxDHO2zTlJQNgJXtxmOTAGytfdELS
+S8VZCAeHvsXDf+eW2eHcKJfWjwXj9ZtOyh1QRwVTsMo554WgicEFOwE30z9J4nfr
+I8iIZjs9OXYhRvHsXyO466JmdXTBQPfYaJqT4i2pLr0cox7IdMakLXogqzu4sEb9
+b91fUlV1YvCXoHzXOP0l382gmxDPi7g4Xl7FtKYCNqEeXxzP4padKar9mK5S4fNB
+UvupLnKWnyfjqnN9+BojZns7q2WwMgFLFT49ok8MKzWixtlnEjUwzXYuFrOZnk1P
+Ti07NEPhmg4NpGaXutIcSkwsKouLgU9xGqndXHt7CMUADTdA43x7VF8vhV929ven
+sBxXVsFy6K2ir40zSbofitzmdHxghm+Hl3s=
+-----END CERTIFICATE-----
+
+# Issuer: CN=ISRG Root X2 O=Internet Security Research Group
+# Subject: CN=ISRG Root X2 O=Internet Security Research Group
+# Label: "ISRG Root X2"
+# Serial: 87493402998870891108772069816698636114
+# MD5 Fingerprint: d3:9e:c4:1e:23:3c:a6:df:cf:a3:7e:6d:e0:14:e6:e5
+# SHA1 Fingerprint: bd:b1:b9:3c:d5:97:8d:45:c6:26:14:55:f8:db:95:c7:5a:d1:53:af
+# SHA256 Fingerprint: 69:72:9b:8e:15:a8:6e:fc:17:7a:57:af:b7:17:1d:fc:64:ad:d2:8c:2f:ca:8c:f1:50:7e:34:45:3c:cb:14:70
+-----BEGIN CERTIFICATE-----
+MIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw
+CQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg
+R3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00
+MDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT
+ZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw
+EAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW
++1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9
+ItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T
+AQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI
+zj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW
+tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1
+/q4AaOeMSQ+2b1tbFfLn
+-----END CERTIFICATE-----
+
+# Issuer: CN=HiPKI Root CA - G1 O=Chunghwa Telecom Co., Ltd.
+# Subject: CN=HiPKI Root CA - G1 O=Chunghwa Telecom Co., Ltd.
+# Label: "HiPKI Root CA - G1"
+# Serial: 60966262342023497858655262305426234976
+# MD5 Fingerprint: 69:45:df:16:65:4b:e8:68:9a:8f:76:5f:ff:80:9e:d3
+# SHA1 Fingerprint: 6a:92:e4:a8:ee:1b:ec:96:45:37:e3:29:57:49:cd:96:e3:e5:d2:60
+# SHA256 Fingerprint: f0:15:ce:3c:c2:39:bf:ef:06:4b:e9:f1:d2:c4:17:e1:a0:26:4a:0a:94:be:1f:0c:8d:12:18:64:eb:69:49:cc
+-----BEGIN CERTIFICATE-----
+MIIFajCCA1KgAwIBAgIQLd2szmKXlKFD6LDNdmpeYDANBgkqhkiG9w0BAQsFADBP
+MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0
+ZC4xGzAZBgNVBAMMEkhpUEtJIFJvb3QgQ0EgLSBHMTAeFw0xOTAyMjIwOTQ2MDRa
+Fw0zNzEyMzExNTU5NTlaME8xCzAJBgNVBAYTAlRXMSMwIQYDVQQKDBpDaHVuZ2h3
+YSBUZWxlY29tIENvLiwgTHRkLjEbMBkGA1UEAwwSSGlQS0kgUm9vdCBDQSAtIEcx
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA9B5/UnMyDHPkvRN0o9Qw
+qNCuS9i233VHZvR85zkEHmpwINJaR3JnVfSl6J3VHiGh8Ge6zCFovkRTv4354twv
+Vcg3Px+kwJyz5HdcoEb+d/oaoDjq7Zpy3iu9lFc6uux55199QmQ5eiY29yTw1S+6
+lZgRZq2XNdZ1AYDgr/SEYYwNHl98h5ZeQa/rh+r4XfEuiAU+TCK72h8q3VJGZDnz
+Qs7ZngyzsHeXZJzA9KMuH5UHsBffMNsAGJZMoYFL3QRtU6M9/Aes1MU3guvklQgZ
+KILSQjqj2FPseYlgSGDIcpJQ3AOPgz+yQlda22rpEZfdhSi8MEyr48KxRURHH+CK
+FgeW0iEPU8DtqX7UTuybCeyvQqww1r/REEXgphaypcXTT3OUM3ECoWqj1jOXTyFj
+HluP2cFeRXF3D4FdXyGarYPM+l7WjSNfGz1BryB1ZlpK9p/7qxj3ccC2HTHsOyDr
+y+K49a6SsvfhhEvyovKTmiKe0xRvNlS9H15ZFblzqMF8b3ti6RZsR1pl8w4Rm0bZ
+/W3c1pzAtH2lsN0/Vm+h+fbkEkj9Bn8SV7apI09bA8PgcSojt/ewsTu8mL3WmKgM
+a/aOEmem8rJY5AIJEzypuxC00jBF8ez3ABHfZfjcK0NVvxaXxA/VLGGEqnKG/uY6
+fsI/fe78LxQ+5oXdUG+3Se0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQU8ncX+l6o/vY9cdVouslGDDjYr7AwDgYDVR0PAQH/BAQDAgGGMA0GCSqG
+SIb3DQEBCwUAA4ICAQBQUfB13HAE4/+qddRxosuej6ip0691x1TPOhwEmSKsxBHi
+7zNKpiMdDg1H2DfHb680f0+BazVP6XKlMeJ45/dOlBhbQH3PayFUhuaVevvGyuqc
+SE5XCV0vrPSltJczWNWseanMX/mF+lLFjfiRFOs6DRfQUsJ748JzjkZ4Bjgs6Fza
+ZsT0pPBWGTMpWmWSBUdGSquEwx4noR8RkpkndZMPvDY7l1ePJlsMu5wP1G4wB9Tc
+XzZoZjmDlicmisjEOf6aIW/Vcobpf2Lll07QJNBAsNB1CI69aO4I1258EHBGG3zg
+iLKecoaZAeO/n0kZtCW+VmWuF2PlHt/o/0elv+EmBYTksMCv5wiZqAxeJoBF1Pho
+L5aPruJKHJwWDBNvOIf2u8g0X5IDUXlwpt/L9ZlNec1OvFefQ05rLisY+GpzjLrF
+Ne85akEez3GoorKGB1s6yeHvP2UEgEcyRHCVTjFnanRbEEV16rCf0OY1/k6fi8wr
+kkVbbiVghUbN0aqwdmaTd5a+g744tiROJgvM7XpWGuDpWsZkrUx6AEhEL7lAuxM+
+vhV4nYWBSipX3tUZQ9rbyltHhoMLP7YNdnhzeSJesYAfz77RP1YQmCuVh6EfnWQU
+YDksswBVLuT1sw5XxJFBAJw/6KXf6vb/yPCtbVKoF6ubYfwSUTXkJf2vqmqGOQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Label: "GlobalSign ECC Root CA - R4"
+# Serial: 159662223612894884239637590694
+# MD5 Fingerprint: 26:29:f8:6d:e1:88:bf:a2:65:7f:aa:c4:cd:0f:7f:fc
+# SHA1 Fingerprint: 6b:a0:b0:98:e1:71:ef:5a:ad:fe:48:15:80:77:10:f4:bd:6f:0b:28
+# SHA256 Fingerprint: b0:85:d7:0b:96:4f:19:1a:73:e4:af:0d:54:ae:7a:0e:07:aa:fd:af:9b:71:dd:08:62:13:8a:b7:32:5a:24:a2
+-----BEGIN CERTIFICATE-----
+MIIB3DCCAYOgAwIBAgINAgPlfvU/k/2lCSGypjAKBggqhkjOPQQDAjBQMSQwIgYD
+VQQLExtHbG9iYWxTaWduIEVDQyBSb290IENBIC0gUjQxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTIxMTEzMDAwMDAwWhcNMzgw
+MTE5MDMxNDA3WjBQMSQwIgYDVQQLExtHbG9iYWxTaWduIEVDQyBSb290IENBIC0g
+UjQxEzARBgNVBAoTCkdsb2JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wWTAT
+BgcqhkjOPQIBBggqhkjOPQMBBwNCAAS4xnnTj2wlDp8uORkcA6SumuU5BwkWymOx
+uYb4ilfBV85C+nOh92VC/x7BALJucw7/xyHlGKSq2XE/qNS5zowdo0IwQDAOBgNV
+HQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVLB7rUW44kB/
++wpu+74zyTyjhNUwCgYIKoZIzj0EAwIDRwAwRAIgIk90crlgr/HmnKAWBVBfw147
+bmF0774BxL4YSFlhgjICICadVGNA3jdgUM/I2O2dgq43mLyjj0xMqTQrbO/7lZsm
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R1 O=Google Trust Services LLC
+# Subject: CN=GTS Root R1 O=Google Trust Services LLC
+# Label: "GTS Root R1"
+# Serial: 159662320309726417404178440727
+# MD5 Fingerprint: 05:fe:d0:bf:71:a8:a3:76:63:da:01:e0:d8:52:dc:40
+# SHA1 Fingerprint: e5:8c:1c:c4:91:3b:38:63:4b:e9:10:6e:e3:ad:8e:6b:9d:d9:81:4a
+# SHA256 Fingerprint: d9:47:43:2a:bd:e7:b7:fa:90:fc:2e:6b:59:10:1b:12:80:e0:e1:c7:e4:e4:0f:a3:c6:88:7f:ff:57:a7:f4:cf
+-----BEGIN CERTIFICATE-----
+MIIFVzCCAz+gAwIBAgINAgPlk28xsBNJiGuiFzANBgkqhkiG9w0BAQwFADBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEBAQUA
+A4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaMf/vo
+27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vXmX7w
+Cl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7zUjw
+TcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0Pfybl
+qAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtcvfaH
+szVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4Zor8
+Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUspzBmk
+MiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOORc92
+wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYWk70p
+aDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+DVrN
+VjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgFlQID
+AQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBAJ+qQibb
+C5u+/x6Wki4+omVKapi6Ist9wTrYggoGxval3sBOh2Z5ofmmWJyq+bXmYOfg6LEe
+QkEzCzc9zolwFcq1JKjPa7XSQCGYzyI0zzvFIoTgxQ6KfF2I5DUkzps+GlQebtuy
+h6f88/qBVRRiClmpIgUxPoLW7ttXNLwzldMXG+gnoot7TiYaelpkttGsN/H9oPM4
+7HLwEXWdyzRSjeZ2axfG34arJ45JK3VmgRAhpuo+9K4l/3wV3s6MJT/KYnAK9y8J
+ZgfIPxz88NtFMN9iiMG1D53Dn0reWVlHxYciNuaCp+0KueIHoI17eko8cdLiA6Ef
+MgfdG+RCzgwARWGAtQsgWSl4vflVy2PFPEz0tv/bal8xa5meLMFrUKTX5hgUvYU/
+Z6tGn6D/Qqc6f1zLXbBwHSs09dR2CQzreExZBfMzQsNhFRAbd03OIozUhfJFfbdT
+6u9AWpQKXCBfTkBdYiJ23//OYb2MI3jSNwLgjt7RETeJ9r/tSQdirpLsQBqvFAnZ
+0E6yove+7u7Y/9waLd64NnHi/Hm3lCXRSHNboTXns5lndcEZOitHTtNCjv0xyBZm
+2tIMPNuzjsmhDYAPexZ3FL//2wmUspO8IFgV6dtxQ/PeEMMA3KgqlbbC1j+Qa3bb
+bP6MvPJwNQzcmRk13NfIRmPVNnGuV/u3gm3c
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R2 O=Google Trust Services LLC
+# Subject: CN=GTS Root R2 O=Google Trust Services LLC
+# Label: "GTS Root R2"
+# Serial: 159662449406622349769042896298
+# MD5 Fingerprint: 1e:39:c0:53:e6:1e:29:82:0b:ca:52:55:36:5d:57:dc
+# SHA1 Fingerprint: 9a:44:49:76:32:db:de:fa:d0:bc:fb:5a:7b:17:bd:9e:56:09:24:94
+# SHA256 Fingerprint: 8d:25:cd:97:22:9d:bf:70:35:6b:da:4e:b3:cc:73:40:31:e2:4c:f0:0f:af:cf:d3:2d:c7:6e:b5:84:1c:7e:a8
+-----BEGIN CERTIFICATE-----
+MIIFVzCCAz+gAwIBAgINAgPlrsWNBCUaqxElqjANBgkqhkiG9w0BAQwFADBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEBAQUA
+A4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3LvCvpt
+nfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3KgGjSY
+6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9BuXvAu
+MC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOdre7k
+RXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXuPuWg
+f9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1mKPV
++3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K8Yzo
+dDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqjx5RW
+Ir9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsRnTKa
+G73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0kzCq
+gc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9OktwID
+AQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBAB/Kzt3H
+vqGf2SdMC9wXmBFqiN495nFWcrKeGk6c1SuYJF2ba3uwM4IJvd8lRuqYnrYb/oM8
+0mJhwQTtzuDFycgTE1XnqGOtjHsB/ncw4c5omwX4Eu55MaBBRTUoCnGkJE+M3DyC
+B19m3H0Q/gxhswWV7uGugQ+o+MePTagjAiZrHYNSVc61LwDKgEDg4XSsYPWHgJ2u
+NmSRXbBoGOqKYcl3qJfEycel/FVL8/B/uWU9J2jQzGv6U53hkRrJXRqWbTKH7QMg
+yALOWr7Z6v2yTcQvG99fevX4i8buMTolUVVnjWQye+mew4K6Ki3pHrTgSAai/Gev
+HyICc/sgCq+dVEuhzf9gR7A/Xe8bVr2XIZYtCtFenTgCR2y59PYjJbigapordwj6
+xLEokCZYCDzifqrXPW+6MYgKBesntaFJ7qBFVHvmJ2WZICGoo7z7GJa7Um8M7YNR
+TOlZ4iBgxcJlkoKM8xAfDoqXvneCbT+PHV28SSe9zE8P4c52hgQjxcCMElv924Sg
+JPFI/2R80L5cFtHvma3AH/vLrrw4IgYmZNralw4/KBVEqE8AyvCazM90arQ+POuV
+7LXTWtiBmelDGDfrs7vRWGJB82bSj6p4lVQgw1oudCvV0b4YacCs1aTPObpRhANl
+6WLAYv7YTVWW4tAR+kg0Eeye7QUd5MjWHYbL
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R3 O=Google Trust Services LLC
+# Subject: CN=GTS Root R3 O=Google Trust Services LLC
+# Label: "GTS Root R3"
+# Serial: 159662495401136852707857743206
+# MD5 Fingerprint: 3e:e7:9d:58:02:94:46:51:94:e5:e0:22:4a:8b:e7:73
+# SHA1 Fingerprint: ed:e5:71:80:2b:c8:92:b9:5b:83:3c:d2:32:68:3f:09:cd:a0:1e:46
+# SHA256 Fingerprint: 34:d8:a7:3e:e2:08:d9:bc:db:0d:95:65:20:93:4b:4e:40:e6:94:82:59:6e:8b:6f:73:c8:42:6b:01:0a:6f:48
+-----BEGIN CERTIFICATE-----
+MIICCTCCAY6gAwIBAgINAgPluILrIPglJ209ZjAKBggqhkjOPQQDAzBHMQswCQYD
+VQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEUMBIG
+A1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAwMDAw
+WjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2Vz
+IExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout736G
+jOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2ADDL2
+4CejQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEA9uEglRR7
+VKOQFhG/hMjqb2sXnh5GmCCbn9MN2azTL818+FsuVbu/3ZL3pAzcMeGiAjEA/Jdm
+ZuVDFhOD3cffL74UOO0BzrEXGhF16b0DjyZ+hOXJYKaV11RZt+cRLInUue4X
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R4 O=Google Trust Services LLC
+# Subject: CN=GTS Root R4 O=Google Trust Services LLC
+# Label: "GTS Root R4"
+# Serial: 159662532700760215368942768210
+# MD5 Fingerprint: 43:96:83:77:19:4d:76:b3:9d:65:52:e4:1d:22:a5:e8
+# SHA1 Fingerprint: 77:d3:03:67:b5:e0:0c:15:f6:0c:38:61:df:7c:e1:3b:92:46:4d:47
+# SHA256 Fingerprint: 34:9d:fa:40:58:c5:e2:63:12:3b:39:8a:e7:95:57:3c:4e:13:13:c8:3f:e6:8f:93:55:6c:d5:e8:03:1b:3c:7d
+-----BEGIN CERTIFICATE-----
+MIICCTCCAY6gAwIBAgINAgPlwGjvYxqccpBQUjAKBggqhkjOPQQDAzBHMQswCQYD
+VQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEUMBIG
+A1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAwMDAw
+WjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2Vz
+IExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzuhXyi
+QHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/lxKvR
+HYqjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNpADBmAjEA6ED/g94D
+9J+uHXqnLrmvT/aDHQ4thQEd0dlq7A/Cr8deVl5c1RxYIigL9zC2L7F8AjEA8GE8
+p/SgguMh1YQdc4acLa/KNJvxn7kjNuK8YAOdgLOaVsjh4rsUecrNIdSUtUlD
+-----END CERTIFICATE-----
+
+# Issuer: CN=Telia Root CA v2 O=Telia Finland Oyj
+# Subject: CN=Telia Root CA v2 O=Telia Finland Oyj
+# Label: "Telia Root CA v2"
+# Serial: 7288924052977061235122729490515358
+# MD5 Fingerprint: 0e:8f:ac:aa:82:df:85:b1:f4:dc:10:1c:fc:99:d9:48
+# SHA1 Fingerprint: b9:99:cd:d1:73:50:8a:c4:47:05:08:9c:8c:88:fb:be:a0:2b:40:cd
+# SHA256 Fingerprint: 24:2b:69:74:2f:cb:1e:5b:2a:bf:98:89:8b:94:57:21:87:54:4e:5b:4d:99:11:78:65:73:62:1f:6a:74:b8:2c
+-----BEGIN CERTIFICATE-----
+MIIFdDCCA1ygAwIBAgIPAWdfJ9b+euPkrL4JWwWeMA0GCSqGSIb3DQEBCwUAMEQx
+CzAJBgNVBAYTAkZJMRowGAYDVQQKDBFUZWxpYSBGaW5sYW5kIE95ajEZMBcGA1UE
+AwwQVGVsaWEgUm9vdCBDQSB2MjAeFw0xODExMjkxMTU1NTRaFw00MzExMjkxMTU1
+NTRaMEQxCzAJBgNVBAYTAkZJMRowGAYDVQQKDBFUZWxpYSBGaW5sYW5kIE95ajEZ
+MBcGA1UEAwwQVGVsaWEgUm9vdCBDQSB2MjCCAiIwDQYJKoZIhvcNAQEBBQADggIP
+ADCCAgoCggIBALLQPwe84nvQa5n44ndp586dpAO8gm2h/oFlH0wnrI4AuhZ76zBq
+AMCzdGh+sq/H1WKzej9Qyow2RCRj0jbpDIX2Q3bVTKFgcmfiKDOlyzG4OiIjNLh9
+vVYiQJ3q9HsDrWj8soFPmNB06o3lfc1jw6P23pLCWBnglrvFxKk9pXSW/q/5iaq9
+lRdU2HhE8Qx3FZLgmEKnpNaqIJLNwaCzlrI6hEKNfdWV5Nbb6WLEWLN5xYzTNTOD
+n3WhUidhOPFZPY5Q4L15POdslv5e2QJltI5c0BE0312/UqeBAMN/mUWZFdUXyApT
+7GPzmX3MaRKGwhfwAZ6/hLzRUssbkmbOpFPlob/E2wnW5olWK8jjfN7j/4nlNW4o
+6GwLI1GpJQXrSPjdscr6bAhR77cYbETKJuFzxokGgeWKrLDiKca5JLNrRBH0pUPC
+TEPlcDaMtjNXepUugqD0XBCzYYP2AgWGLnwtbNwDRm41k9V6lS/eINhbfpSQBGq6
+WT0EBXWdN6IOLj3rwaRSg/7Qa9RmjtzG6RJOHSpXqhC8fF6CfaamyfItufUXJ63R
+DolUK5X6wK0dmBR4M0KGCqlztft0DbcbMBnEWg4cJ7faGND/isgFuvGqHKI3t+ZI
+pEYslOqodmJHixBTB0hXbOKSTbauBcvcwUpej6w9GU7C7WB1K9vBykLVAgMBAAGj
+YzBhMB8GA1UdIwQYMBaAFHKs5DN5qkWH9v2sHZ7Wxy+G2CQ5MB0GA1UdDgQWBBRy
+rOQzeapFh/b9rB2e1scvhtgkOTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUw
+AwEB/zANBgkqhkiG9w0BAQsFAAOCAgEAoDtZpwmUPjaE0n4vOaWWl/oRrfxn83EJ
+8rKJhGdEr7nv7ZbsnGTbMjBvZ5qsfl+yqwE2foH65IRe0qw24GtixX1LDoJt0nZi
+0f6X+J8wfBj5tFJ3gh1229MdqfDBmgC9bXXYfef6xzijnHDoRnkDry5023X4blMM
+A8iZGok1GTzTyVR8qPAs5m4HeW9q4ebqkYJpCh3DflminmtGFZhb069GHWLIzoBS
+SRE/yQQSwxN8PzuKlts8oB4KtItUsiRnDe+Cy748fdHif64W1lZYudogsYMVoe+K
+TTJvQS8TUoKU1xrBeKJR3Stwbbca+few4GeXVtt8YVMJAygCQMez2P2ccGrGKMOF
+6eLtGpOg3kuYooQ+BXcBlj37tCAPnHICehIv1aO6UXivKitEZU61/Qrowc15h2Er
+3oBXRb9n8ZuRXqWk7FlIEA04x7D6w0RtBPV4UBySllva9bguulvP5fBqnUsvWHMt
+Ty3EHD70sz+rFQ47GUGKpMFXEmZxTPpT41frYpUJnlTd0cI8Vzy9OK2YZLe4A5pT
+VmBds9hCG1xLEooc6+t9xnppxyd/pPiL8uSUZodL6ZQHCRJ5irLrdATczvREWeAW
+ysUsWNc8e89ihmpQfTU2Zqf7N+cox9jQraVplI/owd8k+BsHMYeB2F326CjYSlKA
+rBPuUBQemMc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST BR Root CA 1 2020 O=D-Trust GmbH
+# Subject: CN=D-TRUST BR Root CA 1 2020 O=D-Trust GmbH
+# Label: "D-TRUST BR Root CA 1 2020"
+# Serial: 165870826978392376648679885835942448534
+# MD5 Fingerprint: b5:aa:4b:d5:ed:f7:e3:55:2e:8f:72:0a:f3:75:b8:ed
+# SHA1 Fingerprint: 1f:5b:98:f0:e3:b5:f7:74:3c:ed:e6:b0:36:7d:32:cd:f4:09:41:67
+# SHA256 Fingerprint: e5:9a:aa:81:60:09:c2:2b:ff:5b:25:ba:d3:7d:f3:06:f0:49:79:7c:1f:81:d8:5a:b0:89:e6:57:bd:8f:00:44
+-----BEGIN CERTIFICATE-----
+MIIC2zCCAmCgAwIBAgIQfMmPK4TX3+oPyWWa00tNljAKBggqhkjOPQQDAzBIMQsw
+CQYDVQQGEwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRS
+VVNUIEJSIFJvb3QgQ0EgMSAyMDIwMB4XDTIwMDIxMTA5NDUwMFoXDTM1MDIxMTA5
+NDQ1OVowSDELMAkGA1UEBhMCREUxFTATBgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAG
+A1UEAxMZRC1UUlVTVCBCUiBSb290IENBIDEgMjAyMDB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABMbLxyjR+4T1mu9CFCDhQ2tuda38KwOE1HaTJddZO0Flax7mNCq7dPYS
+zuht56vkPE4/RAiLzRZxy7+SmfSk1zxQVFKQhYN4lGdnoxwJGT11NIXe7WB9xwy0
+QVK5buXuQqOCAQ0wggEJMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFHOREKv/
+VbNafAkl1bK6CKBrqx9tMA4GA1UdDwEB/wQEAwIBBjCBxgYDVR0fBIG+MIG7MD6g
+PKA6hjhodHRwOi8vY3JsLmQtdHJ1c3QubmV0L2NybC9kLXRydXN0X2JyX3Jvb3Rf
+Y2FfMV8yMDIwLmNybDB5oHegdYZzbGRhcDovL2RpcmVjdG9yeS5kLXRydXN0Lm5l
+dC9DTj1ELVRSVVNUJTIwQlIlMjBSb290JTIwQ0ElMjAxJTIwMjAyMCxPPUQtVHJ1
+c3QlMjBHbWJILEM9REU/Y2VydGlmaWNhdGVyZXZvY2F0aW9ubGlzdDAKBggqhkjO
+PQQDAwNpADBmAjEAlJAtE/rhY/hhY+ithXhUkZy4kzg+GkHaQBZTQgjKL47xPoFW
+wKrY7RjEsK70PvomAjEA8yjixtsrmfu3Ubgko6SUeho/5jbiA1czijDLgsfWFBHV
+dWNbFJWcHwHP2NVypw87
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST EV Root CA 1 2020 O=D-Trust GmbH
+# Subject: CN=D-TRUST EV Root CA 1 2020 O=D-Trust GmbH
+# Label: "D-TRUST EV Root CA 1 2020"
+# Serial: 126288379621884218666039612629459926992
+# MD5 Fingerprint: 8c:2d:9d:70:9f:48:99:11:06:11:fb:e9:cb:30:c0:6e
+# SHA1 Fingerprint: 61:db:8c:21:59:69:03:90:d8:7c:9c:12:86:54:cf:9d:3d:f4:dd:07
+# SHA256 Fingerprint: 08:17:0d:1a:a3:64:53:90:1a:2f:95:92:45:e3:47:db:0c:8d:37:ab:aa:bc:56:b8:1a:a1:00:dc:95:89:70:db
+-----BEGIN CERTIFICATE-----
+MIIC2zCCAmCgAwIBAgIQXwJB13qHfEwDo6yWjfv/0DAKBggqhkjOPQQDAzBIMQsw
+CQYDVQQGEwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRS
+VVNUIEVWIFJvb3QgQ0EgMSAyMDIwMB4XDTIwMDIxMTEwMDAwMFoXDTM1MDIxMTA5
+NTk1OVowSDELMAkGA1UEBhMCREUxFTATBgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAG
+A1UEAxMZRC1UUlVTVCBFViBSb290IENBIDEgMjAyMDB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABPEL3YZDIBnfl4XoIkqbz52Yv7QFJsnL46bSj8WeeHsxiamJrSc8ZRCC
+/N/DnU7wMyPE0jL1HLDfMxddxfCxivnvubcUyilKwg+pf3VlSSowZ/Rk99Yad9rD
+wpdhQntJraOCAQ0wggEJMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFH8QARY3
+OqQo5FD4pPfsazK2/umLMA4GA1UdDwEB/wQEAwIBBjCBxgYDVR0fBIG+MIG7MD6g
+PKA6hjhodHRwOi8vY3JsLmQtdHJ1c3QubmV0L2NybC9kLXRydXN0X2V2X3Jvb3Rf
+Y2FfMV8yMDIwLmNybDB5oHegdYZzbGRhcDovL2RpcmVjdG9yeS5kLXRydXN0Lm5l
+dC9DTj1ELVRSVVNUJTIwRVYlMjBSb290JTIwQ0ElMjAxJTIwMjAyMCxPPUQtVHJ1
+c3QlMjBHbWJILEM9REU/Y2VydGlmaWNhdGVyZXZvY2F0aW9ubGlzdDAKBggqhkjO
+PQQDAwNpADBmAjEAyjzGKnXCXnViOTYAYFqLwZOZzNnbQTs7h5kXO9XMT8oi96CA
+y/m0sRtW9XLS/BnRAjEAkfcwkz8QRitxpNA7RJvAKQIFskF3UfN5Wp6OFKBOQtJb
+gfM0agPnIjhQW+0ZT0MW
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert TLS ECC P384 Root G5 O=DigiCert, Inc.
+# Subject: CN=DigiCert TLS ECC P384 Root G5 O=DigiCert, Inc.
+# Label: "DigiCert TLS ECC P384 Root G5"
+# Serial: 13129116028163249804115411775095713523
+# MD5 Fingerprint: d3:71:04:6a:43:1c:db:a6:59:e1:a8:a3:aa:c5:71:ed
+# SHA1 Fingerprint: 17:f3:de:5e:9f:0f:19:e9:8e:f6:1f:32:26:6e:20:c4:07:ae:30:ee
+# SHA256 Fingerprint: 01:8e:13:f0:77:25:32:cf:80:9b:d1:b1:72:81:86:72:83:fc:48:c6:e1:3b:e9:c6:98:12:85:4a:49:0c:1b:05
+-----BEGIN CERTIFICATE-----
+MIICGTCCAZ+gAwIBAgIQCeCTZaz32ci5PhwLBCou8zAKBggqhkjOPQQDAzBOMQsw
+CQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xJjAkBgNVBAMTHURp
+Z2lDZXJ0IFRMUyBFQ0MgUDM4NCBSb290IEc1MB4XDTIxMDExNTAwMDAwMFoXDTQ2
+MDExNDIzNTk1OVowTjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDkRpZ2lDZXJ0LCBJ
+bmMuMSYwJAYDVQQDEx1EaWdpQ2VydCBUTFMgRUNDIFAzODQgUm9vdCBHNTB2MBAG
+ByqGSM49AgEGBSuBBAAiA2IABMFEoc8Rl1Ca3iOCNQfN0MsYndLxf3c1TzvdlHJS
+7cI7+Oz6e2tYIOyZrsn8aLN1udsJ7MgT9U7GCh1mMEy7H0cKPGEQQil8pQgO4CLp
+0zVozptjn4S1mU1YoI71VOeVyaNCMEAwHQYDVR0OBBYEFMFRRVBZqz7nLFr6ICIS
+B4CIfBFqMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MAoGCCqGSM49
+BAMDA2gAMGUCMQCJao1H5+z8blUD2WdsJk6Dxv3J+ysTvLd6jLRl0mlpYxNjOyZQ
+LgGheQaRnUi/wr4CMEfDFXuxoJGZSZOoPHzoRgaLLPIxAJSdYsiJvRmEFOml+wG4
+DXZDjC5Ty3zfDBeWUA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert TLS RSA4096 Root G5 O=DigiCert, Inc.
+# Subject: CN=DigiCert TLS RSA4096 Root G5 O=DigiCert, Inc.
+# Label: "DigiCert TLS RSA4096 Root G5"
+# Serial: 11930366277458970227240571539258396554
+# MD5 Fingerprint: ac:fe:f7:34:96:a9:f2:b3:b4:12:4b:e4:27:41:6f:e1
+# SHA1 Fingerprint: a7:88:49:dc:5d:7c:75:8c:8c:de:39:98:56:b3:aa:d0:b2:a5:71:35
+# SHA256 Fingerprint: 37:1a:00:dc:05:33:b3:72:1a:7e:eb:40:e8:41:9e:70:79:9d:2b:0a:0f:2c:1d:80:69:31:65:f7:ce:c4:ad:75
+-----BEGIN CERTIFICATE-----
+MIIFZjCCA06gAwIBAgIQCPm0eKj6ftpqMzeJ3nzPijANBgkqhkiG9w0BAQwFADBN
+MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xJTAjBgNVBAMT
+HERpZ2lDZXJ0IFRMUyBSU0E0MDk2IFJvb3QgRzUwHhcNMjEwMTE1MDAwMDAwWhcN
+NDYwMTE0MjM1OTU5WjBNMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQs
+IEluYy4xJTAjBgNVBAMTHERpZ2lDZXJ0IFRMUyBSU0E0MDk2IFJvb3QgRzUwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCz0PTJeRGd/fxmgefM1eS87IE+
+ajWOLrfn3q/5B03PMJ3qCQuZvWxX2hhKuHisOjmopkisLnLlvevxGs3npAOpPxG0
+2C+JFvuUAT27L/gTBaF4HI4o4EXgg/RZG5Wzrn4DReW+wkL+7vI8toUTmDKdFqgp
+wgscONyfMXdcvyej/Cestyu9dJsXLfKB2l2w4SMXPohKEiPQ6s+d3gMXsUJKoBZM
+pG2T6T867jp8nVid9E6P/DsjyG244gXazOvswzH016cpVIDPRFtMbzCe88zdH5RD
+nU1/cHAN1DrRN/BsnZvAFJNY781BOHW8EwOVfH/jXOnVDdXifBBiqmvwPXbzP6Po
+sMH976pXTayGpxi0KcEsDr9kvimM2AItzVwv8n/vFfQMFawKsPHTDU9qTXeXAaDx
+Zre3zu/O7Oyldcqs4+Fj97ihBMi8ez9dLRYiVu1ISf6nL3kwJZu6ay0/nTvEF+cd
+Lvvyz6b84xQslpghjLSR6Rlgg/IwKwZzUNWYOwbpx4oMYIwo+FKbbuH2TbsGJJvX
+KyY//SovcfXWJL5/MZ4PbeiPT02jP/816t9JXkGPhvnxd3lLG7SjXi/7RgLQZhNe
+XoVPzthwiHvOAbWWl9fNff2C+MIkwcoBOU+NosEUQB+cZtUMCUbW8tDRSHZWOkPL
+tgoRObqME2wGtZ7P6wIDAQABo0IwQDAdBgNVHQ4EFgQUUTMc7TZArxfTJc1paPKv
+TiM+s0EwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcN
+AQEMBQADggIBAGCmr1tfV9qJ20tQqcQjNSH/0GEwhJG3PxDPJY7Jv0Y02cEhJhxw
+GXIeo8mH/qlDZJY6yFMECrZBu8RHANmfGBg7sg7zNOok992vIGCukihfNudd5N7H
+PNtQOa27PShNlnx2xlv0wdsUpasZYgcYQF+Xkdycx6u1UQ3maVNVzDl92sURVXLF
+O4uJ+DQtpBflF+aZfTCIITfNMBc9uPK8qHWgQ9w+iUuQrm0D4ByjoJYJu32jtyoQ
+REtGBzRj7TG5BO6jm5qu5jF49OokYTurWGT/u4cnYiWB39yhL/btp/96j1EuMPik
+AdKFOV8BmZZvWltwGUb+hmA+rYAQCd05JS9Yf7vSdPD3Rh9GOUrYU9DzLjtxpdRv
+/PNn5AeP3SYZ4Y1b+qOTEZvpyDrDVWiakuFSdjjo4bq9+0/V77PnSIMx8IIh47a+
+p6tv75/fTM8BuGJqIz3nCU2AG3swpMPdB380vqQmsvZB6Akd4yCYqjdP//fx4ilw
+MUc/dNAUFvohigLVigmUdy7yWSiLfFCSCmZ4OIN1xLVaqBHG5cGdZlXPU8Sv13WF
+qUITVuwhd4GTWgzqltlJyqEI8pc7bZsEGCREjnwB8twl2F6GmrE52/WRMmrRpnCK
+ovfepEWFJqgejF0pW8hL2JpqA15w8oVPbEtoL8pU9ozaMv7Da4M/OMZ+
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certainly Root R1 O=Certainly
+# Subject: CN=Certainly Root R1 O=Certainly
+# Label: "Certainly Root R1"
+# Serial: 188833316161142517227353805653483829216
+# MD5 Fingerprint: 07:70:d4:3e:82:87:a0:fa:33:36:13:f4:fa:33:e7:12
+# SHA1 Fingerprint: a0:50:ee:0f:28:71:f4:27:b2:12:6d:6f:50:96:25:ba:cc:86:42:af
+# SHA256 Fingerprint: 77:b8:2c:d8:64:4c:43:05:f7:ac:c5:cb:15:6b:45:67:50:04:03:3d:51:c6:0c:62:02:a8:e0:c3:34:67:d3:a0
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIRAI4P+UuQcWhlM1T01EQ5t+AwDQYJKoZIhvcNAQELBQAw
+PTELMAkGA1UEBhMCVVMxEjAQBgNVBAoTCUNlcnRhaW5seTEaMBgGA1UEAxMRQ2Vy
+dGFpbmx5IFJvb3QgUjEwHhcNMjEwNDAxMDAwMDAwWhcNNDYwNDAxMDAwMDAwWjA9
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJQ2VydGFpbmx5MRowGAYDVQQDExFDZXJ0
+YWlubHkgUm9vdCBSMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANA2
+1B/q3avk0bbm+yLA3RMNansiExyXPGhjZjKcA7WNpIGD2ngwEc/csiu+kr+O5MQT
+vqRoTNoCaBZ0vrLdBORrKt03H2As2/X3oXyVtwxwhi7xOu9S98zTm/mLvg7fMbed
+aFySpvXl8wo0tf97ouSHocavFwDvA5HtqRxOcT3Si2yJ9HiG5mpJoM610rCrm/b0
+1C7jcvk2xusVtyWMOvwlDbMicyF0yEqWYZL1LwsYpfSt4u5BvQF5+paMjRcCMLT5
+r3gajLQ2EBAHBXDQ9DGQilHFhiZ5shGIXsXwClTNSaa/ApzSRKft43jvRl5tcdF5
+cBxGX1HpyTfcX35pe0HfNEXgO4T0oYoKNp43zGJS4YkNKPl6I7ENPT2a/Z2B7yyQ
+wHtETrtJ4A5KVpK8y7XdeReJkd5hiXSSqOMyhb5OhaRLWcsrxXiOcVTQAjeZjOVJ
+6uBUcqQRBi8LjMFbvrWhsFNunLhgkR9Za/kt9JQKl7XsxXYDVBtlUrpMklZRNaBA
+2CnbrlJ2Oy0wQJuK0EJWtLeIAaSHO1OWzaMWj/Nmqhexx2DgwUMFDO6bW2BvBlyH
+Wyf5QBGenDPBt+U1VwV/J84XIIwc/PH72jEpSe31C4SnT8H2TsIonPru4K8H+zMR
+eiFPCyEQtkA6qyI6BJyLm4SGcprSp6XEtHWRqSsjAgMBAAGjQjBAMA4GA1UdDwEB
+/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTgqj8ljZ9EXME66C6u
+d0yEPmcM9DANBgkqhkiG9w0BAQsFAAOCAgEAuVevuBLaV4OPaAszHQNTVfSVcOQr
+PbA56/qJYv331hgELyE03fFo8NWWWt7CgKPBjcZq91l3rhVkz1t5BXdm6ozTaw3d
+8VkswTOlMIAVRQdFGjEitpIAq5lNOo93r6kiyi9jyhXWx8bwPWz8HA2YEGGeEaIi
+1wrykXprOQ4vMMM2SZ/g6Q8CRFA3lFV96p/2O7qUpUzpvD5RtOjKkjZUbVwlKNrd
+rRT90+7iIgXr0PK3aBLXWopBGsaSpVo7Y0VPv+E6dyIvXL9G+VoDhRNCX8reU9di
+taY1BMJH/5n9hN9czulegChB8n3nHpDYT3Y+gjwN/KUD+nsa2UUeYNrEjvn8K8l7
+lcUq/6qJ34IxD3L/DCfXCh5WAFAeDJDBlrXYFIW7pw0WwfgHJBu6haEaBQmAupVj
+yTrsJZ9/nbqkRxWbRHDxakvWOF5D8xh+UG7pWijmZeZ3Gzr9Hb4DJqPb1OG7fpYn
+Kx3upPvaJVQTA945xsMfTZDsjxtK0hzthZU4UHlG1sGQUDGpXJpuHfUzVounmdLy
+yCwzk5Iwx06MZTMQZBf9JBeW0Y3COmor6xOLRPIh80oat3df1+2IpHLlOR+Vnb5n
+wXARPbv0+Em34yaXOp/SX3z7wJl8OSngex2/DaeP0ik0biQVy96QXr8axGbqwua6
+OV+KmalBWQewLK8=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certainly Root E1 O=Certainly
+# Subject: CN=Certainly Root E1 O=Certainly
+# Label: "Certainly Root E1"
+# Serial: 8168531406727139161245376702891150584
+# MD5 Fingerprint: 0a:9e:ca:cd:3e:52:50:c6:36:f3:4b:a3:ed:a7:53:e9
+# SHA1 Fingerprint: f9:e1:6d:dc:01:89:cf:d5:82:45:63:3e:c5:37:7d:c2:eb:93:6f:2b
+# SHA256 Fingerprint: b4:58:5f:22:e4:ac:75:6a:4e:86:12:a1:36:1c:5d:9d:03:1a:93:fd:84:fe:bb:77:8f:a3:06:8b:0f:c4:2d:c2
+-----BEGIN CERTIFICATE-----
+MIIB9zCCAX2gAwIBAgIQBiUzsUcDMydc+Y2aub/M+DAKBggqhkjOPQQDAzA9MQsw
+CQYDVQQGEwJVUzESMBAGA1UEChMJQ2VydGFpbmx5MRowGAYDVQQDExFDZXJ0YWlu
+bHkgUm9vdCBFMTAeFw0yMTA0MDEwMDAwMDBaFw00NjA0MDEwMDAwMDBaMD0xCzAJ
+BgNVBAYTAlVTMRIwEAYDVQQKEwlDZXJ0YWlubHkxGjAYBgNVBAMTEUNlcnRhaW5s
+eSBSb290IEUxMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE3m/4fxzf7flHh4axpMCK
++IKXgOqPyEpeKn2IaKcBYhSRJHpcnqMXfYqGITQYUBsQ3tA3SybHGWCA6TS9YBk2
+QNYphwk8kXr2vBMj3VlOBF7PyAIcGFPBMdjaIOlEjeR2o0IwQDAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ygYy2R17ikq6+2uI1g4
+hevIIgcwCgYIKoZIzj0EAwMDaAAwZQIxALGOWiDDshliTd6wT99u0nCK8Z9+aozm
+ut6Dacpps6kFtZaSF4fC0urQe87YQVt8rgIwRt7qy12a7DLCZRawTDBcMPPaTnOG
+BtjOiQRINzf43TNRnXCve1XYAS59BWQOhriR
+-----END CERTIFICATE-----
+
+# Issuer: CN=Security Communication RootCA3 O=SECOM Trust Systems CO.,LTD.
+# Subject: CN=Security Communication RootCA3 O=SECOM Trust Systems CO.,LTD.
+# Label: "Security Communication RootCA3"
+# Serial: 16247922307909811815
+# MD5 Fingerprint: 1c:9a:16:ff:9e:5c:e0:4d:8a:14:01:f4:35:5d:29:26
+# SHA1 Fingerprint: c3:03:c8:22:74:92:e5:61:a2:9c:5f:79:91:2b:1e:44:13:91:30:3a
+# SHA256 Fingerprint: 24:a5:5c:2a:b0:51:44:2d:06:17:76:65:41:23:9a:4a:d0:32:d7:c5:51:75:aa:34:ff:de:2f:bc:4f:5c:52:94
+-----BEGIN CERTIFICATE-----
+MIIFfzCCA2egAwIBAgIJAOF8N0D9G/5nMA0GCSqGSIb3DQEBDAUAMF0xCzAJBgNV
+BAYTAkpQMSUwIwYDVQQKExxTRUNPTSBUcnVzdCBTeXN0ZW1zIENPLixMVEQuMScw
+JQYDVQQDEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTMwHhcNMTYwNjE2
+MDYxNzE2WhcNMzgwMTE4MDYxNzE2WjBdMQswCQYDVQQGEwJKUDElMCMGA1UEChMc
+U0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UEAxMeU2VjdXJpdHkg
+Q29tbXVuaWNhdGlvbiBSb290Q0EzMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC
+CgKCAgEA48lySfcw3gl8qUCBWNO0Ot26YQ+TUG5pPDXC7ltzkBtnTCHsXzW7OT4r
+CmDvu20rhvtxosis5FaU+cmvsXLUIKx00rgVrVH+hXShuRD+BYD5UpOzQD11EKzA
+lrenfna84xtSGc4RHwsENPXY9Wk8d/Nk9A2qhd7gCVAEF5aEt8iKvE1y/By7z/MG
+TfmfZPd+pmaGNXHIEYBMwXFAWB6+oHP2/D5Q4eAvJj1+XCO1eXDe+uDRpdYMQXF7
+9+qMHIjH7Iv10S9VlkZ8WjtYO/u62C21Jdp6Ts9EriGmnpjKIG58u4iFW/vAEGK7
+8vknR+/RiTlDxN/e4UG/VHMgly1s2vPUB6PmudhvrvyMGS7TZ2crldtYXLVqAvO4
+g160a75BflcJdURQVc1aEWEhCmHCqYj9E7wtiS/NYeCVvsq1e+F7NGcLH7YMx3we
+GVPKp7FKFSBWFHA9K4IsD50VHUeAR/94mQ4xr28+j+2GaR57GIgUssL8gjMunEst
++3A7caoreyYn8xrC3PsXuKHqy6C0rtOUfnrQq8PsOC0RLoi/1D+tEjtCrI8Cbn3M
+0V9hvqG8OmpI6iZVIhZdXw3/JzOfGAN0iltSIEdrRU0id4xVJ/CvHozJgyJUt5rQ
+T9nO/NkuHJYosQLTA70lUhw0Zk8jq/R3gpYd0VcwCBEF/VfR2ccCAwEAAaNCMEAw
+HQYDVR0OBBYEFGQUfPxYchamCik0FW8qy7z8r6irMA4GA1UdDwEB/wQEAwIBBjAP
+BgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBDAUAA4ICAQDcAiMI4u8hOscNtybS
+YpOnpSNyByCCYN8Y11StaSWSntkUz5m5UoHPrmyKO1o5yGwBQ8IibQLwYs1OY0PA
+FNr0Y/Dq9HHuTofjcan0yVflLl8cebsjqodEV+m9NU1Bu0soo5iyG9kLFwfl9+qd
+9XbXv8S2gVj/yP9kaWJ5rW4OH3/uHWnlt3Jxs/6lATWUVCvAUm2PVcTJ0rjLyjQI
+UYWg9by0F1jqClx6vWPGOi//lkkZhOpn2ASxYfQAW0q3nHE3GYV5v4GwxxMOdnE+
+OoAGrgYWp421wsTL/0ClXI2lyTrtcoHKXJg80jQDdwj98ClZXSEIx2C/pHF7uNke
+gr4Jr2VvKKu/S7XuPghHJ6APbw+LP6yVGPO5DtxnVW5inkYO0QR4ynKudtml+LLf
+iAlhi+8kTtFZP1rUPcmTPCtk9YENFpb3ksP+MW/oKjJ0DvRMmEoYDjBU1cXrvMUV
+nuiZIesnKwkK2/HmcBhWuwzkvvnoEKQTkrgc4NtnHVMDpCKn3F2SEDzq//wbEBrD
+2NCcnWXL0CsnMQMeNuE9dnUM/0Umud1RvCPHX9jYhxBAEg09ODfnRDwYwFMJZI//
+1ZqmfHAuc1Uh6N//g7kdPjIe1qZ9LPFm6Vwdp6POXiUyK+OVrCoHzrQoeIY8Laad
+TdJ0MN1kURXbg4NR16/9M51NZg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Security Communication ECC RootCA1 O=SECOM Trust Systems CO.,LTD.
+# Subject: CN=Security Communication ECC RootCA1 O=SECOM Trust Systems CO.,LTD.
+# Label: "Security Communication ECC RootCA1"
+# Serial: 15446673492073852651
+# MD5 Fingerprint: 7e:43:b0:92:68:ec:05:43:4c:98:ab:5d:35:2e:7e:86
+# SHA1 Fingerprint: b8:0e:26:a9:bf:d2:b2:3b:c0:ef:46:c9:ba:c7:bb:f6:1d:0d:41:41
+# SHA256 Fingerprint: e7:4f:bd:a5:5b:d5:64:c4:73:a3:6b:44:1a:a7:99:c8:a6:8e:07:74:40:e8:28:8b:9f:a1:e5:0e:4b:ba:ca:11
+-----BEGIN CERTIFICATE-----
+MIICODCCAb6gAwIBAgIJANZdm7N4gS7rMAoGCCqGSM49BAMDMGExCzAJBgNVBAYT
+AkpQMSUwIwYDVQQKExxTRUNPTSBUcnVzdCBTeXN0ZW1zIENPLixMVEQuMSswKQYD
+VQQDEyJTZWN1cml0eSBDb21tdW5pY2F0aW9uIEVDQyBSb290Q0ExMB4XDTE2MDYx
+NjA1MTUyOFoXDTM4MDExODA1MTUyOFowYTELMAkGA1UEBhMCSlAxJTAjBgNVBAoT
+HFNFQ09NIFRydXN0IFN5c3RlbXMgQ08uLExURC4xKzApBgNVBAMTIlNlY3VyaXR5
+IENvbW11bmljYXRpb24gRUNDIFJvb3RDQTEwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AASkpW9gAwPDvTH00xecK4R1rOX9PVdu12O/5gSJko6BnOPpR27KkBLIE+Cnnfdl
+dB9sELLo5OnvbYUymUSxXv3MdhDYW72ixvnWQuRXdtyQwjWpS4g8EkdtXP9JTxpK
+ULGjQjBAMB0GA1UdDgQWBBSGHOf+LaVKiwj+KBH6vqNm+GBZLzAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjAVXUI9/Lbu
+9zuxNuie9sRGKEkz0FhDKmMpzE2xtHqiuQ04pV1IKv3LsnNdo4gIxwwCMQDAqy0O
+be0YottT6SXbVQjgUMzfRGEWgqtJsLKB7HOHeLRMsmIbEvoWTSVLY70eN9k=
+-----END CERTIFICATE-----
+
+# Issuer: CN=BJCA Global Root CA1 O=BEIJING CERTIFICATE AUTHORITY
+# Subject: CN=BJCA Global Root CA1 O=BEIJING CERTIFICATE AUTHORITY
+# Label: "BJCA Global Root CA1"
+# Serial: 113562791157148395269083148143378328608
+# MD5 Fingerprint: 42:32:99:76:43:33:36:24:35:07:82:9b:28:f9:d0:90
+# SHA1 Fingerprint: d5:ec:8d:7b:4c:ba:79:f4:e7:e8:cb:9d:6b:ae:77:83:10:03:21:6a
+# SHA256 Fingerprint: f3:89:6f:88:fe:7c:0a:88:27:66:a7:fa:6a:d2:74:9f:b5:7a:7f:3e:98:fb:76:9c:1f:a7:b0:9c:2c:44:d5:ae
+-----BEGIN CERTIFICATE-----
+MIIFdDCCA1ygAwIBAgIQVW9l47TZkGobCdFsPsBsIDANBgkqhkiG9w0BAQsFADBU
+MQswCQYDVQQGEwJDTjEmMCQGA1UECgwdQkVJSklORyBDRVJUSUZJQ0FURSBBVVRI
+T1JJVFkxHTAbBgNVBAMMFEJKQ0EgR2xvYmFsIFJvb3QgQ0ExMB4XDTE5MTIxOTAz
+MTYxN1oXDTQ0MTIxMjAzMTYxN1owVDELMAkGA1UEBhMCQ04xJjAkBgNVBAoMHUJF
+SUpJTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZMR0wGwYDVQQDDBRCSkNBIEdsb2Jh
+bCBSb290IENBMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAPFmCL3Z
+xRVhy4QEQaVpN3cdwbB7+sN3SJATcmTRuHyQNZ0YeYjjlwE8R4HyDqKYDZ4/N+AZ
+spDyRhySsTphzvq3Rp4Dhtczbu33RYx2N95ulpH3134rhxfVizXuhJFyV9xgw8O5
+58dnJCNPYwpj9mZ9S1WnP3hkSWkSl+BMDdMJoDIwOvqfwPKcxRIqLhy1BDPapDgR
+at7GGPZHOiJBhyL8xIkoVNiMpTAK+BcWyqw3/XmnkRd4OJmtWO2y3syJfQOcs4ll
+5+M7sSKGjwZteAf9kRJ/sGsciQ35uMt0WwfCyPQ10WRjeulumijWML3mG90Vr4Tq
+nMfK9Q7q8l0ph49pczm+LiRvRSGsxdRpJQaDrXpIhRMsDQa4bHlW/KNnMoH1V6XK
+V0Jp6VwkYe/iMBhORJhVb3rCk9gZtt58R4oRTklH2yiUAguUSiz5EtBP6DF+bHq/
+pj+bOT0CFqMYs2esWz8sgytnOYFcuX6U1WTdno9uruh8W7TXakdI136z1C2OVnZO
+z2nxbkRs1CTqjSShGL+9V/6pmTW12xB3uD1IutbB5/EjPtffhZ0nPNRAvQoMvfXn
+jSXWgXSHRtQpdaJCbPdzied9v3pKH9MiyRVVz99vfFXQpIsHETdfg6YmV6YBW37+
+WGgHqel62bno/1Afq8K0wM7o6v0PvY1NuLxxAgMBAAGjQjBAMB0GA1UdDgQWBBTF
+7+3M2I0hxkjk49cULqcWk+WYATAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE
+AwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAUoKsITQfI/Ki2Pm4rzc2IInRNwPWaZ+4
+YRC6ojGYWUfo0Q0lHhVBDOAqVdVXUsv45Mdpox1NcQJeXyFFYEhcCY5JEMEE3Kli
+awLwQ8hOnThJdMkycFRtwUf8jrQ2ntScvd0g1lPJGKm1Vrl2i5VnZu69mP6u775u
++2D2/VnGKhs/I0qUJDAnyIm860Qkmss9vk/Ves6OF8tiwdneHg56/0OGNFK8YT88
+X7vZdrRTvJez/opMEi4r89fO4aL/3Xtw+zuhTaRjAv04l5U/BXCga99igUOLtFkN
+SoxUnMW7gZ/NfaXvCyUeOiDbHPwfmGcCCtRzRBPbUYQaVQNW4AB+dAb/OMRyHdOo
+P2gxXdMJxy6MW2Pg6Nwe0uxhHvLe5e/2mXZgLR6UcnHGCyoyx5JO1UbXHfmpGQrI
++pXObSOYqgs4rZpWDW+N8TEAiMEXnM0ZNjX+VVOg4DwzX5Ze4jLp3zO7Bkqp2IRz
+znfSxqxx4VyjHQy7Ct9f4qNx2No3WqB4K/TUfet27fJhcKVlmtOJNBir+3I+17Q9
+eVzYH6Eze9mCUAyTF6ps3MKCuwJXNq+YJyo5UOGwifUll35HaBC07HPKs5fRJNz2
+YqAo07WjuGS3iGJCz51TzZm+ZGiPTx4SSPfSKcOYKMryMguTjClPPGAyzQWWYezy
+r/6zcCwupvI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=BJCA Global Root CA2 O=BEIJING CERTIFICATE AUTHORITY
+# Subject: CN=BJCA Global Root CA2 O=BEIJING CERTIFICATE AUTHORITY
+# Label: "BJCA Global Root CA2"
+# Serial: 58605626836079930195615843123109055211
+# MD5 Fingerprint: 5e:0a:f6:47:5f:a6:14:e8:11:01:95:3f:4d:01:eb:3c
+# SHA1 Fingerprint: f4:27:86:eb:6e:b8:6d:88:31:67:02:fb:ba:66:a4:53:00:aa:7a:a6
+# SHA256 Fingerprint: 57:4d:f6:93:1e:27:80:39:66:7b:72:0a:fd:c1:60:0f:c2:7e:b6:6d:d3:09:29:79:fb:73:85:64:87:21:28:82
+-----BEGIN CERTIFICATE-----
+MIICJTCCAaugAwIBAgIQLBcIfWQqwP6FGFkGz7RK6zAKBggqhkjOPQQDAzBUMQsw
+CQYDVQQGEwJDTjEmMCQGA1UECgwdQkVJSklORyBDRVJUSUZJQ0FURSBBVVRIT1JJ
+VFkxHTAbBgNVBAMMFEJKQ0EgR2xvYmFsIFJvb3QgQ0EyMB4XDTE5MTIxOTAzMTgy
+MVoXDTQ0MTIxMjAzMTgyMVowVDELMAkGA1UEBhMCQ04xJjAkBgNVBAoMHUJFSUpJ
+TkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZMR0wGwYDVQQDDBRCSkNBIEdsb2JhbCBS
+b290IENBMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABJ3LgJGNU2e1uVCxA/jlSR9B
+IgmwUVJY1is0j8USRhTFiy8shP8sbqjV8QnjAyEUxEM9fMEsxEtqSs3ph+B99iK+
++kpRuDCK/eHeGBIK9ke35xe/J4rUQUyWPGCWwf0VHKNCMEAwHQYDVR0OBBYEFNJK
+sVF/BvDRgh9Obl+rg/xI1LCRMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMAoGCCqGSM49BAMDA2gAMGUCMBq8W9f+qdJUDkpd0m2xQNz0Q9XSSpkZElaA
+94M04TVOSG0ED1cxMDAtsaqdAzjbBgIxAMvMh1PLet8gUXOQwKhbYdDFUDn9hf7B
+43j4ptZLvZuHjw/l1lOWqzzIQNph91Oj9w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Sectigo Public Server Authentication Root E46 O=Sectigo Limited
+# Subject: CN=Sectigo Public Server Authentication Root E46 O=Sectigo Limited
+# Label: "Sectigo Public Server Authentication Root E46"
+# Serial: 88989738453351742415770396670917916916
+# MD5 Fingerprint: 28:23:f8:b2:98:5c:37:16:3b:3e:46:13:4e:b0:b3:01
+# SHA1 Fingerprint: ec:8a:39:6c:40:f0:2e:bc:42:75:d4:9f:ab:1c:1a:5b:67:be:d2:9a
+# SHA256 Fingerprint: c9:0f:26:f0:fb:1b:40:18:b2:22:27:51:9b:5c:a2:b5:3e:2c:a5:b3:be:5c:f1:8e:fe:1b:ef:47:38:0c:53:83
+-----BEGIN CERTIFICATE-----
+MIICOjCCAcGgAwIBAgIQQvLM2htpN0RfFf51KBC49DAKBggqhkjOPQQDAzBfMQsw
+CQYDVQQGEwJHQjEYMBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQDEy1T
+ZWN0aWdvIFB1YmxpYyBTZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBFNDYwHhcN
+MjEwMzIyMDAwMDAwWhcNNDYwMzIxMjM1OTU5WjBfMQswCQYDVQQGEwJHQjEYMBYG
+A1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQDEy1TZWN0aWdvIFB1YmxpYyBT
+ZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBFNDYwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAAR2+pmpbiDt+dd34wc7qNs9Xzjoq1WmVk/WSOrsfy2qw7LFeeyZYX8QeccC
+WvkEN/U0NSt3zn8gj1KjAIns1aeibVvjS5KToID1AZTc8GgHHs3u/iVStSBDHBv+
+6xnOQ6OjQjBAMB0GA1UdDgQWBBTRItpMWfFLXyY4qp3W7usNw/upYTAOBgNVHQ8B
+Af8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNnADBkAjAn7qRa
+qCG76UeXlImldCBteU/IvZNeWBj7LRoAasm4PdCkT0RHlAFWovgzJQxC36oCMB3q
+4S6ILuH5px0CMk7yn2xVdOOurvulGu7t0vzCAxHrRVxgED1cf5kDW21USAGKcw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Sectigo Public Server Authentication Root R46 O=Sectigo Limited
+# Subject: CN=Sectigo Public Server Authentication Root R46 O=Sectigo Limited
+# Label: "Sectigo Public Server Authentication Root R46"
+# Serial: 156256931880233212765902055439220583700
+# MD5 Fingerprint: 32:10:09:52:00:d5:7e:6c:43:df:15:c0:b1:16:93:e5
+# SHA1 Fingerprint: ad:98:f9:f3:e4:7d:75:3b:65:d4:82:b3:a4:52:17:bb:6e:f5:e4:38
+# SHA256 Fingerprint: 7b:b6:47:a6:2a:ee:ac:88:bf:25:7a:a5:22:d0:1f:fe:a3:95:e0:ab:45:c7:3f:93:f6:56:54:ec:38:f2:5a:06
+-----BEGIN CERTIFICATE-----
+MIIFijCCA3KgAwIBAgIQdY39i658BwD6qSWn4cetFDANBgkqhkiG9w0BAQwFADBf
+MQswCQYDVQQGEwJHQjEYMBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQD
+Ey1TZWN0aWdvIFB1YmxpYyBTZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBSNDYw
+HhcNMjEwMzIyMDAwMDAwWhcNNDYwMzIxMjM1OTU5WjBfMQswCQYDVQQGEwJHQjEY
+MBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQDEy1TZWN0aWdvIFB1Ymxp
+YyBTZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBSNDYwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCTvtU2UnXYASOgHEdCSe5jtrch/cSV1UgrJnwUUxDa
+ef0rty2k1Cz66jLdScK5vQ9IPXtamFSvnl0xdE8H/FAh3aTPaE8bEmNtJZlMKpnz
+SDBh+oF8HqcIStw+KxwfGExxqjWMrfhu6DtK2eWUAtaJhBOqbchPM8xQljeSM9xf
+iOefVNlI8JhD1mb9nxc4Q8UBUQvX4yMPFF1bFOdLvt30yNoDN9HWOaEhUTCDsG3X
+ME6WW5HwcCSrv0WBZEMNvSE6Lzzpng3LILVCJ8zab5vuZDCQOc2TZYEhMbUjUDM3
+IuM47fgxMMxF/mL50V0yeUKH32rMVhlATc6qu/m1dkmU8Sf4kaWD5QazYw6A3OAS
+VYCmO2a0OYctyPDQ0RTp5A1NDvZdV3LFOxxHVp3i1fuBYYzMTYCQNFu31xR13NgE
+SJ/AwSiItOkcyqex8Va3e0lMWeUgFaiEAin6OJRpmkkGj80feRQXEgyDet4fsZfu
++Zd4KKTIRJLpfSYFplhym3kT2BFfrsU4YjRosoYwjviQYZ4ybPUHNs2iTG7sijbt
+8uaZFURww3y8nDnAtOFr94MlI1fZEoDlSfB1D++N6xybVCi0ITz8fAr/73trdf+L
+HaAZBav6+CuBQug4urv7qv094PPK306Xlynt8xhW6aWWrL3DkJiy4Pmi1KZHQ3xt
+zwIDAQABo0IwQDAdBgNVHQ4EFgQUVnNYZJX5khqwEioEYnmhQBWIIUkwDgYDVR0P
+AQH/BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAC9c
+mTz8Bl6MlC5w6tIyMY208FHVvArzZJ8HXtXBc2hkeqK5Duj5XYUtqDdFqij0lgVQ
+YKlJfp/imTYpE0RHap1VIDzYm/EDMrraQKFz6oOht0SmDpkBm+S8f74TlH7Kph52
+gDY9hAaLMyZlbcp+nv4fjFg4exqDsQ+8FxG75gbMY/qB8oFM2gsQa6H61SilzwZA
+Fv97fRheORKkU55+MkIQpiGRqRxOF3yEvJ+M0ejf5lG5Nkc/kLnHvALcWxxPDkjB
+JYOcCj+esQMzEhonrPcibCTRAUH4WAP+JWgiH5paPHxsnnVI84HxZmduTILA7rpX
+DhjvLpr3Etiga+kFpaHpaPi8TD8SHkXoUsCjvxInebnMMTzD9joiFgOgyY9mpFui
+TdaBJQbpdqQACj7LzTWb4OE4y2BThihCQRxEV+ioratF4yUQvNs+ZUH7G6aXD+u5
+dHn5HrwdVw1Hr8Mvn4dGp+smWg9WY7ViYG4A++MnESLn/pmPNPW56MORcr3Ywx65
+LvKRRFHQV80MNNVIIb/bE/FmJUNS0nAiNs2fxBx1IK1jcmMGDw4nztJqDby1ORrp
+0XZ60Vzk50lJLVU3aPAaOpg+VBeHVOmmJ1CJeyAvP/+/oYtKR5j/K3tJPsMpRmAY
+QqszKbrAKbkTidOIijlBO8n9pu0f9GBj39ItVQGL
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com TLS RSA Root CA 2022 O=SSL Corporation
+# Subject: CN=SSL.com TLS RSA Root CA 2022 O=SSL Corporation
+# Label: "SSL.com TLS RSA Root CA 2022"
+# Serial: 148535279242832292258835760425842727825
+# MD5 Fingerprint: d8:4e:c6:59:30:d8:fe:a0:d6:7a:5a:2c:2c:69:78:da
+# SHA1 Fingerprint: ec:2c:83:40:72:af:26:95:10:ff:0e:f2:03:ee:31:70:f6:78:9d:ca
+# SHA256 Fingerprint: 8f:af:7d:2e:2c:b4:70:9b:b8:e0:b3:36:66:bf:75:a5:dd:45:b5:de:48:0f:8e:a8:d4:bf:e6:be:bc:17:f2:ed
+-----BEGIN CERTIFICATE-----
+MIIFiTCCA3GgAwIBAgIQb77arXO9CEDii02+1PdbkTANBgkqhkiG9w0BAQsFADBO
+MQswCQYDVQQGEwJVUzEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMSUwIwYDVQQD
+DBxTU0wuY29tIFRMUyBSU0EgUm9vdCBDQSAyMDIyMB4XDTIyMDgyNTE2MzQyMloX
+DTQ2MDgxOTE2MzQyMVowTjELMAkGA1UEBhMCVVMxGDAWBgNVBAoMD1NTTCBDb3Jw
+b3JhdGlvbjElMCMGA1UEAwwcU1NMLmNvbSBUTFMgUlNBIFJvb3QgQ0EgMjAyMjCC
+AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANCkCXJPQIgSYT41I57u9nTP
+L3tYPc48DRAokC+X94xI2KDYJbFMsBFMF3NQ0CJKY7uB0ylu1bUJPiYYf7ISf5OY
+t6/wNr/y7hienDtSxUcZXXTzZGbVXcdotL8bHAajvI9AI7YexoS9UcQbOcGV0ins
+S657Lb85/bRi3pZ7QcacoOAGcvvwB5cJOYF0r/c0WRFXCsJbwST0MXMwgsadugL3
+PnxEX4MN8/HdIGkWCVDi1FW24IBydm5MR7d1VVm0U3TZlMZBrViKMWYPHqIbKUBO
+L9975hYsLfy/7PO0+r4Y9ptJ1O4Fbtk085zx7AGL0SDGD6C1vBdOSHtRwvzpXGk3
+R2azaPgVKPC506QVzFpPulJwoxJF3ca6TvvC0PeoUidtbnm1jPx7jMEWTO6Af77w
+dr5BUxIzrlo4QqvXDz5BjXYHMtWrifZOZ9mxQnUjbvPNQrL8VfVThxc7wDNY8VLS
++YCk8OjwO4s4zKTGkH8PnP2L0aPP2oOnaclQNtVcBdIKQXTbYxE3waWglksejBYS
+d66UNHsef8JmAOSqg+qKkK3ONkRN0VHpvB/zagX9wHQfJRlAUW7qglFA35u5CCoG
+AtUjHBPW6dvbxrB6y3snm/vg1UYk7RBLY0ulBY+6uB0rpvqR4pJSvezrZ5dtmi2f
+gTIFZzL7SAg/2SW4BCUvAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0j
+BBgwFoAU+y437uOEeicuzRk1sTN8/9REQrkwHQYDVR0OBBYEFPsuN+7jhHonLs0Z
+NbEzfP/UREK5MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAjYlt
+hEUY8U+zoO9opMAdrDC8Z2awms22qyIZZtM7QbUQnRC6cm4pJCAcAZli05bg4vsM
+QtfhWsSWTVTNj8pDU/0quOr4ZcoBwq1gaAafORpR2eCNJvkLTqVTJXojpBzOCBvf
+R4iyrT7gJ4eLSYwfqUdYe5byiB0YrrPRpgqU+tvT5TgKa3kSM/tKWTcWQA673vWJ
+DPFs0/dRa1419dvAJuoSc06pkZCmF8NsLzjUo3KUQyxi4U5cMj29TH0ZR6LDSeeW
+P4+a0zvkEdiLA9z2tmBVGKaBUfPhqBVq6+AL8BQx1rmMRTqoENjwuSfr98t67wVy
+lrXEj5ZzxOhWc5y8aVFjvO9nHEMaX3cZHxj4HCUp+UmZKbaSPaKDN7EgkaibMOlq
+bLQjk2UEqxHzDh1TJElTHaE/nUiSEeJ9DU/1172iWD54nR4fK/4huxoTtrEoZP2w
+AgDHbICivRZQIA9ygV/MlP+7mea6kMvq+cYMwq7FGc4zoWtcu358NFcXrfA/rs3q
+r5nsLFR+jM4uElZI7xc7P0peYNLcdDa8pUNjyw9bowJWCZ4kLOGGgYz+qxcs+sji
+Mho6/4UIyYOf8kpIEFR3N+2ivEC+5BB09+Rbu7nzifmPQdjH5FCQNYA+HLhNkNPU
+98OwoX6EyneSMSy4kLGCenROmxMmtNVQZlR4rmA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com TLS ECC Root CA 2022 O=SSL Corporation
+# Subject: CN=SSL.com TLS ECC Root CA 2022 O=SSL Corporation
+# Label: "SSL.com TLS ECC Root CA 2022"
+# Serial: 26605119622390491762507526719404364228
+# MD5 Fingerprint: 99:d7:5c:f1:51:36:cc:e9:ce:d9:19:2e:77:71:56:c5
+# SHA1 Fingerprint: 9f:5f:d9:1a:54:6d:f5:0c:71:f0:ee:7a:bd:17:49:98:84:73:e2:39
+# SHA256 Fingerprint: c3:2f:fd:9f:46:f9:36:d1:6c:36:73:99:09:59:43:4b:9a:d6:0a:af:bb:9e:7c:f3:36:54:f1:44:cc:1b:a1:43
+-----BEGIN CERTIFICATE-----
+MIICOjCCAcCgAwIBAgIQFAP1q/s3ixdAW+JDsqXRxDAKBggqhkjOPQQDAzBOMQsw
+CQYDVQQGEwJVUzEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMSUwIwYDVQQDDBxT
+U0wuY29tIFRMUyBFQ0MgUm9vdCBDQSAyMDIyMB4XDTIyMDgyNTE2MzM0OFoXDTQ2
+MDgxOTE2MzM0N1owTjELMAkGA1UEBhMCVVMxGDAWBgNVBAoMD1NTTCBDb3Jwb3Jh
+dGlvbjElMCMGA1UEAwwcU1NMLmNvbSBUTFMgRUNDIFJvb3QgQ0EgMjAyMjB2MBAG
+ByqGSM49AgEGBSuBBAAiA2IABEUpNXP6wrgjzhR9qLFNoFs27iosU8NgCTWyJGYm
+acCzldZdkkAZDsalE3D07xJRKF3nzL35PIXBz5SQySvOkkJYWWf9lCcQZIxPBLFN
+SeR7T5v15wj4A4j3p8OSSxlUgaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSME
+GDAWgBSJjy+j6CugFFR781a4Jl9nOAuc0DAdBgNVHQ4EFgQUiY8vo+groBRUe/NW
+uCZfZzgLnNAwDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMDA2gAMGUCMFXjIlbp
+15IkWE8elDIPDAI2wv2sdDJO4fscgIijzPvX6yv/N33w7deedWo1dlJF4AIxAMeN
+b0Igj762TVntd00pxCAgRWSGOlDGxK0tk/UYfXLtqc/ErFc2KAhl3zx5Zn6g6g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot Root CA ECC TLS 2021 O=Atos
+# Subject: CN=Atos TrustedRoot Root CA ECC TLS 2021 O=Atos
+# Label: "Atos TrustedRoot Root CA ECC TLS 2021"
+# Serial: 81873346711060652204712539181482831616
+# MD5 Fingerprint: 16:9f:ad:f1:70:ad:79:d6:ed:29:b4:d1:c5:79:70:a8
+# SHA1 Fingerprint: 9e:bc:75:10:42:b3:02:f3:81:f4:f7:30:62:d4:8f:c3:a7:51:b2:dd
+# SHA256 Fingerprint: b2:fa:e5:3e:14:cc:d7:ab:92:12:06:47:01:ae:27:9c:1d:89:88:fa:cb:77:5f:a8:a0:08:91:4e:66:39:88:a8
+-----BEGIN CERTIFICATE-----
+MIICFTCCAZugAwIBAgIQPZg7pmY9kGP3fiZXOATvADAKBggqhkjOPQQDAzBMMS4w
+LAYDVQQDDCVBdG9zIFRydXN0ZWRSb290IFJvb3QgQ0EgRUNDIFRMUyAyMDIxMQ0w
+CwYDVQQKDARBdG9zMQswCQYDVQQGEwJERTAeFw0yMTA0MjIwOTI2MjNaFw00MTA0
+MTcwOTI2MjJaMEwxLjAsBgNVBAMMJUF0b3MgVHJ1c3RlZFJvb3QgUm9vdCBDQSBF
+Q0MgVExTIDIwMjExDTALBgNVBAoMBEF0b3MxCzAJBgNVBAYTAkRFMHYwEAYHKoZI
+zj0CAQYFK4EEACIDYgAEloZYKDcKZ9Cg3iQZGeHkBQcfl+3oZIK59sRxUM6KDP/X
+tXa7oWyTbIOiaG6l2b4siJVBzV3dscqDY4PMwL502eCdpO5KTlbgmClBk1IQ1SQ4
+AjJn8ZQSb+/Xxd4u/RmAo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBR2
+KCXWfeBmmnoJsmo7jjPXNtNPojAOBgNVHQ8BAf8EBAMCAYYwCgYIKoZIzj0EAwMD
+aAAwZQIwW5kp85wxtolrbNa9d+F851F+uDrNozZffPc8dz7kUK2o59JZDCaOMDtu
+CCrCp1rIAjEAmeMM56PDr9NJLkaCI2ZdyQAUEv049OGYa3cpetskz2VAv9LcjBHo
+9H1/IISpQuQo
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot Root CA RSA TLS 2021 O=Atos
+# Subject: CN=Atos TrustedRoot Root CA RSA TLS 2021 O=Atos
+# Label: "Atos TrustedRoot Root CA RSA TLS 2021"
+# Serial: 111436099570196163832749341232207667876
+# MD5 Fingerprint: d4:d3:46:b8:9a:c0:9c:76:5d:9e:3a:c3:b9:99:31:d2
+# SHA1 Fingerprint: 18:52:3b:0d:06:37:e4:d6:3a:df:23:e4:98:fb:5b:16:fb:86:74:48
+# SHA256 Fingerprint: 81:a9:08:8e:a5:9f:b3:64:c5:48:a6:f8:55:59:09:9b:6f:04:05:ef:bf:18:e5:32:4e:c9:f4:57:ba:00:11:2f
+-----BEGIN CERTIFICATE-----
+MIIFZDCCA0ygAwIBAgIQU9XP5hmTC/srBRLYwiqipDANBgkqhkiG9w0BAQwFADBM
+MS4wLAYDVQQDDCVBdG9zIFRydXN0ZWRSb290IFJvb3QgQ0EgUlNBIFRMUyAyMDIx
+MQ0wCwYDVQQKDARBdG9zMQswCQYDVQQGEwJERTAeFw0yMTA0MjIwOTIxMTBaFw00
+MTA0MTcwOTIxMDlaMEwxLjAsBgNVBAMMJUF0b3MgVHJ1c3RlZFJvb3QgUm9vdCBD
+QSBSU0EgVExTIDIwMjExDTALBgNVBAoMBEF0b3MxCzAJBgNVBAYTAkRFMIICIjAN
+BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAtoAOxHm9BYx9sKOdTSJNy/BBl01Z
+4NH+VoyX8te9j2y3I49f1cTYQcvyAh5x5en2XssIKl4w8i1mx4QbZFc4nXUtVsYv
+Ye+W/CBGvevUez8/fEc4BKkbqlLfEzfTFRVOvV98r61jx3ncCHvVoOX3W3WsgFWZ
+kmGbzSoXfduP9LVq6hdKZChmFSlsAvFr1bqjM9xaZ6cF4r9lthawEO3NUDPJcFDs
+GY6wx/J0W2tExn2WuZgIWWbeKQGb9Cpt0xU6kGpn8bRrZtkh68rZYnxGEFzedUln
+nkL5/nWpo63/dgpnQOPF943HhZpZnmKaau1Fh5hnstVKPNe0OwANwI8f4UDErmwh
+3El+fsqyjW22v5MvoVw+j8rtgI5Y4dtXz4U2OLJxpAmMkokIiEjxQGMYsluMWuPD
+0xeqqxmjLBvk1cbiZnrXghmmOxYsL3GHX0WelXOTwkKBIROW1527k2gV+p2kHYzy
+geBYBr3JtuP2iV2J+axEoctr+hbxx1A9JNr3w+SH1VbxT5Aw+kUJWdo0zuATHAR8
+ANSbhqRAvNncTFd+rrcztl524WWLZt+NyteYr842mIycg5kDcPOvdO3GDjbnvezB
+c6eUWsuSZIKmAMFwoW4sKeFYV+xafJlrJaSQOoD0IJ2azsct+bJLKZWD6TWNp0lI
+pw9MGZHQ9b8Q4HECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU
+dEmZ0f+0emhFdcN+tNzMzjkz2ggwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB
+DAUAA4ICAQAjQ1MkYlxt/T7Cz1UAbMVWiLkO3TriJQ2VSpfKgInuKs1l+NsW4AmS
+4BjHeJi78+xCUvuppILXTdiK/ORO/auQxDh1MoSf/7OwKwIzNsAQkG8dnK/haZPs
+o0UvFJ/1TCplQ3IM98P4lYsU84UgYt1UU90s3BiVaU+DR3BAM1h3Egyi61IxHkzJ
+qM7F78PRreBrAwA0JrRUITWXAdxfG/F851X6LWh3e9NpzNMOa7pNdkTWwhWaJuyw
+xfW70Xp0wmzNxbVe9kzmWy2B27O3Opee7c9GslA9hGCZcbUztVdF5kJHdWoOsAgM
+rr3e97sPWD2PAzHoPYJQyi9eDF20l74gNAf0xBLh7tew2VktafcxBPTy+av5EzH4
+AXcOPUIjJsyacmdRIXrMPIWo6iFqO9taPKU0nprALN+AnCng33eU0aKAQv9qTFsR
+0PXNor6uzFFcw9VUewyu1rkGd4Di7wcaaMxZUa1+XGdrudviB0JbuAEFWDlN5LuY
+o7Ey7Nmj1m+UI/87tyll5gfp77YZ6ufCOB0yiJA8EytuzO+rdwY0d4RPcuSBhPm5
+dDTedk+SKlOxJTnbPP/lPqYO5Wue/9vsL3SD3460s6neFE3/MaNFcyT6lSnMEpcE
+oji2jbDwN/zIIX8/syQbPYtuzE2wFg2WHYMfRsCbvUOZ58SWLs5fyQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustAsia Global Root CA G3 O=TrustAsia Technologies, Inc.
+# Subject: CN=TrustAsia Global Root CA G3 O=TrustAsia Technologies, Inc.
+# Label: "TrustAsia Global Root CA G3"
+# Serial: 576386314500428537169965010905813481816650257167
+# MD5 Fingerprint: 30:42:1b:b7:bb:81:75:35:e4:16:4f:53:d2:94:de:04
+# SHA1 Fingerprint: 63:cf:b6:c1:27:2b:56:e4:88:8e:1c:23:9a:b6:2e:81:47:24:c3:c7
+# SHA256 Fingerprint: e0:d3:22:6a:eb:11:63:c2:e4:8f:f9:be:3b:50:b4:c6:43:1b:e7:bb:1e:ac:c5:c3:6b:5d:5e:c5:09:03:9a:08
+-----BEGIN CERTIFICATE-----
+MIIFpTCCA42gAwIBAgIUZPYOZXdhaqs7tOqFhLuxibhxkw8wDQYJKoZIhvcNAQEM
+BQAwWjELMAkGA1UEBhMCQ04xJTAjBgNVBAoMHFRydXN0QXNpYSBUZWNobm9sb2dp
+ZXMsIEluYy4xJDAiBgNVBAMMG1RydXN0QXNpYSBHbG9iYWwgUm9vdCBDQSBHMzAe
+Fw0yMTA1MjAwMjEwMTlaFw00NjA1MTkwMjEwMTlaMFoxCzAJBgNVBAYTAkNOMSUw
+IwYDVQQKDBxUcnVzdEFzaWEgVGVjaG5vbG9naWVzLCBJbmMuMSQwIgYDVQQDDBtU
+cnVzdEFzaWEgR2xvYmFsIFJvb3QgQ0EgRzMwggIiMA0GCSqGSIb3DQEBAQUAA4IC
+DwAwggIKAoICAQDAMYJhkuSUGwoqZdC+BqmHO1ES6nBBruL7dOoKjbmzTNyPtxNS
+T1QY4SxzlZHFZjtqz6xjbYdT8PfxObegQ2OwxANdV6nnRM7EoYNl9lA+sX4WuDqK
+AtCWHwDNBSHvBm3dIZwZQ0WhxeiAysKtQGIXBsaqvPPW5vxQfmZCHzyLpnl5hkA1
+nyDvP+uLRx+PjsXUjrYsyUQE49RDdT/VP68czH5GX6zfZBCK70bwkPAPLfSIC7Ep
+qq+FqklYqL9joDiR5rPmd2jE+SoZhLsO4fWvieylL1AgdB4SQXMeJNnKziyhWTXA
+yB1GJ2Faj/lN03J5Zh6fFZAhLf3ti1ZwA0pJPn9pMRJpxx5cynoTi+jm9WAPzJMs
+hH/x/Gr8m0ed262IPfN2dTPXS6TIi/n1Q1hPy8gDVI+lhXgEGvNz8teHHUGf59gX
+zhqcD0r83ERoVGjiQTz+LISGNzzNPy+i2+f3VANfWdP3kXjHi3dqFuVJhZBFcnAv
+kV34PmVACxmZySYgWmjBNb9Pp1Hx2BErW+Canig7CjoKH8GB5S7wprlppYiU5msT
+f9FkPz2ccEblooV7WIQn3MSAPmeamseaMQ4w7OYXQJXZRe0Blqq/DPNL0WP3E1jA
+uPP6Z92bfW1K/zJMtSU7/xxnD4UiWQWRkUF3gdCFTIcQcf+eQxuulXUtgQIDAQAB
+o2MwYTAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFEDk5PIj7zjKsK5Xf/Ih
+MBY027ySMB0GA1UdDgQWBBRA5OTyI+84yrCuV3/yITAWNNu8kjAOBgNVHQ8BAf8E
+BAMCAQYwDQYJKoZIhvcNAQEMBQADggIBACY7UeFNOPMyGLS0XuFlXsSUT9SnYaP4
+wM8zAQLpw6o1D/GUE3d3NZ4tVlFEbuHGLige/9rsR82XRBf34EzC4Xx8MnpmyFq2
+XFNFV1pF1AWZLy4jVe5jaN/TG3inEpQGAHUNcoTpLrxaatXeL1nHo+zSh2bbt1S1
+JKv0Q3jbSwTEb93mPmY+KfJLaHEih6D4sTNjduMNhXJEIlU/HHzp/LgV6FL6qj6j
+ITk1dImmasI5+njPtqzn59ZW/yOSLlALqbUHM/Q4X6RJpstlcHboCoWASzY9M/eV
+VHUl2qzEc4Jl6VL1XP04lQJqaTDFHApXB64ipCz5xUG3uOyfT0gA+QEEVcys+TIx
+xHWVBqB/0Y0n3bOppHKH/lmLmnp0Ft0WpWIp6zqW3IunaFnT63eROfjXy9mPX1on
+AX1daBli2MjN9LdyR75bl87yraKZk62Uy5P2EgmVtqvXO9A/EcswFi55gORngS1d
+7XB4tmBZrOFdRWOPyN9yaFvqHbgB8X7754qz41SgOAngPN5C8sLtLpvzHzW2Ntjj
+gKGLzZlkD8Kqq7HK9W+eQ42EVJmzbsASZthwEPEGNTNDqJwuuhQxzhB/HIbjj9LV
++Hfsm6vxL2PZQl/gZ4FkkfGXL/xuJvYz+NO1+MRiqzFRJQJ6+N1rZdVtTTDIZbpo
+FGWsJwt0ivKH
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustAsia Global Root CA G4 O=TrustAsia Technologies, Inc.
+# Subject: CN=TrustAsia Global Root CA G4 O=TrustAsia Technologies, Inc.
+# Label: "TrustAsia Global Root CA G4"
+# Serial: 451799571007117016466790293371524403291602933463
+# MD5 Fingerprint: 54:dd:b2:d7:5f:d8:3e:ed:7c:e0:0b:2e:cc:ed:eb:eb
+# SHA1 Fingerprint: 57:73:a5:61:5d:80:b2:e6:ac:38:82:fc:68:07:31:ac:9f:b5:92:5a
+# SHA256 Fingerprint: be:4b:56:cb:50:56:c0:13:6a:52:6d:f4:44:50:8d:aa:36:a0:b5:4f:42:e4:ac:38:f7:2a:f4:70:e4:79:65:4c
+-----BEGIN CERTIFICATE-----
+MIICVTCCAdygAwIBAgIUTyNkuI6XY57GU4HBdk7LKnQV1tcwCgYIKoZIzj0EAwMw
+WjELMAkGA1UEBhMCQ04xJTAjBgNVBAoMHFRydXN0QXNpYSBUZWNobm9sb2dpZXMs
+IEluYy4xJDAiBgNVBAMMG1RydXN0QXNpYSBHbG9iYWwgUm9vdCBDQSBHNDAeFw0y
+MTA1MjAwMjEwMjJaFw00NjA1MTkwMjEwMjJaMFoxCzAJBgNVBAYTAkNOMSUwIwYD
+VQQKDBxUcnVzdEFzaWEgVGVjaG5vbG9naWVzLCBJbmMuMSQwIgYDVQQDDBtUcnVz
+dEFzaWEgR2xvYmFsIFJvb3QgQ0EgRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATx
+s8045CVD5d4ZCbuBeaIVXxVjAd7Cq92zphtnS4CDr5nLrBfbK5bKfFJV4hrhPVbw
+LxYI+hW8m7tH5j/uqOFMjPXTNvk4XatwmkcN4oFBButJ+bAp3TPsUKV/eSm4IJij
+YzBhMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUpbtKl86zK3+kMd6Xg1mD
+pm9xy94wHQYDVR0OBBYEFKW7SpfOsyt/pDHel4NZg6ZvccveMA4GA1UdDwEB/wQE
+AwIBBjAKBggqhkjOPQQDAwNnADBkAjBe8usGzEkxn0AAbbd+NvBNEU/zy4k6LHiR
+UKNbwMp1JvK/kF0LgoxgKJ/GcJpo5PECMFxYDlZ2z1jD1xCMuo6u47xkdUfFVZDj
+/bpV6wfEU6s3qe4hsiFbYI89MvHVI5TWWA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust ECC Root-01 O=CommScope
+# Subject: CN=CommScope Public Trust ECC Root-01 O=CommScope
+# Label: "CommScope Public Trust ECC Root-01"
+# Serial: 385011430473757362783587124273108818652468453534
+# MD5 Fingerprint: 3a:40:a7:fc:03:8c:9c:38:79:2f:3a:a2:6c:b6:0a:16
+# SHA1 Fingerprint: 07:86:c0:d8:dd:8e:c0:80:98:06:98:d0:58:7a:ef:de:a6:cc:a2:5d
+# SHA256 Fingerprint: 11:43:7c:da:7b:b4:5e:41:36:5f:45:b3:9a:38:98:6b:0d:e0:0d:ef:34:8e:0c:7b:b0:87:36:33:80:0b:c3:8b
+-----BEGIN CERTIFICATE-----
+MIICHTCCAaOgAwIBAgIUQ3CCd89NXTTxyq4yLzf39H91oJ4wCgYIKoZIzj0EAwMw
+TjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwiQ29t
+bVNjb3BlIFB1YmxpYyBUcnVzdCBFQ0MgUm9vdC0wMTAeFw0yMTA0MjgxNzM1NDNa
+Fw00NjA0MjgxNzM1NDJaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21tU2Nv
+cGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgRUNDIFJvb3QtMDEw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAARLNumuV16ocNfQj3Rid8NeeqrltqLxeP0C
+flfdkXmcbLlSiFS8LwS+uM32ENEp7LXQoMPwiXAZu1FlxUOcw5tjnSCDPgYLpkJE
+hRGnSjot6dZoL0hOUysHP029uax3OVejQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYD
+VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSOB2LAUN3GGQYARnQE9/OufXVNMDAKBggq
+hkjOPQQDAwNoADBlAjEAnDPfQeMjqEI2Jpc1XHvr20v4qotzVRVcrHgpD7oh2MSg
+2NED3W3ROT3Ek2DS43KyAjB8xX6I01D1HiXo+k515liWpDVfG2XqYZpwI7UNo5uS
+Um9poIyNStDuiw7LR47QjRE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust ECC Root-02 O=CommScope
+# Subject: CN=CommScope Public Trust ECC Root-02 O=CommScope
+# Label: "CommScope Public Trust ECC Root-02"
+# Serial: 234015080301808452132356021271193974922492992893
+# MD5 Fingerprint: 59:b0:44:d5:65:4d:b8:5c:55:19:92:02:b6:d1:94:b2
+# SHA1 Fingerprint: 3c:3f:ef:57:0f:fe:65:93:86:9e:a0:fe:b0:f6:ed:8e:d1:13:c7:e5
+# SHA256 Fingerprint: 2f:fb:7f:81:3b:bb:b3:c8:9a:b4:e8:16:2d:0f:16:d7:15:09:a8:30:cc:9d:73:c2:62:e5:14:08:75:d1:ad:4a
+-----BEGIN CERTIFICATE-----
+MIICHDCCAaOgAwIBAgIUKP2ZYEFHpgE6yhR7H+/5aAiDXX0wCgYIKoZIzj0EAwMw
+TjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwiQ29t
+bVNjb3BlIFB1YmxpYyBUcnVzdCBFQ0MgUm9vdC0wMjAeFw0yMTA0MjgxNzQ0NTRa
+Fw00NjA0MjgxNzQ0NTNaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21tU2Nv
+cGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgRUNDIFJvb3QtMDIw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAAR4MIHoYx7l63FRD/cHB8o5mXxO1Q/MMDAL
+j2aTPs+9xYa9+bG3tD60B8jzljHz7aRP+KNOjSkVWLjVb3/ubCK1sK9IRQq9qEmU
+v4RDsNuESgMjGWdqb8FuvAY5N9GIIvejQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYD
+VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTmGHX/72DehKT1RsfeSlXjMjZ59TAKBggq
+hkjOPQQDAwNnADBkAjAmc0l6tqvmSfR9Uj/UQQSugEODZXW5hYA4O9Zv5JOGq4/n
+ich/m35rChJVYaoR4HkCMHfoMXGsPHED1oQmHhS48zs73u1Z/GtMMH9ZzkXpc2AV
+mkzw5l4lIhVtwodZ0LKOag==
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust RSA Root-01 O=CommScope
+# Subject: CN=CommScope Public Trust RSA Root-01 O=CommScope
+# Label: "CommScope Public Trust RSA Root-01"
+# Serial: 354030733275608256394402989253558293562031411421
+# MD5 Fingerprint: 0e:b4:15:bc:87:63:5d:5d:02:73:d4:26:38:68:73:d8
+# SHA1 Fingerprint: 6d:0a:5f:f7:b4:23:06:b4:85:b3:b7:97:64:fc:ac:75:f5:33:f2:93
+# SHA256 Fingerprint: 02:bd:f9:6e:2a:45:dd:9b:f1:8f:c7:e1:db:df:21:a0:37:9b:a3:c9:c2:61:03:44:cf:d8:d6:06:fe:c1:ed:81
+-----BEGIN CERTIFICATE-----
+MIIFbDCCA1SgAwIBAgIUPgNJgXUWdDGOTKvVxZAplsU5EN0wDQYJKoZIhvcNAQEL
+BQAwTjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwi
+Q29tbVNjb3BlIFB1YmxpYyBUcnVzdCBSU0EgUm9vdC0wMTAeFw0yMTA0MjgxNjQ1
+NTRaFw00NjA0MjgxNjQ1NTNaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21t
+U2NvcGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgUlNBIFJvb3Qt
+MDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCwSGWjDR1C45FtnYSk
+YZYSwu3D2iM0GXb26v1VWvZVAVMP8syMl0+5UMuzAURWlv2bKOx7dAvnQmtVzslh
+suitQDy6uUEKBU8bJoWPQ7VAtYXR1HHcg0Hz9kXHgKKEUJdGzqAMxGBWBB0HW0al
+DrJLpA6lfO741GIDuZNqihS4cPgugkY4Iw50x2tBt9Apo52AsH53k2NC+zSDO3Oj
+WiE260f6GBfZumbCk6SP/F2krfxQapWsvCQz0b2If4b19bJzKo98rwjyGpg/qYFl
+P8GMicWWMJoKz/TUyDTtnS+8jTiGU+6Xn6myY5QXjQ/cZip8UlF1y5mO6D1cv547
+KI2DAg+pn3LiLCuz3GaXAEDQpFSOm117RTYm1nJD68/A6g3czhLmfTifBSeolz7p
+UcZsBSjBAg/pGG3svZwG1KdJ9FQFa2ww8esD1eo9anbCyxooSU1/ZOD6K9pzg4H/
+kQO9lLvkuI6cMmPNn7togbGEW682v3fuHX/3SZtS7NJ3Wn2RnU3COS3kuoL4b/JO
+Hg9O5j9ZpSPcPYeoKFgo0fEbNttPxP/hjFtyjMcmAyejOQoBqsCyMWCDIqFPEgkB
+Ea801M/XrmLTBQe0MXXgDW1XT2mH+VepuhX2yFJtocucH+X8eKg1mp9BFM6ltM6U
+CBwJrVbl2rZJmkrqYxhTnCwuwwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUN12mmnQywsL5x6YVEFm45P3luG0wDQYJ
+KoZIhvcNAQELBQADggIBAK+nz97/4L1CjU3lIpbfaOp9TSp90K09FlxD533Ahuh6
+NWPxzIHIxgvoLlI1pKZJkGNRrDSsBTtXAOnTYtPZKdVUvhwQkZyybf5Z/Xn36lbQ
+nmhUQo8mUuJM3y+Xpi/SB5io82BdS5pYV4jvguX6r2yBS5KPQJqTRlnLX3gWsWc+
+QgvfKNmwrZggvkN80V4aCRckjXtdlemrwWCrWxhkgPut4AZ9HcpZuPN4KWfGVh2v
+trV0KnahP/t1MJ+UXjulYPPLXAziDslg+MkfFoom3ecnf+slpoq9uC02EJqxWE2a
+aE9gVOX2RhOOiKy8IUISrcZKiX2bwdgt6ZYD9KJ0DLwAHb/WNyVntHKLr4W96ioD
+j8z7PEQkguIBpQtZtjSNMgsSDesnwv1B10A8ckYpwIzqug/xBpMu95yo9GA+o/E4
+Xo4TwbM6l4c/ksp4qRyv0LAbJh6+cOx69TOY6lz/KwsETkPdY34Op054A5U+1C0w
+lREQKC6/oAI+/15Z0wUOlV9TRe9rh9VIzRamloPh37MG88EU26fsHItdkJANclHn
+YfkUyq+Dj7+vsQpZXdxc1+SWrVtgHdqul7I52Qb1dgAT+GhMIbA1xNxVssnBQVoc
+icCMb3SgazNNtQEo/a2tiRc7ppqEvOuM6sRxJKi6KfkIsidWNTJf6jn7MZrVGczw
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust RSA Root-02 O=CommScope
+# Subject: CN=CommScope Public Trust RSA Root-02 O=CommScope
+# Label: "CommScope Public Trust RSA Root-02"
+# Serial: 480062499834624527752716769107743131258796508494
+# MD5 Fingerprint: e1:29:f9:62:7b:76:e2:96:6d:f3:d4:d7:0f:ae:1f:aa
+# SHA1 Fingerprint: ea:b0:e2:52:1b:89:93:4c:11:68:f2:d8:9a:ac:22:4c:a3:8a:57:ae
+# SHA256 Fingerprint: ff:e9:43:d7:93:42:4b:4f:7c:44:0c:1c:3d:64:8d:53:63:f3:4b:82:dc:87:aa:7a:9f:11:8f:c5:de:e1:01:f1
+-----BEGIN CERTIFICATE-----
+MIIFbDCCA1SgAwIBAgIUVBa/O345lXGN0aoApYYNK496BU4wDQYJKoZIhvcNAQEL
+BQAwTjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwi
+Q29tbVNjb3BlIFB1YmxpYyBUcnVzdCBSU0EgUm9vdC0wMjAeFw0yMTA0MjgxNzE2
+NDNaFw00NjA0MjgxNzE2NDJaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21t
+U2NvcGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgUlNBIFJvb3Qt
+MDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDh+g77aAASyE3VrCLE
+NQE7xVTlWXZjpX/rwcRqmL0yjReA61260WI9JSMZNRTpf4mnG2I81lDnNJUDMrG0
+kyI9p+Kx7eZ7Ti6Hmw0zdQreqjXnfuU2mKKuJZ6VszKWpCtYHu8//mI0SFHRtI1C
+rWDaSWqVcN3SAOLMV2MCe5bdSZdbkk6V0/nLKR8YSvgBKtJjCW4k6YnS5cciTNxz
+hkcAqg2Ijq6FfUrpuzNPDlJwnZXjfG2WWy09X6GDRl224yW4fKcZgBzqZUPckXk2
+LHR88mcGyYnJ27/aaL8j7dxrrSiDeS/sOKUNNwFnJ5rpM9kzXzehxfCrPfp4sOcs
+n/Y+n2Dg70jpkEUeBVF4GiwSLFworA2iI540jwXmojPOEXcT1A6kHkIfhs1w/tku
+FT0du7jyU1fbzMZ0KZwYszZ1OC4PVKH4kh+Jlk+71O6d6Ts2QrUKOyrUZHk2EOH5
+kQMreyBUzQ0ZGshBMjTRsJnhkB4BQDa1t/qp5Xd1pCKBXbCL5CcSD1SIxtuFdOa3
+wNemKfrb3vOTlycEVS8KbzfFPROvCgCpLIscgSjX74Yxqa7ybrjKaixUR9gqiC6v
+wQcQeKwRoi9C8DfF8rhW3Q5iLc4tVn5V8qdE9isy9COoR+jUKgF4z2rDN6ieZdIs
+5fq6M8EGRPbmz6UNp2YINIos8wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUR9DnsSL/nSz12Vdgs7GxcJXvYXowDQYJ
+KoZIhvcNAQELBQADggIBAIZpsU0v6Z9PIpNojuQhmaPORVMbc0RTAIFhzTHjCLqB
+KCh6krm2qMhDnscTJk3C2OVVnJJdUNjCK9v+5qiXz1I6JMNlZFxHMaNlNRPDk7n3
++VGXu6TwYofF1gbTl4MgqX67tiHCpQ2EAOHyJxCDut0DgdXdaMNmEMjRdrSzbyme
+APnCKfWxkxlSaRosTKCL4BWaMS/TiJVZbuXEs1DIFAhKm4sTg7GkcrI7djNB3Nyq
+pgdvHSQSn8h2vS/ZjvQs7rfSOBAkNlEv41xdgSGn2rtO/+YHqP65DSdsu3BaVXoT
+6fEqSWnHX4dXTEN5bTpl6TBcQe7rd6VzEojov32u5cSoHw2OHG1QAk8mGEPej1WF
+sQs3BWDJVTkSBKEqz3EWnzZRSb9wO55nnPt7eck5HHisd5FUmrh1CoFSl+NmYWvt
+PjgelmFV4ZFUjO2MJB+ByRCac5krFk5yAD9UG/iNuovnFNa2RU9g7Jauwy8CTl2d
+lklyALKrdVwPaFsdZcJfMw8eD/A7hvWwTruc9+olBdytoptLFwG+Qt81IR2tq670
+v64fG9PiO/yzcnMcmyiQiRM9HcEARwmWmjgb3bHPDcK0RPOWlc4yOo80nOAXx17O
+rg3bhzjlP1v9mxnhMUF6cKojawHhRUzNlM47ni3niAIi9G7oyOzWPPO5std3eqx7
+-----END CERTIFICATE-----
diff --git a/lib/python3.11/site-packages/certifi/core.py b/lib/python3.11/site-packages/certifi/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..de028981b97e1fcc8ef4ab2c817cc8731b9c8738
--- /dev/null
+++ b/lib/python3.11/site-packages/certifi/core.py
@@ -0,0 +1,108 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import sys
+
+
+if sys.version_info >= (3, 11):
+
+    from importlib.resources import as_file, files
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = as_file(files("certifi").joinpath("cacert.pem"))
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return files("certifi").joinpath("cacert.pem").read_text(encoding="ascii")
+
+elif sys.version_info >= (3, 7):
+
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the
+        # file in cases where we're inside of a zipimport situation until
+        # someone actually calls where(), but we don't want to re-extract
+        # the file on every call of where(), so we'll do it once then store
+        # it in a global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you
+            # to manage the cleanup of this file, so it doesn't actually
+            # return a path, it returns a context manager that will give
+            # you the path when you enter it and will do any cleanup when
+            # you leave it. In the common case of not needing a temporary
+            # file, it will just return the file system location and the
+            # __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")
+
+else:
+    import os
+    import types
+    from typing import Union
+
+    Package = Union[types.ModuleType, str]
+    Resource = Union[str, "os.PathLike"]
+
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(
+        package: Package,
+        resource: Resource,
+        encoding: str = 'utf-8',
+        errors: str = 'strict'
+    ) -> str:
+        with open(where(), encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where() -> str:
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")
diff --git a/lib/python3.11/site-packages/certifi/py.typed b/lib/python3.11/site-packages/certifi/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/INSTALLER b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/LICENSE b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..ad82355b802d542e8443dc78b937fa36fdcc0ace
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 TAHRI Ahmed R.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/METADATA b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..822550e36bfc53472baf4f4d059b878817c87496
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/METADATA
@@ -0,0 +1,683 @@
+Metadata-Version: 2.1
+Name: charset-normalizer
+Version: 3.3.2
+Summary: The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet.
+Home-page: https://github.com/Ousret/charset_normalizer
+Author: Ahmed TAHRI
+Author-email: ahmed.tahri@cloudnursery.dev
+License: MIT
+Project-URL: Bug Reports, https://github.com/Ousret/charset_normalizer/issues
+Project-URL: Documentation, https://charset-normalizer.readthedocs.io/en/latest
+Keywords: encoding,charset,charset-detector,detector,normalization,unicode,chardet,detect
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.7.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: unicode_backport
+
+<h1 align="center">Charset Detection, for Everyone 👋</h1>
+
+<p align="center">
+  <sup>The Real First Universal Charset Detector</sup><br>
+  <a href="https://pypi.org/project/charset-normalizer">
+    <img src="https://img.shields.io/pypi/pyversions/charset_normalizer.svg?orange=blue" />
+  </a>
+  <a href="https://pepy.tech/project/charset-normalizer/">
+    <img alt="Download Count Total" src="https://static.pepy.tech/badge/charset-normalizer/month" />
+  </a>
+  <a href="https://bestpractices.coreinfrastructure.org/projects/7297">
+    <img src="https://bestpractices.coreinfrastructure.org/projects/7297/badge">
+  </a>
+</p>
+<p align="center">
+  <sup><i>Featured Packages</i></sup><br>
+  <a href="https://github.com/jawah/niquests">
+   <img alt="Static Badge" src="https://img.shields.io/badge/Niquests-HTTP_1.1%2C%202%2C_and_3_Client-cyan">
+  </a>
+  <a href="https://github.com/jawah/wassima">
+   <img alt="Static Badge" src="https://img.shields.io/badge/Wassima-Certifi_Killer-cyan">
+  </a>
+</p>
+<p align="center">
+  <sup><i>In other language (unofficial port - by the community)</i></sup><br>
+  <a href="https://github.com/nickspring/charset-normalizer-rs">
+   <img alt="Static Badge" src="https://img.shields.io/badge/Rust-red">
+  </a>
+</p>
+
+> A library that helps you read text from an unknown charset encoding.<br /> Motivated by `chardet`,
+> I'm trying to resolve the issue by taking a new approach.
+> All IANA character set names for which the Python core library provides codecs are supported.
+
+<p align="center">
+  >>>>> <a href="https://charsetnormalizerweb.ousret.now.sh" target="_blank">👉 Try Me Online Now, Then Adopt Me 👈 </a> <<<<<
+</p>
+
+This project offers you an alternative to **Universal Charset Encoding Detector**, also known as **Chardet**.
+
+| Feature                                          | [Chardet](https://github.com/chardet/chardet) |                                         Charset Normalizer                                         | [cChardet](https://github.com/PyYoshi/cChardet) |
+|--------------------------------------------------|:---------------------------------------------:|:--------------------------------------------------------------------------------------------------:|:-----------------------------------------------:|
+| `Fast`                                           |                       ❌                       |                                                 ✅                                                  |                        ✅                        |
+| `Universal**`                                    |                       ❌                       |                                                 ✅                                                  |                        ❌                        |
+| `Reliable` **without** distinguishable standards |                       ❌                       |                                                 ✅                                                  |                        ✅                        |
+| `Reliable` **with** distinguishable standards    |                       ✅                       |                                                 ✅                                                  |                        ✅                        |
+| `License`                                        |           LGPL-2.1<br>_restrictive_           |                                                MIT                                                 |            MPL-1.1<br>_restrictive_             |
+| `Native Python`                                  |                       ✅                       |                                                 ✅                                                  |                        ❌                        |
+| `Detect spoken language`                         |                       ❌                       |                                                 ✅                                                  |                       N/A                       |
+| `UnicodeDecodeError Safety`                      |                       ❌                       |                                                 ✅                                                  |                        ❌                        |
+| `Whl Size (min)`                                 |                   193.6 kB                    |                                               42 kB                                                |                     ~200 kB                     |
+| `Supported Encoding`                             |                      33                       | 🎉 [99](https://charset-normalizer.readthedocs.io/en/latest/user/support.html#supported-encodings) |                       40                        |
+
+<p align="center">
+<img src="https://i.imgflip.com/373iay.gif" alt="Reading Normalized Text" width="226"/><img src="https://media.tenor.com/images/c0180f70732a18b4965448d33adba3d0/tenor.gif" alt="Cat Reading Text" width="200"/>
+</p>
+
+*\*\* : They are clearly using specific code for a specific encoding even if covering most of used one*<br> 
+Did you got there because of the logs? See [https://charset-normalizer.readthedocs.io/en/latest/user/miscellaneous.html](https://charset-normalizer.readthedocs.io/en/latest/user/miscellaneous.html)
+
+## ⚡ Performance
+
+This package offer better performance than its counterpart Chardet. Here are some numbers.
+
+| Package                                       | Accuracy | Mean per file (ms) | File per sec (est) |
+|-----------------------------------------------|:--------:|:------------------:|:------------------:|
+| [chardet](https://github.com/chardet/chardet) |   86 %   |       200 ms       |     5 file/sec     |
+| charset-normalizer                            | **98 %** |     **10 ms**      |    100 file/sec    |
+
+| Package                                       | 99th percentile | 95th percentile | 50th percentile |
+|-----------------------------------------------|:---------------:|:---------------:|:---------------:|
+| [chardet](https://github.com/chardet/chardet) |     1200 ms     |     287 ms      |      23 ms      |
+| charset-normalizer                            |     100 ms      |      50 ms      |      5 ms       |
+
+Chardet's performance on larger file (1MB+) are very poor. Expect huge difference on large payload.
+
+> Stats are generated using 400+ files using default parameters. More details on used files, see GHA workflows.
+> And yes, these results might change at any time. The dataset can be updated to include more files.
+> The actual delays heavily depends on your CPU capabilities. The factors should remain the same.
+> Keep in mind that the stats are generous and that Chardet accuracy vs our is measured using Chardet initial capability
+> (eg. Supported Encoding) Challenge-them if you want.
+
+## ✨ Installation
+
+Using pip:
+
+```sh
+pip install charset-normalizer -U
+```
+
+## 🚀 Basic Usage
+
+### CLI
+This package comes with a CLI.
+
+```
+usage: normalizer [-h] [-v] [-a] [-n] [-m] [-r] [-f] [-t THRESHOLD]
+                  file [file ...]
+
+The Real First Universal Charset Detector. Discover originating encoding used
+on text file. Normalize text to unicode.
+
+positional arguments:
+  files                 File(s) to be analysed
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -v, --verbose         Display complementary information about file if any.
+                        Stdout will contain logs about the detection process.
+  -a, --with-alternative
+                        Output complementary possibilities if any. Top-level
+                        JSON WILL be a list.
+  -n, --normalize       Permit to normalize input file. If not set, program
+                        does not write anything.
+  -m, --minimal         Only output the charset detected to STDOUT. Disabling
+                        JSON output.
+  -r, --replace         Replace file when trying to normalize it instead of
+                        creating a new one.
+  -f, --force           Replace file without asking if you are sure, use this
+                        flag with caution.
+  -t THRESHOLD, --threshold THRESHOLD
+                        Define a custom maximum amount of chaos allowed in
+                        decoded content. 0. <= chaos <= 1.
+  --version             Show version information and exit.
+```
+
+```bash
+normalizer ./data/sample.1.fr.srt
+```
+
+or
+
+```bash
+python -m charset_normalizer ./data/sample.1.fr.srt
+```
+
+🎉 Since version 1.4.0 the CLI produce easily usable stdout result in JSON format.
+
+```json
+{
+    "path": "/home/default/projects/charset_normalizer/data/sample.1.fr.srt",
+    "encoding": "cp1252",
+    "encoding_aliases": [
+        "1252",
+        "windows_1252"
+    ],
+    "alternative_encodings": [
+        "cp1254",
+        "cp1256",
+        "cp1258",
+        "iso8859_14",
+        "iso8859_15",
+        "iso8859_16",
+        "iso8859_3",
+        "iso8859_9",
+        "latin_1",
+        "mbcs"
+    ],
+    "language": "French",
+    "alphabets": [
+        "Basic Latin",
+        "Latin-1 Supplement"
+    ],
+    "has_sig_or_bom": false,
+    "chaos": 0.149,
+    "coherence": 97.152,
+    "unicode_path": null,
+    "is_preferred": true
+}
+```
+
+### Python
+*Just print out normalized text*
+```python
+from charset_normalizer import from_path
+
+results = from_path('./my_subtitle.srt')
+
+print(str(results.best()))
+```
+
+*Upgrade your code without effort*
+```python
+from charset_normalizer import detect
+```
+
+The above code will behave the same as **chardet**. We ensure that we offer the best (reasonable) BC result possible.
+
+See the docs for advanced usage : [readthedocs.io](https://charset-normalizer.readthedocs.io/en/latest/)
+
+## 😇 Why
+
+When I started using Chardet, I noticed that it was not suited to my expectations, and I wanted to propose a
+reliable alternative using a completely different method. Also! I never back down on a good challenge!
+
+I **don't care** about the **originating charset** encoding, because **two different tables** can
+produce **two identical rendered string.**
+What I want is to get readable text, the best I can. 
+
+In a way, **I'm brute forcing text decoding.** How cool is that ? 😎
+
+Don't confuse package **ftfy** with charset-normalizer or chardet. ftfy goal is to repair unicode string whereas charset-normalizer to convert raw file in unknown encoding to unicode.
+
+## 🍰 How
+
+  - Discard all charset encoding table that could not fit the binary content.
+  - Measure noise, or the mess once opened (by chunks) with a corresponding charset encoding.
+  - Extract matches with the lowest mess detected.
+  - Additionally, we measure coherence / probe for a language.
+
+**Wait a minute**, what is noise/mess and coherence according to **YOU ?**
+
+*Noise :* I opened hundred of text files, **written by humans**, with the wrong encoding table. **I observed**, then
+**I established** some ground rules about **what is obvious** when **it seems like** a mess.
+ I know that my interpretation of what is noise is probably incomplete, feel free to contribute in order to
+ improve or rewrite it.
+
+*Coherence :* For each language there is on earth, we have computed ranked letter appearance occurrences (the best we can). So I thought
+that intel is worth something here. So I use those records against decoded text to check if I can detect intelligent design.
+
+## ⚡ Known limitations
+
+  - Language detection is unreliable when text contains two or more languages sharing identical letters. (eg. HTML (english tags) + Turkish content (Sharing Latin characters))
+  - Every charset detector heavily depends on sufficient content. In common cases, do not bother run detection on very tiny content.
+
+## ⚠️ About Python EOLs
+
+**If you are running:**
+
+- Python >=2.7,<3.5: Unsupported
+- Python 3.5: charset-normalizer < 2.1
+- Python 3.6: charset-normalizer < 3.1
+- Python 3.7: charset-normalizer < 4.0
+
+Upgrade your Python interpreter as soon as possible.
+
+## 👤 Contributing
+
+Contributions, issues and feature requests are very much welcome.<br />
+Feel free to check [issues page](https://github.com/ousret/charset_normalizer/issues) if you want to contribute.
+
+## 📝 License
+
+Copyright © [Ahmed TAHRI @Ousret](https://github.com/Ousret).<br />
+This project is [MIT](https://github.com/Ousret/charset_normalizer/blob/master/LICENSE) licensed.
+
+Characters frequencies used in this project © 2012 [Denny Vrandečić](http://simia.net/letters/)
+
+## 💼 For Enterprise
+
+Professional support for charset-normalizer is available as part of the [Tidelift
+Subscription][1]. Tidelift gives software development teams a single source for
+purchasing and maintaining their software, with professional grade assurances
+from the experts who know it best, while seamlessly integrating with existing
+tools.
+
+[1]: https://tidelift.com/subscription/pkg/pypi-charset-normalizer?utm_source=pypi-charset-normalizer&utm_medium=readme
+
+# Changelog
+All notable changes to charset-normalizer will be documented in this file. This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [3.3.2](https://github.com/Ousret/charset_normalizer/compare/3.3.1...3.3.2) (2023-10-31)
+
+### Fixed
+- Unintentional memory usage regression when using large payload that match several encoding (#376)
+- Regression on some detection case showcased in the documentation (#371)
+
+### Added
+- Noise (md) probe that identify malformed arabic representation due to the presence of letters in isolated form (credit to my wife)
+
+## [3.3.1](https://github.com/Ousret/charset_normalizer/compare/3.3.0...3.3.1) (2023-10-22)
+
+### Changed
+- Optional mypyc compilation upgraded to version 1.6.1 for Python >= 3.8
+- Improved the general detection reliability based on reports from the community
+
+## [3.3.0](https://github.com/Ousret/charset_normalizer/compare/3.2.0...3.3.0) (2023-09-30)
+
+### Added
+- Allow to execute the CLI (e.g. normalizer) through `python -m charset_normalizer.cli` or `python -m charset_normalizer`
+- Support for 9 forgotten encoding that are supported by Python but unlisted in `encoding.aliases` as they have no alias (#323)
+
+### Removed
+- (internal) Redundant utils.is_ascii function and unused function is_private_use_only
+- (internal) charset_normalizer.assets is moved inside charset_normalizer.constant
+
+### Changed
+- (internal) Unicode code blocks in constants are updated using the latest v15.0.0 definition to improve detection
+- Optional mypyc compilation upgraded to version 1.5.1 for Python >= 3.8
+
+### Fixed
+- Unable to properly sort CharsetMatch when both chaos/noise and coherence were close due to an unreachable condition in \_\_lt\_\_ (#350)
+
+## [3.2.0](https://github.com/Ousret/charset_normalizer/compare/3.1.0...3.2.0) (2023-06-07)
+
+### Changed
+- Typehint for function `from_path` no longer enforce `PathLike` as its first argument
+- Minor improvement over the global detection reliability
+
+### Added
+- Introduce function `is_binary` that relies on main capabilities, and optimized to detect binaries
+- Propagate `enable_fallback` argument throughout `from_bytes`, `from_path`, and `from_fp` that allow a deeper control over the detection (default True)
+- Explicit support for Python 3.12
+
+### Fixed
+- Edge case detection failure where a file would contain 'very-long' camel cased word (Issue #289)
+
+## [3.1.0](https://github.com/Ousret/charset_normalizer/compare/3.0.1...3.1.0) (2023-03-06)
+
+### Added
+- Argument `should_rename_legacy` for legacy function `detect` and disregard any new arguments without errors (PR #262)
+
+### Removed
+- Support for Python 3.6 (PR #260)
+
+### Changed
+- Optional speedup provided by mypy/c 1.0.1
+
+## [3.0.1](https://github.com/Ousret/charset_normalizer/compare/3.0.0...3.0.1) (2022-11-18)
+
+### Fixed
+- Multi-bytes cutter/chunk generator did not always cut correctly (PR #233)
+
+### Changed
+- Speedup provided by mypy/c 0.990 on Python >= 3.7
+
+## [3.0.0](https://github.com/Ousret/charset_normalizer/compare/2.1.1...3.0.0) (2022-10-20)
+
+### Added
+- Extend the capability of explain=True when cp_isolation contains at most two entries (min one), will log in details of the Mess-detector results
+- Support for alternative language frequency set in charset_normalizer.assets.FREQUENCIES
+- Add parameter `language_threshold` in `from_bytes`, `from_path` and `from_fp` to adjust the minimum expected coherence ratio
+- `normalizer --version` now specify if current version provide extra speedup (meaning mypyc compilation whl)
+
+### Changed
+- Build with static metadata using 'build' frontend
+- Make the language detection stricter
+- Optional: Module `md.py` can be compiled using Mypyc to provide an extra speedup up to 4x faster than v2.1
+
+### Fixed
+- CLI with opt --normalize fail when using full path for files
+- TooManyAccentuatedPlugin induce false positive on the mess detection when too few alpha character have been fed to it
+- Sphinx warnings when generating the documentation
+
+### Removed
+- Coherence detector no longer return 'Simple English' instead return 'English'
+- Coherence detector no longer return 'Classical Chinese' instead return 'Chinese'
+- Breaking: Method `first()` and `best()` from CharsetMatch
+- UTF-7 will no longer appear as "detected" without a recognized SIG/mark (is unreliable/conflict with ASCII)
+- Breaking: Class aliases CharsetDetector, CharsetDoctor, CharsetNormalizerMatch and CharsetNormalizerMatches
+- Breaking: Top-level function `normalize`
+- Breaking: Properties `chaos_secondary_pass`, `coherence_non_latin` and `w_counter` from CharsetMatch
+- Support for the backport `unicodedata2`
+
+## [3.0.0rc1](https://github.com/Ousret/charset_normalizer/compare/3.0.0b2...3.0.0rc1) (2022-10-18)
+
+### Added
+- Extend the capability of explain=True when cp_isolation contains at most two entries (min one), will log in details of the Mess-detector results
+- Support for alternative language frequency set in charset_normalizer.assets.FREQUENCIES
+- Add parameter `language_threshold` in `from_bytes`, `from_path` and `from_fp` to adjust the minimum expected coherence ratio
+
+### Changed
+- Build with static metadata using 'build' frontend
+- Make the language detection stricter
+
+### Fixed
+- CLI with opt --normalize fail when using full path for files
+- TooManyAccentuatedPlugin induce false positive on the mess detection when too few alpha character have been fed to it
+
+### Removed
+- Coherence detector no longer return 'Simple English' instead return 'English'
+- Coherence detector no longer return 'Classical Chinese' instead return 'Chinese'
+
+## [3.0.0b2](https://github.com/Ousret/charset_normalizer/compare/3.0.0b1...3.0.0b2) (2022-08-21)
+
+### Added
+- `normalizer --version` now specify if current version provide extra speedup (meaning mypyc compilation whl)
+
+### Removed
+- Breaking: Method `first()` and `best()` from CharsetMatch
+- UTF-7 will no longer appear as "detected" without a recognized SIG/mark (is unreliable/conflict with ASCII)
+
+### Fixed
+- Sphinx warnings when generating the documentation
+
+## [3.0.0b1](https://github.com/Ousret/charset_normalizer/compare/2.1.0...3.0.0b1) (2022-08-15)
+
+### Changed
+- Optional: Module `md.py` can be compiled using Mypyc to provide an extra speedup up to 4x faster than v2.1
+
+### Removed
+- Breaking: Class aliases CharsetDetector, CharsetDoctor, CharsetNormalizerMatch and CharsetNormalizerMatches
+- Breaking: Top-level function `normalize`
+- Breaking: Properties `chaos_secondary_pass`, `coherence_non_latin` and `w_counter` from CharsetMatch
+- Support for the backport `unicodedata2`
+
+## [2.1.1](https://github.com/Ousret/charset_normalizer/compare/2.1.0...2.1.1) (2022-08-19)
+
+### Deprecated
+- Function `normalize` scheduled for removal in 3.0
+
+### Changed
+- Removed useless call to decode in fn is_unprintable (#206)
+
+### Fixed
+- Third-party library (i18n xgettext) crashing not recognizing utf_8 (PEP 263) with underscore from [@aleksandernovikov](https://github.com/aleksandernovikov) (#204)
+
+## [2.1.0](https://github.com/Ousret/charset_normalizer/compare/2.0.12...2.1.0) (2022-06-19)
+
+### Added
+- Output the Unicode table version when running the CLI with `--version` (PR #194)
+
+### Changed
+- Re-use decoded buffer for single byte character sets from [@nijel](https://github.com/nijel) (PR #175)
+- Fixing some performance bottlenecks from [@deedy5](https://github.com/deedy5) (PR #183)
+
+### Fixed
+- Workaround potential bug in cpython with Zero Width No-Break Space located in Arabic Presentation Forms-B, Unicode 1.1 not acknowledged as space (PR #175)
+- CLI default threshold aligned with the API threshold from [@oleksandr-kuzmenko](https://github.com/oleksandr-kuzmenko) (PR #181)
+
+### Removed
+- Support for Python 3.5 (PR #192)
+
+### Deprecated
+- Use of backport unicodedata from `unicodedata2` as Python is quickly catching up, scheduled for removal in 3.0 (PR #194)
+
+## [2.0.12](https://github.com/Ousret/charset_normalizer/compare/2.0.11...2.0.12) (2022-02-12)
+
+### Fixed
+- ASCII miss-detection on rare cases (PR #170) 
+
+## [2.0.11](https://github.com/Ousret/charset_normalizer/compare/2.0.10...2.0.11) (2022-01-30)
+
+### Added
+- Explicit support for Python 3.11 (PR #164)
+
+### Changed
+- The logging behavior have been completely reviewed, now using only TRACE and DEBUG levels (PR #163 #165)
+
+## [2.0.10](https://github.com/Ousret/charset_normalizer/compare/2.0.9...2.0.10) (2022-01-04)
+
+### Fixed
+- Fallback match entries might lead to UnicodeDecodeError for large bytes sequence (PR #154)
+
+### Changed
+- Skipping the language-detection (CD) on ASCII (PR #155)
+
+## [2.0.9](https://github.com/Ousret/charset_normalizer/compare/2.0.8...2.0.9) (2021-12-03)
+
+### Changed
+- Moderating the logging impact (since 2.0.8) for specific environments (PR #147)
+
+### Fixed
+- Wrong logging level applied when setting kwarg `explain` to True (PR #146)
+
+## [2.0.8](https://github.com/Ousret/charset_normalizer/compare/2.0.7...2.0.8) (2021-11-24)
+### Changed
+- Improvement over Vietnamese detection (PR #126)
+- MD improvement on trailing data and long foreign (non-pure latin) data (PR #124)
+- Efficiency improvements in cd/alphabet_languages from [@adbar](https://github.com/adbar) (PR #122)
+- call sum() without an intermediary list following PEP 289 recommendations from [@adbar](https://github.com/adbar) (PR #129)
+- Code style as refactored by Sourcery-AI (PR #131) 
+- Minor adjustment on the MD around european words (PR #133)
+- Remove and replace SRTs from assets / tests (PR #139)
+- Initialize the library logger with a `NullHandler` by default from [@nmaynes](https://github.com/nmaynes) (PR #135)
+- Setting kwarg `explain` to True will add provisionally (bounded to function lifespan) a specific stream handler (PR #135)
+
+### Fixed
+- Fix large (misleading) sequence giving UnicodeDecodeError (PR #137)
+- Avoid using too insignificant chunk (PR #137)
+
+### Added
+- Add and expose function `set_logging_handler` to configure a specific StreamHandler from [@nmaynes](https://github.com/nmaynes) (PR #135)
+- Add `CHANGELOG.md` entries, format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) (PR #141)
+
+## [2.0.7](https://github.com/Ousret/charset_normalizer/compare/2.0.6...2.0.7) (2021-10-11)
+### Added
+- Add support for Kazakh (Cyrillic) language detection (PR #109)
+
+### Changed
+- Further, improve inferring the language from a given single-byte code page (PR #112)
+- Vainly trying to leverage PEP263 when PEP3120 is not supported (PR #116)
+- Refactoring for potential performance improvements in loops from [@adbar](https://github.com/adbar) (PR #113)
+- Various detection improvement (MD+CD) (PR #117)
+
+### Removed
+- Remove redundant logging entry about detected language(s) (PR #115)
+
+### Fixed
+- Fix a minor inconsistency between Python 3.5 and other versions regarding language detection (PR #117 #102)
+
+## [2.0.6](https://github.com/Ousret/charset_normalizer/compare/2.0.5...2.0.6) (2021-09-18)
+### Fixed
+- Unforeseen regression with the loss of the backward-compatibility with some older minor of Python 3.5.x (PR #100)
+- Fix CLI crash when using --minimal output in certain cases (PR #103)
+
+### Changed
+- Minor improvement to the detection efficiency (less than 1%) (PR #106 #101)
+
+## [2.0.5](https://github.com/Ousret/charset_normalizer/compare/2.0.4...2.0.5) (2021-09-14)
+### Changed
+- The project now comply with: flake8, mypy, isort and black to ensure a better overall quality (PR #81)
+- The BC-support with v1.x was improved, the old staticmethods are restored (PR #82)
+- The Unicode detection is slightly improved (PR #93)
+- Add syntax sugar \_\_bool\_\_ for results CharsetMatches list-container (PR #91)
+
+### Removed
+- The project no longer raise warning on tiny content given for detection, will be simply logged as warning instead (PR #92)
+
+### Fixed
+- In some rare case, the chunks extractor could cut in the middle of a multi-byte character and could mislead the mess detection (PR #95)
+- Some rare 'space' characters could trip up the UnprintablePlugin/Mess detection (PR #96)
+- The MANIFEST.in was not exhaustive (PR #78)
+
+## [2.0.4](https://github.com/Ousret/charset_normalizer/compare/2.0.3...2.0.4) (2021-07-30)
+### Fixed
+- The CLI no longer raise an unexpected exception when no encoding has been found (PR #70)
+- Fix accessing the 'alphabets' property when the payload contains surrogate characters (PR #68)
+- The logger could mislead (explain=True) on detected languages and the impact of one MBCS match (PR #72)
+- Submatch factoring could be wrong in rare edge cases (PR #72)
+- Multiple files given to the CLI were ignored when publishing results to STDOUT. (After the first path) (PR #72)
+- Fix line endings from CRLF to LF for certain project files (PR #67)
+
+### Changed
+- Adjust the MD to lower the sensitivity, thus improving the global detection reliability (PR #69 #76)
+- Allow fallback on specified encoding if any (PR #71)
+
+## [2.0.3](https://github.com/Ousret/charset_normalizer/compare/2.0.2...2.0.3) (2021-07-16)
+### Changed
+- Part of the detection mechanism has been improved to be less sensitive, resulting in more accurate detection results. Especially ASCII. (PR #63)
+- According to the community wishes, the detection will fall back on ASCII or UTF-8 in a last-resort case. (PR #64)
+
+## [2.0.2](https://github.com/Ousret/charset_normalizer/compare/2.0.1...2.0.2) (2021-07-15)
+### Fixed
+- Empty/Too small JSON payload miss-detection fixed. Report from [@tseaver](https://github.com/tseaver) (PR #59) 
+
+### Changed
+- Don't inject unicodedata2 into sys.modules from [@akx](https://github.com/akx) (PR #57)
+
+## [2.0.1](https://github.com/Ousret/charset_normalizer/compare/2.0.0...2.0.1) (2021-07-13)
+### Fixed
+- Make it work where there isn't a filesystem available, dropping assets frequencies.json. Report from [@sethmlarson](https://github.com/sethmlarson). (PR #55)
+- Using explain=False permanently disable the verbose output in the current runtime (PR #47)
+- One log entry (language target preemptive) was not show in logs when using explain=True (PR #47)
+- Fix undesired exception (ValueError) on getitem of instance CharsetMatches (PR #52)
+
+### Changed
+- Public function normalize default args values were not aligned with from_bytes (PR #53)
+
+### Added
+- You may now use charset aliases in cp_isolation and cp_exclusion arguments (PR #47)
+
+## [2.0.0](https://github.com/Ousret/charset_normalizer/compare/1.4.1...2.0.0) (2021-07-02)
+### Changed
+- 4x to 5 times faster than the previous 1.4.0 release. At least 2x faster than Chardet.
+- Accent has been made on UTF-8 detection, should perform rather instantaneous.
+- The backward compatibility with Chardet has been greatly improved. The legacy detect function returns an identical charset name whenever possible.
+- The detection mechanism has been slightly improved, now Turkish content is detected correctly (most of the time)
+- The program has been rewritten to ease the readability and maintainability. (+Using static typing)+
+- utf_7 detection has been reinstated.
+
+### Removed
+- This package no longer require anything when used with Python 3.5 (Dropped cached_property)
+- Removed support for these languages: Catalan, Esperanto, Kazakh, Baque, Volapük, Azeri, Galician, Nynorsk, Macedonian, and Serbocroatian.
+- The exception hook on UnicodeDecodeError has been removed.
+
+### Deprecated
+- Methods coherence_non_latin, w_counter, chaos_secondary_pass of the class CharsetMatch are now deprecated and scheduled for removal in v3.0
+
+### Fixed
+- The CLI output used the relative path of the file(s). Should be absolute.
+
+## [1.4.1](https://github.com/Ousret/charset_normalizer/compare/1.4.0...1.4.1) (2021-05-28)
+### Fixed
+- Logger configuration/usage no longer conflict with others (PR #44)
+
+## [1.4.0](https://github.com/Ousret/charset_normalizer/compare/1.3.9...1.4.0) (2021-05-21)
+### Removed
+- Using standard logging instead of using the package loguru.
+- Dropping nose test framework in favor of the maintained pytest.
+- Choose to not use dragonmapper package to help with gibberish Chinese/CJK text.
+- Require cached_property only for Python 3.5 due to constraint. Dropping for every other interpreter version.
+- Stop support for UTF-7 that does not contain a SIG.
+- Dropping PrettyTable, replaced with pure JSON output in CLI.
+
+### Fixed
+- BOM marker in a CharsetNormalizerMatch instance could be False in rare cases even if obviously present. Due to the sub-match factoring process.
+- Not searching properly for the BOM when trying utf32/16 parent codec.
+
+### Changed
+- Improving the package final size by compressing frequencies.json.
+- Huge improvement over the larges payload.
+
+### Added
+- CLI now produces JSON consumable output.
+- Return ASCII if given sequences fit. Given reasonable confidence.
+
+## [1.3.9](https://github.com/Ousret/charset_normalizer/compare/1.3.8...1.3.9) (2021-05-13)
+
+### Fixed
+- In some very rare cases, you may end up getting encode/decode errors due to a bad bytes payload (PR #40)
+
+## [1.3.8](https://github.com/Ousret/charset_normalizer/compare/1.3.7...1.3.8) (2021-05-12)
+
+### Fixed
+- Empty given payload for detection may cause an exception if trying to access the `alphabets` property. (PR #39)
+
+## [1.3.7](https://github.com/Ousret/charset_normalizer/compare/1.3.6...1.3.7) (2021-05-12)
+
+### Fixed
+- The legacy detect function should return UTF-8-SIG if sig is present in the payload. (PR #38)
+
+## [1.3.6](https://github.com/Ousret/charset_normalizer/compare/1.3.5...1.3.6) (2021-02-09)
+
+### Changed
+- Amend the previous release to allow prettytable 2.0 (PR #35)
+
+## [1.3.5](https://github.com/Ousret/charset_normalizer/compare/1.3.4...1.3.5) (2021-02-08)
+
+### Fixed
+- Fix error while using the package with a python pre-release interpreter (PR #33)
+
+### Changed
+- Dependencies refactoring, constraints revised.
+
+### Added
+- Add python 3.9 and 3.10 to the supported interpreters
+
+MIT License
+
+Copyright (c) 2019 TAHRI Ahmed R.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/RECORD b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..e40131e06df44a128ffa27ea2d60997b74a76d48
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/RECORD
@@ -0,0 +1,35 @@
+../../../bin/normalizer,sha256=YnnjWFnBo-5ncwqWx_Z70rELAOBcQEMlV7bxTgbUYVY,296
+charset_normalizer-3.3.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+charset_normalizer-3.3.2.dist-info/LICENSE,sha256=6zGgxaT7Cbik4yBV0lweX5w1iidS_vPNcgIT0cz-4kE,1070
+charset_normalizer-3.3.2.dist-info/METADATA,sha256=cfLhl5A6SI-F0oclm8w8ux9wshL1nipdeCdVnYb4AaA,33550
+charset_normalizer-3.3.2.dist-info/RECORD,,
+charset_normalizer-3.3.2.dist-info/WHEEL,sha256=eaDTbMedWofVq8IZjew9qeAkoA5Sw2MOU2ppdIRr1Jg,110
+charset_normalizer-3.3.2.dist-info/entry_points.txt,sha256=ADSTKrkXZ3hhdOVFi6DcUEHQRS0xfxDIE_pEz4wLIXA,65
+charset_normalizer-3.3.2.dist-info/top_level.txt,sha256=7ASyzePr8_xuZWJsnqJjIBtyV8vhEo0wBCv1MPRRi3Q,19
+charset_normalizer/__init__.py,sha256=UzI3xC8PhmcLRMzSgPb6minTmRq0kWznnCBJ8ZCc2XI,1577
+charset_normalizer/__main__.py,sha256=JxY8bleaENOFlLRb9HfoeZCzAMnn2A1oGR5Xm2eyqg0,73
+charset_normalizer/__pycache__/__init__.cpython-311.pyc,,
+charset_normalizer/__pycache__/__main__.cpython-311.pyc,,
+charset_normalizer/__pycache__/api.cpython-311.pyc,,
+charset_normalizer/__pycache__/cd.cpython-311.pyc,,
+charset_normalizer/__pycache__/constant.cpython-311.pyc,,
+charset_normalizer/__pycache__/legacy.cpython-311.pyc,,
+charset_normalizer/__pycache__/md.cpython-311.pyc,,
+charset_normalizer/__pycache__/models.cpython-311.pyc,,
+charset_normalizer/__pycache__/utils.cpython-311.pyc,,
+charset_normalizer/__pycache__/version.cpython-311.pyc,,
+charset_normalizer/api.py,sha256=WOlWjy6wT8SeMYFpaGbXZFN1TMXa-s8vZYfkL4G29iQ,21097
+charset_normalizer/cd.py,sha256=xwZliZcTQFA3jU0c00PRiu9MNxXTFxQkFLWmMW24ZzI,12560
+charset_normalizer/cli/__init__.py,sha256=D5ERp8P62llm2FuoMzydZ7d9rs8cvvLXqE-1_6oViPc,100
+charset_normalizer/cli/__main__.py,sha256=2F-xURZJzo063Ye-2RLJ2wcmURpbKeAzKwpiws65dAs,9744
+charset_normalizer/cli/__pycache__/__init__.cpython-311.pyc,,
+charset_normalizer/cli/__pycache__/__main__.cpython-311.pyc,,
+charset_normalizer/constant.py,sha256=p0IsOVcEbPWYPOdWhnhRbjK1YVBy6fs05C5vKC-zoxU,40481
+charset_normalizer/legacy.py,sha256=T-QuVMsMeDiQEk8WSszMrzVJg_14AMeSkmHdRYhdl1k,2071
+charset_normalizer/md.cpython-311-darwin.so,sha256=zbs-p3GrSygP9-4v4GVAUcyRpreXASFbQqgK9rvFoKw,50117
+charset_normalizer/md.py,sha256=NkSuVLK13_a8c7BxZ4cGIQ5vOtGIWOdh22WZEvjp-7U,19624
+charset_normalizer/md__mypyc.cpython-311-darwin.so,sha256=5u-KvFhpxi_WDpF0bB0tfYS2z7PzQ08aO8DAOMiMAXI,232636
+charset_normalizer/models.py,sha256=I5i0s4aKCCgLPY2tUY3pwkgFA-BUbbNxQ7hVkVTt62s,11624
+charset_normalizer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+charset_normalizer/utils.py,sha256=teiosMqzKjXyAHXnGdjSBOgnBZwx-SkBbCLrx0UXy8M,11894
+charset_normalizer/version.py,sha256=iHKUfHD3kDRSyrh_BN2ojh43TA5-UZQjvbVIEFfpHDs,79
diff --git a/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/WHEEL b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..5feb1eeba52cffb96bc20980b20ca1eb17bea57f
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64
+
diff --git a/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/entry_points.txt b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65619e73ec06c20c2a70c9507b872ad624d1a85c
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+normalizer = charset_normalizer.cli:cli_detect
diff --git a/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/top_level.txt b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..66958f0a069d7aea7939bed40b9197608e93b243
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer-3.3.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+charset_normalizer
diff --git a/lib/python3.11/site-packages/charset_normalizer/__init__.py b/lib/python3.11/site-packages/charset_normalizer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..55991fc38062b9c800805437ee49b0cf42b98103
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/__init__.py
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""
+Charset-Normalizer
+~~~~~~~~~~~~~~
+The Real First Universal Charset Detector.
+A library that helps you read text from an unknown charset encoding.
+Motivated by chardet, This package is trying to resolve the issue by taking a new approach.
+All IANA character set names for which the Python core library provides codecs are supported.
+
+Basic usage:
+   >>> from charset_normalizer import from_bytes
+   >>> results = from_bytes('Bсеки човек има право на образование. Oбразованието!'.encode('utf_8'))
+   >>> best_guess = results.best()
+   >>> str(best_guess)
+   'Bсеки човек има право на образование. Oбразованието!'
+
+Others methods and usages are available - see the full documentation
+at <https://github.com/Ousret/charset_normalizer>.
+:copyright: (c) 2021 by Ahmed TAHRI
+:license: MIT, see LICENSE for more details.
+"""
+import logging
+
+from .api import from_bytes, from_fp, from_path, is_binary
+from .legacy import detect
+from .models import CharsetMatch, CharsetMatches
+from .utils import set_logging_handler
+from .version import VERSION, __version__
+
+__all__ = (
+    "from_fp",
+    "from_path",
+    "from_bytes",
+    "is_binary",
+    "detect",
+    "CharsetMatch",
+    "CharsetMatches",
+    "__version__",
+    "VERSION",
+    "set_logging_handler",
+)
+
+# Attach a NullHandler to the top level logger by default
+# https://docs.python.org/3.3/howto/logging.html#configuring-logging-for-a-library
+
+logging.getLogger("charset_normalizer").addHandler(logging.NullHandler())
diff --git a/lib/python3.11/site-packages/charset_normalizer/__main__.py b/lib/python3.11/site-packages/charset_normalizer/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..beae2ef77490c9f9c9255dd68facbb6de132841f
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/__main__.py
@@ -0,0 +1,4 @@
+from .cli import cli_detect
+
+if __name__ == "__main__":
+    cli_detect()
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0443290438d90f3145f41656bc64affa4c9e30ea
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/__main__.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/__main__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b79c8db45e98f8cbf40eb48052dbfc77d948daf3
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/__main__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/api.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3c7e52f735eb03c019ddd49ec7f2837a30fd3866
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/api.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/cd.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/cd.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ca7f42b115f671e0882ef222fc21ea2af9e89a3
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/cd.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/constant.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/constant.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..954ae01db7d15cf3673aee1658e402784bf6d916
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/constant.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/legacy.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/legacy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..99819c899232ef504d475fece04e517772db9f28
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/legacy.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/md.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/md.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e00ae16513a1882b3700e51cdcce6d140f3467e3
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/md.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/models.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/models.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ce9440647fc4216d750650e2696ad43a2a49eb5
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/models.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/utils.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d463223de1276a140049677e13a27f1917eddc89
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/__pycache__/version.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/__pycache__/version.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8591d8aa31786366bbcb7e3ec1c7ab13edeebec0
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/__pycache__/version.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/api.py b/lib/python3.11/site-packages/charset_normalizer/api.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ba08e3a50ba6d61e75f3f31772eb4dfdd3f8f05
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/api.py
@@ -0,0 +1,626 @@
+import logging
+from os import PathLike
+from typing import BinaryIO, List, Optional, Set, Union
+
+from .cd import (
+    coherence_ratio,
+    encoding_languages,
+    mb_encoding_languages,
+    merge_coherence_ratios,
+)
+from .constant import IANA_SUPPORTED, TOO_BIG_SEQUENCE, TOO_SMALL_SEQUENCE, TRACE
+from .md import mess_ratio
+from .models import CharsetMatch, CharsetMatches
+from .utils import (
+    any_specified_encoding,
+    cut_sequence_chunks,
+    iana_name,
+    identify_sig_or_bom,
+    is_cp_similar,
+    is_multi_byte_encoding,
+    should_strip_sig_or_bom,
+)
+
+# Will most likely be controversial
+# logging.addLevelName(TRACE, "TRACE")
+logger = logging.getLogger("charset_normalizer")
+explain_handler = logging.StreamHandler()
+explain_handler.setFormatter(
+    logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
+)
+
+
+def from_bytes(
+    sequences: Union[bytes, bytearray],
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.2,
+    cp_isolation: Optional[List[str]] = None,
+    cp_exclusion: Optional[List[str]] = None,
+    preemptive_behaviour: bool = True,
+    explain: bool = False,
+    language_threshold: float = 0.1,
+    enable_fallback: bool = True,
+) -> CharsetMatches:
+    """
+    Given a raw bytes sequence, return the best possibles charset usable to render str objects.
+    If there is no results, it is a strong indicator that the source is binary/not text.
+    By default, the process will extract 5 blocks of 512o each to assess the mess and coherence of a given sequence.
+    And will give up a particular code page after 20% of measured mess. Those criteria are customizable at will.
+
+    The preemptive behavior DOES NOT replace the traditional detection workflow, it prioritize a particular code page
+    but never take it for granted. Can improve the performance.
+
+    You may want to focus your attention to some code page or/and not others, use cp_isolation and cp_exclusion for that
+    purpose.
+
+    This function will strip the SIG in the payload/sequence every time except on UTF-16, UTF-32.
+    By default the library does not setup any handler other than the NullHandler, if you choose to set the 'explain'
+    toggle to True it will alter the logger configuration to add a StreamHandler that is suitable for debugging.
+    Custom logging format and handler can be set manually.
+    """
+
+    if not isinstance(sequences, (bytearray, bytes)):
+        raise TypeError(
+            "Expected object of type bytes or bytearray, got: {0}".format(
+                type(sequences)
+            )
+        )
+
+    if explain:
+        previous_logger_level: int = logger.level
+        logger.addHandler(explain_handler)
+        logger.setLevel(TRACE)
+
+    length: int = len(sequences)
+
+    if length == 0:
+        logger.debug("Encoding detection on empty bytes, assuming utf_8 intention.")
+        if explain:
+            logger.removeHandler(explain_handler)
+            logger.setLevel(previous_logger_level or logging.WARNING)
+        return CharsetMatches([CharsetMatch(sequences, "utf_8", 0.0, False, [], "")])
+
+    if cp_isolation is not None:
+        logger.log(
+            TRACE,
+            "cp_isolation is set. use this flag for debugging purpose. "
+            "limited list of encoding allowed : %s.",
+            ", ".join(cp_isolation),
+        )
+        cp_isolation = [iana_name(cp, False) for cp in cp_isolation]
+    else:
+        cp_isolation = []
+
+    if cp_exclusion is not None:
+        logger.log(
+            TRACE,
+            "cp_exclusion is set. use this flag for debugging purpose. "
+            "limited list of encoding excluded : %s.",
+            ", ".join(cp_exclusion),
+        )
+        cp_exclusion = [iana_name(cp, False) for cp in cp_exclusion]
+    else:
+        cp_exclusion = []
+
+    if length <= (chunk_size * steps):
+        logger.log(
+            TRACE,
+            "override steps (%i) and chunk_size (%i) as content does not fit (%i byte(s) given) parameters.",
+            steps,
+            chunk_size,
+            length,
+        )
+        steps = 1
+        chunk_size = length
+
+    if steps > 1 and length / steps < chunk_size:
+        chunk_size = int(length / steps)
+
+    is_too_small_sequence: bool = len(sequences) < TOO_SMALL_SEQUENCE
+    is_too_large_sequence: bool = len(sequences) >= TOO_BIG_SEQUENCE
+
+    if is_too_small_sequence:
+        logger.log(
+            TRACE,
+            "Trying to detect encoding from a tiny portion of ({}) byte(s).".format(
+                length
+            ),
+        )
+    elif is_too_large_sequence:
+        logger.log(
+            TRACE,
+            "Using lazy str decoding because the payload is quite large, ({}) byte(s).".format(
+                length
+            ),
+        )
+
+    prioritized_encodings: List[str] = []
+
+    specified_encoding: Optional[str] = (
+        any_specified_encoding(sequences) if preemptive_behaviour else None
+    )
+
+    if specified_encoding is not None:
+        prioritized_encodings.append(specified_encoding)
+        logger.log(
+            TRACE,
+            "Detected declarative mark in sequence. Priority +1 given for %s.",
+            specified_encoding,
+        )
+
+    tested: Set[str] = set()
+    tested_but_hard_failure: List[str] = []
+    tested_but_soft_failure: List[str] = []
+
+    fallback_ascii: Optional[CharsetMatch] = None
+    fallback_u8: Optional[CharsetMatch] = None
+    fallback_specified: Optional[CharsetMatch] = None
+
+    results: CharsetMatches = CharsetMatches()
+
+    sig_encoding, sig_payload = identify_sig_or_bom(sequences)
+
+    if sig_encoding is not None:
+        prioritized_encodings.append(sig_encoding)
+        logger.log(
+            TRACE,
+            "Detected a SIG or BOM mark on first %i byte(s). Priority +1 given for %s.",
+            len(sig_payload),
+            sig_encoding,
+        )
+
+    prioritized_encodings.append("ascii")
+
+    if "utf_8" not in prioritized_encodings:
+        prioritized_encodings.append("utf_8")
+
+    for encoding_iana in prioritized_encodings + IANA_SUPPORTED:
+        if cp_isolation and encoding_iana not in cp_isolation:
+            continue
+
+        if cp_exclusion and encoding_iana in cp_exclusion:
+            continue
+
+        if encoding_iana in tested:
+            continue
+
+        tested.add(encoding_iana)
+
+        decoded_payload: Optional[str] = None
+        bom_or_sig_available: bool = sig_encoding == encoding_iana
+        strip_sig_or_bom: bool = bom_or_sig_available and should_strip_sig_or_bom(
+            encoding_iana
+        )
+
+        if encoding_iana in {"utf_16", "utf_32"} and not bom_or_sig_available:
+            logger.log(
+                TRACE,
+                "Encoding %s won't be tested as-is because it require a BOM. Will try some sub-encoder LE/BE.",
+                encoding_iana,
+            )
+            continue
+        if encoding_iana in {"utf_7"} and not bom_or_sig_available:
+            logger.log(
+                TRACE,
+                "Encoding %s won't be tested as-is because detection is unreliable without BOM/SIG.",
+                encoding_iana,
+            )
+            continue
+
+        try:
+            is_multi_byte_decoder: bool = is_multi_byte_encoding(encoding_iana)
+        except (ModuleNotFoundError, ImportError):
+            logger.log(
+                TRACE,
+                "Encoding %s does not provide an IncrementalDecoder",
+                encoding_iana,
+            )
+            continue
+
+        try:
+            if is_too_large_sequence and is_multi_byte_decoder is False:
+                str(
+                    sequences[: int(50e4)]
+                    if strip_sig_or_bom is False
+                    else sequences[len(sig_payload) : int(50e4)],
+                    encoding=encoding_iana,
+                )
+            else:
+                decoded_payload = str(
+                    sequences
+                    if strip_sig_or_bom is False
+                    else sequences[len(sig_payload) :],
+                    encoding=encoding_iana,
+                )
+        except (UnicodeDecodeError, LookupError) as e:
+            if not isinstance(e, LookupError):
+                logger.log(
+                    TRACE,
+                    "Code page %s does not fit given bytes sequence at ALL. %s",
+                    encoding_iana,
+                    str(e),
+                )
+            tested_but_hard_failure.append(encoding_iana)
+            continue
+
+        similar_soft_failure_test: bool = False
+
+        for encoding_soft_failed in tested_but_soft_failure:
+            if is_cp_similar(encoding_iana, encoding_soft_failed):
+                similar_soft_failure_test = True
+                break
+
+        if similar_soft_failure_test:
+            logger.log(
+                TRACE,
+                "%s is deemed too similar to code page %s and was consider unsuited already. Continuing!",
+                encoding_iana,
+                encoding_soft_failed,
+            )
+            continue
+
+        r_ = range(
+            0 if not bom_or_sig_available else len(sig_payload),
+            length,
+            int(length / steps),
+        )
+
+        multi_byte_bonus: bool = (
+            is_multi_byte_decoder
+            and decoded_payload is not None
+            and len(decoded_payload) < length
+        )
+
+        if multi_byte_bonus:
+            logger.log(
+                TRACE,
+                "Code page %s is a multi byte encoding table and it appear that at least one character "
+                "was encoded using n-bytes.",
+                encoding_iana,
+            )
+
+        max_chunk_gave_up: int = int(len(r_) / 4)
+
+        max_chunk_gave_up = max(max_chunk_gave_up, 2)
+        early_stop_count: int = 0
+        lazy_str_hard_failure = False
+
+        md_chunks: List[str] = []
+        md_ratios = []
+
+        try:
+            for chunk in cut_sequence_chunks(
+                sequences,
+                encoding_iana,
+                r_,
+                chunk_size,
+                bom_or_sig_available,
+                strip_sig_or_bom,
+                sig_payload,
+                is_multi_byte_decoder,
+                decoded_payload,
+            ):
+                md_chunks.append(chunk)
+
+                md_ratios.append(
+                    mess_ratio(
+                        chunk,
+                        threshold,
+                        explain is True and 1 <= len(cp_isolation) <= 2,
+                    )
+                )
+
+                if md_ratios[-1] >= threshold:
+                    early_stop_count += 1
+
+                if (early_stop_count >= max_chunk_gave_up) or (
+                    bom_or_sig_available and strip_sig_or_bom is False
+                ):
+                    break
+        except (
+            UnicodeDecodeError
+        ) as e:  # Lazy str loading may have missed something there
+            logger.log(
+                TRACE,
+                "LazyStr Loading: After MD chunk decode, code page %s does not fit given bytes sequence at ALL. %s",
+                encoding_iana,
+                str(e),
+            )
+            early_stop_count = max_chunk_gave_up
+            lazy_str_hard_failure = True
+
+        # We might want to check the sequence again with the whole content
+        # Only if initial MD tests passes
+        if (
+            not lazy_str_hard_failure
+            and is_too_large_sequence
+            and not is_multi_byte_decoder
+        ):
+            try:
+                sequences[int(50e3) :].decode(encoding_iana, errors="strict")
+            except UnicodeDecodeError as e:
+                logger.log(
+                    TRACE,
+                    "LazyStr Loading: After final lookup, code page %s does not fit given bytes sequence at ALL. %s",
+                    encoding_iana,
+                    str(e),
+                )
+                tested_but_hard_failure.append(encoding_iana)
+                continue
+
+        mean_mess_ratio: float = sum(md_ratios) / len(md_ratios) if md_ratios else 0.0
+        if mean_mess_ratio >= threshold or early_stop_count >= max_chunk_gave_up:
+            tested_but_soft_failure.append(encoding_iana)
+            logger.log(
+                TRACE,
+                "%s was excluded because of initial chaos probing. Gave up %i time(s). "
+                "Computed mean chaos is %f %%.",
+                encoding_iana,
+                early_stop_count,
+                round(mean_mess_ratio * 100, ndigits=3),
+            )
+            # Preparing those fallbacks in case we got nothing.
+            if (
+                enable_fallback
+                and encoding_iana in ["ascii", "utf_8", specified_encoding]
+                and not lazy_str_hard_failure
+            ):
+                fallback_entry = CharsetMatch(
+                    sequences, encoding_iana, threshold, False, [], decoded_payload
+                )
+                if encoding_iana == specified_encoding:
+                    fallback_specified = fallback_entry
+                elif encoding_iana == "ascii":
+                    fallback_ascii = fallback_entry
+                else:
+                    fallback_u8 = fallback_entry
+            continue
+
+        logger.log(
+            TRACE,
+            "%s passed initial chaos probing. Mean measured chaos is %f %%",
+            encoding_iana,
+            round(mean_mess_ratio * 100, ndigits=3),
+        )
+
+        if not is_multi_byte_decoder:
+            target_languages: List[str] = encoding_languages(encoding_iana)
+        else:
+            target_languages = mb_encoding_languages(encoding_iana)
+
+        if target_languages:
+            logger.log(
+                TRACE,
+                "{} should target any language(s) of {}".format(
+                    encoding_iana, str(target_languages)
+                ),
+            )
+
+        cd_ratios = []
+
+        # We shall skip the CD when its about ASCII
+        # Most of the time its not relevant to run "language-detection" on it.
+        if encoding_iana != "ascii":
+            for chunk in md_chunks:
+                chunk_languages = coherence_ratio(
+                    chunk,
+                    language_threshold,
+                    ",".join(target_languages) if target_languages else None,
+                )
+
+                cd_ratios.append(chunk_languages)
+
+        cd_ratios_merged = merge_coherence_ratios(cd_ratios)
+
+        if cd_ratios_merged:
+            logger.log(
+                TRACE,
+                "We detected language {} using {}".format(
+                    cd_ratios_merged, encoding_iana
+                ),
+            )
+
+        results.append(
+            CharsetMatch(
+                sequences,
+                encoding_iana,
+                mean_mess_ratio,
+                bom_or_sig_available,
+                cd_ratios_merged,
+                decoded_payload,
+            )
+        )
+
+        if (
+            encoding_iana in [specified_encoding, "ascii", "utf_8"]
+            and mean_mess_ratio < 0.1
+        ):
+            logger.debug(
+                "Encoding detection: %s is most likely the one.", encoding_iana
+            )
+            if explain:
+                logger.removeHandler(explain_handler)
+                logger.setLevel(previous_logger_level)
+            return CharsetMatches([results[encoding_iana]])
+
+        if encoding_iana == sig_encoding:
+            logger.debug(
+                "Encoding detection: %s is most likely the one as we detected a BOM or SIG within "
+                "the beginning of the sequence.",
+                encoding_iana,
+            )
+            if explain:
+                logger.removeHandler(explain_handler)
+                logger.setLevel(previous_logger_level)
+            return CharsetMatches([results[encoding_iana]])
+
+    if len(results) == 0:
+        if fallback_u8 or fallback_ascii or fallback_specified:
+            logger.log(
+                TRACE,
+                "Nothing got out of the detection process. Using ASCII/UTF-8/Specified fallback.",
+            )
+
+        if fallback_specified:
+            logger.debug(
+                "Encoding detection: %s will be used as a fallback match",
+                fallback_specified.encoding,
+            )
+            results.append(fallback_specified)
+        elif (
+            (fallback_u8 and fallback_ascii is None)
+            or (
+                fallback_u8
+                and fallback_ascii
+                and fallback_u8.fingerprint != fallback_ascii.fingerprint
+            )
+            or (fallback_u8 is not None)
+        ):
+            logger.debug("Encoding detection: utf_8 will be used as a fallback match")
+            results.append(fallback_u8)
+        elif fallback_ascii:
+            logger.debug("Encoding detection: ascii will be used as a fallback match")
+            results.append(fallback_ascii)
+
+    if results:
+        logger.debug(
+            "Encoding detection: Found %s as plausible (best-candidate) for content. With %i alternatives.",
+            results.best().encoding,  # type: ignore
+            len(results) - 1,
+        )
+    else:
+        logger.debug("Encoding detection: Unable to determine any suitable charset.")
+
+    if explain:
+        logger.removeHandler(explain_handler)
+        logger.setLevel(previous_logger_level)
+
+    return results
+
+
+def from_fp(
+    fp: BinaryIO,
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.20,
+    cp_isolation: Optional[List[str]] = None,
+    cp_exclusion: Optional[List[str]] = None,
+    preemptive_behaviour: bool = True,
+    explain: bool = False,
+    language_threshold: float = 0.1,
+    enable_fallback: bool = True,
+) -> CharsetMatches:
+    """
+    Same thing than the function from_bytes but using a file pointer that is already ready.
+    Will not close the file pointer.
+    """
+    return from_bytes(
+        fp.read(),
+        steps,
+        chunk_size,
+        threshold,
+        cp_isolation,
+        cp_exclusion,
+        preemptive_behaviour,
+        explain,
+        language_threshold,
+        enable_fallback,
+    )
+
+
+def from_path(
+    path: Union[str, bytes, PathLike],  # type: ignore[type-arg]
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.20,
+    cp_isolation: Optional[List[str]] = None,
+    cp_exclusion: Optional[List[str]] = None,
+    preemptive_behaviour: bool = True,
+    explain: bool = False,
+    language_threshold: float = 0.1,
+    enable_fallback: bool = True,
+) -> CharsetMatches:
+    """
+    Same thing than the function from_bytes but with one extra step. Opening and reading given file path in binary mode.
+    Can raise IOError.
+    """
+    with open(path, "rb") as fp:
+        return from_fp(
+            fp,
+            steps,
+            chunk_size,
+            threshold,
+            cp_isolation,
+            cp_exclusion,
+            preemptive_behaviour,
+            explain,
+            language_threshold,
+            enable_fallback,
+        )
+
+
+def is_binary(
+    fp_or_path_or_payload: Union[PathLike, str, BinaryIO, bytes],  # type: ignore[type-arg]
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.20,
+    cp_isolation: Optional[List[str]] = None,
+    cp_exclusion: Optional[List[str]] = None,
+    preemptive_behaviour: bool = True,
+    explain: bool = False,
+    language_threshold: float = 0.1,
+    enable_fallback: bool = False,
+) -> bool:
+    """
+    Detect if the given input (file, bytes, or path) points to a binary file. aka. not a string.
+    Based on the same main heuristic algorithms and default kwargs at the sole exception that fallbacks match
+    are disabled to be stricter around ASCII-compatible but unlikely to be a string.
+    """
+    if isinstance(fp_or_path_or_payload, (str, PathLike)):
+        guesses = from_path(
+            fp_or_path_or_payload,
+            steps=steps,
+            chunk_size=chunk_size,
+            threshold=threshold,
+            cp_isolation=cp_isolation,
+            cp_exclusion=cp_exclusion,
+            preemptive_behaviour=preemptive_behaviour,
+            explain=explain,
+            language_threshold=language_threshold,
+            enable_fallback=enable_fallback,
+        )
+    elif isinstance(
+        fp_or_path_or_payload,
+        (
+            bytes,
+            bytearray,
+        ),
+    ):
+        guesses = from_bytes(
+            fp_or_path_or_payload,
+            steps=steps,
+            chunk_size=chunk_size,
+            threshold=threshold,
+            cp_isolation=cp_isolation,
+            cp_exclusion=cp_exclusion,
+            preemptive_behaviour=preemptive_behaviour,
+            explain=explain,
+            language_threshold=language_threshold,
+            enable_fallback=enable_fallback,
+        )
+    else:
+        guesses = from_fp(
+            fp_or_path_or_payload,
+            steps=steps,
+            chunk_size=chunk_size,
+            threshold=threshold,
+            cp_isolation=cp_isolation,
+            cp_exclusion=cp_exclusion,
+            preemptive_behaviour=preemptive_behaviour,
+            explain=explain,
+            language_threshold=language_threshold,
+            enable_fallback=enable_fallback,
+        )
+
+    return not guesses
diff --git a/lib/python3.11/site-packages/charset_normalizer/cd.py b/lib/python3.11/site-packages/charset_normalizer/cd.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ea6760c45bce5773bfe4b46d7b3c07c2c139d49
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/cd.py
@@ -0,0 +1,395 @@
+import importlib
+from codecs import IncrementalDecoder
+from collections import Counter
+from functools import lru_cache
+from typing import Counter as TypeCounter, Dict, List, Optional, Tuple
+
+from .constant import (
+    FREQUENCIES,
+    KO_NAMES,
+    LANGUAGE_SUPPORTED_COUNT,
+    TOO_SMALL_SEQUENCE,
+    ZH_NAMES,
+)
+from .md import is_suspiciously_successive_range
+from .models import CoherenceMatches
+from .utils import (
+    is_accentuated,
+    is_latin,
+    is_multi_byte_encoding,
+    is_unicode_range_secondary,
+    unicode_range,
+)
+
+
+def encoding_unicode_range(iana_name: str) -> List[str]:
+    """
+    Return associated unicode ranges in a single byte code page.
+    """
+    if is_multi_byte_encoding(iana_name):
+        raise IOError("Function not supported on multi-byte code page")
+
+    decoder = importlib.import_module(
+        "encodings.{}".format(iana_name)
+    ).IncrementalDecoder
+
+    p: IncrementalDecoder = decoder(errors="ignore")
+    seen_ranges: Dict[str, int] = {}
+    character_count: int = 0
+
+    for i in range(0x40, 0xFF):
+        chunk: str = p.decode(bytes([i]))
+
+        if chunk:
+            character_range: Optional[str] = unicode_range(chunk)
+
+            if character_range is None:
+                continue
+
+            if is_unicode_range_secondary(character_range) is False:
+                if character_range not in seen_ranges:
+                    seen_ranges[character_range] = 0
+                seen_ranges[character_range] += 1
+                character_count += 1
+
+    return sorted(
+        [
+            character_range
+            for character_range in seen_ranges
+            if seen_ranges[character_range] / character_count >= 0.15
+        ]
+    )
+
+
+def unicode_range_languages(primary_range: str) -> List[str]:
+    """
+    Return inferred languages used with a unicode range.
+    """
+    languages: List[str] = []
+
+    for language, characters in FREQUENCIES.items():
+        for character in characters:
+            if unicode_range(character) == primary_range:
+                languages.append(language)
+                break
+
+    return languages
+
+
+@lru_cache()
+def encoding_languages(iana_name: str) -> List[str]:
+    """
+    Single-byte encoding language association. Some code page are heavily linked to particular language(s).
+    This function does the correspondence.
+    """
+    unicode_ranges: List[str] = encoding_unicode_range(iana_name)
+    primary_range: Optional[str] = None
+
+    for specified_range in unicode_ranges:
+        if "Latin" not in specified_range:
+            primary_range = specified_range
+            break
+
+    if primary_range is None:
+        return ["Latin Based"]
+
+    return unicode_range_languages(primary_range)
+
+
+@lru_cache()
+def mb_encoding_languages(iana_name: str) -> List[str]:
+    """
+    Multi-byte encoding language association. Some code page are heavily linked to particular language(s).
+    This function does the correspondence.
+    """
+    if (
+        iana_name.startswith("shift_")
+        or iana_name.startswith("iso2022_jp")
+        or iana_name.startswith("euc_j")
+        or iana_name == "cp932"
+    ):
+        return ["Japanese"]
+    if iana_name.startswith("gb") or iana_name in ZH_NAMES:
+        return ["Chinese"]
+    if iana_name.startswith("iso2022_kr") or iana_name in KO_NAMES:
+        return ["Korean"]
+
+    return []
+
+
+@lru_cache(maxsize=LANGUAGE_SUPPORTED_COUNT)
+def get_target_features(language: str) -> Tuple[bool, bool]:
+    """
+    Determine main aspects from a supported language if it contains accents and if is pure Latin.
+    """
+    target_have_accents: bool = False
+    target_pure_latin: bool = True
+
+    for character in FREQUENCIES[language]:
+        if not target_have_accents and is_accentuated(character):
+            target_have_accents = True
+        if target_pure_latin and is_latin(character) is False:
+            target_pure_latin = False
+
+    return target_have_accents, target_pure_latin
+
+
+def alphabet_languages(
+    characters: List[str], ignore_non_latin: bool = False
+) -> List[str]:
+    """
+    Return associated languages associated to given characters.
+    """
+    languages: List[Tuple[str, float]] = []
+
+    source_have_accents = any(is_accentuated(character) for character in characters)
+
+    for language, language_characters in FREQUENCIES.items():
+        target_have_accents, target_pure_latin = get_target_features(language)
+
+        if ignore_non_latin and target_pure_latin is False:
+            continue
+
+        if target_have_accents is False and source_have_accents:
+            continue
+
+        character_count: int = len(language_characters)
+
+        character_match_count: int = len(
+            [c for c in language_characters if c in characters]
+        )
+
+        ratio: float = character_match_count / character_count
+
+        if ratio >= 0.2:
+            languages.append((language, ratio))
+
+    languages = sorted(languages, key=lambda x: x[1], reverse=True)
+
+    return [compatible_language[0] for compatible_language in languages]
+
+
+def characters_popularity_compare(
+    language: str, ordered_characters: List[str]
+) -> float:
+    """
+    Determine if a ordered characters list (by occurrence from most appearance to rarest) match a particular language.
+    The result is a ratio between 0. (absolutely no correspondence) and 1. (near perfect fit).
+    Beware that is function is not strict on the match in order to ease the detection. (Meaning close match is 1.)
+    """
+    if language not in FREQUENCIES:
+        raise ValueError("{} not available".format(language))
+
+    character_approved_count: int = 0
+    FREQUENCIES_language_set = set(FREQUENCIES[language])
+
+    ordered_characters_count: int = len(ordered_characters)
+    target_language_characters_count: int = len(FREQUENCIES[language])
+
+    large_alphabet: bool = target_language_characters_count > 26
+
+    for character, character_rank in zip(
+        ordered_characters, range(0, ordered_characters_count)
+    ):
+        if character not in FREQUENCIES_language_set:
+            continue
+
+        character_rank_in_language: int = FREQUENCIES[language].index(character)
+        expected_projection_ratio: float = (
+            target_language_characters_count / ordered_characters_count
+        )
+        character_rank_projection: int = int(character_rank * expected_projection_ratio)
+
+        if (
+            large_alphabet is False
+            and abs(character_rank_projection - character_rank_in_language) > 4
+        ):
+            continue
+
+        if (
+            large_alphabet is True
+            and abs(character_rank_projection - character_rank_in_language)
+            < target_language_characters_count / 3
+        ):
+            character_approved_count += 1
+            continue
+
+        characters_before_source: List[str] = FREQUENCIES[language][
+            0:character_rank_in_language
+        ]
+        characters_after_source: List[str] = FREQUENCIES[language][
+            character_rank_in_language:
+        ]
+        characters_before: List[str] = ordered_characters[0:character_rank]
+        characters_after: List[str] = ordered_characters[character_rank:]
+
+        before_match_count: int = len(
+            set(characters_before) & set(characters_before_source)
+        )
+
+        after_match_count: int = len(
+            set(characters_after) & set(characters_after_source)
+        )
+
+        if len(characters_before_source) == 0 and before_match_count <= 4:
+            character_approved_count += 1
+            continue
+
+        if len(characters_after_source) == 0 and after_match_count <= 4:
+            character_approved_count += 1
+            continue
+
+        if (
+            before_match_count / len(characters_before_source) >= 0.4
+            or after_match_count / len(characters_after_source) >= 0.4
+        ):
+            character_approved_count += 1
+            continue
+
+    return character_approved_count / len(ordered_characters)
+
+
+def alpha_unicode_split(decoded_sequence: str) -> List[str]:
+    """
+    Given a decoded text sequence, return a list of str. Unicode range / alphabet separation.
+    Ex. a text containing English/Latin with a bit a Hebrew will return two items in the resulting list;
+    One containing the latin letters and the other hebrew.
+    """
+    layers: Dict[str, str] = {}
+
+    for character in decoded_sequence:
+        if character.isalpha() is False:
+            continue
+
+        character_range: Optional[str] = unicode_range(character)
+
+        if character_range is None:
+            continue
+
+        layer_target_range: Optional[str] = None
+
+        for discovered_range in layers:
+            if (
+                is_suspiciously_successive_range(discovered_range, character_range)
+                is False
+            ):
+                layer_target_range = discovered_range
+                break
+
+        if layer_target_range is None:
+            layer_target_range = character_range
+
+        if layer_target_range not in layers:
+            layers[layer_target_range] = character.lower()
+            continue
+
+        layers[layer_target_range] += character.lower()
+
+    return list(layers.values())
+
+
+def merge_coherence_ratios(results: List[CoherenceMatches]) -> CoherenceMatches:
+    """
+    This function merge results previously given by the function coherence_ratio.
+    The return type is the same as coherence_ratio.
+    """
+    per_language_ratios: Dict[str, List[float]] = {}
+    for result in results:
+        for sub_result in result:
+            language, ratio = sub_result
+            if language not in per_language_ratios:
+                per_language_ratios[language] = [ratio]
+                continue
+            per_language_ratios[language].append(ratio)
+
+    merge = [
+        (
+            language,
+            round(
+                sum(per_language_ratios[language]) / len(per_language_ratios[language]),
+                4,
+            ),
+        )
+        for language in per_language_ratios
+    ]
+
+    return sorted(merge, key=lambda x: x[1], reverse=True)
+
+
+def filter_alt_coherence_matches(results: CoherenceMatches) -> CoherenceMatches:
+    """
+    We shall NOT return "English—" in CoherenceMatches because it is an alternative
+    of "English". This function only keeps the best match and remove the em-dash in it.
+    """
+    index_results: Dict[str, List[float]] = dict()
+
+    for result in results:
+        language, ratio = result
+        no_em_name: str = language.replace("—", "")
+
+        if no_em_name not in index_results:
+            index_results[no_em_name] = []
+
+        index_results[no_em_name].append(ratio)
+
+    if any(len(index_results[e]) > 1 for e in index_results):
+        filtered_results: CoherenceMatches = []
+
+        for language in index_results:
+            filtered_results.append((language, max(index_results[language])))
+
+        return filtered_results
+
+    return results
+
+
+@lru_cache(maxsize=2048)
+def coherence_ratio(
+    decoded_sequence: str, threshold: float = 0.1, lg_inclusion: Optional[str] = None
+) -> CoherenceMatches:
+    """
+    Detect ANY language that can be identified in given sequence. The sequence will be analysed by layers.
+    A layer = Character extraction by alphabets/ranges.
+    """
+
+    results: List[Tuple[str, float]] = []
+    ignore_non_latin: bool = False
+
+    sufficient_match_count: int = 0
+
+    lg_inclusion_list = lg_inclusion.split(",") if lg_inclusion is not None else []
+    if "Latin Based" in lg_inclusion_list:
+        ignore_non_latin = True
+        lg_inclusion_list.remove("Latin Based")
+
+    for layer in alpha_unicode_split(decoded_sequence):
+        sequence_frequencies: TypeCounter[str] = Counter(layer)
+        most_common = sequence_frequencies.most_common()
+
+        character_count: int = sum(o for c, o in most_common)
+
+        if character_count <= TOO_SMALL_SEQUENCE:
+            continue
+
+        popular_character_ordered: List[str] = [c for c, o in most_common]
+
+        for language in lg_inclusion_list or alphabet_languages(
+            popular_character_ordered, ignore_non_latin
+        ):
+            ratio: float = characters_popularity_compare(
+                language, popular_character_ordered
+            )
+
+            if ratio < threshold:
+                continue
+            elif ratio >= 0.8:
+                sufficient_match_count += 1
+
+            results.append((language, round(ratio, 4)))
+
+            if sufficient_match_count >= 3:
+                break
+
+    return sorted(
+        filter_alt_coherence_matches(results), key=lambda x: x[1], reverse=True
+    )
diff --git a/lib/python3.11/site-packages/charset_normalizer/cli/__init__.py b/lib/python3.11/site-packages/charset_normalizer/cli/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d95fedfe5723713337f1a94ec8f0a00b6ca7816a
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/cli/__init__.py
@@ -0,0 +1,6 @@
+from .__main__ import cli_detect, query_yes_no
+
+__all__ = (
+    "cli_detect",
+    "query_yes_no",
+)
diff --git a/lib/python3.11/site-packages/charset_normalizer/cli/__main__.py b/lib/python3.11/site-packages/charset_normalizer/cli/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4bcbaac049b542a004918a0b1499122fcca9cc0
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/cli/__main__.py
@@ -0,0 +1,296 @@
+import argparse
+import sys
+from json import dumps
+from os.path import abspath, basename, dirname, join, realpath
+from platform import python_version
+from typing import List, Optional
+from unicodedata import unidata_version
+
+import charset_normalizer.md as md_module
+from charset_normalizer import from_fp
+from charset_normalizer.models import CliDetectionResult
+from charset_normalizer.version import __version__
+
+
+def query_yes_no(question: str, default: str = "yes") -> bool:
+    """Ask a yes/no question via input() and return their answer.
+
+    "question" is a string that is presented to the user.
+    "default" is the presumed answer if the user just hits <Enter>.
+        It must be "yes" (the default), "no" or None (meaning
+        an answer is required of the user).
+
+    The "answer" return value is True for "yes" or False for "no".
+
+    Credit goes to (c) https://stackoverflow.com/questions/3041986/apt-command-line-interface-like-yes-no-input
+    """
+    valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
+    if default is None:
+        prompt = " [y/n] "
+    elif default == "yes":
+        prompt = " [Y/n] "
+    elif default == "no":
+        prompt = " [y/N] "
+    else:
+        raise ValueError("invalid default answer: '%s'" % default)
+
+    while True:
+        sys.stdout.write(question + prompt)
+        choice = input().lower()
+        if default is not None and choice == "":
+            return valid[default]
+        elif choice in valid:
+            return valid[choice]
+        else:
+            sys.stdout.write("Please respond with 'yes' or 'no' " "(or 'y' or 'n').\n")
+
+
+def cli_detect(argv: Optional[List[str]] = None) -> int:
+    """
+    CLI assistant using ARGV and ArgumentParser
+    :param argv:
+    :return: 0 if everything is fine, anything else equal trouble
+    """
+    parser = argparse.ArgumentParser(
+        description="The Real First Universal Charset Detector. "
+        "Discover originating encoding used on text file. "
+        "Normalize text to unicode."
+    )
+
+    parser.add_argument(
+        "files", type=argparse.FileType("rb"), nargs="+", help="File(s) to be analysed"
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        default=False,
+        dest="verbose",
+        help="Display complementary information about file if any. "
+        "Stdout will contain logs about the detection process.",
+    )
+    parser.add_argument(
+        "-a",
+        "--with-alternative",
+        action="store_true",
+        default=False,
+        dest="alternatives",
+        help="Output complementary possibilities if any. Top-level JSON WILL be a list.",
+    )
+    parser.add_argument(
+        "-n",
+        "--normalize",
+        action="store_true",
+        default=False,
+        dest="normalize",
+        help="Permit to normalize input file. If not set, program does not write anything.",
+    )
+    parser.add_argument(
+        "-m",
+        "--minimal",
+        action="store_true",
+        default=False,
+        dest="minimal",
+        help="Only output the charset detected to STDOUT. Disabling JSON output.",
+    )
+    parser.add_argument(
+        "-r",
+        "--replace",
+        action="store_true",
+        default=False,
+        dest="replace",
+        help="Replace file when trying to normalize it instead of creating a new one.",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        dest="force",
+        help="Replace file without asking if you are sure, use this flag with caution.",
+    )
+    parser.add_argument(
+        "-t",
+        "--threshold",
+        action="store",
+        default=0.2,
+        type=float,
+        dest="threshold",
+        help="Define a custom maximum amount of chaos allowed in decoded content. 0. <= chaos <= 1.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="Charset-Normalizer {} - Python {} - Unicode {} - SpeedUp {}".format(
+            __version__,
+            python_version(),
+            unidata_version,
+            "OFF" if md_module.__file__.lower().endswith(".py") else "ON",
+        ),
+        help="Show version information and exit.",
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.replace is True and args.normalize is False:
+        print("Use --replace in addition of --normalize only.", file=sys.stderr)
+        return 1
+
+    if args.force is True and args.replace is False:
+        print("Use --force in addition of --replace only.", file=sys.stderr)
+        return 1
+
+    if args.threshold < 0.0 or args.threshold > 1.0:
+        print("--threshold VALUE should be between 0. AND 1.", file=sys.stderr)
+        return 1
+
+    x_ = []
+
+    for my_file in args.files:
+        matches = from_fp(my_file, threshold=args.threshold, explain=args.verbose)
+
+        best_guess = matches.best()
+
+        if best_guess is None:
+            print(
+                'Unable to identify originating encoding for "{}". {}'.format(
+                    my_file.name,
+                    "Maybe try increasing maximum amount of chaos."
+                    if args.threshold < 1.0
+                    else "",
+                ),
+                file=sys.stderr,
+            )
+            x_.append(
+                CliDetectionResult(
+                    abspath(my_file.name),
+                    None,
+                    [],
+                    [],
+                    "Unknown",
+                    [],
+                    False,
+                    1.0,
+                    0.0,
+                    None,
+                    True,
+                )
+            )
+        else:
+            x_.append(
+                CliDetectionResult(
+                    abspath(my_file.name),
+                    best_guess.encoding,
+                    best_guess.encoding_aliases,
+                    [
+                        cp
+                        for cp in best_guess.could_be_from_charset
+                        if cp != best_guess.encoding
+                    ],
+                    best_guess.language,
+                    best_guess.alphabets,
+                    best_guess.bom,
+                    best_guess.percent_chaos,
+                    best_guess.percent_coherence,
+                    None,
+                    True,
+                )
+            )
+
+            if len(matches) > 1 and args.alternatives:
+                for el in matches:
+                    if el != best_guess:
+                        x_.append(
+                            CliDetectionResult(
+                                abspath(my_file.name),
+                                el.encoding,
+                                el.encoding_aliases,
+                                [
+                                    cp
+                                    for cp in el.could_be_from_charset
+                                    if cp != el.encoding
+                                ],
+                                el.language,
+                                el.alphabets,
+                                el.bom,
+                                el.percent_chaos,
+                                el.percent_coherence,
+                                None,
+                                False,
+                            )
+                        )
+
+            if args.normalize is True:
+                if best_guess.encoding.startswith("utf") is True:
+                    print(
+                        '"{}" file does not need to be normalized, as it already came from unicode.'.format(
+                            my_file.name
+                        ),
+                        file=sys.stderr,
+                    )
+                    if my_file.closed is False:
+                        my_file.close()
+                    continue
+
+                dir_path = dirname(realpath(my_file.name))
+                file_name = basename(realpath(my_file.name))
+
+                o_: List[str] = file_name.split(".")
+
+                if args.replace is False:
+                    o_.insert(-1, best_guess.encoding)
+                    if my_file.closed is False:
+                        my_file.close()
+                elif (
+                    args.force is False
+                    and query_yes_no(
+                        'Are you sure to normalize "{}" by replacing it ?'.format(
+                            my_file.name
+                        ),
+                        "no",
+                    )
+                    is False
+                ):
+                    if my_file.closed is False:
+                        my_file.close()
+                    continue
+
+                try:
+                    x_[0].unicode_path = join(dir_path, ".".join(o_))
+
+                    with open(x_[0].unicode_path, "w", encoding="utf-8") as fp:
+                        fp.write(str(best_guess))
+                except IOError as e:
+                    print(str(e), file=sys.stderr)
+                    if my_file.closed is False:
+                        my_file.close()
+                    return 2
+
+        if my_file.closed is False:
+            my_file.close()
+
+    if args.minimal is False:
+        print(
+            dumps(
+                [el.__dict__ for el in x_] if len(x_) > 1 else x_[0].__dict__,
+                ensure_ascii=True,
+                indent=4,
+            )
+        )
+    else:
+        for my_file in args.files:
+            print(
+                ", ".join(
+                    [
+                        el.encoding or "undefined"
+                        for el in x_
+                        if el.path == abspath(my_file.name)
+                    ]
+                )
+            )
+
+    return 0
+
+
+if __name__ == "__main__":
+    cli_detect()
diff --git a/lib/python3.11/site-packages/charset_normalizer/cli/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/cli/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cd5b74bb444e662cb6a88cc436d70d0ef80252ee
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/cli/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/cli/__pycache__/__main__.cpython-311.pyc b/lib/python3.11/site-packages/charset_normalizer/cli/__pycache__/__main__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..750fc2c94b21790e2c00fc77c8a5e59aa56c0e82
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/cli/__pycache__/__main__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/constant.py b/lib/python3.11/site-packages/charset_normalizer/constant.py
new file mode 100644
index 0000000000000000000000000000000000000000..863490461eacf57ca5f62658b713685476987149
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/constant.py
@@ -0,0 +1,1995 @@
+# -*- coding: utf-8 -*-
+from codecs import BOM_UTF8, BOM_UTF16_BE, BOM_UTF16_LE, BOM_UTF32_BE, BOM_UTF32_LE
+from encodings.aliases import aliases
+from re import IGNORECASE, compile as re_compile
+from typing import Dict, List, Set, Union
+
+# Contain for each eligible encoding a list of/item bytes SIG/BOM
+ENCODING_MARKS: Dict[str, Union[bytes, List[bytes]]] = {
+    "utf_8": BOM_UTF8,
+    "utf_7": [
+        b"\x2b\x2f\x76\x38",
+        b"\x2b\x2f\x76\x39",
+        b"\x2b\x2f\x76\x2b",
+        b"\x2b\x2f\x76\x2f",
+        b"\x2b\x2f\x76\x38\x2d",
+    ],
+    "gb18030": b"\x84\x31\x95\x33",
+    "utf_32": [BOM_UTF32_BE, BOM_UTF32_LE],
+    "utf_16": [BOM_UTF16_BE, BOM_UTF16_LE],
+}
+
+TOO_SMALL_SEQUENCE: int = 32
+TOO_BIG_SEQUENCE: int = int(10e6)
+
+UTF8_MAXIMAL_ALLOCATION: int = 1_112_064
+
+# Up-to-date Unicode ucd/15.0.0
+UNICODE_RANGES_COMBINED: Dict[str, range] = {
+    "Control character": range(32),
+    "Basic Latin": range(32, 128),
+    "Latin-1 Supplement": range(128, 256),
+    "Latin Extended-A": range(256, 384),
+    "Latin Extended-B": range(384, 592),
+    "IPA Extensions": range(592, 688),
+    "Spacing Modifier Letters": range(688, 768),
+    "Combining Diacritical Marks": range(768, 880),
+    "Greek and Coptic": range(880, 1024),
+    "Cyrillic": range(1024, 1280),
+    "Cyrillic Supplement": range(1280, 1328),
+    "Armenian": range(1328, 1424),
+    "Hebrew": range(1424, 1536),
+    "Arabic": range(1536, 1792),
+    "Syriac": range(1792, 1872),
+    "Arabic Supplement": range(1872, 1920),
+    "Thaana": range(1920, 1984),
+    "NKo": range(1984, 2048),
+    "Samaritan": range(2048, 2112),
+    "Mandaic": range(2112, 2144),
+    "Syriac Supplement": range(2144, 2160),
+    "Arabic Extended-B": range(2160, 2208),
+    "Arabic Extended-A": range(2208, 2304),
+    "Devanagari": range(2304, 2432),
+    "Bengali": range(2432, 2560),
+    "Gurmukhi": range(2560, 2688),
+    "Gujarati": range(2688, 2816),
+    "Oriya": range(2816, 2944),
+    "Tamil": range(2944, 3072),
+    "Telugu": range(3072, 3200),
+    "Kannada": range(3200, 3328),
+    "Malayalam": range(3328, 3456),
+    "Sinhala": range(3456, 3584),
+    "Thai": range(3584, 3712),
+    "Lao": range(3712, 3840),
+    "Tibetan": range(3840, 4096),
+    "Myanmar": range(4096, 4256),
+    "Georgian": range(4256, 4352),
+    "Hangul Jamo": range(4352, 4608),
+    "Ethiopic": range(4608, 4992),
+    "Ethiopic Supplement": range(4992, 5024),
+    "Cherokee": range(5024, 5120),
+    "Unified Canadian Aboriginal Syllabics": range(5120, 5760),
+    "Ogham": range(5760, 5792),
+    "Runic": range(5792, 5888),
+    "Tagalog": range(5888, 5920),
+    "Hanunoo": range(5920, 5952),
+    "Buhid": range(5952, 5984),
+    "Tagbanwa": range(5984, 6016),
+    "Khmer": range(6016, 6144),
+    "Mongolian": range(6144, 6320),
+    "Unified Canadian Aboriginal Syllabics Extended": range(6320, 6400),
+    "Limbu": range(6400, 6480),
+    "Tai Le": range(6480, 6528),
+    "New Tai Lue": range(6528, 6624),
+    "Khmer Symbols": range(6624, 6656),
+    "Buginese": range(6656, 6688),
+    "Tai Tham": range(6688, 6832),
+    "Combining Diacritical Marks Extended": range(6832, 6912),
+    "Balinese": range(6912, 7040),
+    "Sundanese": range(7040, 7104),
+    "Batak": range(7104, 7168),
+    "Lepcha": range(7168, 7248),
+    "Ol Chiki": range(7248, 7296),
+    "Cyrillic Extended-C": range(7296, 7312),
+    "Georgian Extended": range(7312, 7360),
+    "Sundanese Supplement": range(7360, 7376),
+    "Vedic Extensions": range(7376, 7424),
+    "Phonetic Extensions": range(7424, 7552),
+    "Phonetic Extensions Supplement": range(7552, 7616),
+    "Combining Diacritical Marks Supplement": range(7616, 7680),
+    "Latin Extended Additional": range(7680, 7936),
+    "Greek Extended": range(7936, 8192),
+    "General Punctuation": range(8192, 8304),
+    "Superscripts and Subscripts": range(8304, 8352),
+    "Currency Symbols": range(8352, 8400),
+    "Combining Diacritical Marks for Symbols": range(8400, 8448),
+    "Letterlike Symbols": range(8448, 8528),
+    "Number Forms": range(8528, 8592),
+    "Arrows": range(8592, 8704),
+    "Mathematical Operators": range(8704, 8960),
+    "Miscellaneous Technical": range(8960, 9216),
+    "Control Pictures": range(9216, 9280),
+    "Optical Character Recognition": range(9280, 9312),
+    "Enclosed Alphanumerics": range(9312, 9472),
+    "Box Drawing": range(9472, 9600),
+    "Block Elements": range(9600, 9632),
+    "Geometric Shapes": range(9632, 9728),
+    "Miscellaneous Symbols": range(9728, 9984),
+    "Dingbats": range(9984, 10176),
+    "Miscellaneous Mathematical Symbols-A": range(10176, 10224),
+    "Supplemental Arrows-A": range(10224, 10240),
+    "Braille Patterns": range(10240, 10496),
+    "Supplemental Arrows-B": range(10496, 10624),
+    "Miscellaneous Mathematical Symbols-B": range(10624, 10752),
+    "Supplemental Mathematical Operators": range(10752, 11008),
+    "Miscellaneous Symbols and Arrows": range(11008, 11264),
+    "Glagolitic": range(11264, 11360),
+    "Latin Extended-C": range(11360, 11392),
+    "Coptic": range(11392, 11520),
+    "Georgian Supplement": range(11520, 11568),
+    "Tifinagh": range(11568, 11648),
+    "Ethiopic Extended": range(11648, 11744),
+    "Cyrillic Extended-A": range(11744, 11776),
+    "Supplemental Punctuation": range(11776, 11904),
+    "CJK Radicals Supplement": range(11904, 12032),
+    "Kangxi Radicals": range(12032, 12256),
+    "Ideographic Description Characters": range(12272, 12288),
+    "CJK Symbols and Punctuation": range(12288, 12352),
+    "Hiragana": range(12352, 12448),
+    "Katakana": range(12448, 12544),
+    "Bopomofo": range(12544, 12592),
+    "Hangul Compatibility Jamo": range(12592, 12688),
+    "Kanbun": range(12688, 12704),
+    "Bopomofo Extended": range(12704, 12736),
+    "CJK Strokes": range(12736, 12784),
+    "Katakana Phonetic Extensions": range(12784, 12800),
+    "Enclosed CJK Letters and Months": range(12800, 13056),
+    "CJK Compatibility": range(13056, 13312),
+    "CJK Unified Ideographs Extension A": range(13312, 19904),
+    "Yijing Hexagram Symbols": range(19904, 19968),
+    "CJK Unified Ideographs": range(19968, 40960),
+    "Yi Syllables": range(40960, 42128),
+    "Yi Radicals": range(42128, 42192),
+    "Lisu": range(42192, 42240),
+    "Vai": range(42240, 42560),
+    "Cyrillic Extended-B": range(42560, 42656),
+    "Bamum": range(42656, 42752),
+    "Modifier Tone Letters": range(42752, 42784),
+    "Latin Extended-D": range(42784, 43008),
+    "Syloti Nagri": range(43008, 43056),
+    "Common Indic Number Forms": range(43056, 43072),
+    "Phags-pa": range(43072, 43136),
+    "Saurashtra": range(43136, 43232),
+    "Devanagari Extended": range(43232, 43264),
+    "Kayah Li": range(43264, 43312),
+    "Rejang": range(43312, 43360),
+    "Hangul Jamo Extended-A": range(43360, 43392),
+    "Javanese": range(43392, 43488),
+    "Myanmar Extended-B": range(43488, 43520),
+    "Cham": range(43520, 43616),
+    "Myanmar Extended-A": range(43616, 43648),
+    "Tai Viet": range(43648, 43744),
+    "Meetei Mayek Extensions": range(43744, 43776),
+    "Ethiopic Extended-A": range(43776, 43824),
+    "Latin Extended-E": range(43824, 43888),
+    "Cherokee Supplement": range(43888, 43968),
+    "Meetei Mayek": range(43968, 44032),
+    "Hangul Syllables": range(44032, 55216),
+    "Hangul Jamo Extended-B": range(55216, 55296),
+    "High Surrogates": range(55296, 56192),
+    "High Private Use Surrogates": range(56192, 56320),
+    "Low Surrogates": range(56320, 57344),
+    "Private Use Area": range(57344, 63744),
+    "CJK Compatibility Ideographs": range(63744, 64256),
+    "Alphabetic Presentation Forms": range(64256, 64336),
+    "Arabic Presentation Forms-A": range(64336, 65024),
+    "Variation Selectors": range(65024, 65040),
+    "Vertical Forms": range(65040, 65056),
+    "Combining Half Marks": range(65056, 65072),
+    "CJK Compatibility Forms": range(65072, 65104),
+    "Small Form Variants": range(65104, 65136),
+    "Arabic Presentation Forms-B": range(65136, 65280),
+    "Halfwidth and Fullwidth Forms": range(65280, 65520),
+    "Specials": range(65520, 65536),
+    "Linear B Syllabary": range(65536, 65664),
+    "Linear B Ideograms": range(65664, 65792),
+    "Aegean Numbers": range(65792, 65856),
+    "Ancient Greek Numbers": range(65856, 65936),
+    "Ancient Symbols": range(65936, 66000),
+    "Phaistos Disc": range(66000, 66048),
+    "Lycian": range(66176, 66208),
+    "Carian": range(66208, 66272),
+    "Coptic Epact Numbers": range(66272, 66304),
+    "Old Italic": range(66304, 66352),
+    "Gothic": range(66352, 66384),
+    "Old Permic": range(66384, 66432),
+    "Ugaritic": range(66432, 66464),
+    "Old Persian": range(66464, 66528),
+    "Deseret": range(66560, 66640),
+    "Shavian": range(66640, 66688),
+    "Osmanya": range(66688, 66736),
+    "Osage": range(66736, 66816),
+    "Elbasan": range(66816, 66864),
+    "Caucasian Albanian": range(66864, 66928),
+    "Vithkuqi": range(66928, 67008),
+    "Linear A": range(67072, 67456),
+    "Latin Extended-F": range(67456, 67520),
+    "Cypriot Syllabary": range(67584, 67648),
+    "Imperial Aramaic": range(67648, 67680),
+    "Palmyrene": range(67680, 67712),
+    "Nabataean": range(67712, 67760),
+    "Hatran": range(67808, 67840),
+    "Phoenician": range(67840, 67872),
+    "Lydian": range(67872, 67904),
+    "Meroitic Hieroglyphs": range(67968, 68000),
+    "Meroitic Cursive": range(68000, 68096),
+    "Kharoshthi": range(68096, 68192),
+    "Old South Arabian": range(68192, 68224),
+    "Old North Arabian": range(68224, 68256),
+    "Manichaean": range(68288, 68352),
+    "Avestan": range(68352, 68416),
+    "Inscriptional Parthian": range(68416, 68448),
+    "Inscriptional Pahlavi": range(68448, 68480),
+    "Psalter Pahlavi": range(68480, 68528),
+    "Old Turkic": range(68608, 68688),
+    "Old Hungarian": range(68736, 68864),
+    "Hanifi Rohingya": range(68864, 68928),
+    "Rumi Numeral Symbols": range(69216, 69248),
+    "Yezidi": range(69248, 69312),
+    "Arabic Extended-C": range(69312, 69376),
+    "Old Sogdian": range(69376, 69424),
+    "Sogdian": range(69424, 69488),
+    "Old Uyghur": range(69488, 69552),
+    "Chorasmian": range(69552, 69600),
+    "Elymaic": range(69600, 69632),
+    "Brahmi": range(69632, 69760),
+    "Kaithi": range(69760, 69840),
+    "Sora Sompeng": range(69840, 69888),
+    "Chakma": range(69888, 69968),
+    "Mahajani": range(69968, 70016),
+    "Sharada": range(70016, 70112),
+    "Sinhala Archaic Numbers": range(70112, 70144),
+    "Khojki": range(70144, 70224),
+    "Multani": range(70272, 70320),
+    "Khudawadi": range(70320, 70400),
+    "Grantha": range(70400, 70528),
+    "Newa": range(70656, 70784),
+    "Tirhuta": range(70784, 70880),
+    "Siddham": range(71040, 71168),
+    "Modi": range(71168, 71264),
+    "Mongolian Supplement": range(71264, 71296),
+    "Takri": range(71296, 71376),
+    "Ahom": range(71424, 71504),
+    "Dogra": range(71680, 71760),
+    "Warang Citi": range(71840, 71936),
+    "Dives Akuru": range(71936, 72032),
+    "Nandinagari": range(72096, 72192),
+    "Zanabazar Square": range(72192, 72272),
+    "Soyombo": range(72272, 72368),
+    "Unified Canadian Aboriginal Syllabics Extended-A": range(72368, 72384),
+    "Pau Cin Hau": range(72384, 72448),
+    "Devanagari Extended-A": range(72448, 72544),
+    "Bhaiksuki": range(72704, 72816),
+    "Marchen": range(72816, 72896),
+    "Masaram Gondi": range(72960, 73056),
+    "Gunjala Gondi": range(73056, 73136),
+    "Makasar": range(73440, 73472),
+    "Kawi": range(73472, 73568),
+    "Lisu Supplement": range(73648, 73664),
+    "Tamil Supplement": range(73664, 73728),
+    "Cuneiform": range(73728, 74752),
+    "Cuneiform Numbers and Punctuation": range(74752, 74880),
+    "Early Dynastic Cuneiform": range(74880, 75088),
+    "Cypro-Minoan": range(77712, 77824),
+    "Egyptian Hieroglyphs": range(77824, 78896),
+    "Egyptian Hieroglyph Format Controls": range(78896, 78944),
+    "Anatolian Hieroglyphs": range(82944, 83584),
+    "Bamum Supplement": range(92160, 92736),
+    "Mro": range(92736, 92784),
+    "Tangsa": range(92784, 92880),
+    "Bassa Vah": range(92880, 92928),
+    "Pahawh Hmong": range(92928, 93072),
+    "Medefaidrin": range(93760, 93856),
+    "Miao": range(93952, 94112),
+    "Ideographic Symbols and Punctuation": range(94176, 94208),
+    "Tangut": range(94208, 100352),
+    "Tangut Components": range(100352, 101120),
+    "Khitan Small Script": range(101120, 101632),
+    "Tangut Supplement": range(101632, 101760),
+    "Kana Extended-B": range(110576, 110592),
+    "Kana Supplement": range(110592, 110848),
+    "Kana Extended-A": range(110848, 110896),
+    "Small Kana Extension": range(110896, 110960),
+    "Nushu": range(110960, 111360),
+    "Duployan": range(113664, 113824),
+    "Shorthand Format Controls": range(113824, 113840),
+    "Znamenny Musical Notation": range(118528, 118736),
+    "Byzantine Musical Symbols": range(118784, 119040),
+    "Musical Symbols": range(119040, 119296),
+    "Ancient Greek Musical Notation": range(119296, 119376),
+    "Kaktovik Numerals": range(119488, 119520),
+    "Mayan Numerals": range(119520, 119552),
+    "Tai Xuan Jing Symbols": range(119552, 119648),
+    "Counting Rod Numerals": range(119648, 119680),
+    "Mathematical Alphanumeric Symbols": range(119808, 120832),
+    "Sutton SignWriting": range(120832, 121520),
+    "Latin Extended-G": range(122624, 122880),
+    "Glagolitic Supplement": range(122880, 122928),
+    "Cyrillic Extended-D": range(122928, 123024),
+    "Nyiakeng Puachue Hmong": range(123136, 123216),
+    "Toto": range(123536, 123584),
+    "Wancho": range(123584, 123648),
+    "Nag Mundari": range(124112, 124160),
+    "Ethiopic Extended-B": range(124896, 124928),
+    "Mende Kikakui": range(124928, 125152),
+    "Adlam": range(125184, 125280),
+    "Indic Siyaq Numbers": range(126064, 126144),
+    "Ottoman Siyaq Numbers": range(126208, 126288),
+    "Arabic Mathematical Alphabetic Symbols": range(126464, 126720),
+    "Mahjong Tiles": range(126976, 127024),
+    "Domino Tiles": range(127024, 127136),
+    "Playing Cards": range(127136, 127232),
+    "Enclosed Alphanumeric Supplement": range(127232, 127488),
+    "Enclosed Ideographic Supplement": range(127488, 127744),
+    "Miscellaneous Symbols and Pictographs": range(127744, 128512),
+    "Emoticons range(Emoji)": range(128512, 128592),
+    "Ornamental Dingbats": range(128592, 128640),
+    "Transport and Map Symbols": range(128640, 128768),
+    "Alchemical Symbols": range(128768, 128896),
+    "Geometric Shapes Extended": range(128896, 129024),
+    "Supplemental Arrows-C": range(129024, 129280),
+    "Supplemental Symbols and Pictographs": range(129280, 129536),
+    "Chess Symbols": range(129536, 129648),
+    "Symbols and Pictographs Extended-A": range(129648, 129792),
+    "Symbols for Legacy Computing": range(129792, 130048),
+    "CJK Unified Ideographs Extension B": range(131072, 173792),
+    "CJK Unified Ideographs Extension C": range(173824, 177984),
+    "CJK Unified Ideographs Extension D": range(177984, 178208),
+    "CJK Unified Ideographs Extension E": range(178208, 183984),
+    "CJK Unified Ideographs Extension F": range(183984, 191472),
+    "CJK Compatibility Ideographs Supplement": range(194560, 195104),
+    "CJK Unified Ideographs Extension G": range(196608, 201552),
+    "CJK Unified Ideographs Extension H": range(201552, 205744),
+    "Tags": range(917504, 917632),
+    "Variation Selectors Supplement": range(917760, 918000),
+    "Supplementary Private Use Area-A": range(983040, 1048576),
+    "Supplementary Private Use Area-B": range(1048576, 1114112),
+}
+
+
+UNICODE_SECONDARY_RANGE_KEYWORD: List[str] = [
+    "Supplement",
+    "Extended",
+    "Extensions",
+    "Modifier",
+    "Marks",
+    "Punctuation",
+    "Symbols",
+    "Forms",
+    "Operators",
+    "Miscellaneous",
+    "Drawing",
+    "Block",
+    "Shapes",
+    "Supplemental",
+    "Tags",
+]
+
+RE_POSSIBLE_ENCODING_INDICATION = re_compile(
+    r"(?:(?:encoding)|(?:charset)|(?:coding))(?:[\:= ]{1,10})(?:[\"\']?)([a-zA-Z0-9\-_]+)(?:[\"\']?)",
+    IGNORECASE,
+)
+
+IANA_NO_ALIASES = [
+    "cp720",
+    "cp737",
+    "cp856",
+    "cp874",
+    "cp875",
+    "cp1006",
+    "koi8_r",
+    "koi8_t",
+    "koi8_u",
+]
+
+IANA_SUPPORTED: List[str] = sorted(
+    filter(
+        lambda x: x.endswith("_codec") is False
+        and x not in {"rot_13", "tactis", "mbcs"},
+        list(set(aliases.values())) + IANA_NO_ALIASES,
+    )
+)
+
+IANA_SUPPORTED_COUNT: int = len(IANA_SUPPORTED)
+
+# pre-computed code page that are similar using the function cp_similarity.
+IANA_SUPPORTED_SIMILAR: Dict[str, List[str]] = {
+    "cp037": ["cp1026", "cp1140", "cp273", "cp500"],
+    "cp1026": ["cp037", "cp1140", "cp273", "cp500"],
+    "cp1125": ["cp866"],
+    "cp1140": ["cp037", "cp1026", "cp273", "cp500"],
+    "cp1250": ["iso8859_2"],
+    "cp1251": ["kz1048", "ptcp154"],
+    "cp1252": ["iso8859_15", "iso8859_9", "latin_1"],
+    "cp1253": ["iso8859_7"],
+    "cp1254": ["iso8859_15", "iso8859_9", "latin_1"],
+    "cp1257": ["iso8859_13"],
+    "cp273": ["cp037", "cp1026", "cp1140", "cp500"],
+    "cp437": ["cp850", "cp858", "cp860", "cp861", "cp862", "cp863", "cp865"],
+    "cp500": ["cp037", "cp1026", "cp1140", "cp273"],
+    "cp850": ["cp437", "cp857", "cp858", "cp865"],
+    "cp857": ["cp850", "cp858", "cp865"],
+    "cp858": ["cp437", "cp850", "cp857", "cp865"],
+    "cp860": ["cp437", "cp861", "cp862", "cp863", "cp865"],
+    "cp861": ["cp437", "cp860", "cp862", "cp863", "cp865"],
+    "cp862": ["cp437", "cp860", "cp861", "cp863", "cp865"],
+    "cp863": ["cp437", "cp860", "cp861", "cp862", "cp865"],
+    "cp865": ["cp437", "cp850", "cp857", "cp858", "cp860", "cp861", "cp862", "cp863"],
+    "cp866": ["cp1125"],
+    "iso8859_10": ["iso8859_14", "iso8859_15", "iso8859_4", "iso8859_9", "latin_1"],
+    "iso8859_11": ["tis_620"],
+    "iso8859_13": ["cp1257"],
+    "iso8859_14": [
+        "iso8859_10",
+        "iso8859_15",
+        "iso8859_16",
+        "iso8859_3",
+        "iso8859_9",
+        "latin_1",
+    ],
+    "iso8859_15": [
+        "cp1252",
+        "cp1254",
+        "iso8859_10",
+        "iso8859_14",
+        "iso8859_16",
+        "iso8859_3",
+        "iso8859_9",
+        "latin_1",
+    ],
+    "iso8859_16": [
+        "iso8859_14",
+        "iso8859_15",
+        "iso8859_2",
+        "iso8859_3",
+        "iso8859_9",
+        "latin_1",
+    ],
+    "iso8859_2": ["cp1250", "iso8859_16", "iso8859_4"],
+    "iso8859_3": ["iso8859_14", "iso8859_15", "iso8859_16", "iso8859_9", "latin_1"],
+    "iso8859_4": ["iso8859_10", "iso8859_2", "iso8859_9", "latin_1"],
+    "iso8859_7": ["cp1253"],
+    "iso8859_9": [
+        "cp1252",
+        "cp1254",
+        "cp1258",
+        "iso8859_10",
+        "iso8859_14",
+        "iso8859_15",
+        "iso8859_16",
+        "iso8859_3",
+        "iso8859_4",
+        "latin_1",
+    ],
+    "kz1048": ["cp1251", "ptcp154"],
+    "latin_1": [
+        "cp1252",
+        "cp1254",
+        "cp1258",
+        "iso8859_10",
+        "iso8859_14",
+        "iso8859_15",
+        "iso8859_16",
+        "iso8859_3",
+        "iso8859_4",
+        "iso8859_9",
+    ],
+    "mac_iceland": ["mac_roman", "mac_turkish"],
+    "mac_roman": ["mac_iceland", "mac_turkish"],
+    "mac_turkish": ["mac_iceland", "mac_roman"],
+    "ptcp154": ["cp1251", "kz1048"],
+    "tis_620": ["iso8859_11"],
+}
+
+
+CHARDET_CORRESPONDENCE: Dict[str, str] = {
+    "iso2022_kr": "ISO-2022-KR",
+    "iso2022_jp": "ISO-2022-JP",
+    "euc_kr": "EUC-KR",
+    "tis_620": "TIS-620",
+    "utf_32": "UTF-32",
+    "euc_jp": "EUC-JP",
+    "koi8_r": "KOI8-R",
+    "iso8859_1": "ISO-8859-1",
+    "iso8859_2": "ISO-8859-2",
+    "iso8859_5": "ISO-8859-5",
+    "iso8859_6": "ISO-8859-6",
+    "iso8859_7": "ISO-8859-7",
+    "iso8859_8": "ISO-8859-8",
+    "utf_16": "UTF-16",
+    "cp855": "IBM855",
+    "mac_cyrillic": "MacCyrillic",
+    "gb2312": "GB2312",
+    "gb18030": "GB18030",
+    "cp932": "CP932",
+    "cp866": "IBM866",
+    "utf_8": "utf-8",
+    "utf_8_sig": "UTF-8-SIG",
+    "shift_jis": "SHIFT_JIS",
+    "big5": "Big5",
+    "cp1250": "windows-1250",
+    "cp1251": "windows-1251",
+    "cp1252": "Windows-1252",
+    "cp1253": "windows-1253",
+    "cp1255": "windows-1255",
+    "cp1256": "windows-1256",
+    "cp1254": "Windows-1254",
+    "cp949": "CP949",
+}
+
+
+COMMON_SAFE_ASCII_CHARACTERS: Set[str] = {
+    "<",
+    ">",
+    "=",
+    ":",
+    "/",
+    "&",
+    ";",
+    "{",
+    "}",
+    "[",
+    "]",
+    ",",
+    "|",
+    '"',
+    "-",
+}
+
+
+KO_NAMES: Set[str] = {"johab", "cp949", "euc_kr"}
+ZH_NAMES: Set[str] = {"big5", "cp950", "big5hkscs", "hz"}
+
+# Logging LEVEL below DEBUG
+TRACE: int = 5
+
+
+# Language label that contain the em dash "—"
+# character are to be considered alternative seq to origin
+FREQUENCIES: Dict[str, List[str]] = {
+    "English": [
+        "e",
+        "a",
+        "t",
+        "i",
+        "o",
+        "n",
+        "s",
+        "r",
+        "h",
+        "l",
+        "d",
+        "c",
+        "u",
+        "m",
+        "f",
+        "p",
+        "g",
+        "w",
+        "y",
+        "b",
+        "v",
+        "k",
+        "x",
+        "j",
+        "z",
+        "q",
+    ],
+    "English—": [
+        "e",
+        "a",
+        "t",
+        "i",
+        "o",
+        "n",
+        "s",
+        "r",
+        "h",
+        "l",
+        "d",
+        "c",
+        "m",
+        "u",
+        "f",
+        "p",
+        "g",
+        "w",
+        "b",
+        "y",
+        "v",
+        "k",
+        "j",
+        "x",
+        "z",
+        "q",
+    ],
+    "German": [
+        "e",
+        "n",
+        "i",
+        "r",
+        "s",
+        "t",
+        "a",
+        "d",
+        "h",
+        "u",
+        "l",
+        "g",
+        "o",
+        "c",
+        "m",
+        "b",
+        "f",
+        "k",
+        "w",
+        "z",
+        "p",
+        "v",
+        "ü",
+        "ä",
+        "ö",
+        "j",
+    ],
+    "French": [
+        "e",
+        "a",
+        "s",
+        "n",
+        "i",
+        "t",
+        "r",
+        "l",
+        "u",
+        "o",
+        "d",
+        "c",
+        "p",
+        "m",
+        "é",
+        "v",
+        "g",
+        "f",
+        "b",
+        "h",
+        "q",
+        "à",
+        "x",
+        "è",
+        "y",
+        "j",
+    ],
+    "Dutch": [
+        "e",
+        "n",
+        "a",
+        "i",
+        "r",
+        "t",
+        "o",
+        "d",
+        "s",
+        "l",
+        "g",
+        "h",
+        "v",
+        "m",
+        "u",
+        "k",
+        "c",
+        "p",
+        "b",
+        "w",
+        "j",
+        "z",
+        "f",
+        "y",
+        "x",
+        "ë",
+    ],
+    "Italian": [
+        "e",
+        "i",
+        "a",
+        "o",
+        "n",
+        "l",
+        "t",
+        "r",
+        "s",
+        "c",
+        "d",
+        "u",
+        "p",
+        "m",
+        "g",
+        "v",
+        "f",
+        "b",
+        "z",
+        "h",
+        "q",
+        "è",
+        "à",
+        "k",
+        "y",
+        "ò",
+    ],
+    "Polish": [
+        "a",
+        "i",
+        "o",
+        "e",
+        "n",
+        "r",
+        "z",
+        "w",
+        "s",
+        "c",
+        "t",
+        "k",
+        "y",
+        "d",
+        "p",
+        "m",
+        "u",
+        "l",
+        "j",
+        "ł",
+        "g",
+        "b",
+        "h",
+        "ą",
+        "ę",
+        "ó",
+    ],
+    "Spanish": [
+        "e",
+        "a",
+        "o",
+        "n",
+        "s",
+        "r",
+        "i",
+        "l",
+        "d",
+        "t",
+        "c",
+        "u",
+        "m",
+        "p",
+        "b",
+        "g",
+        "v",
+        "f",
+        "y",
+        "ó",
+        "h",
+        "q",
+        "í",
+        "j",
+        "z",
+        "á",
+    ],
+    "Russian": [
+        "о",
+        "а",
+        "е",
+        "и",
+        "н",
+        "с",
+        "т",
+        "р",
+        "в",
+        "л",
+        "к",
+        "м",
+        "д",
+        "п",
+        "у",
+        "г",
+        "я",
+        "ы",
+        "з",
+        "б",
+        "й",
+        "ь",
+        "ч",
+        "х",
+        "ж",
+        "ц",
+    ],
+    # Jap-Kanji
+    "Japanese": [
+        "人",
+        "一",
+        "大",
+        "亅",
+        "丁",
+        "丨",
+        "竹",
+        "笑",
+        "口",
+        "日",
+        "今",
+        "二",
+        "彳",
+        "行",
+        "十",
+        "土",
+        "丶",
+        "寸",
+        "寺",
+        "時",
+        "乙",
+        "丿",
+        "乂",
+        "气",
+        "気",
+        "冂",
+        "巾",
+        "亠",
+        "市",
+        "目",
+        "儿",
+        "見",
+        "八",
+        "小",
+        "凵",
+        "県",
+        "月",
+        "彐",
+        "門",
+        "間",
+        "木",
+        "東",
+        "山",
+        "出",
+        "本",
+        "中",
+        "刀",
+        "分",
+        "耳",
+        "又",
+        "取",
+        "最",
+        "言",
+        "田",
+        "心",
+        "思",
+        "刂",
+        "前",
+        "京",
+        "尹",
+        "事",
+        "生",
+        "厶",
+        "云",
+        "会",
+        "未",
+        "来",
+        "白",
+        "冫",
+        "楽",
+        "灬",
+        "馬",
+        "尸",
+        "尺",
+        "駅",
+        "明",
+        "耂",
+        "者",
+        "了",
+        "阝",
+        "都",
+        "高",
+        "卜",
+        "占",
+        "厂",
+        "广",
+        "店",
+        "子",
+        "申",
+        "奄",
+        "亻",
+        "俺",
+        "上",
+        "方",
+        "冖",
+        "学",
+        "衣",
+        "艮",
+        "食",
+        "自",
+    ],
+    # Jap-Katakana
+    "Japanese—": [
+        "ー",
+        "ン",
+        "ス",
+        "・",
+        "ル",
+        "ト",
+        "リ",
+        "イ",
+        "ア",
+        "ラ",
+        "ッ",
+        "ク",
+        "ド",
+        "シ",
+        "レ",
+        "ジ",
+        "タ",
+        "フ",
+        "ロ",
+        "カ",
+        "テ",
+        "マ",
+        "ィ",
+        "グ",
+        "バ",
+        "ム",
+        "プ",
+        "オ",
+        "コ",
+        "デ",
+        "ニ",
+        "ウ",
+        "メ",
+        "サ",
+        "ビ",
+        "ナ",
+        "ブ",
+        "ャ",
+        "エ",
+        "ュ",
+        "チ",
+        "キ",
+        "ズ",
+        "ダ",
+        "パ",
+        "ミ",
+        "ェ",
+        "ョ",
+        "ハ",
+        "セ",
+        "ベ",
+        "ガ",
+        "モ",
+        "ツ",
+        "ネ",
+        "ボ",
+        "ソ",
+        "ノ",
+        "ァ",
+        "ヴ",
+        "ワ",
+        "ポ",
+        "ペ",
+        "ピ",
+        "ケ",
+        "ゴ",
+        "ギ",
+        "ザ",
+        "ホ",
+        "ゲ",
+        "ォ",
+        "ヤ",
+        "ヒ",
+        "ユ",
+        "ヨ",
+        "ヘ",
+        "ゼ",
+        "ヌ",
+        "ゥ",
+        "ゾ",
+        "ヶ",
+        "ヂ",
+        "ヲ",
+        "ヅ",
+        "ヵ",
+        "ヱ",
+        "ヰ",
+        "ヮ",
+        "ヽ",
+        "゠",
+        "ヾ",
+        "ヷ",
+        "ヿ",
+        "ヸ",
+        "ヹ",
+        "ヺ",
+    ],
+    # Jap-Hiragana
+    "Japanese——": [
+        "の",
+        "に",
+        "る",
+        "た",
+        "と",
+        "は",
+        "し",
+        "い",
+        "を",
+        "で",
+        "て",
+        "が",
+        "な",
+        "れ",
+        "か",
+        "ら",
+        "さ",
+        "っ",
+        "り",
+        "す",
+        "あ",
+        "も",
+        "こ",
+        "ま",
+        "う",
+        "く",
+        "よ",
+        "き",
+        "ん",
+        "め",
+        "お",
+        "け",
+        "そ",
+        "つ",
+        "だ",
+        "や",
+        "え",
+        "ど",
+        "わ",
+        "ち",
+        "み",
+        "せ",
+        "じ",
+        "ば",
+        "へ",
+        "び",
+        "ず",
+        "ろ",
+        "ほ",
+        "げ",
+        "む",
+        "べ",
+        "ひ",
+        "ょ",
+        "ゆ",
+        "ぶ",
+        "ご",
+        "ゃ",
+        "ね",
+        "ふ",
+        "ぐ",
+        "ぎ",
+        "ぼ",
+        "ゅ",
+        "づ",
+        "ざ",
+        "ぞ",
+        "ぬ",
+        "ぜ",
+        "ぱ",
+        "ぽ",
+        "ぷ",
+        "ぴ",
+        "ぃ",
+        "ぁ",
+        "ぇ",
+        "ぺ",
+        "ゞ",
+        "ぢ",
+        "ぉ",
+        "ぅ",
+        "ゐ",
+        "ゝ",
+        "ゑ",
+        "゛",
+        "゜",
+        "ゎ",
+        "ゔ",
+        "゚",
+        "ゟ",
+        "゙",
+        "ゕ",
+        "ゖ",
+    ],
+    "Portuguese": [
+        "a",
+        "e",
+        "o",
+        "s",
+        "i",
+        "r",
+        "d",
+        "n",
+        "t",
+        "m",
+        "u",
+        "c",
+        "l",
+        "p",
+        "g",
+        "v",
+        "b",
+        "f",
+        "h",
+        "ã",
+        "q",
+        "é",
+        "ç",
+        "á",
+        "z",
+        "í",
+    ],
+    "Swedish": [
+        "e",
+        "a",
+        "n",
+        "r",
+        "t",
+        "s",
+        "i",
+        "l",
+        "d",
+        "o",
+        "m",
+        "k",
+        "g",
+        "v",
+        "h",
+        "f",
+        "u",
+        "p",
+        "ä",
+        "c",
+        "b",
+        "ö",
+        "å",
+        "y",
+        "j",
+        "x",
+    ],
+    "Chinese": [
+        "的",
+        "一",
+        "是",
+        "不",
+        "了",
+        "在",
+        "人",
+        "有",
+        "我",
+        "他",
+        "这",
+        "个",
+        "们",
+        "中",
+        "来",
+        "上",
+        "大",
+        "为",
+        "和",
+        "国",
+        "地",
+        "到",
+        "以",
+        "说",
+        "时",
+        "要",
+        "就",
+        "出",
+        "会",
+        "可",
+        "也",
+        "你",
+        "对",
+        "生",
+        "能",
+        "而",
+        "子",
+        "那",
+        "得",
+        "于",
+        "着",
+        "下",
+        "自",
+        "之",
+        "年",
+        "过",
+        "发",
+        "后",
+        "作",
+        "里",
+        "用",
+        "道",
+        "行",
+        "所",
+        "然",
+        "家",
+        "种",
+        "事",
+        "成",
+        "方",
+        "多",
+        "经",
+        "么",
+        "去",
+        "法",
+        "学",
+        "如",
+        "都",
+        "同",
+        "现",
+        "当",
+        "没",
+        "动",
+        "面",
+        "起",
+        "看",
+        "定",
+        "天",
+        "分",
+        "还",
+        "进",
+        "好",
+        "小",
+        "部",
+        "其",
+        "些",
+        "主",
+        "样",
+        "理",
+        "心",
+        "她",
+        "本",
+        "前",
+        "开",
+        "但",
+        "因",
+        "只",
+        "从",
+        "想",
+        "实",
+    ],
+    "Ukrainian": [
+        "о",
+        "а",
+        "н",
+        "і",
+        "и",
+        "р",
+        "в",
+        "т",
+        "е",
+        "с",
+        "к",
+        "л",
+        "у",
+        "д",
+        "м",
+        "п",
+        "з",
+        "я",
+        "ь",
+        "б",
+        "г",
+        "й",
+        "ч",
+        "х",
+        "ц",
+        "ї",
+    ],
+    "Norwegian": [
+        "e",
+        "r",
+        "n",
+        "t",
+        "a",
+        "s",
+        "i",
+        "o",
+        "l",
+        "d",
+        "g",
+        "k",
+        "m",
+        "v",
+        "f",
+        "p",
+        "u",
+        "b",
+        "h",
+        "å",
+        "y",
+        "j",
+        "ø",
+        "c",
+        "æ",
+        "w",
+    ],
+    "Finnish": [
+        "a",
+        "i",
+        "n",
+        "t",
+        "e",
+        "s",
+        "l",
+        "o",
+        "u",
+        "k",
+        "ä",
+        "m",
+        "r",
+        "v",
+        "j",
+        "h",
+        "p",
+        "y",
+        "d",
+        "ö",
+        "g",
+        "c",
+        "b",
+        "f",
+        "w",
+        "z",
+    ],
+    "Vietnamese": [
+        "n",
+        "h",
+        "t",
+        "i",
+        "c",
+        "g",
+        "a",
+        "o",
+        "u",
+        "m",
+        "l",
+        "r",
+        "à",
+        "đ",
+        "s",
+        "e",
+        "v",
+        "p",
+        "b",
+        "y",
+        "ư",
+        "d",
+        "á",
+        "k",
+        "ộ",
+        "ế",
+    ],
+    "Czech": [
+        "o",
+        "e",
+        "a",
+        "n",
+        "t",
+        "s",
+        "i",
+        "l",
+        "v",
+        "r",
+        "k",
+        "d",
+        "u",
+        "m",
+        "p",
+        "í",
+        "c",
+        "h",
+        "z",
+        "á",
+        "y",
+        "j",
+        "b",
+        "ě",
+        "é",
+        "ř",
+    ],
+    "Hungarian": [
+        "e",
+        "a",
+        "t",
+        "l",
+        "s",
+        "n",
+        "k",
+        "r",
+        "i",
+        "o",
+        "z",
+        "á",
+        "é",
+        "g",
+        "m",
+        "b",
+        "y",
+        "v",
+        "d",
+        "h",
+        "u",
+        "p",
+        "j",
+        "ö",
+        "f",
+        "c",
+    ],
+    "Korean": [
+        "이",
+        "다",
+        "에",
+        "의",
+        "는",
+        "로",
+        "하",
+        "을",
+        "가",
+        "고",
+        "지",
+        "서",
+        "한",
+        "은",
+        "기",
+        "으",
+        "년",
+        "대",
+        "사",
+        "시",
+        "를",
+        "리",
+        "도",
+        "인",
+        "스",
+        "일",
+    ],
+    "Indonesian": [
+        "a",
+        "n",
+        "e",
+        "i",
+        "r",
+        "t",
+        "u",
+        "s",
+        "d",
+        "k",
+        "m",
+        "l",
+        "g",
+        "p",
+        "b",
+        "o",
+        "h",
+        "y",
+        "j",
+        "c",
+        "w",
+        "f",
+        "v",
+        "z",
+        "x",
+        "q",
+    ],
+    "Turkish": [
+        "a",
+        "e",
+        "i",
+        "n",
+        "r",
+        "l",
+        "ı",
+        "k",
+        "d",
+        "t",
+        "s",
+        "m",
+        "y",
+        "u",
+        "o",
+        "b",
+        "ü",
+        "ş",
+        "v",
+        "g",
+        "z",
+        "h",
+        "c",
+        "p",
+        "ç",
+        "ğ",
+    ],
+    "Romanian": [
+        "e",
+        "i",
+        "a",
+        "r",
+        "n",
+        "t",
+        "u",
+        "l",
+        "o",
+        "c",
+        "s",
+        "d",
+        "p",
+        "m",
+        "ă",
+        "f",
+        "v",
+        "î",
+        "g",
+        "b",
+        "ș",
+        "ț",
+        "z",
+        "h",
+        "â",
+        "j",
+    ],
+    "Farsi": [
+        "ا",
+        "ی",
+        "ر",
+        "د",
+        "ن",
+        "ه",
+        "و",
+        "م",
+        "ت",
+        "ب",
+        "س",
+        "ل",
+        "ک",
+        "ش",
+        "ز",
+        "ف",
+        "گ",
+        "ع",
+        "خ",
+        "ق",
+        "ج",
+        "آ",
+        "پ",
+        "ح",
+        "ط",
+        "ص",
+    ],
+    "Arabic": [
+        "ا",
+        "ل",
+        "ي",
+        "م",
+        "و",
+        "ن",
+        "ر",
+        "ت",
+        "ب",
+        "ة",
+        "ع",
+        "د",
+        "س",
+        "ف",
+        "ه",
+        "ك",
+        "ق",
+        "أ",
+        "ح",
+        "ج",
+        "ش",
+        "ط",
+        "ص",
+        "ى",
+        "خ",
+        "إ",
+    ],
+    "Danish": [
+        "e",
+        "r",
+        "n",
+        "t",
+        "a",
+        "i",
+        "s",
+        "d",
+        "l",
+        "o",
+        "g",
+        "m",
+        "k",
+        "f",
+        "v",
+        "u",
+        "b",
+        "h",
+        "p",
+        "å",
+        "y",
+        "ø",
+        "æ",
+        "c",
+        "j",
+        "w",
+    ],
+    "Serbian": [
+        "а",
+        "и",
+        "о",
+        "е",
+        "н",
+        "р",
+        "с",
+        "у",
+        "т",
+        "к",
+        "ј",
+        "в",
+        "д",
+        "м",
+        "п",
+        "л",
+        "г",
+        "з",
+        "б",
+        "a",
+        "i",
+        "e",
+        "o",
+        "n",
+        "ц",
+        "ш",
+    ],
+    "Lithuanian": [
+        "i",
+        "a",
+        "s",
+        "o",
+        "r",
+        "e",
+        "t",
+        "n",
+        "u",
+        "k",
+        "m",
+        "l",
+        "p",
+        "v",
+        "d",
+        "j",
+        "g",
+        "ė",
+        "b",
+        "y",
+        "ų",
+        "š",
+        "ž",
+        "c",
+        "ą",
+        "į",
+    ],
+    "Slovene": [
+        "e",
+        "a",
+        "i",
+        "o",
+        "n",
+        "r",
+        "s",
+        "l",
+        "t",
+        "j",
+        "v",
+        "k",
+        "d",
+        "p",
+        "m",
+        "u",
+        "z",
+        "b",
+        "g",
+        "h",
+        "č",
+        "c",
+        "š",
+        "ž",
+        "f",
+        "y",
+    ],
+    "Slovak": [
+        "o",
+        "a",
+        "e",
+        "n",
+        "i",
+        "r",
+        "v",
+        "t",
+        "s",
+        "l",
+        "k",
+        "d",
+        "m",
+        "p",
+        "u",
+        "c",
+        "h",
+        "j",
+        "b",
+        "z",
+        "á",
+        "y",
+        "ý",
+        "í",
+        "č",
+        "é",
+    ],
+    "Hebrew": [
+        "י",
+        "ו",
+        "ה",
+        "ל",
+        "ר",
+        "ב",
+        "ת",
+        "מ",
+        "א",
+        "ש",
+        "נ",
+        "ע",
+        "ם",
+        "ד",
+        "ק",
+        "ח",
+        "פ",
+        "ס",
+        "כ",
+        "ג",
+        "ט",
+        "צ",
+        "ן",
+        "ז",
+        "ך",
+    ],
+    "Bulgarian": [
+        "а",
+        "и",
+        "о",
+        "е",
+        "н",
+        "т",
+        "р",
+        "с",
+        "в",
+        "л",
+        "к",
+        "д",
+        "п",
+        "м",
+        "з",
+        "г",
+        "я",
+        "ъ",
+        "у",
+        "б",
+        "ч",
+        "ц",
+        "й",
+        "ж",
+        "щ",
+        "х",
+    ],
+    "Croatian": [
+        "a",
+        "i",
+        "o",
+        "e",
+        "n",
+        "r",
+        "j",
+        "s",
+        "t",
+        "u",
+        "k",
+        "l",
+        "v",
+        "d",
+        "m",
+        "p",
+        "g",
+        "z",
+        "b",
+        "c",
+        "č",
+        "h",
+        "š",
+        "ž",
+        "ć",
+        "f",
+    ],
+    "Hindi": [
+        "क",
+        "र",
+        "स",
+        "न",
+        "त",
+        "म",
+        "ह",
+        "प",
+        "य",
+        "ल",
+        "व",
+        "ज",
+        "द",
+        "ग",
+        "ब",
+        "श",
+        "ट",
+        "अ",
+        "ए",
+        "थ",
+        "भ",
+        "ड",
+        "च",
+        "ध",
+        "ष",
+        "इ",
+    ],
+    "Estonian": [
+        "a",
+        "i",
+        "e",
+        "s",
+        "t",
+        "l",
+        "u",
+        "n",
+        "o",
+        "k",
+        "r",
+        "d",
+        "m",
+        "v",
+        "g",
+        "p",
+        "j",
+        "h",
+        "ä",
+        "b",
+        "õ",
+        "ü",
+        "f",
+        "c",
+        "ö",
+        "y",
+    ],
+    "Thai": [
+        "า",
+        "น",
+        "ร",
+        "อ",
+        "ก",
+        "เ",
+        "ง",
+        "ม",
+        "ย",
+        "ล",
+        "ว",
+        "ด",
+        "ท",
+        "ส",
+        "ต",
+        "ะ",
+        "ป",
+        "บ",
+        "ค",
+        "ห",
+        "แ",
+        "จ",
+        "พ",
+        "ช",
+        "ข",
+        "ใ",
+    ],
+    "Greek": [
+        "α",
+        "τ",
+        "ο",
+        "ι",
+        "ε",
+        "ν",
+        "ρ",
+        "σ",
+        "κ",
+        "η",
+        "π",
+        "ς",
+        "υ",
+        "μ",
+        "λ",
+        "ί",
+        "ό",
+        "ά",
+        "γ",
+        "έ",
+        "δ",
+        "ή",
+        "ω",
+        "χ",
+        "θ",
+        "ύ",
+    ],
+    "Tamil": [
+        "க",
+        "த",
+        "ப",
+        "ட",
+        "ர",
+        "ம",
+        "ல",
+        "ன",
+        "வ",
+        "ற",
+        "ய",
+        "ள",
+        "ச",
+        "ந",
+        "இ",
+        "ண",
+        "அ",
+        "ஆ",
+        "ழ",
+        "ங",
+        "எ",
+        "உ",
+        "ஒ",
+        "ஸ",
+    ],
+    "Kazakh": [
+        "а",
+        "ы",
+        "е",
+        "н",
+        "т",
+        "р",
+        "л",
+        "і",
+        "д",
+        "с",
+        "м",
+        "қ",
+        "к",
+        "о",
+        "б",
+        "и",
+        "у",
+        "ғ",
+        "ж",
+        "ң",
+        "з",
+        "ш",
+        "й",
+        "п",
+        "г",
+        "ө",
+    ],
+}
+
+LANGUAGE_SUPPORTED_COUNT: int = len(FREQUENCIES)
diff --git a/lib/python3.11/site-packages/charset_normalizer/legacy.py b/lib/python3.11/site-packages/charset_normalizer/legacy.py
new file mode 100644
index 0000000000000000000000000000000000000000..43aad21a9dd1c08c8d31e38908485d46b14efbd2
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/legacy.py
@@ -0,0 +1,54 @@
+from typing import Any, Dict, Optional, Union
+from warnings import warn
+
+from .api import from_bytes
+from .constant import CHARDET_CORRESPONDENCE
+
+
+def detect(
+    byte_str: bytes, should_rename_legacy: bool = False, **kwargs: Any
+) -> Dict[str, Optional[Union[str, float]]]:
+    """
+    chardet legacy method
+    Detect the encoding of the given byte string. It should be mostly backward-compatible.
+    Encoding name will match Chardet own writing whenever possible. (Not on encoding name unsupported by it)
+    This function is deprecated and should be used to migrate your project easily, consult the documentation for
+    further information. Not planned for removal.
+
+    :param byte_str:     The byte sequence to examine.
+    :param should_rename_legacy:  Should we rename legacy encodings
+                                  to their more modern equivalents?
+    """
+    if len(kwargs):
+        warn(
+            f"charset-normalizer disregard arguments '{','.join(list(kwargs.keys()))}' in legacy function detect()"
+        )
+
+    if not isinstance(byte_str, (bytearray, bytes)):
+        raise TypeError(  # pragma: nocover
+            "Expected object of type bytes or bytearray, got: "
+            "{0}".format(type(byte_str))
+        )
+
+    if isinstance(byte_str, bytearray):
+        byte_str = bytes(byte_str)
+
+    r = from_bytes(byte_str).best()
+
+    encoding = r.encoding if r is not None else None
+    language = r.language if r is not None and r.language != "Unknown" else ""
+    confidence = 1.0 - r.chaos if r is not None else None
+
+    # Note: CharsetNormalizer does not return 'UTF-8-SIG' as the sig get stripped in the detection/normalization process
+    # but chardet does return 'utf-8-sig' and it is a valid codec name.
+    if r is not None and encoding == "utf_8" and r.bom:
+        encoding += "_sig"
+
+    if should_rename_legacy is False and encoding in CHARDET_CORRESPONDENCE:
+        encoding = CHARDET_CORRESPONDENCE[encoding]
+
+    return {
+        "encoding": encoding,
+        "language": language,
+        "confidence": confidence,
+    }
diff --git a/lib/python3.11/site-packages/charset_normalizer/md.cpython-311-darwin.so b/lib/python3.11/site-packages/charset_normalizer/md.cpython-311-darwin.so
new file mode 100644
index 0000000000000000000000000000000000000000..296378b92d3f13769e2fd24de0f5c5a7fcd0d770
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/md.cpython-311-darwin.so differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/md.py b/lib/python3.11/site-packages/charset_normalizer/md.py
new file mode 100644
index 0000000000000000000000000000000000000000..77897aae4f44d084d6a59d7f7f1665035ff0047d
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/md.py
@@ -0,0 +1,615 @@
+from functools import lru_cache
+from logging import getLogger
+from typing import List, Optional
+
+from .constant import (
+    COMMON_SAFE_ASCII_CHARACTERS,
+    TRACE,
+    UNICODE_SECONDARY_RANGE_KEYWORD,
+)
+from .utils import (
+    is_accentuated,
+    is_arabic,
+    is_arabic_isolated_form,
+    is_case_variable,
+    is_cjk,
+    is_emoticon,
+    is_hangul,
+    is_hiragana,
+    is_katakana,
+    is_latin,
+    is_punctuation,
+    is_separator,
+    is_symbol,
+    is_thai,
+    is_unprintable,
+    remove_accent,
+    unicode_range,
+)
+
+
+class MessDetectorPlugin:
+    """
+    Base abstract class used for mess detection plugins.
+    All detectors MUST extend and implement given methods.
+    """
+
+    def eligible(self, character: str) -> bool:
+        """
+        Determine if given character should be fed in.
+        """
+        raise NotImplementedError  # pragma: nocover
+
+    def feed(self, character: str) -> None:
+        """
+        The main routine to be executed upon character.
+        Insert the logic in witch the text would be considered chaotic.
+        """
+        raise NotImplementedError  # pragma: nocover
+
+    def reset(self) -> None:  # pragma: no cover
+        """
+        Permit to reset the plugin to the initial state.
+        """
+        raise NotImplementedError
+
+    @property
+    def ratio(self) -> float:
+        """
+        Compute the chaos ratio based on what your feed() has seen.
+        Must NOT be lower than 0.; No restriction gt 0.
+        """
+        raise NotImplementedError  # pragma: nocover
+
+
+class TooManySymbolOrPunctuationPlugin(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._punctuation_count: int = 0
+        self._symbol_count: int = 0
+        self._character_count: int = 0
+
+        self._last_printable_char: Optional[str] = None
+        self._frenzy_symbol_in_word: bool = False
+
+    def eligible(self, character: str) -> bool:
+        return character.isprintable()
+
+    def feed(self, character: str) -> None:
+        self._character_count += 1
+
+        if (
+            character != self._last_printable_char
+            and character not in COMMON_SAFE_ASCII_CHARACTERS
+        ):
+            if is_punctuation(character):
+                self._punctuation_count += 1
+            elif (
+                character.isdigit() is False
+                and is_symbol(character)
+                and is_emoticon(character) is False
+            ):
+                self._symbol_count += 2
+
+        self._last_printable_char = character
+
+    def reset(self) -> None:  # pragma: no cover
+        self._punctuation_count = 0
+        self._character_count = 0
+        self._symbol_count = 0
+
+    @property
+    def ratio(self) -> float:
+        if self._character_count == 0:
+            return 0.0
+
+        ratio_of_punctuation: float = (
+            self._punctuation_count + self._symbol_count
+        ) / self._character_count
+
+        return ratio_of_punctuation if ratio_of_punctuation >= 0.3 else 0.0
+
+
+class TooManyAccentuatedPlugin(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._character_count: int = 0
+        self._accentuated_count: int = 0
+
+    def eligible(self, character: str) -> bool:
+        return character.isalpha()
+
+    def feed(self, character: str) -> None:
+        self._character_count += 1
+
+        if is_accentuated(character):
+            self._accentuated_count += 1
+
+    def reset(self) -> None:  # pragma: no cover
+        self._character_count = 0
+        self._accentuated_count = 0
+
+    @property
+    def ratio(self) -> float:
+        if self._character_count < 8:
+            return 0.0
+
+        ratio_of_accentuation: float = self._accentuated_count / self._character_count
+        return ratio_of_accentuation if ratio_of_accentuation >= 0.35 else 0.0
+
+
+class UnprintablePlugin(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._unprintable_count: int = 0
+        self._character_count: int = 0
+
+    def eligible(self, character: str) -> bool:
+        return True
+
+    def feed(self, character: str) -> None:
+        if is_unprintable(character):
+            self._unprintable_count += 1
+        self._character_count += 1
+
+    def reset(self) -> None:  # pragma: no cover
+        self._unprintable_count = 0
+
+    @property
+    def ratio(self) -> float:
+        if self._character_count == 0:
+            return 0.0
+
+        return (self._unprintable_count * 8) / self._character_count
+
+
+class SuspiciousDuplicateAccentPlugin(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._successive_count: int = 0
+        self._character_count: int = 0
+
+        self._last_latin_character: Optional[str] = None
+
+    def eligible(self, character: str) -> bool:
+        return character.isalpha() and is_latin(character)
+
+    def feed(self, character: str) -> None:
+        self._character_count += 1
+        if (
+            self._last_latin_character is not None
+            and is_accentuated(character)
+            and is_accentuated(self._last_latin_character)
+        ):
+            if character.isupper() and self._last_latin_character.isupper():
+                self._successive_count += 1
+            # Worse if its the same char duplicated with different accent.
+            if remove_accent(character) == remove_accent(self._last_latin_character):
+                self._successive_count += 1
+        self._last_latin_character = character
+
+    def reset(self) -> None:  # pragma: no cover
+        self._successive_count = 0
+        self._character_count = 0
+        self._last_latin_character = None
+
+    @property
+    def ratio(self) -> float:
+        if self._character_count == 0:
+            return 0.0
+
+        return (self._successive_count * 2) / self._character_count
+
+
+class SuspiciousRange(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._suspicious_successive_range_count: int = 0
+        self._character_count: int = 0
+        self._last_printable_seen: Optional[str] = None
+
+    def eligible(self, character: str) -> bool:
+        return character.isprintable()
+
+    def feed(self, character: str) -> None:
+        self._character_count += 1
+
+        if (
+            character.isspace()
+            or is_punctuation(character)
+            or character in COMMON_SAFE_ASCII_CHARACTERS
+        ):
+            self._last_printable_seen = None
+            return
+
+        if self._last_printable_seen is None:
+            self._last_printable_seen = character
+            return
+
+        unicode_range_a: Optional[str] = unicode_range(self._last_printable_seen)
+        unicode_range_b: Optional[str] = unicode_range(character)
+
+        if is_suspiciously_successive_range(unicode_range_a, unicode_range_b):
+            self._suspicious_successive_range_count += 1
+
+        self._last_printable_seen = character
+
+    def reset(self) -> None:  # pragma: no cover
+        self._character_count = 0
+        self._suspicious_successive_range_count = 0
+        self._last_printable_seen = None
+
+    @property
+    def ratio(self) -> float:
+        if self._character_count <= 24:
+            return 0.0
+
+        ratio_of_suspicious_range_usage: float = (
+            self._suspicious_successive_range_count * 2
+        ) / self._character_count
+
+        return ratio_of_suspicious_range_usage
+
+
+class SuperWeirdWordPlugin(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._word_count: int = 0
+        self._bad_word_count: int = 0
+        self._foreign_long_count: int = 0
+
+        self._is_current_word_bad: bool = False
+        self._foreign_long_watch: bool = False
+
+        self._character_count: int = 0
+        self._bad_character_count: int = 0
+
+        self._buffer: str = ""
+        self._buffer_accent_count: int = 0
+
+    def eligible(self, character: str) -> bool:
+        return True
+
+    def feed(self, character: str) -> None:
+        if character.isalpha():
+            self._buffer += character
+            if is_accentuated(character):
+                self._buffer_accent_count += 1
+            if (
+                self._foreign_long_watch is False
+                and (is_latin(character) is False or is_accentuated(character))
+                and is_cjk(character) is False
+                and is_hangul(character) is False
+                and is_katakana(character) is False
+                and is_hiragana(character) is False
+                and is_thai(character) is False
+            ):
+                self._foreign_long_watch = True
+            return
+        if not self._buffer:
+            return
+        if (
+            character.isspace() or is_punctuation(character) or is_separator(character)
+        ) and self._buffer:
+            self._word_count += 1
+            buffer_length: int = len(self._buffer)
+
+            self._character_count += buffer_length
+
+            if buffer_length >= 4:
+                if self._buffer_accent_count / buffer_length > 0.34:
+                    self._is_current_word_bad = True
+                # Word/Buffer ending with an upper case accentuated letter are so rare,
+                # that we will consider them all as suspicious. Same weight as foreign_long suspicious.
+                if (
+                    is_accentuated(self._buffer[-1])
+                    and self._buffer[-1].isupper()
+                    and all(_.isupper() for _ in self._buffer) is False
+                ):
+                    self._foreign_long_count += 1
+                    self._is_current_word_bad = True
+            if buffer_length >= 24 and self._foreign_long_watch:
+                camel_case_dst = [
+                    i
+                    for c, i in zip(self._buffer, range(0, buffer_length))
+                    if c.isupper()
+                ]
+                probable_camel_cased: bool = False
+
+                if camel_case_dst and (len(camel_case_dst) / buffer_length <= 0.3):
+                    probable_camel_cased = True
+
+                if not probable_camel_cased:
+                    self._foreign_long_count += 1
+                    self._is_current_word_bad = True
+
+            if self._is_current_word_bad:
+                self._bad_word_count += 1
+                self._bad_character_count += len(self._buffer)
+                self._is_current_word_bad = False
+
+            self._foreign_long_watch = False
+            self._buffer = ""
+            self._buffer_accent_count = 0
+        elif (
+            character not in {"<", ">", "-", "=", "~", "|", "_"}
+            and character.isdigit() is False
+            and is_symbol(character)
+        ):
+            self._is_current_word_bad = True
+            self._buffer += character
+
+    def reset(self) -> None:  # pragma: no cover
+        self._buffer = ""
+        self._is_current_word_bad = False
+        self._foreign_long_watch = False
+        self._bad_word_count = 0
+        self._word_count = 0
+        self._character_count = 0
+        self._bad_character_count = 0
+        self._foreign_long_count = 0
+
+    @property
+    def ratio(self) -> float:
+        if self._word_count <= 10 and self._foreign_long_count == 0:
+            return 0.0
+
+        return self._bad_character_count / self._character_count
+
+
+class CjkInvalidStopPlugin(MessDetectorPlugin):
+    """
+    GB(Chinese) based encoding often render the stop incorrectly when the content does not fit and
+    can be easily detected. Searching for the overuse of '丅' and '丄'.
+    """
+
+    def __init__(self) -> None:
+        self._wrong_stop_count: int = 0
+        self._cjk_character_count: int = 0
+
+    def eligible(self, character: str) -> bool:
+        return True
+
+    def feed(self, character: str) -> None:
+        if character in {"丅", "丄"}:
+            self._wrong_stop_count += 1
+            return
+        if is_cjk(character):
+            self._cjk_character_count += 1
+
+    def reset(self) -> None:  # pragma: no cover
+        self._wrong_stop_count = 0
+        self._cjk_character_count = 0
+
+    @property
+    def ratio(self) -> float:
+        if self._cjk_character_count < 16:
+            return 0.0
+        return self._wrong_stop_count / self._cjk_character_count
+
+
+class ArchaicUpperLowerPlugin(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._buf: bool = False
+
+        self._character_count_since_last_sep: int = 0
+
+        self._successive_upper_lower_count: int = 0
+        self._successive_upper_lower_count_final: int = 0
+
+        self._character_count: int = 0
+
+        self._last_alpha_seen: Optional[str] = None
+        self._current_ascii_only: bool = True
+
+    def eligible(self, character: str) -> bool:
+        return True
+
+    def feed(self, character: str) -> None:
+        is_concerned = character.isalpha() and is_case_variable(character)
+        chunk_sep = is_concerned is False
+
+        if chunk_sep and self._character_count_since_last_sep > 0:
+            if (
+                self._character_count_since_last_sep <= 64
+                and character.isdigit() is False
+                and self._current_ascii_only is False
+            ):
+                self._successive_upper_lower_count_final += (
+                    self._successive_upper_lower_count
+                )
+
+            self._successive_upper_lower_count = 0
+            self._character_count_since_last_sep = 0
+            self._last_alpha_seen = None
+            self._buf = False
+            self._character_count += 1
+            self._current_ascii_only = True
+
+            return
+
+        if self._current_ascii_only is True and character.isascii() is False:
+            self._current_ascii_only = False
+
+        if self._last_alpha_seen is not None:
+            if (character.isupper() and self._last_alpha_seen.islower()) or (
+                character.islower() and self._last_alpha_seen.isupper()
+            ):
+                if self._buf is True:
+                    self._successive_upper_lower_count += 2
+                    self._buf = False
+                else:
+                    self._buf = True
+            else:
+                self._buf = False
+
+        self._character_count += 1
+        self._character_count_since_last_sep += 1
+        self._last_alpha_seen = character
+
+    def reset(self) -> None:  # pragma: no cover
+        self._character_count = 0
+        self._character_count_since_last_sep = 0
+        self._successive_upper_lower_count = 0
+        self._successive_upper_lower_count_final = 0
+        self._last_alpha_seen = None
+        self._buf = False
+        self._current_ascii_only = True
+
+    @property
+    def ratio(self) -> float:
+        if self._character_count == 0:
+            return 0.0
+
+        return self._successive_upper_lower_count_final / self._character_count
+
+
+class ArabicIsolatedFormPlugin(MessDetectorPlugin):
+    def __init__(self) -> None:
+        self._character_count: int = 0
+        self._isolated_form_count: int = 0
+
+    def reset(self) -> None:  # pragma: no cover
+        self._character_count = 0
+        self._isolated_form_count = 0
+
+    def eligible(self, character: str) -> bool:
+        return is_arabic(character)
+
+    def feed(self, character: str) -> None:
+        self._character_count += 1
+
+        if is_arabic_isolated_form(character):
+            self._isolated_form_count += 1
+
+    @property
+    def ratio(self) -> float:
+        if self._character_count < 8:
+            return 0.0
+
+        isolated_form_usage: float = self._isolated_form_count / self._character_count
+
+        return isolated_form_usage
+
+
+@lru_cache(maxsize=1024)
+def is_suspiciously_successive_range(
+    unicode_range_a: Optional[str], unicode_range_b: Optional[str]
+) -> bool:
+    """
+    Determine if two Unicode range seen next to each other can be considered as suspicious.
+    """
+    if unicode_range_a is None or unicode_range_b is None:
+        return True
+
+    if unicode_range_a == unicode_range_b:
+        return False
+
+    if "Latin" in unicode_range_a and "Latin" in unicode_range_b:
+        return False
+
+    if "Emoticons" in unicode_range_a or "Emoticons" in unicode_range_b:
+        return False
+
+    # Latin characters can be accompanied with a combining diacritical mark
+    # eg. Vietnamese.
+    if ("Latin" in unicode_range_a or "Latin" in unicode_range_b) and (
+        "Combining" in unicode_range_a or "Combining" in unicode_range_b
+    ):
+        return False
+
+    keywords_range_a, keywords_range_b = unicode_range_a.split(
+        " "
+    ), unicode_range_b.split(" ")
+
+    for el in keywords_range_a:
+        if el in UNICODE_SECONDARY_RANGE_KEYWORD:
+            continue
+        if el in keywords_range_b:
+            return False
+
+    # Japanese Exception
+    range_a_jp_chars, range_b_jp_chars = (
+        unicode_range_a
+        in (
+            "Hiragana",
+            "Katakana",
+        ),
+        unicode_range_b in ("Hiragana", "Katakana"),
+    )
+    if (range_a_jp_chars or range_b_jp_chars) and (
+        "CJK" in unicode_range_a or "CJK" in unicode_range_b
+    ):
+        return False
+    if range_a_jp_chars and range_b_jp_chars:
+        return False
+
+    if "Hangul" in unicode_range_a or "Hangul" in unicode_range_b:
+        if "CJK" in unicode_range_a or "CJK" in unicode_range_b:
+            return False
+        if unicode_range_a == "Basic Latin" or unicode_range_b == "Basic Latin":
+            return False
+
+    # Chinese/Japanese use dedicated range for punctuation and/or separators.
+    if ("CJK" in unicode_range_a or "CJK" in unicode_range_b) or (
+        unicode_range_a in ["Katakana", "Hiragana"]
+        and unicode_range_b in ["Katakana", "Hiragana"]
+    ):
+        if "Punctuation" in unicode_range_a or "Punctuation" in unicode_range_b:
+            return False
+        if "Forms" in unicode_range_a or "Forms" in unicode_range_b:
+            return False
+        if unicode_range_a == "Basic Latin" or unicode_range_b == "Basic Latin":
+            return False
+
+    return True
+
+
+@lru_cache(maxsize=2048)
+def mess_ratio(
+    decoded_sequence: str, maximum_threshold: float = 0.2, debug: bool = False
+) -> float:
+    """
+    Compute a mess ratio given a decoded bytes sequence. The maximum threshold does stop the computation earlier.
+    """
+
+    detectors: List[MessDetectorPlugin] = [
+        md_class() for md_class in MessDetectorPlugin.__subclasses__()
+    ]
+
+    length: int = len(decoded_sequence) + 1
+
+    mean_mess_ratio: float = 0.0
+
+    if length < 512:
+        intermediary_mean_mess_ratio_calc: int = 32
+    elif length <= 1024:
+        intermediary_mean_mess_ratio_calc = 64
+    else:
+        intermediary_mean_mess_ratio_calc = 128
+
+    for character, index in zip(decoded_sequence + "\n", range(length)):
+        for detector in detectors:
+            if detector.eligible(character):
+                detector.feed(character)
+
+        if (
+            index > 0 and index % intermediary_mean_mess_ratio_calc == 0
+        ) or index == length - 1:
+            mean_mess_ratio = sum(dt.ratio for dt in detectors)
+
+            if mean_mess_ratio >= maximum_threshold:
+                break
+
+    if debug:
+        logger = getLogger("charset_normalizer")
+
+        logger.log(
+            TRACE,
+            "Mess-detector extended-analysis start. "
+            f"intermediary_mean_mess_ratio_calc={intermediary_mean_mess_ratio_calc} mean_mess_ratio={mean_mess_ratio} "
+            f"maximum_threshold={maximum_threshold}",
+        )
+
+        if len(decoded_sequence) > 16:
+            logger.log(TRACE, f"Starting with: {decoded_sequence[:16]}")
+            logger.log(TRACE, f"Ending with: {decoded_sequence[-16::]}")
+
+        for dt in detectors:  # pragma: nocover
+            logger.log(TRACE, f"{dt.__class__}: {dt.ratio}")
+
+    return round(mean_mess_ratio, 3)
diff --git a/lib/python3.11/site-packages/charset_normalizer/md__mypyc.cpython-311-darwin.so b/lib/python3.11/site-packages/charset_normalizer/md__mypyc.cpython-311-darwin.so
new file mode 100644
index 0000000000000000000000000000000000000000..cd6c310e635dd4586bb382e685f621207aa2f034
Binary files /dev/null and b/lib/python3.11/site-packages/charset_normalizer/md__mypyc.cpython-311-darwin.so differ
diff --git a/lib/python3.11/site-packages/charset_normalizer/models.py b/lib/python3.11/site-packages/charset_normalizer/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..a760b9c558d953f6907d29fa31844d07d06f9ce1
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/models.py
@@ -0,0 +1,340 @@
+from encodings.aliases import aliases
+from hashlib import sha256
+from json import dumps
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+
+from .constant import TOO_BIG_SEQUENCE
+from .utils import iana_name, is_multi_byte_encoding, unicode_range
+
+
+class CharsetMatch:
+    def __init__(
+        self,
+        payload: bytes,
+        guessed_encoding: str,
+        mean_mess_ratio: float,
+        has_sig_or_bom: bool,
+        languages: "CoherenceMatches",
+        decoded_payload: Optional[str] = None,
+    ):
+        self._payload: bytes = payload
+
+        self._encoding: str = guessed_encoding
+        self._mean_mess_ratio: float = mean_mess_ratio
+        self._languages: CoherenceMatches = languages
+        self._has_sig_or_bom: bool = has_sig_or_bom
+        self._unicode_ranges: Optional[List[str]] = None
+
+        self._leaves: List[CharsetMatch] = []
+        self._mean_coherence_ratio: float = 0.0
+
+        self._output_payload: Optional[bytes] = None
+        self._output_encoding: Optional[str] = None
+
+        self._string: Optional[str] = decoded_payload
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CharsetMatch):
+            raise TypeError(
+                "__eq__ cannot be invoked on {} and {}.".format(
+                    str(other.__class__), str(self.__class__)
+                )
+            )
+        return self.encoding == other.encoding and self.fingerprint == other.fingerprint
+
+    def __lt__(self, other: object) -> bool:
+        """
+        Implemented to make sorted available upon CharsetMatches items.
+        """
+        if not isinstance(other, CharsetMatch):
+            raise ValueError
+
+        chaos_difference: float = abs(self.chaos - other.chaos)
+        coherence_difference: float = abs(self.coherence - other.coherence)
+
+        # Below 1% difference --> Use Coherence
+        if chaos_difference < 0.01 and coherence_difference > 0.02:
+            return self.coherence > other.coherence
+        elif chaos_difference < 0.01 and coherence_difference <= 0.02:
+            # When having a difficult decision, use the result that decoded as many multi-byte as possible.
+            # preserve RAM usage!
+            if len(self._payload) >= TOO_BIG_SEQUENCE:
+                return self.chaos < other.chaos
+            return self.multi_byte_usage > other.multi_byte_usage
+
+        return self.chaos < other.chaos
+
+    @property
+    def multi_byte_usage(self) -> float:
+        return 1.0 - (len(str(self)) / len(self.raw))
+
+    def __str__(self) -> str:
+        # Lazy Str Loading
+        if self._string is None:
+            self._string = str(self._payload, self._encoding, "strict")
+        return self._string
+
+    def __repr__(self) -> str:
+        return "<CharsetMatch '{}' bytes({})>".format(self.encoding, self.fingerprint)
+
+    def add_submatch(self, other: "CharsetMatch") -> None:
+        if not isinstance(other, CharsetMatch) or other == self:
+            raise ValueError(
+                "Unable to add instance <{}> as a submatch of a CharsetMatch".format(
+                    other.__class__
+                )
+            )
+
+        other._string = None  # Unload RAM usage; dirty trick.
+        self._leaves.append(other)
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    @property
+    def encoding_aliases(self) -> List[str]:
+        """
+        Encoding name are known by many name, using this could help when searching for IBM855 when it's listed as CP855.
+        """
+        also_known_as: List[str] = []
+        for u, p in aliases.items():
+            if self.encoding == u:
+                also_known_as.append(p)
+            elif self.encoding == p:
+                also_known_as.append(u)
+        return also_known_as
+
+    @property
+    def bom(self) -> bool:
+        return self._has_sig_or_bom
+
+    @property
+    def byte_order_mark(self) -> bool:
+        return self._has_sig_or_bom
+
+    @property
+    def languages(self) -> List[str]:
+        """
+        Return the complete list of possible languages found in decoded sequence.
+        Usually not really useful. Returned list may be empty even if 'language' property return something != 'Unknown'.
+        """
+        return [e[0] for e in self._languages]
+
+    @property
+    def language(self) -> str:
+        """
+        Most probable language found in decoded sequence. If none were detected or inferred, the property will return
+        "Unknown".
+        """
+        if not self._languages:
+            # Trying to infer the language based on the given encoding
+            # Its either English or we should not pronounce ourselves in certain cases.
+            if "ascii" in self.could_be_from_charset:
+                return "English"
+
+            # doing it there to avoid circular import
+            from charset_normalizer.cd import encoding_languages, mb_encoding_languages
+
+            languages = (
+                mb_encoding_languages(self.encoding)
+                if is_multi_byte_encoding(self.encoding)
+                else encoding_languages(self.encoding)
+            )
+
+            if len(languages) == 0 or "Latin Based" in languages:
+                return "Unknown"
+
+            return languages[0]
+
+        return self._languages[0][0]
+
+    @property
+    def chaos(self) -> float:
+        return self._mean_mess_ratio
+
+    @property
+    def coherence(self) -> float:
+        if not self._languages:
+            return 0.0
+        return self._languages[0][1]
+
+    @property
+    def percent_chaos(self) -> float:
+        return round(self.chaos * 100, ndigits=3)
+
+    @property
+    def percent_coherence(self) -> float:
+        return round(self.coherence * 100, ndigits=3)
+
+    @property
+    def raw(self) -> bytes:
+        """
+        Original untouched bytes.
+        """
+        return self._payload
+
+    @property
+    def submatch(self) -> List["CharsetMatch"]:
+        return self._leaves
+
+    @property
+    def has_submatch(self) -> bool:
+        return len(self._leaves) > 0
+
+    @property
+    def alphabets(self) -> List[str]:
+        if self._unicode_ranges is not None:
+            return self._unicode_ranges
+        # list detected ranges
+        detected_ranges: List[Optional[str]] = [
+            unicode_range(char) for char in str(self)
+        ]
+        # filter and sort
+        self._unicode_ranges = sorted(list({r for r in detected_ranges if r}))
+        return self._unicode_ranges
+
+    @property
+    def could_be_from_charset(self) -> List[str]:
+        """
+        The complete list of encoding that output the exact SAME str result and therefore could be the originating
+        encoding.
+        This list does include the encoding available in property 'encoding'.
+        """
+        return [self._encoding] + [m.encoding for m in self._leaves]
+
+    def output(self, encoding: str = "utf_8") -> bytes:
+        """
+        Method to get re-encoded bytes payload using given target encoding. Default to UTF-8.
+        Any errors will be simply ignored by the encoder NOT replaced.
+        """
+        if self._output_encoding is None or self._output_encoding != encoding:
+            self._output_encoding = encoding
+            self._output_payload = str(self).encode(encoding, "replace")
+
+        return self._output_payload  # type: ignore
+
+    @property
+    def fingerprint(self) -> str:
+        """
+        Retrieve the unique SHA256 computed using the transformed (re-encoded) payload. Not the original one.
+        """
+        return sha256(self.output()).hexdigest()
+
+
+class CharsetMatches:
+    """
+    Container with every CharsetMatch items ordered by default from most probable to the less one.
+    Act like a list(iterable) but does not implements all related methods.
+    """
+
+    def __init__(self, results: Optional[List[CharsetMatch]] = None):
+        self._results: List[CharsetMatch] = sorted(results) if results else []
+
+    def __iter__(self) -> Iterator[CharsetMatch]:
+        yield from self._results
+
+    def __getitem__(self, item: Union[int, str]) -> CharsetMatch:
+        """
+        Retrieve a single item either by its position or encoding name (alias may be used here).
+        Raise KeyError upon invalid index or encoding not present in results.
+        """
+        if isinstance(item, int):
+            return self._results[item]
+        if isinstance(item, str):
+            item = iana_name(item, False)
+            for result in self._results:
+                if item in result.could_be_from_charset:
+                    return result
+        raise KeyError
+
+    def __len__(self) -> int:
+        return len(self._results)
+
+    def __bool__(self) -> bool:
+        return len(self._results) > 0
+
+    def append(self, item: CharsetMatch) -> None:
+        """
+        Insert a single match. Will be inserted accordingly to preserve sort.
+        Can be inserted as a submatch.
+        """
+        if not isinstance(item, CharsetMatch):
+            raise ValueError(
+                "Cannot append instance '{}' to CharsetMatches".format(
+                    str(item.__class__)
+                )
+            )
+        # We should disable the submatch factoring when the input file is too heavy (conserve RAM usage)
+        if len(item.raw) <= TOO_BIG_SEQUENCE:
+            for match in self._results:
+                if match.fingerprint == item.fingerprint and match.chaos == item.chaos:
+                    match.add_submatch(item)
+                    return
+        self._results.append(item)
+        self._results = sorted(self._results)
+
+    def best(self) -> Optional["CharsetMatch"]:
+        """
+        Simply return the first match. Strict equivalent to matches[0].
+        """
+        if not self._results:
+            return None
+        return self._results[0]
+
+    def first(self) -> Optional["CharsetMatch"]:
+        """
+        Redundant method, call the method best(). Kept for BC reasons.
+        """
+        return self.best()
+
+
+CoherenceMatch = Tuple[str, float]
+CoherenceMatches = List[CoherenceMatch]
+
+
+class CliDetectionResult:
+    def __init__(
+        self,
+        path: str,
+        encoding: Optional[str],
+        encoding_aliases: List[str],
+        alternative_encodings: List[str],
+        language: str,
+        alphabets: List[str],
+        has_sig_or_bom: bool,
+        chaos: float,
+        coherence: float,
+        unicode_path: Optional[str],
+        is_preferred: bool,
+    ):
+        self.path: str = path
+        self.unicode_path: Optional[str] = unicode_path
+        self.encoding: Optional[str] = encoding
+        self.encoding_aliases: List[str] = encoding_aliases
+        self.alternative_encodings: List[str] = alternative_encodings
+        self.language: str = language
+        self.alphabets: List[str] = alphabets
+        self.has_sig_or_bom: bool = has_sig_or_bom
+        self.chaos: float = chaos
+        self.coherence: float = coherence
+        self.is_preferred: bool = is_preferred
+
+    @property
+    def __dict__(self) -> Dict[str, Any]:  # type: ignore
+        return {
+            "path": self.path,
+            "encoding": self.encoding,
+            "encoding_aliases": self.encoding_aliases,
+            "alternative_encodings": self.alternative_encodings,
+            "language": self.language,
+            "alphabets": self.alphabets,
+            "has_sig_or_bom": self.has_sig_or_bom,
+            "chaos": self.chaos,
+            "coherence": self.coherence,
+            "unicode_path": self.unicode_path,
+            "is_preferred": self.is_preferred,
+        }
+
+    def to_json(self) -> str:
+        return dumps(self.__dict__, ensure_ascii=True, indent=4)
diff --git a/lib/python3.11/site-packages/charset_normalizer/py.typed b/lib/python3.11/site-packages/charset_normalizer/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/charset_normalizer/utils.py b/lib/python3.11/site-packages/charset_normalizer/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5cbbf4c0ddfa5c1b5898d8a4405e27292100d41
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/utils.py
@@ -0,0 +1,421 @@
+import importlib
+import logging
+import unicodedata
+from codecs import IncrementalDecoder
+from encodings.aliases import aliases
+from functools import lru_cache
+from re import findall
+from typing import Generator, List, Optional, Set, Tuple, Union
+
+from _multibytecodec import MultibyteIncrementalDecoder
+
+from .constant import (
+    ENCODING_MARKS,
+    IANA_SUPPORTED_SIMILAR,
+    RE_POSSIBLE_ENCODING_INDICATION,
+    UNICODE_RANGES_COMBINED,
+    UNICODE_SECONDARY_RANGE_KEYWORD,
+    UTF8_MAXIMAL_ALLOCATION,
+)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_accentuated(character: str) -> bool:
+    try:
+        description: str = unicodedata.name(character)
+    except ValueError:
+        return False
+    return (
+        "WITH GRAVE" in description
+        or "WITH ACUTE" in description
+        or "WITH CEDILLA" in description
+        or "WITH DIAERESIS" in description
+        or "WITH CIRCUMFLEX" in description
+        or "WITH TILDE" in description
+        or "WITH MACRON" in description
+        or "WITH RING ABOVE" in description
+    )
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def remove_accent(character: str) -> str:
+    decomposed: str = unicodedata.decomposition(character)
+    if not decomposed:
+        return character
+
+    codes: List[str] = decomposed.split(" ")
+
+    return chr(int(codes[0], 16))
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def unicode_range(character: str) -> Optional[str]:
+    """
+    Retrieve the Unicode range official name from a single character.
+    """
+    character_ord: int = ord(character)
+
+    for range_name, ord_range in UNICODE_RANGES_COMBINED.items():
+        if character_ord in ord_range:
+            return range_name
+
+    return None
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_latin(character: str) -> bool:
+    try:
+        description: str = unicodedata.name(character)
+    except ValueError:
+        return False
+    return "LATIN" in description
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_punctuation(character: str) -> bool:
+    character_category: str = unicodedata.category(character)
+
+    if "P" in character_category:
+        return True
+
+    character_range: Optional[str] = unicode_range(character)
+
+    if character_range is None:
+        return False
+
+    return "Punctuation" in character_range
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_symbol(character: str) -> bool:
+    character_category: str = unicodedata.category(character)
+
+    if "S" in character_category or "N" in character_category:
+        return True
+
+    character_range: Optional[str] = unicode_range(character)
+
+    if character_range is None:
+        return False
+
+    return "Forms" in character_range and character_category != "Lo"
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_emoticon(character: str) -> bool:
+    character_range: Optional[str] = unicode_range(character)
+
+    if character_range is None:
+        return False
+
+    return "Emoticons" in character_range or "Pictographs" in character_range
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_separator(character: str) -> bool:
+    if character.isspace() or character in {"｜", "+", "<", ">"}:
+        return True
+
+    character_category: str = unicodedata.category(character)
+
+    return "Z" in character_category or character_category in {"Po", "Pd", "Pc"}
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_case_variable(character: str) -> bool:
+    return character.islower() != character.isupper()
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_cjk(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "CJK" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_hiragana(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "HIRAGANA" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_katakana(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "KATAKANA" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_hangul(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "HANGUL" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_thai(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "THAI" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_arabic(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "ARABIC" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_arabic_isolated_form(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "ARABIC" in character_name and "ISOLATED FORM" in character_name
+
+
+@lru_cache(maxsize=len(UNICODE_RANGES_COMBINED))
+def is_unicode_range_secondary(range_name: str) -> bool:
+    return any(keyword in range_name for keyword in UNICODE_SECONDARY_RANGE_KEYWORD)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_unprintable(character: str) -> bool:
+    return (
+        character.isspace() is False  # includes \n \t \r \v
+        and character.isprintable() is False
+        and character != "\x1A"  # Why? Its the ASCII substitute character.
+        and character != "\ufeff"  # bug discovered in Python,
+        # Zero Width No-Break Space located in 	Arabic Presentation Forms-B, Unicode 1.1 not acknowledged as space.
+    )
+
+
+def any_specified_encoding(sequence: bytes, search_zone: int = 8192) -> Optional[str]:
+    """
+    Extract using ASCII-only decoder any specified encoding in the first n-bytes.
+    """
+    if not isinstance(sequence, bytes):
+        raise TypeError
+
+    seq_len: int = len(sequence)
+
+    results: List[str] = findall(
+        RE_POSSIBLE_ENCODING_INDICATION,
+        sequence[: min(seq_len, search_zone)].decode("ascii", errors="ignore"),
+    )
+
+    if len(results) == 0:
+        return None
+
+    for specified_encoding in results:
+        specified_encoding = specified_encoding.lower().replace("-", "_")
+
+        encoding_alias: str
+        encoding_iana: str
+
+        for encoding_alias, encoding_iana in aliases.items():
+            if encoding_alias == specified_encoding:
+                return encoding_iana
+            if encoding_iana == specified_encoding:
+                return encoding_iana
+
+    return None
+
+
+@lru_cache(maxsize=128)
+def is_multi_byte_encoding(name: str) -> bool:
+    """
+    Verify is a specific encoding is a multi byte one based on it IANA name
+    """
+    return name in {
+        "utf_8",
+        "utf_8_sig",
+        "utf_16",
+        "utf_16_be",
+        "utf_16_le",
+        "utf_32",
+        "utf_32_le",
+        "utf_32_be",
+        "utf_7",
+    } or issubclass(
+        importlib.import_module("encodings.{}".format(name)).IncrementalDecoder,
+        MultibyteIncrementalDecoder,
+    )
+
+
+def identify_sig_or_bom(sequence: bytes) -> Tuple[Optional[str], bytes]:
+    """
+    Identify and extract SIG/BOM in given sequence.
+    """
+
+    for iana_encoding in ENCODING_MARKS:
+        marks: Union[bytes, List[bytes]] = ENCODING_MARKS[iana_encoding]
+
+        if isinstance(marks, bytes):
+            marks = [marks]
+
+        for mark in marks:
+            if sequence.startswith(mark):
+                return iana_encoding, mark
+
+    return None, b""
+
+
+def should_strip_sig_or_bom(iana_encoding: str) -> bool:
+    return iana_encoding not in {"utf_16", "utf_32"}
+
+
+def iana_name(cp_name: str, strict: bool = True) -> str:
+    cp_name = cp_name.lower().replace("-", "_")
+
+    encoding_alias: str
+    encoding_iana: str
+
+    for encoding_alias, encoding_iana in aliases.items():
+        if cp_name in [encoding_alias, encoding_iana]:
+            return encoding_iana
+
+    if strict:
+        raise ValueError("Unable to retrieve IANA for '{}'".format(cp_name))
+
+    return cp_name
+
+
+def range_scan(decoded_sequence: str) -> List[str]:
+    ranges: Set[str] = set()
+
+    for character in decoded_sequence:
+        character_range: Optional[str] = unicode_range(character)
+
+        if character_range is None:
+            continue
+
+        ranges.add(character_range)
+
+    return list(ranges)
+
+
+def cp_similarity(iana_name_a: str, iana_name_b: str) -> float:
+    if is_multi_byte_encoding(iana_name_a) or is_multi_byte_encoding(iana_name_b):
+        return 0.0
+
+    decoder_a = importlib.import_module(
+        "encodings.{}".format(iana_name_a)
+    ).IncrementalDecoder
+    decoder_b = importlib.import_module(
+        "encodings.{}".format(iana_name_b)
+    ).IncrementalDecoder
+
+    id_a: IncrementalDecoder = decoder_a(errors="ignore")
+    id_b: IncrementalDecoder = decoder_b(errors="ignore")
+
+    character_match_count: int = 0
+
+    for i in range(255):
+        to_be_decoded: bytes = bytes([i])
+        if id_a.decode(to_be_decoded) == id_b.decode(to_be_decoded):
+            character_match_count += 1
+
+    return character_match_count / 254
+
+
+def is_cp_similar(iana_name_a: str, iana_name_b: str) -> bool:
+    """
+    Determine if two code page are at least 80% similar. IANA_SUPPORTED_SIMILAR dict was generated using
+    the function cp_similarity.
+    """
+    return (
+        iana_name_a in IANA_SUPPORTED_SIMILAR
+        and iana_name_b in IANA_SUPPORTED_SIMILAR[iana_name_a]
+    )
+
+
+def set_logging_handler(
+    name: str = "charset_normalizer",
+    level: int = logging.INFO,
+    format_string: str = "%(asctime)s | %(levelname)s | %(message)s",
+) -> None:
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(format_string))
+    logger.addHandler(handler)
+
+
+def cut_sequence_chunks(
+    sequences: bytes,
+    encoding_iana: str,
+    offsets: range,
+    chunk_size: int,
+    bom_or_sig_available: bool,
+    strip_sig_or_bom: bool,
+    sig_payload: bytes,
+    is_multi_byte_decoder: bool,
+    decoded_payload: Optional[str] = None,
+) -> Generator[str, None, None]:
+    if decoded_payload and is_multi_byte_decoder is False:
+        for i in offsets:
+            chunk = decoded_payload[i : i + chunk_size]
+            if not chunk:
+                break
+            yield chunk
+    else:
+        for i in offsets:
+            chunk_end = i + chunk_size
+            if chunk_end > len(sequences) + 8:
+                continue
+
+            cut_sequence = sequences[i : i + chunk_size]
+
+            if bom_or_sig_available and strip_sig_or_bom is False:
+                cut_sequence = sig_payload + cut_sequence
+
+            chunk = cut_sequence.decode(
+                encoding_iana,
+                errors="ignore" if is_multi_byte_decoder else "strict",
+            )
+
+            # multi-byte bad cutting detector and adjustment
+            # not the cleanest way to perform that fix but clever enough for now.
+            if is_multi_byte_decoder and i > 0:
+                chunk_partial_size_chk: int = min(chunk_size, 16)
+
+                if (
+                    decoded_payload
+                    and chunk[:chunk_partial_size_chk] not in decoded_payload
+                ):
+                    for j in range(i, i - 4, -1):
+                        cut_sequence = sequences[j:chunk_end]
+
+                        if bom_or_sig_available and strip_sig_or_bom is False:
+                            cut_sequence = sig_payload + cut_sequence
+
+                        chunk = cut_sequence.decode(encoding_iana, errors="ignore")
+
+                        if chunk[:chunk_partial_size_chk] in decoded_payload:
+                            break
+
+            yield chunk
diff --git a/lib/python3.11/site-packages/charset_normalizer/version.py b/lib/python3.11/site-packages/charset_normalizer/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a4da4ff49bc80ef49e8aa7e01cc8555518bd1b1
--- /dev/null
+++ b/lib/python3.11/site-packages/charset_normalizer/version.py
@@ -0,0 +1,6 @@
+"""
+Expose version
+"""
+
+__version__ = "3.3.2"
+VERSION = __version__.split(".")
diff --git a/lib/python3.11/site-packages/distutils-precedence.pth b/lib/python3.11/site-packages/distutils-precedence.pth
new file mode 100644
index 0000000000000000000000000000000000000000..c659194195f07bd6f19b5522515551309af14a3d
--- /dev/null
+++ b/lib/python3.11/site-packages/distutils-precedence.pth
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2638ce9e2500e572a5e0de7faed6661eb569d1b696fcba07b0dd223da5f5d224
+size 151
diff --git a/lib/python3.11/site-packages/filelock-3.13.1.dist-info/INSTALLER b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/filelock-3.13.1.dist-info/METADATA b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..f8bcc58eb2894b4de4655c4bd498bc043fb052c1
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/METADATA
@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: filelock
+Version: 3.13.1
+Summary: A platform independent file lock.
+Project-URL: Documentation, https://py-filelock.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/py-filelock
+Project-URL: Source, https://github.com/tox-dev/py-filelock
+Project-URL: Tracker, https://github.com/tox-dev/py-filelock/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License-Expression: Unlicense
+License-File: LICENSE
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System
+Requires-Python: >=3.8
+Provides-Extra: docs
+Requires-Dist: furo>=2023.9.10; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints!=1.23.4,>=1.24; extra == 'docs'
+Requires-Dist: sphinx>=7.2.6; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: covdefaults>=2.3; extra == 'testing'
+Requires-Dist: coverage>=7.3.2; extra == 'testing'
+Requires-Dist: diff-cover>=8; extra == 'testing'
+Requires-Dist: pytest-cov>=4.1; extra == 'testing'
+Requires-Dist: pytest-mock>=3.12; extra == 'testing'
+Requires-Dist: pytest-timeout>=2.2; extra == 'testing'
+Requires-Dist: pytest>=7.4.3; extra == 'testing'
+Provides-Extra: typing
+Requires-Dist: typing-extensions>=4.8; python_version < '3.11' and extra == 'typing'
+Description-Content-Type: text/markdown
+
+# filelock
+
+[![PyPI](https://img.shields.io/pypi/v/filelock)](https://pypi.org/project/filelock/)
+[![Supported Python
+versions](https://img.shields.io/pypi/pyversions/filelock.svg)](https://pypi.org/project/filelock/)
+[![Documentation
+status](https://readthedocs.org/projects/py-filelock/badge/?version=latest)](https://py-filelock.readthedocs.io/en/latest/?badge=latest)
+[![Code style:
+black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Downloads](https://static.pepy.tech/badge/filelock/month)](https://pepy.tech/project/filelock)
+[![check](https://github.com/tox-dev/py-filelock/actions/workflows/check.yml/badge.svg)](https://github.com/tox-dev/py-filelock/actions/workflows/check.yml)
+
+For more information checkout the [official documentation](https://py-filelock.readthedocs.io/en/latest/index.html).
diff --git a/lib/python3.11/site-packages/filelock-3.13.1.dist-info/RECORD b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..4e5a0ee35ae0ff75ae59a3e5ccc20d0ba05718d3
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/RECORD
@@ -0,0 +1,22 @@
+filelock-3.13.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.13.1.dist-info/METADATA,sha256=gi7LyG-dEuOBZC32wie-OOG0OkPZHABsn9rXvxuQlcA,2784
+filelock-3.13.1.dist-info/RECORD,,
+filelock-3.13.1.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
+filelock-3.13.1.dist-info/licenses/LICENSE,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210
+filelock/__init__.py,sha256=wAVZ_9_-3Y14xzzupRk5BTTRewFJekR2vf9oIx4M750,1213
+filelock/__pycache__/__init__.cpython-311.pyc,,
+filelock/__pycache__/_api.cpython-311.pyc,,
+filelock/__pycache__/_error.cpython-311.pyc,,
+filelock/__pycache__/_soft.cpython-311.pyc,,
+filelock/__pycache__/_unix.cpython-311.pyc,,
+filelock/__pycache__/_util.cpython-311.pyc,,
+filelock/__pycache__/_windows.cpython-311.pyc,,
+filelock/__pycache__/version.cpython-311.pyc,,
+filelock/_api.py,sha256=UsVWPEOOgFH1pR_6WMk2b5hWZ7nWhUPT5GZX9WuYaC8,11860
+filelock/_error.py,sha256=-5jMcjTu60YAvAO1UbqDD1GIEjVkwr8xCFwDBtMeYDg,787
+filelock/_soft.py,sha256=haqtc_TB_KJbYv2a8iuEAclKuM4fMG1vTcp28sK919c,1711
+filelock/_unix.py,sha256=ViG38PgJsIhT3xaArugvw0TPP6VWoP2VJj7FEIWypkg,2157
+filelock/_util.py,sha256=dBDlIj1dHL_juXX0Qqq6bZtyE53YZTN8GFhtyTV043o,1708
+filelock/_windows.py,sha256=eMKL8dZKrgekf5VYVGR14an29JGEInRtUO8ui9ABywg,2177
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=fmajg3X8ZdOn-UpUewARwK5cfYf4wP4Xa0DcHjigFYo,413
diff --git a/lib/python3.11/site-packages/filelock-3.13.1.dist-info/WHEEL b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..ba1a8af28bcccdacebb8c22dfda1537447a1a58a
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.18.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/lib/python3.11/site-packages/filelock-3.13.1.dist-info/licenses/LICENSE b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..cf1ab25da0349f84a3fdd40032f0ce99db813b8b
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock-3.13.1.dist-info/licenses/LICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>
diff --git a/lib/python3.11/site-packages/filelock/__init__.py b/lib/python3.11/site-packages/filelock/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cf3b507d7f908a3eff1b3e01db7164ee9209807
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/__init__.py
@@ -0,0 +1,51 @@
+"""
+A platform independent file lock that supports the with-statement.
+
+.. autodata:: filelock.__version__
+   :no-value:
+
+"""
+from __future__ import annotations
+
+import sys
+import warnings
+from typing import TYPE_CHECKING
+
+from ._api import AcquireReturnProxy, BaseFileLock
+from ._error import Timeout
+from ._soft import SoftFileLock
+from ._unix import UnixFileLock, has_fcntl
+from ._windows import WindowsFileLock
+from .version import version
+
+#: version of the project as a string
+__version__: str = version
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+    _FileLock: type[BaseFileLock] = WindowsFileLock
+else:  # pragma: win32 no cover # noqa: PLR5501
+    if has_fcntl:
+        _FileLock: type[BaseFileLock] = UnixFileLock
+    else:
+        _FileLock = SoftFileLock
+        if warnings is not None:
+            warnings.warn("only soft file lock is available", stacklevel=2)
+
+if TYPE_CHECKING:
+    FileLock = SoftFileLock
+else:
+    #: Alias for the lock, which should be used for the current platform.
+    FileLock = _FileLock
+
+
+__all__ = [
+    "__version__",
+    "FileLock",
+    "SoftFileLock",
+    "Timeout",
+    "UnixFileLock",
+    "WindowsFileLock",
+    "BaseFileLock",
+    "AcquireReturnProxy",
+]
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f046754e000ba8f4e2d66e34cc00c1647d735833
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/_api.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e688139f0b8553b3b38d9998cd63a54e4655a28a
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/_api.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/_error.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/_error.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7a1cf31b31df92b60bbd74e25be5a81a7658be07
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/_error.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/_soft.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/_soft.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3cf0698fd9300aec4697a35addc3b39caa097a80
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/_soft.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/_unix.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/_unix.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3423a5c0a298700e9ed62ec971ed2e529542f8a8
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/_unix.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/_util.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/_util.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..68de5a2b21aca4cad85fdcf6d31f00e90c34c66c
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/_util.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/_windows.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/_windows.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30bbdde5fc8090154299977e89bb33611b8c5975
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/_windows.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/__pycache__/version.cpython-311.pyc b/lib/python3.11/site-packages/filelock/__pycache__/version.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71437e6f7b3215dac22375b9c68b3c8345300c2e
Binary files /dev/null and b/lib/python3.11/site-packages/filelock/__pycache__/version.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/filelock/_api.py b/lib/python3.11/site-packages/filelock/_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e9cdbad2bca3a01ae1a79568af37852fc250242
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/_api.py
@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import time
+import warnings
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from threading import local
+from typing import TYPE_CHECKING, Any, ClassVar
+from weakref import WeakValueDictionary
+
+from ._error import Timeout
+
+if TYPE_CHECKING:
+    import sys
+    from types import TracebackType
+
+    if sys.version_info >= (3, 11):  # pragma: no cover (py311+)
+        from typing import Self
+    else:  # pragma: no cover (<py311)
+        from typing_extensions import Self
+
+
+_LOGGER = logging.getLogger("filelock")
+
+
+# This is a helper class which is returned by :meth:`BaseFileLock.acquire` and wraps the lock to make sure __enter__
+# is not called twice when entering the with statement. If we would simply return *self*, the lock would be acquired
+# again in the *__enter__* method of the BaseFileLock, but not released again automatically. issue #37 (memory leak)
+class AcquireReturnProxy:
+    """A context aware object that will release the lock file when exiting."""
+
+    def __init__(self, lock: BaseFileLock) -> None:
+        self.lock = lock
+
+    def __enter__(self) -> BaseFileLock:
+        return self.lock
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.lock.release()
+
+
+@dataclass
+class FileLockContext:
+    """A dataclass which holds the context for a ``BaseFileLock`` object."""
+
+    # The context is held in a separate class to allow optional use of thread local storage via the
+    # ThreadLocalFileContext class.
+
+    #: The path to the lock file.
+    lock_file: str
+
+    #: The default timeout value.
+    timeout: float
+
+    #: The mode for the lock files
+    mode: int
+
+    #: The file descriptor for the *_lock_file* as it is returned by the os.open() function, not None when lock held
+    lock_file_fd: int | None = None
+
+    #: The lock counter is used for implementing the nested locking mechanism.
+    lock_counter: int = 0  # When the lock is acquired is increased and the lock is only released, when this value is 0
+
+
+class ThreadLocalFileContext(FileLockContext, local):
+    """A thread local version of the ``FileLockContext`` class."""
+
+
+class BaseFileLock(ABC, contextlib.ContextDecorator):
+    """Abstract base class for a file lock object."""
+
+    _instances: ClassVar[WeakValueDictionary[str, BaseFileLock]] = WeakValueDictionary()
+
+    def __new__(  # noqa: PLR0913
+        cls,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,  # noqa: ARG003
+        mode: int = 0o644,  # noqa: ARG003
+        thread_local: bool = True,  # noqa: ARG003, FBT001, FBT002
+        *,
+        is_singleton: bool = False,
+        **kwargs: dict[str, Any],  # capture remaining kwargs for subclasses  # noqa: ARG003
+    ) -> Self:
+        """Create a new lock object or if specified return the singleton instance for the lock file."""
+        if not is_singleton:
+            return super().__new__(cls)
+
+        instance = cls._instances.get(str(lock_file))
+        if not instance:
+            instance = super().__new__(cls)
+            cls._instances[str(lock_file)] = instance
+
+        return instance  # type: ignore[return-value] # https://github.com/python/mypy/issues/15322
+
+    def __init__(  # noqa: PLR0913
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = 0o644,
+        thread_local: bool = True,  # noqa: FBT001, FBT002
+        *,
+        is_singleton: bool = False,
+    ) -> None:
+        """
+        Create a new lock object.
+
+        :param lock_file: path to the file
+        :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in \
+            the acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it \
+            to a negative value. A timeout of 0 means, that there is exactly one attempt to acquire the file lock.
+        :param mode: file permissions for the lockfile
+        :param thread_local: Whether this object's internal context should be thread local or not. If this is set to \
+            ``False`` then the lock will be reentrant across threads.
+        :param is_singleton: If this is set to ``True`` then only one instance of this class will be created \
+            per lock file. This is useful if you want to use the lock object for reentrant locking without needing \
+            to pass the same object around.
+        """
+        self._is_thread_local = thread_local
+        self._is_singleton = is_singleton
+
+        # Create the context. Note that external code should not work with the context directly  and should instead use
+        # properties of this class.
+        kwargs: dict[str, Any] = {
+            "lock_file": os.fspath(lock_file),
+            "timeout": timeout,
+            "mode": mode,
+        }
+        self._context: FileLockContext = (ThreadLocalFileContext if thread_local else FileLockContext)(**kwargs)
+
+    def is_thread_local(self) -> bool:
+        """:return: a flag indicating if this lock is thread local or not"""
+        return self._is_thread_local
+
+    @property
+    def is_singleton(self) -> bool:
+        """:return: a flag indicating if this lock is singleton or not"""
+        return self._is_singleton
+
+    @property
+    def lock_file(self) -> str:
+        """:return: path to the lock file"""
+        return self._context.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """
+        :return: the default timeout value, in seconds
+
+        .. versionadded:: 2.0.0
+        """
+        return self._context.timeout
+
+    @timeout.setter
+    def timeout(self, value: float | str) -> None:
+        """
+        Change the default timeout value.
+
+        :param value: the new value, in seconds
+        """
+        self._context.timeout = float(value)
+
+    @abstractmethod
+    def _acquire(self) -> None:
+        """If the file lock could be acquired, self._context.lock_file_fd holds the file descriptor of the lock file."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _release(self) -> None:
+        """Releases the lock and sets self._context.lock_file_fd to None."""
+        raise NotImplementedError
+
+    @property
+    def is_locked(self) -> bool:
+        """
+
+        :return: A boolean indicating if the lock file is holding the lock currently.
+
+        .. versionchanged:: 2.0.0
+
+            This was previously a method and is now a property.
+        """
+        return self._context.lock_file_fd is not None
+
+    @property
+    def lock_counter(self) -> int:
+        """:return: The number of times this lock has been acquired (but not yet released)."""
+        return self._context.lock_counter
+
+    def acquire(
+        self,
+        timeout: float | None = None,
+        poll_interval: float = 0.05,
+        *,
+        poll_intervall: float | None = None,
+        blocking: bool = True,
+    ) -> AcquireReturnProxy:
+        """
+        Try to acquire the file lock.
+
+        :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default :attr:`~timeout` is and
+         if ``timeout < 0``, there is no timeout and this method will block until the lock could be acquired
+        :param poll_interval: interval of trying to acquire the lock file
+        :param poll_intervall: deprecated, kept for backwards compatibility, use ``poll_interval`` instead
+        :param blocking: defaults to True. If False, function will return immediately if it cannot obtain a lock on the
+         first attempt. Otherwise, this method will block until the timeout expires or the lock is acquired.
+        :raises Timeout: if fails to acquire lock within the timeout period
+        :return: a context object that will unlock the file when the context is exited
+
+        .. code-block:: python
+
+            # You can use this method in the context manager (recommended)
+            with lock.acquire():
+                pass
+
+            # Or use an equivalent try-finally construct:
+            lock.acquire()
+            try:
+                pass
+            finally:
+                lock.release()
+
+        .. versionchanged:: 2.0.0
+
+            This method returns now a *proxy* object instead of *self*,
+            so that it can be used in a with statement without side effects.
+
+        """
+        # Use the default timeout, if no timeout is provided.
+        if timeout is None:
+            timeout = self._context.timeout
+
+        if poll_intervall is not None:
+            msg = "use poll_interval instead of poll_intervall"
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            poll_interval = poll_intervall
+
+        # Increment the number right at the beginning. We can still undo it, if something fails.
+        self._context.lock_counter += 1
+
+        lock_id = id(self)
+        lock_filename = self.lock_file
+        start_time = time.perf_counter()
+        try:
+            while True:
+                if not self.is_locked:
+                    _LOGGER.debug("Attempting to acquire lock %s on %s", lock_id, lock_filename)
+                    self._acquire()
+                if self.is_locked:
+                    _LOGGER.debug("Lock %s acquired on %s", lock_id, lock_filename)
+                    break
+                if blocking is False:
+                    _LOGGER.debug("Failed to immediately acquire lock %s on %s", lock_id, lock_filename)
+                    raise Timeout(lock_filename)  # noqa: TRY301
+                if 0 <= timeout < time.perf_counter() - start_time:
+                    _LOGGER.debug("Timeout on acquiring lock %s on %s", lock_id, lock_filename)
+                    raise Timeout(lock_filename)  # noqa: TRY301
+                msg = "Lock %s not acquired on %s, waiting %s seconds ..."
+                _LOGGER.debug(msg, lock_id, lock_filename, poll_interval)
+                time.sleep(poll_interval)
+        except BaseException:  # Something did go wrong, so decrement the counter.
+            self._context.lock_counter = max(0, self._context.lock_counter - 1)
+            raise
+        return AcquireReturnProxy(lock=self)
+
+    def release(self, force: bool = False) -> None:  # noqa: FBT001, FBT002
+        """
+        Releases the file lock. Please note, that the lock is only completely released, if the lock counter is 0. Also
+        note, that the lock file itself is not automatically deleted.
+
+        :param force: If true, the lock counter is ignored and the lock is released in every case/
+        """
+        if self.is_locked:
+            self._context.lock_counter -= 1
+
+            if self._context.lock_counter == 0 or force:
+                lock_id, lock_filename = id(self), self.lock_file
+
+                _LOGGER.debug("Attempting to release lock %s on %s", lock_id, lock_filename)
+                self._release()
+                self._context.lock_counter = 0
+                _LOGGER.debug("Lock %s released on %s", lock_id, lock_filename)
+
+    def __enter__(self) -> Self:
+        """
+        Acquire the lock.
+
+        :return: the lock object
+        """
+        self.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """
+        Release the lock.
+
+        :param exc_type: the exception type if raised
+        :param exc_value: the exception value if raised
+        :param traceback: the exception traceback if raised
+        """
+        self.release()
+
+    def __del__(self) -> None:
+        """Called when the lock object is deleted."""
+        self.release(force=True)
+
+
+__all__ = [
+    "BaseFileLock",
+    "AcquireReturnProxy",
+]
diff --git a/lib/python3.11/site-packages/filelock/_error.py b/lib/python3.11/site-packages/filelock/_error.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7ff08c0f508ad7077eb6ed1990898840c952b3a
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/_error.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class Timeout(TimeoutError):  # noqa: N818
+    """Raised when the lock could not be acquired in *timeout* seconds."""
+
+    def __init__(self, lock_file: str) -> None:
+        super().__init__()
+        self._lock_file = lock_file
+
+    def __reduce__(self) -> str | tuple[Any, ...]:
+        return self.__class__, (self._lock_file,)  # Properly pickle the exception
+
+    def __str__(self) -> str:
+        return f"The file lock '{self._lock_file}' could not be acquired."
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.lock_file!r})"
+
+    @property
+    def lock_file(self) -> str:
+        """:return: The path of the file lock."""
+        return self._lock_file
+
+
+__all__ = [
+    "Timeout",
+]
diff --git a/lib/python3.11/site-packages/filelock/_soft.py b/lib/python3.11/site-packages/filelock/_soft.py
new file mode 100644
index 0000000000000000000000000000000000000000..28c67f74cc82b8f55e47afd6a71972cc1fb95eb6
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/_soft.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import suppress
+from errno import EACCES, EEXIST
+from pathlib import Path
+
+from ._api import BaseFileLock
+from ._util import ensure_directory_exists, raise_on_not_writable_file
+
+
+class SoftFileLock(BaseFileLock):
+    """Simply watches the existence of the lock file."""
+
+    def _acquire(self) -> None:
+        raise_on_not_writable_file(self.lock_file)
+        ensure_directory_exists(self.lock_file)
+        # first check for exists and read-only mode as the open will mask this case as EEXIST
+        flags = (
+            os.O_WRONLY  # open for writing only
+            | os.O_CREAT
+            | os.O_EXCL  # together with above raise EEXIST if the file specified by filename exists
+            | os.O_TRUNC  # truncate the file to zero byte
+        )
+        try:
+            file_handler = os.open(self.lock_file, flags, self._context.mode)
+        except OSError as exception:  # re-raise unless expected exception
+            if not (
+                exception.errno == EEXIST  # lock already exist
+                or (exception.errno == EACCES and sys.platform == "win32")  # has no access to this lock
+            ):  # pragma: win32 no cover
+                raise
+        else:
+            self._context.lock_file_fd = file_handler
+
+    def _release(self) -> None:
+        assert self._context.lock_file_fd is not None  # noqa: S101
+        os.close(self._context.lock_file_fd)  # the lock file is definitely not None
+        self._context.lock_file_fd = None
+        with suppress(OSError):  # the file is already deleted and that's what we want
+            Path(self.lock_file).unlink()
+
+
+__all__ = [
+    "SoftFileLock",
+]
diff --git a/lib/python3.11/site-packages/filelock/_unix.py b/lib/python3.11/site-packages/filelock/_unix.py
new file mode 100644
index 0000000000000000000000000000000000000000..93ce3be58fbea2a736072cddb0dc5d6454395cc2
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/_unix.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import suppress
+from errno import ENOSYS
+from typing import cast
+
+from ._api import BaseFileLock
+from ._util import ensure_directory_exists
+
+#: a flag to indicate if the fcntl API is available
+has_fcntl = False
+if sys.platform == "win32":  # pragma: win32 cover
+
+    class UnixFileLock(BaseFileLock):
+        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+        def _acquire(self) -> None:
+            raise NotImplementedError
+
+        def _release(self) -> None:
+            raise NotImplementedError
+
+else:  # pragma: win32 no cover
+    try:
+        import fcntl
+    except ImportError:
+        pass
+    else:
+        has_fcntl = True
+
+    class UnixFileLock(BaseFileLock):
+        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+        def _acquire(self) -> None:
+            ensure_directory_exists(self.lock_file)
+            open_flags = os.O_RDWR | os.O_CREAT | os.O_TRUNC
+            fd = os.open(self.lock_file, open_flags, self._context.mode)
+            with suppress(PermissionError):  # This locked is not owned by this UID
+                os.fchmod(fd, self._context.mode)
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except OSError as exception:
+                os.close(fd)
+                if exception.errno == ENOSYS:  # NotImplemented error
+                    msg = "FileSystem does not appear to support flock; user SoftFileLock instead"
+                    raise NotImplementedError(msg) from exception
+            else:
+                self._context.lock_file_fd = fd
+
+        def _release(self) -> None:
+            # Do not remove the lockfile:
+            #   https://github.com/tox-dev/py-filelock/issues/31
+            #   https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
+            fd = cast(int, self._context.lock_file_fd)
+            self._context.lock_file_fd = None
+            fcntl.flock(fd, fcntl.LOCK_UN)
+            os.close(fd)
+
+
+__all__ = [
+    "has_fcntl",
+    "UnixFileLock",
+]
diff --git a/lib/python3.11/site-packages/filelock/_util.py b/lib/python3.11/site-packages/filelock/_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..543c1394678821cef6bdcbfeb59a545b99d0a7cf
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/_util.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import stat
+import sys
+from errno import EACCES, EISDIR
+from pathlib import Path
+
+
+def raise_on_not_writable_file(filename: str) -> None:
+    """
+    Raise an exception if attempting to open the file for writing would fail.
+    This is done so files that will never be writable can be separated from
+    files that are writable but currently locked
+    :param filename: file to check
+    :raises OSError: as if the file was opened for writing.
+    """
+    try:  # use stat to do exists + can write to check without race condition
+        file_stat = os.stat(filename)  # noqa: PTH116
+    except OSError:
+        return  # swallow does not exist or other errors
+
+    if file_stat.st_mtime != 0:  # if os.stat returns but modification is zero that's an invalid os.stat - ignore it
+        if not (file_stat.st_mode & stat.S_IWUSR):
+            raise PermissionError(EACCES, "Permission denied", filename)
+
+        if stat.S_ISDIR(file_stat.st_mode):
+            if sys.platform == "win32":  # pragma: win32 cover
+                # On Windows, this is PermissionError
+                raise PermissionError(EACCES, "Permission denied", filename)
+            else:  # pragma: win32 no cover # noqa: RET506
+                # On linux / macOS, this is IsADirectoryError
+                raise IsADirectoryError(EISDIR, "Is a directory", filename)
+
+
+def ensure_directory_exists(filename: Path | str) -> None:
+    """
+    Ensure the directory containing the file exists (create it if necessary)
+    :param filename: file.
+    """
+    Path(filename).parent.mkdir(parents=True, exist_ok=True)
+
+
+__all__ = [
+    "raise_on_not_writable_file",
+    "ensure_directory_exists",
+]
diff --git a/lib/python3.11/site-packages/filelock/_windows.py b/lib/python3.11/site-packages/filelock/_windows.py
new file mode 100644
index 0000000000000000000000000000000000000000..8db55dcbaa3e7bab091781b17ce22fde1fc239f2
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/_windows.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import suppress
+from errno import EACCES
+from pathlib import Path
+from typing import cast
+
+from ._api import BaseFileLock
+from ._util import ensure_directory_exists, raise_on_not_writable_file
+
+if sys.platform == "win32":  # pragma: win32 cover
+    import msvcrt
+
+    class WindowsFileLock(BaseFileLock):
+        """Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems."""
+
+        def _acquire(self) -> None:
+            raise_on_not_writable_file(self.lock_file)
+            ensure_directory_exists(self.lock_file)
+            flags = (
+                os.O_RDWR  # open for read and write
+                | os.O_CREAT  # create file if not exists
+                | os.O_TRUNC  # truncate file if not empty
+            )
+            try:
+                fd = os.open(self.lock_file, flags, self._context.mode)
+            except OSError as exception:
+                if exception.errno != EACCES:  # has no access to this lock
+                    raise
+            else:
+                try:
+                    msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+                except OSError as exception:
+                    os.close(fd)  # close file first
+                    if exception.errno != EACCES:  # file is already locked
+                        raise
+                else:
+                    self._context.lock_file_fd = fd
+
+        def _release(self) -> None:
+            fd = cast(int, self._context.lock_file_fd)
+            self._context.lock_file_fd = None
+            msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
+            os.close(fd)
+
+            with suppress(OSError):  # Probably another instance of the application hat acquired the file lock.
+                Path(self.lock_file).unlink()
+
+else:  # pragma: win32 no cover
+
+    class WindowsFileLock(BaseFileLock):
+        """Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems."""
+
+        def _acquire(self) -> None:
+            raise NotImplementedError
+
+        def _release(self) -> None:
+            raise NotImplementedError
+
+
+__all__ = [
+    "WindowsFileLock",
+]
diff --git a/lib/python3.11/site-packages/filelock/py.typed b/lib/python3.11/site-packages/filelock/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/filelock/version.py b/lib/python3.11/site-packages/filelock/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc9fc1550b3b64cc4ff85291e33b6cb0a745af97
--- /dev/null
+++ b/lib/python3.11/site-packages/filelock/version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '3.13.1'
+__version_tuple__ = version_tuple = (3, 13, 1)
diff --git a/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/INSTALLER b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/LICENSE b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..67590a5e5be5a5a2dde3fe53a7512e404a896c22
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2018, Martin Durant
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/METADATA b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..e94dd19dba46ab879c60b13813c4cf26bf959128
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/METADATA
@@ -0,0 +1,168 @@
+Metadata-Version: 2.1
+Name: fsspec
+Version: 2023.12.2
+Summary: File-system specification
+Home-page: https://github.com/fsspec/filesystem_spec
+Maintainer: Martin Durant
+Maintainer-email: mdurant@anaconda.com
+License: BSD
+Project-URL: Changelog, https://filesystem-spec.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://filesystem-spec.readthedocs.io/en/latest/
+Keywords: file
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: abfs
+Requires-Dist: adlfs ; extra == 'abfs'
+Provides-Extra: adl
+Requires-Dist: adlfs ; extra == 'adl'
+Provides-Extra: arrow
+Requires-Dist: pyarrow >=1 ; extra == 'arrow'
+Provides-Extra: dask
+Requires-Dist: dask ; extra == 'dask'
+Requires-Dist: distributed ; extra == 'dask'
+Provides-Extra: devel
+Requires-Dist: pytest ; extra == 'devel'
+Requires-Dist: pytest-cov ; extra == 'devel'
+Provides-Extra: dropbox
+Requires-Dist: dropboxdrivefs ; extra == 'dropbox'
+Requires-Dist: requests ; extra == 'dropbox'
+Requires-Dist: dropbox ; extra == 'dropbox'
+Provides-Extra: entrypoints
+Provides-Extra: full
+Requires-Dist: adlfs ; extra == 'full'
+Requires-Dist: aiohttp !=4.0.0a0,!=4.0.0a1 ; extra == 'full'
+Requires-Dist: dask ; extra == 'full'
+Requires-Dist: distributed ; extra == 'full'
+Requires-Dist: dropbox ; extra == 'full'
+Requires-Dist: dropboxdrivefs ; extra == 'full'
+Requires-Dist: fusepy ; extra == 'full'
+Requires-Dist: gcsfs ; extra == 'full'
+Requires-Dist: libarchive-c ; extra == 'full'
+Requires-Dist: ocifs ; extra == 'full'
+Requires-Dist: panel ; extra == 'full'
+Requires-Dist: paramiko ; extra == 'full'
+Requires-Dist: pyarrow >=1 ; extra == 'full'
+Requires-Dist: pygit2 ; extra == 'full'
+Requires-Dist: requests ; extra == 'full'
+Requires-Dist: s3fs ; extra == 'full'
+Requires-Dist: smbprotocol ; extra == 'full'
+Requires-Dist: tqdm ; extra == 'full'
+Provides-Extra: fuse
+Requires-Dist: fusepy ; extra == 'fuse'
+Provides-Extra: gcs
+Requires-Dist: gcsfs ; extra == 'gcs'
+Provides-Extra: git
+Requires-Dist: pygit2 ; extra == 'git'
+Provides-Extra: github
+Requires-Dist: requests ; extra == 'github'
+Provides-Extra: gs
+Requires-Dist: gcsfs ; extra == 'gs'
+Provides-Extra: gui
+Requires-Dist: panel ; extra == 'gui'
+Provides-Extra: hdfs
+Requires-Dist: pyarrow >=1 ; extra == 'hdfs'
+Provides-Extra: http
+Requires-Dist: requests ; extra == 'http'
+Requires-Dist: aiohttp !=4.0.0a0,!=4.0.0a1 ; extra == 'http'
+Provides-Extra: libarchive
+Requires-Dist: libarchive-c ; extra == 'libarchive'
+Provides-Extra: oci
+Requires-Dist: ocifs ; extra == 'oci'
+Provides-Extra: s3
+Requires-Dist: s3fs ; extra == 's3'
+Provides-Extra: sftp
+Requires-Dist: paramiko ; extra == 'sftp'
+Provides-Extra: smb
+Requires-Dist: smbprotocol ; extra == 'smb'
+Provides-Extra: ssh
+Requires-Dist: paramiko ; extra == 'ssh'
+Provides-Extra: tqdm
+Requires-Dist: tqdm ; extra == 'tqdm'
+
+# filesystem_spec
+
+[![PyPI version](https://badge.fury.io/py/fsspec.svg)](https://pypi.python.org/pypi/fsspec/)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/fsspec/badges/version.svg)](https://anaconda.org/conda-forge/fsspec)
+![Build](https://github.com/fsspec/filesystem_spec/workflows/CI/badge.svg)
+[![Docs](https://readthedocs.org/projects/filesystem-spec/badge/?version=latest)](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+[![PyPi downloads](https://img.shields.io/pypi/dm/fsspec?label=pypi%20downloads&style=flat)](https://pepy.tech/project/fsspec)
+
+A specification for pythonic filesystems.
+
+## Install
+
+```bash
+pip install fsspec
+```
+
+would install the base fsspec. Various optionally supported features might require specification of custom
+extra require, e.g. `pip install fsspec[ssh]` will install dependencies for `ssh` backends support.
+Use `pip install fsspec[full]` for installation of all known extra dependencies.
+
+Up-to-date package also provided through conda-forge distribution:
+
+```bash
+conda install -c conda-forge fsspec
+```
+
+
+## Purpose
+
+To produce a template or specification for a file-system interface, that specific implementations should follow,
+so that applications making use of them can rely on a common behaviour and not have to worry about the specific
+internal implementation decisions with any given backend. Many such implementations are included in this package,
+or in sister projects such as `s3fs` and `gcsfs`.
+
+In addition, if this is well-designed, then additional functionality, such as a key-value store or FUSE
+mounting of the file-system implementation may be available for all implementations "for free".
+
+## Documentation
+
+Please refer to [RTD](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+
+## Develop
+
+fsspec uses GitHub Actions for CI. Environment files can be found
+in the "ci/" directory. Note that the main environment is called "py38",
+but it is expected that the version of python installed be adjustable at
+CI runtime. For local use, pick a version suitable for you.
+
+### Testing
+
+Tests can be run in the dev environment, if activated, via ``pytest fsspec``.
+
+The full fsspec suite requires a system-level docker, docker-compose, and fuse
+installation. If only making changes to one backend implementation, it is
+not generally necessary to run all tests locally.
+
+It is expected that contributors ensure that any change to fsspec does not
+cause issues or regressions for either other fsspec-related packages such
+as gcsfs and s3fs, nor for downstream users of fsspec. The "downstream" CI
+run and corresponding environment file run a set of tests from the dask
+test suite, and very minimal tests against pandas and zarr from the
+test_downstream.py module in this repo.
+
+### Code Formatting
+
+fsspec uses [Black](https://black.readthedocs.io/en/stable) to ensure
+a consistent code format throughout the project.
+Run ``black fsspec`` from the root of the filesystem_spec repository to
+auto-format your code. Additionally, many editors have plugins that will apply
+``black`` as you edit files. ``black`` is included in the ``tox`` environments.
+
+Optionally, you may wish to setup [pre-commit hooks](https://pre-commit.com) to
+automatically run ``black`` when you make a git commit.
+Run ``pre-commit install --install-hooks`` from the root of the
+filesystem_spec repository to setup pre-commit hooks. ``black`` will now be run
+before you commit, reformatting any changed files. You can format without
+committing via ``pre-commit run`` or skip these checks with ``git commit
+--no-verify``.
diff --git a/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/RECORD b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..af83ab61141fdc44283058b126a5086d2c41a8b6
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/RECORD
@@ -0,0 +1,104 @@
+fsspec-2023.12.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+fsspec-2023.12.2.dist-info/LICENSE,sha256=LcNUls5TpzB5FcAIqESq1T53K0mzTN0ARFBnaRQH7JQ,1513
+fsspec-2023.12.2.dist-info/METADATA,sha256=toLeg14fW_MfA33P2NVIPEyWFL7k004pAolypgHrECQ,6829
+fsspec-2023.12.2.dist-info/RECORD,,
+fsspec-2023.12.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+fsspec-2023.12.2.dist-info/top_level.txt,sha256=blt2pDrQDwN3Gklcw13CSPLQRd6aaOgJ8AxqrW395MI,7
+fsspec/__init__.py,sha256=2kT62GfFK-AjgS-LgwSsCo_VA2IePvsyv8Ash5oiaFA,1982
+fsspec/__pycache__/__init__.cpython-311.pyc,,
+fsspec/__pycache__/_version.cpython-311.pyc,,
+fsspec/__pycache__/archive.cpython-311.pyc,,
+fsspec/__pycache__/asyn.cpython-311.pyc,,
+fsspec/__pycache__/caching.cpython-311.pyc,,
+fsspec/__pycache__/callbacks.cpython-311.pyc,,
+fsspec/__pycache__/compression.cpython-311.pyc,,
+fsspec/__pycache__/config.cpython-311.pyc,,
+fsspec/__pycache__/conftest.cpython-311.pyc,,
+fsspec/__pycache__/core.cpython-311.pyc,,
+fsspec/__pycache__/dircache.cpython-311.pyc,,
+fsspec/__pycache__/exceptions.cpython-311.pyc,,
+fsspec/__pycache__/fuse.cpython-311.pyc,,
+fsspec/__pycache__/generic.cpython-311.pyc,,
+fsspec/__pycache__/gui.cpython-311.pyc,,
+fsspec/__pycache__/mapping.cpython-311.pyc,,
+fsspec/__pycache__/parquet.cpython-311.pyc,,
+fsspec/__pycache__/registry.cpython-311.pyc,,
+fsspec/__pycache__/spec.cpython-311.pyc,,
+fsspec/__pycache__/transaction.cpython-311.pyc,,
+fsspec/__pycache__/utils.cpython-311.pyc,,
+fsspec/_version.py,sha256=Kf9CIUDExVlqHjn9lLOn0QJcfeRWAe0PFvFHkRzI9iA,501
+fsspec/archive.py,sha256=S__DzfZj-urAN3tp2W6jJ6YDiXG1fAl7FjvWUN73qIE,2386
+fsspec/asyn.py,sha256=wx6vr5eBJYdW7a2cyv-LkfWu5dCDCcAjcDKjp3ylgR0,36154
+fsspec/caching.py,sha256=N45pzJdD4w5FOX_sxGvHWirggPNB66JTGP1HH6fpSck,28781
+fsspec/callbacks.py,sha256=qmD1v-WWxWmTmcUkEadq-_F_n3OGp9JYarjupUq_j3o,6358
+fsspec/compression.py,sha256=Zrbbb_m2SCF427BMJRYbDKMuSZIIV2YqteoS7AdR8Sc,4867
+fsspec/config.py,sha256=LF4Zmu1vhJW7Je9Q-cwkRc3xP7Rhyy7Xnwj26Z6sv2g,4279
+fsspec/conftest.py,sha256=fVfx-NLrH_OZS1TIpYNoPzM7efEcMoL62reHOdYeFCA,1245
+fsspec/core.py,sha256=0yCj1Z5MhbSDIQiqFs49VORl9QaGwV6hp9bXdkIoPIo,22363
+fsspec/dircache.py,sha256=YzogWJrhEastHU7vWz-cJiJ7sdtLXFXhEpInGKd4EcM,2717
+fsspec/exceptions.py,sha256=s5eA2wIwzj-aeV0i_KDXsBaIhJJRKzmMGUGwuBHTnS4,348
+fsspec/fuse.py,sha256=66amOa6wdIbS0DMhhfAPUoOB37HPorfXD1izV0prmTY,10145
+fsspec/generic.py,sha256=2EcEegwdTLyQ2qSgz3Y6cbAuiWz7bybsEWai_XYkGtw,13457
+fsspec/gui.py,sha256=BEVFplRsQyakNeCWU-vyZBD-16x_flEe0XiDxXparEU,13913
+fsspec/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fsspec/implementations/__pycache__/__init__.cpython-311.pyc,,
+fsspec/implementations/__pycache__/arrow.cpython-311.pyc,,
+fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc,,
+fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc,,
+fsspec/implementations/__pycache__/cached.cpython-311.pyc,,
+fsspec/implementations/__pycache__/dask.cpython-311.pyc,,
+fsspec/implementations/__pycache__/data.cpython-311.pyc,,
+fsspec/implementations/__pycache__/dbfs.cpython-311.pyc,,
+fsspec/implementations/__pycache__/dirfs.cpython-311.pyc,,
+fsspec/implementations/__pycache__/ftp.cpython-311.pyc,,
+fsspec/implementations/__pycache__/git.cpython-311.pyc,,
+fsspec/implementations/__pycache__/github.cpython-311.pyc,,
+fsspec/implementations/__pycache__/http.cpython-311.pyc,,
+fsspec/implementations/__pycache__/jupyter.cpython-311.pyc,,
+fsspec/implementations/__pycache__/libarchive.cpython-311.pyc,,
+fsspec/implementations/__pycache__/local.cpython-311.pyc,,
+fsspec/implementations/__pycache__/memory.cpython-311.pyc,,
+fsspec/implementations/__pycache__/reference.cpython-311.pyc,,
+fsspec/implementations/__pycache__/sftp.cpython-311.pyc,,
+fsspec/implementations/__pycache__/smb.cpython-311.pyc,,
+fsspec/implementations/__pycache__/tar.cpython-311.pyc,,
+fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc,,
+fsspec/implementations/__pycache__/zip.cpython-311.pyc,,
+fsspec/implementations/arrow.py,sha256=1d-c5KceQJxm8QXML8fFXHvQx0wstG-tNJNsrgMX_CI,8240
+fsspec/implementations/cache_mapper.py,sha256=nE_sY3vw-jJbeBcAP6NGtacP3jHW_7EcG3yUSf0A-4Y,2502
+fsspec/implementations/cache_metadata.py,sha256=ZvyA7Y3KK-5Ct4E5pELzD6mH_5T03XqaKVT96qYDADU,8576
+fsspec/implementations/cached.py,sha256=jCQSAIiO7M8OOmwG4cCYn4LGvMVCbldC9j7GeonwoEc,30238
+fsspec/implementations/dask.py,sha256=CXZbJzIVOhKV8ILcxuy3bTvcacCueAbyQxmvAkbPkrk,4466
+fsspec/implementations/data.py,sha256=Oti0dKzyeadnVIedo3s8CADoh9bNM-96_6viTEYr4lo,1245
+fsspec/implementations/dbfs.py,sha256=0ndCE2OQqrWv6Y8ETufxOQ9ymIIO2JA_Q82bnilqTaw,14660
+fsspec/implementations/dirfs.py,sha256=8EEgKin5JgFBqzHaKig7ipiFAZJvbChUX_vpC_jagoY,11136
+fsspec/implementations/ftp.py,sha256=FzcHeieyda-ai_D8w4YKCzvI4gshuFYlBACBuEIx2Nk,11419
+fsspec/implementations/git.py,sha256=vKGI-Vd5q4H2RrvhebkPc9NwlfkZ980OUGhebeCw-M0,4034
+fsspec/implementations/github.py,sha256=hCisC1vXzZ9kP1UnyGz2Ba8c9cS2JmSGFHtgHG_2Gqw,7190
+fsspec/implementations/http.py,sha256=cK7HQdVgR8PVLWkB0q0xsXohOP16X-zQiT2uqB1Kq4E,29265
+fsspec/implementations/jupyter.py,sha256=B2uj7OEm7yIk-vRSsO37_ND0t0EBvn4B-Su43ibN4Pg,3811
+fsspec/implementations/libarchive.py,sha256=5_I2DiLXwQ1JC8x-K7jXu-tBwhO9dj7tFLnb0bTnVMQ,7102
+fsspec/implementations/local.py,sha256=GV5OltZrz9aOM8KKSx3T7QE7-U9KX3BOz3Eql3jw_xY,13371
+fsspec/implementations/memory.py,sha256=-a-NR66T-sGj9xTInUsu8KsEiqd156bF8Ui9BuXfmEA,9698
+fsspec/implementations/reference.py,sha256=BHhvx8LIYyBk5OVBWw-PmZsAs_OCaLvF1p8656bwVJE,42438
+fsspec/implementations/sftp.py,sha256=TNmXVac9c5H9Gmiee2EjZNKXnXdkwwaNL2cHDkp_gG4,5632
+fsspec/implementations/smb.py,sha256=k3RtzW97lJtYuw_QpP1rJRFnUBmSsw9twFjUCex0a5U,10591
+fsspec/implementations/tar.py,sha256=dam78Tp_CozybNqCY2JYgGBS3Uc9FuJUAT9oB0lolOs,4111
+fsspec/implementations/webhdfs.py,sha256=C5T96C_p66pUf2cQda-7HIZ9fKYwfCkupf2LN_7n7Dw,16145
+fsspec/implementations/zip.py,sha256=JDX-3HOI15qUl6VTBsNPuDp5RVN6s2n3Bywd4mMu0T0,4347
+fsspec/mapping.py,sha256=WFEXRWxujQwfzzkRP5tpdIE0265okAtlP97qFZGvV1k,8165
+fsspec/parquet.py,sha256=i4H3EU3K1Q6jp8sqjFji6a6gKnlOEZufaa7DRNE5X-4,19516
+fsspec/registry.py,sha256=-dl7sh2tsfhMA2uxz5KQDsPFehQTgMJIbVjNq6QLoKU,11145
+fsspec/spec.py,sha256=kfZpvKoh-fftKG6cOkOi2k0PJJwRqV4ZX_NElCBdcB8,66154
+fsspec/tests/abstract/__init__.py,sha256=i1wcFixV6QhOwdoB24c8oXjzobISNqiKVz9kl2DvAY8,10028
+fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/common.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/get.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/put.cpython-311.pyc,,
+fsspec/tests/abstract/common.py,sha256=1GQwNo5AONzAnzZj0fWgn8NJPLXALehbsuGxS3FzWVU,4973
+fsspec/tests/abstract/copy.py,sha256=nyCp1Q9apHzti2_UPDh3HzVhRmV7dciD-3dq-wM7JuU,19643
+fsspec/tests/abstract/get.py,sha256=vNR4HztvTR7Cj56AMo7_tx7TeYz1Jgr_2Wb8Lv-UiBY,20755
+fsspec/tests/abstract/put.py,sha256=hEf-yuMWBOT7B6eWcck3tMyJWzdVXtxkY-O6LUt1KAE,20877
+fsspec/transaction.py,sha256=jeexB-H6Aw_gN6Z7hoKKe6v8zizITq39-gyTgpipIKE,2251
+fsspec/utils.py,sha256=_VX_0VwDtoAFSjMYrxvJvnPNX9FMoHO5BlFHXJ0bHFI,23053
diff --git a/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/WHEEL b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..98c0d20b7a64f4f998d7913e1d38a05dba20916c
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/top_level.txt b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..968fea66e533ba30593c7fbfe750c36fae2f3cfe
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec-2023.12.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+fsspec
diff --git a/lib/python3.11/site-packages/fsspec/__init__.py b/lib/python3.11/site-packages/fsspec/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c49eee5c90b7f5648df27aa6a824674672dfcfb
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/__init__.py
@@ -0,0 +1,69 @@
+from importlib.metadata import entry_points
+
+from . import _version, caching
+from .callbacks import Callback
+from .compression import available_compressions
+from .core import get_fs_token_paths, open, open_files, open_local
+from .exceptions import FSTimeoutError
+from .mapping import FSMap, get_mapper
+from .registry import (
+    available_protocols,
+    filesystem,
+    get_filesystem_class,
+    register_implementation,
+    registry,
+)
+from .spec import AbstractFileSystem
+
+__version__ = _version.get_versions()["version"]
+
+__all__ = [
+    "AbstractFileSystem",
+    "FSTimeoutError",
+    "FSMap",
+    "filesystem",
+    "register_implementation",
+    "get_filesystem_class",
+    "get_fs_token_paths",
+    "get_mapper",
+    "open",
+    "open_files",
+    "open_local",
+    "registry",
+    "caching",
+    "Callback",
+    "available_protocols",
+    "available_compressions",
+]
+
+
+def process_entries():
+    if entry_points is not None:
+        try:
+            eps = entry_points()
+        except TypeError:
+            pass  # importlib-metadata < 0.8
+        else:
+            if hasattr(eps, "select"):  # Python 3.10+ / importlib_metadata >= 3.9.0
+                specs = eps.select(group="fsspec.specs")
+            else:
+                specs = eps.get("fsspec.specs", [])
+            registered_names = {}
+            for spec in specs:
+                err_msg = f"Unable to load filesystem from {spec}"
+                name = spec.name
+                if name in registered_names:
+                    continue
+                registered_names[name] = True
+                register_implementation(
+                    name,
+                    spec.value.replace(":", "."),
+                    errtxt=err_msg,
+                    # We take our implementations as the ones to overload with if
+                    # for some reason we encounter some, may be the same, already
+                    # registered
+                    clobber=True,
+                )
+
+
+process_entries()
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07bccfc0dbdbbdbadea0340cf3163f35467a6f68
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/_version.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/_version.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3710a8b01c5c2c3bd014a7fc596471be76855011
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/_version.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/archive.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/archive.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f135404020f9c83d6fc2b0724cef59cefced3cee
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/archive.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/asyn.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/asyn.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2628257149756f804e939668629cd87b3b898f6
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/asyn.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/caching.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/caching.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a377e951d5584bd92be4f8e30bb3a96b8d32b910
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/caching.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/callbacks.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/callbacks.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4eb69fbb3ee96b6a59140ed08c86b6358095dda3
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/callbacks.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/compression.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/compression.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d4c79eea2a1e5b71e81567de2ae8c3d73622ac68
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/compression.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/config.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/config.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..04749cd72dd85a3fefbe83fd9c8786e72a99f870
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/config.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/conftest.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/conftest.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36b54f6a38d99c416006b6c8aed0a5d3a8d7733e
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/conftest.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/core.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/core.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94d157fa70c8e3ee706f068c1b370d6c3b461596
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/core.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/dircache.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/dircache.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..352069e5384cfde6c50fc524570dd130b2804b11
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/dircache.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/exceptions.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f0b37005285747bc08ecc3dd7bce800b9307268
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/exceptions.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/fuse.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/fuse.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43c3308d36f96e6a08248e96be2d164a2984ebe6
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/fuse.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/generic.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/generic.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a6c7898b1878d84bd158ffb8a58f2cccff478a8
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/generic.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/gui.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/gui.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e4fde9e664df605fd6afc682e540e08af31e0a1d
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/gui.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/mapping.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/mapping.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e72d4223d44996a4088ce981a6447bb63719c85
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/mapping.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/parquet.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/parquet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..acaf4eb45da2aad1e2d5f5a4f1b83e270b036314
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/parquet.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/registry.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/registry.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bdaceb59b9da2b9e67d832b558d1a976f7cbf0fa
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/registry.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc376e646ef60b2396362fe26c9801093b98c716
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/transaction.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/transaction.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dc030f9b5bb76db8741dcf999d31ebdea8f98ca1
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/transaction.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/__pycache__/utils.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cacf57420f17724d7e3b1fe78e75c2835b75dfb6
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/__pycache__/utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/_version.py b/lib/python3.11/site-packages/fsspec/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d350fe1f20f8f6269cdd6e1a57dffe0f2af12ff
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/_version.py
@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2023-12-11T16:18:48-0500",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "dd8cb9bf620be4d9153e854dd1431c23a2be6db0",
+ "version": "2023.12.2"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)
diff --git a/lib/python3.11/site-packages/fsspec/archive.py b/lib/python3.11/site-packages/fsspec/archive.py
new file mode 100644
index 0000000000000000000000000000000000000000..f466780fc802d6aa79be02a2af3424c051503708
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/archive.py
@@ -0,0 +1,73 @@
+from fsspec import AbstractFileSystem
+from fsspec.utils import tokenize
+
+
+class AbstractArchiveFileSystem(AbstractFileSystem):
+    """
+    A generic superclass for implementing Archive-based filesystems.
+
+    Currently, it is shared amongst
+    :class:`~fsspec.implementations.zip.ZipFileSystem`,
+    :class:`~fsspec.implementations.libarchive.LibArchiveFileSystem` and
+    :class:`~fsspec.implementations.tar.TarFileSystem`.
+    """
+
+    def __str__(self):
+        return f"<Archive-like object {type(self).__name__} at {id(self)}>"
+
+    __repr__ = __str__
+
+    def ukey(self, path):
+        return tokenize(path, self.fo, self.protocol)
+
+    def _all_dirnames(self, paths):
+        """Returns *all* directory names for each path in paths, including intermediate
+        ones.
+
+        Parameters
+        ----------
+        paths: Iterable of path strings
+        """
+        if len(paths) == 0:
+            return set()
+
+        dirnames = {self._parent(path) for path in paths} - {self.root_marker}
+        return dirnames | self._all_dirnames(dirnames)
+
+    def info(self, path, **kwargs):
+        self._get_dirs()
+        path = self._strip_protocol(path)
+        if path in {"", "/"} and self.dir_cache:
+            return {"name": "", "type": "directory", "size": 0}
+        if path in self.dir_cache:
+            return self.dir_cache[path]
+        elif path + "/" in self.dir_cache:
+            return self.dir_cache[path + "/"]
+        else:
+            raise FileNotFoundError(path)
+
+    def ls(self, path, detail=True, **kwargs):
+        self._get_dirs()
+        paths = {}
+        for p, f in self.dir_cache.items():
+            p = p.rstrip("/")
+            if "/" in p:
+                root = p.rsplit("/", 1)[0]
+            else:
+                root = ""
+            if root == path.rstrip("/"):
+                paths[p] = f
+            elif all(
+                (a == b)
+                for a, b in zip(path.split("/"), [""] + p.strip("/").split("/"))
+            ):
+                # root directory entry
+                ppath = p.rstrip("/").split("/", 1)[0]
+                if ppath not in paths:
+                    out = {"name": ppath, "size": 0, "type": "directory"}
+                    paths[ppath] = out
+        if detail:
+            out = sorted(paths.values(), key=lambda _: _["name"])
+            return out
+        else:
+            return sorted(paths)
diff --git a/lib/python3.11/site-packages/fsspec/asyn.py b/lib/python3.11/site-packages/fsspec/asyn.py
new file mode 100644
index 0000000000000000000000000000000000000000..d19836a1e3edb9eaacb63566e5b5882cfebfb627
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/asyn.py
@@ -0,0 +1,1081 @@
+import asyncio
+import asyncio.events
+import functools
+import inspect
+import io
+import numbers
+import os
+import re
+import threading
+from contextlib import contextmanager
+from glob import has_magic
+from typing import TYPE_CHECKING, Iterable
+
+from .callbacks import _DEFAULT_CALLBACK
+from .exceptions import FSTimeoutError
+from .implementations.local import LocalFileSystem, make_path_posix, trailing_sep
+from .spec import AbstractBufferedFile, AbstractFileSystem
+from .utils import glob_translate, is_exception, other_paths
+
+private = re.compile("_[^_]")
+iothread = [None]  # dedicated fsspec IO thread
+loop = [None]  # global event loop for any non-async instance
+_lock = None  # global lock placeholder
+get_running_loop = asyncio.get_running_loop
+
+
+def get_lock():
+    """Allocate or return a threading lock.
+
+    The lock is allocated on first use to allow setting one lock per forked process.
+    """
+    global _lock
+    if not _lock:
+        _lock = threading.Lock()
+    return _lock
+
+
+def reset_lock():
+    """Reset the global lock.
+
+    This should be called only on the init of a forked process to reset the lock to
+    None, enabling the new forked process to get a new lock.
+    """
+    global _lock
+
+    iothread[0] = None
+    loop[0] = None
+    _lock = None
+
+
+async def _runner(event, coro, result, timeout=None):
+    timeout = timeout if timeout else None  # convert 0 or 0.0 to None
+    if timeout is not None:
+        coro = asyncio.wait_for(coro, timeout=timeout)
+    try:
+        result[0] = await coro
+    except Exception as ex:
+        result[0] = ex
+    finally:
+        event.set()
+
+
+def sync(loop, func, *args, timeout=None, **kwargs):
+    """
+    Make loop run coroutine until it returns. Runs in other thread
+
+    Examples
+    --------
+    >>> fsspec.asyn.sync(fsspec.asyn.get_loop(), func, *args,
+                         timeout=timeout, **kwargs)
+    """
+    timeout = timeout if timeout else None  # convert 0 or 0.0 to None
+    # NB: if the loop is not running *yet*, it is OK to submit work
+    # and we will wait for it
+    if loop is None or loop.is_closed():
+        raise RuntimeError("Loop is not running")
+    try:
+        loop0 = asyncio.events.get_running_loop()
+        if loop0 is loop:
+            raise NotImplementedError("Calling sync() from within a running loop")
+    except NotImplementedError:
+        raise
+    except RuntimeError:
+        pass
+    coro = func(*args, **kwargs)
+    result = [None]
+    event = threading.Event()
+    asyncio.run_coroutine_threadsafe(_runner(event, coro, result, timeout), loop)
+    while True:
+        # this loops allows thread to get interrupted
+        if event.wait(1):
+            break
+        if timeout is not None:
+            timeout -= 1
+            if timeout < 0:
+                raise FSTimeoutError
+
+    return_result = result[0]
+    if isinstance(return_result, asyncio.TimeoutError):
+        # suppress asyncio.TimeoutError, raise FSTimeoutError
+        raise FSTimeoutError from return_result
+    elif isinstance(return_result, BaseException):
+        raise return_result
+    else:
+        return return_result
+
+
+def sync_wrapper(func, obj=None):
+    """Given a function, make so can be called in blocking contexts
+
+    Leave obj=None if defining within a class. Pass the instance if attaching
+    as an attribute of the instance.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        self = obj or args[0]
+        return sync(self.loop, func, *args, **kwargs)
+
+    return wrapper
+
+
+@contextmanager
+def _selector_policy():
+    original_policy = asyncio.get_event_loop_policy()
+    try:
+        if os.name == "nt" and hasattr(asyncio, "WindowsSelectorEventLoopPolicy"):
+            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+        yield
+    finally:
+        asyncio.set_event_loop_policy(original_policy)
+
+
+def get_loop():
+    """Create or return the default fsspec IO loop
+
+    The loop will be running on a separate thread.
+    """
+    if loop[0] is None:
+        with get_lock():
+            # repeat the check just in case the loop got filled between the
+            # previous two calls from another thread
+            if loop[0] is None:
+                with _selector_policy():
+                    loop[0] = asyncio.new_event_loop()
+                th = threading.Thread(target=loop[0].run_forever, name="fsspecIO")
+                th.daemon = True
+                th.start()
+                iothread[0] = th
+    return loop[0]
+
+
+if TYPE_CHECKING:
+    import resource
+
+    ResourceError = resource.error
+else:
+    try:
+        import resource
+    except ImportError:
+        resource = None
+        ResourceError = OSError
+    else:
+        ResourceError = getattr(resource, "error", OSError)
+
+_DEFAULT_BATCH_SIZE = 128
+_NOFILES_DEFAULT_BATCH_SIZE = 1280
+
+
+def _get_batch_size(nofiles=False):
+    from fsspec.config import conf
+
+    if nofiles:
+        if "nofiles_gather_batch_size" in conf:
+            return conf["nofiles_gather_batch_size"]
+    else:
+        if "gather_batch_size" in conf:
+            return conf["gather_batch_size"]
+    if nofiles:
+        return _NOFILES_DEFAULT_BATCH_SIZE
+    if resource is None:
+        return _DEFAULT_BATCH_SIZE
+
+    try:
+        soft_limit, _ = resource.getrlimit(resource.RLIMIT_NOFILE)
+    except (ImportError, ValueError, ResourceError):
+        return _DEFAULT_BATCH_SIZE
+
+    if soft_limit == resource.RLIM_INFINITY:
+        return -1
+    else:
+        return soft_limit // 8
+
+
+def running_async() -> bool:
+    """Being executed by an event loop?"""
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
+
+async def _run_coros_in_chunks(
+    coros,
+    batch_size=None,
+    callback=_DEFAULT_CALLBACK,
+    timeout=None,
+    return_exceptions=False,
+    nofiles=False,
+):
+    """Run the given coroutines in  chunks.
+
+    Parameters
+    ----------
+    coros: list of coroutines to run
+    batch_size: int or None
+        Number of coroutines to submit/wait on simultaneously.
+        If -1, then it will not be any throttling. If
+        None, it will be inferred from _get_batch_size()
+    callback: fsspec.callbacks.Callback instance
+        Gets a relative_update when each coroutine completes
+    timeout: number or None
+        If given, each coroutine times out after this time. Note that, since
+        there are multiple batches, the total run time of this function will in
+        general be longer
+    return_exceptions: bool
+        Same meaning as in asyncio.gather
+    nofiles: bool
+        If inferring the batch_size, does this operation involve local files?
+        If yes, you normally expect smaller batches.
+    """
+
+    if batch_size is None:
+        batch_size = _get_batch_size(nofiles=nofiles)
+
+    if batch_size == -1:
+        batch_size = len(coros)
+
+    assert batch_size > 0
+    results = []
+    for start in range(0, len(coros), batch_size):
+        chunk = [
+            asyncio.Task(asyncio.wait_for(c, timeout=timeout))
+            for c in coros[start : start + batch_size]
+        ]
+        if callback is not _DEFAULT_CALLBACK:
+            [
+                t.add_done_callback(lambda *_, **__: callback.relative_update(1))
+                for t in chunk
+            ]
+        results.extend(
+            await asyncio.gather(*chunk, return_exceptions=return_exceptions),
+        )
+    return results
+
+
+# these methods should be implemented as async by any async-able backend
+async_methods = [
+    "_ls",
+    "_cat_file",
+    "_get_file",
+    "_put_file",
+    "_rm_file",
+    "_cp_file",
+    "_pipe_file",
+    "_expand_path",
+    "_info",
+    "_isfile",
+    "_isdir",
+    "_exists",
+    "_walk",
+    "_glob",
+    "_find",
+    "_du",
+    "_size",
+    "_mkdir",
+    "_makedirs",
+]
+
+
+class AsyncFileSystem(AbstractFileSystem):
+    """Async file operations, default implementations
+
+    Passes bulk operations to asyncio.gather for concurrent operation.
+
+    Implementations that have concurrent batch operations and/or async methods
+    should inherit from this class instead of AbstractFileSystem. Docstrings are
+    copied from the un-underscored method in AbstractFileSystem, if not given.
+    """
+
+    # note that methods do not have docstring here; they will be copied
+    # for _* methods and inferred for overridden methods.
+
+    async_impl = True
+    mirror_sync_methods = True
+    disable_throttling = False
+
+    def __init__(self, *args, asynchronous=False, loop=None, batch_size=None, **kwargs):
+        self.asynchronous = asynchronous
+        self._pid = os.getpid()
+        if not asynchronous:
+            self._loop = loop or get_loop()
+        else:
+            self._loop = None
+        self.batch_size = batch_size
+        super().__init__(*args, **kwargs)
+
+    @property
+    def loop(self):
+        if self._pid != os.getpid():
+            raise RuntimeError("This class is not fork-safe")
+        return self._loop
+
+    async def _rm_file(self, path, **kwargs):
+        raise NotImplementedError
+
+    async def _rm(self, path, recursive=False, batch_size=None, **kwargs):
+        # TODO: implement on_error
+        batch_size = batch_size or self.batch_size
+        path = await self._expand_path(path, recursive=recursive)
+        return await _run_coros_in_chunks(
+            [self._rm_file(p, **kwargs) for p in reversed(path)],
+            batch_size=batch_size,
+            nofiles=True,
+        )
+
+    async def _cp_file(self, path1, path2, **kwargs):
+        raise NotImplementedError
+
+    async def _copy(
+        self,
+        path1,
+        path2,
+        recursive=False,
+        on_error=None,
+        maxdepth=None,
+        batch_size=None,
+        **kwargs,
+    ):
+        if on_error is None and recursive:
+            on_error = "ignore"
+        elif on_error is None:
+            on_error = "raise"
+
+        if isinstance(path1, list) and isinstance(path2, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            paths1 = path1
+            paths2 = path2
+        else:
+            source_is_str = isinstance(path1, str)
+            paths1 = await self._expand_path(
+                path1, maxdepth=maxdepth, recursive=recursive
+            )
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                paths1 = [
+                    p for p in paths1 if not (trailing_sep(p) or await self._isdir(p))
+                ]
+                if not paths1:
+                    return
+
+            source_is_file = len(paths1) == 1
+            dest_is_dir = isinstance(path2, str) and (
+                trailing_sep(path2) or await self._isdir(path2)
+            )
+
+            exists = source_is_str and (
+                (has_magic(path1) and source_is_file)
+                or (not has_magic(path1) and dest_is_dir and not trailing_sep(path1))
+            )
+            paths2 = other_paths(
+                paths1,
+                path2,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        batch_size = batch_size or self.batch_size
+        coros = [self._cp_file(p1, p2, **kwargs) for p1, p2 in zip(paths1, paths2)]
+        result = await _run_coros_in_chunks(
+            coros, batch_size=batch_size, return_exceptions=True, nofiles=True
+        )
+
+        for ex in filter(is_exception, result):
+            if on_error == "ignore" and isinstance(ex, FileNotFoundError):
+                continue
+            raise ex
+
+    async def _pipe_file(self, path, value, **kwargs):
+        raise NotImplementedError
+
+    async def _pipe(self, path, value=None, batch_size=None, **kwargs):
+        if isinstance(path, str):
+            path = {path: value}
+        batch_size = batch_size or self.batch_size
+        return await _run_coros_in_chunks(
+            [self._pipe_file(k, v, **kwargs) for k, v in path.items()],
+            batch_size=batch_size,
+            nofiles=True,
+        )
+
+    async def _process_limits(self, url, start, end):
+        """Helper for "Range"-based _cat_file"""
+        size = None
+        suff = False
+        if start is not None and start < 0:
+            # if start is negative and end None, end is the "suffix length"
+            if end is None:
+                end = -start
+                start = ""
+                suff = True
+            else:
+                size = size or (await self._info(url))["size"]
+                start = size + start
+        elif start is None:
+            start = 0
+        if not suff:
+            if end is not None and end < 0:
+                if start is not None:
+                    size = size or (await self._info(url))["size"]
+                    end = size + end
+            elif end is None:
+                end = ""
+            if isinstance(end, numbers.Integral):
+                end -= 1  # bytes range is inclusive
+        return f"bytes={start}-{end}"
+
+    async def _cat_file(self, path, start=None, end=None, **kwargs):
+        raise NotImplementedError
+
+    async def _cat(
+        self, path, recursive=False, on_error="raise", batch_size=None, **kwargs
+    ):
+        paths = await self._expand_path(path, recursive=recursive)
+        coros = [self._cat_file(path, **kwargs) for path in paths]
+        batch_size = batch_size or self.batch_size
+        out = await _run_coros_in_chunks(
+            coros, batch_size=batch_size, nofiles=True, return_exceptions=True
+        )
+        if on_error == "raise":
+            ex = next(filter(is_exception, out), False)
+            if ex:
+                raise ex
+        if (
+            len(paths) > 1
+            or isinstance(path, list)
+            or paths[0] != self._strip_protocol(path)
+        ):
+            return {
+                k: v
+                for k, v in zip(paths, out)
+                if on_error != "omit" or not is_exception(v)
+            }
+        else:
+            return out[0]
+
+    async def _cat_ranges(
+        self,
+        paths,
+        starts,
+        ends,
+        max_gap=None,
+        batch_size=None,
+        on_error="return",
+        **kwargs,
+    ):
+        """Get the contents of byte ranges from one or more files
+
+        Parameters
+        ----------
+        paths: list
+            A list of of filepaths on this filesystems
+        starts, ends: int or list
+            Bytes limits of the read. If using a single int, the same value will be
+            used to read all the specified files.
+        """
+        # TODO: on_error
+        if max_gap is not None:
+            # use utils.merge_offset_ranges
+            raise NotImplementedError
+        if not isinstance(paths, list):
+            raise TypeError
+        if not isinstance(starts, Iterable):
+            starts = [starts] * len(paths)
+        if not isinstance(ends, Iterable):
+            ends = [ends] * len(paths)
+        if len(starts) != len(paths) or len(ends) != len(paths):
+            raise ValueError
+        coros = [
+            self._cat_file(p, start=s, end=e, **kwargs)
+            for p, s, e in zip(paths, starts, ends)
+        ]
+        batch_size = batch_size or self.batch_size
+        return await _run_coros_in_chunks(
+            coros, batch_size=batch_size, nofiles=True, return_exceptions=True
+        )
+
+    async def _put_file(self, lpath, rpath, **kwargs):
+        raise NotImplementedError
+
+    async def _put(
+        self,
+        lpath,
+        rpath,
+        recursive=False,
+        callback=_DEFAULT_CALLBACK,
+        batch_size=None,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) from local.
+
+        Copies a specific file or tree of files (if recursive=True). If rpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within.
+
+        The put_file method will be called concurrently on a batch of files. The
+        batch_size option can configure the amount of futures that can be executed
+        at the same time. If it is -1, then all the files will be uploaded concurrently.
+        The default can be set for this instance by passing "batch_size" in the
+        constructor, or for all instances by setting the "gather_batch_size" key
+        in ``fsspec.config.conf``, falling back to 1/8th of the system limit .
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            source_is_str = isinstance(lpath, str)
+            if source_is_str:
+                lpath = make_path_posix(lpath)
+            fs = LocalFileSystem()
+            lpaths = fs.expand_path(lpath, recursive=recursive, maxdepth=maxdepth)
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                lpaths = [p for p in lpaths if not (trailing_sep(p) or fs.isdir(p))]
+                if not lpaths:
+                    return
+
+            source_is_file = len(lpaths) == 1
+            dest_is_dir = isinstance(rpath, str) and (
+                trailing_sep(rpath) or await self._isdir(rpath)
+            )
+
+            rpath = self._strip_protocol(rpath)
+            exists = source_is_str and (
+                (has_magic(lpath) and source_is_file)
+                or (not has_magic(lpath) and dest_is_dir and not trailing_sep(lpath))
+            )
+            rpaths = other_paths(
+                lpaths,
+                rpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        is_dir = {l: os.path.isdir(l) for l in lpaths}
+        rdirs = [r for l, r in zip(lpaths, rpaths) if is_dir[l]]
+        file_pairs = [(l, r) for l, r in zip(lpaths, rpaths) if not is_dir[l]]
+
+        await asyncio.gather(*[self._makedirs(d, exist_ok=True) for d in rdirs])
+        batch_size = batch_size or self.batch_size
+
+        coros = []
+        callback.set_size(len(file_pairs))
+        for lfile, rfile in file_pairs:
+            callback.branch(lfile, rfile, kwargs)
+            coros.append(self._put_file(lfile, rfile, **kwargs))
+
+        return await _run_coros_in_chunks(
+            coros, batch_size=batch_size, callback=callback
+        )
+
+    async def _get_file(self, rpath, lpath, **kwargs):
+        raise NotImplementedError
+
+    async def _get(
+        self,
+        rpath,
+        lpath,
+        recursive=False,
+        callback=_DEFAULT_CALLBACK,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) to local.
+
+        Copies a specific file or tree of files (if recursive=True). If lpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within. Can submit a list of paths, which may be glob-patterns
+        and will be expanded.
+
+        The get_file method will be called concurrently on a batch of files. The
+        batch_size option can configure the amount of futures that can be executed
+        at the same time. If it is -1, then all the files will be uploaded concurrently.
+        The default can be set for this instance by passing "batch_size" in the
+        constructor, or for all instances by setting the "gather_batch_size" key
+        in ``fsspec.config.conf``, falling back to 1/8th of the system limit .
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            source_is_str = isinstance(rpath, str)
+            # First check for rpath trailing slash as _strip_protocol removes it.
+            source_not_trailing_sep = source_is_str and not trailing_sep(rpath)
+            rpath = self._strip_protocol(rpath)
+            rpaths = await self._expand_path(
+                rpath, recursive=recursive, maxdepth=maxdepth
+            )
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                rpaths = [
+                    p for p in rpaths if not (trailing_sep(p) or await self._isdir(p))
+                ]
+                if not rpaths:
+                    return
+
+            lpath = make_path_posix(lpath)
+            source_is_file = len(rpaths) == 1
+            dest_is_dir = isinstance(lpath, str) and (
+                trailing_sep(lpath) or LocalFileSystem().isdir(lpath)
+            )
+
+            exists = source_is_str and (
+                (has_magic(rpath) and source_is_file)
+                or (not has_magic(rpath) and dest_is_dir and source_not_trailing_sep)
+            )
+            lpaths = other_paths(
+                rpaths,
+                lpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        [os.makedirs(os.path.dirname(lp), exist_ok=True) for lp in lpaths]
+        batch_size = kwargs.pop("batch_size", self.batch_size)
+
+        coros = []
+        callback.set_size(len(lpaths))
+        for lpath, rpath in zip(lpaths, rpaths):
+            callback.branch(rpath, lpath, kwargs)
+            coros.append(self._get_file(rpath, lpath, **kwargs))
+        return await _run_coros_in_chunks(
+            coros, batch_size=batch_size, callback=callback
+        )
+
+    async def _isfile(self, path):
+        try:
+            return (await self._info(path))["type"] == "file"
+        except:  # noqa: E722
+            return False
+
+    async def _isdir(self, path):
+        try:
+            return (await self._info(path))["type"] == "directory"
+        except OSError:
+            return False
+
+    async def _size(self, path):
+        return (await self._info(path)).get("size", None)
+
+    async def _sizes(self, paths, batch_size=None):
+        batch_size = batch_size or self.batch_size
+        return await _run_coros_in_chunks(
+            [self._size(p) for p in paths], batch_size=batch_size
+        )
+
+    async def _exists(self, path, **kwargs):
+        try:
+            await self._info(path, **kwargs)
+            return True
+        except FileNotFoundError:
+            return False
+
+    async def _info(self, path, **kwargs):
+        raise NotImplementedError
+
+    async def _ls(self, path, detail=True, **kwargs):
+        raise NotImplementedError
+
+    async def _walk(self, path, maxdepth=None, on_error="omit", **kwargs):
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        path = self._strip_protocol(path)
+        full_dirs = {}
+        dirs = {}
+        files = {}
+
+        detail = kwargs.pop("detail", False)
+        try:
+            listing = await self._ls(path, detail=True, **kwargs)
+        except (FileNotFoundError, OSError) as e:
+            if on_error == "raise":
+                raise
+            elif callable(on_error):
+                on_error(e)
+            if detail:
+                yield path, {}, {}
+            else:
+                yield path, [], []
+            return
+
+        for info in listing:
+            # each info name must be at least [path]/part , but here
+            # we check also for names like [path]/part/
+            pathname = info["name"].rstrip("/")
+            name = pathname.rsplit("/", 1)[-1]
+            if info["type"] == "directory" and pathname != path:
+                # do not include "self" path
+                full_dirs[name] = pathname
+                dirs[name] = info
+            elif pathname == path:
+                # file-like with same name as give path
+                files[""] = info
+            else:
+                files[name] = info
+
+        if detail:
+            yield path, dirs, files
+        else:
+            yield path, list(dirs), list(files)
+
+        if maxdepth is not None:
+            maxdepth -= 1
+            if maxdepth < 1:
+                return
+
+        for d in dirs:
+            async for _ in self._walk(
+                full_dirs[d], maxdepth=maxdepth, detail=detail, **kwargs
+            ):
+                yield _
+
+    async def _glob(self, path, maxdepth=None, **kwargs):
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        import re
+
+        seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,)
+        ends_with_sep = path.endswith(seps)  # _strip_protocol strips trailing slash
+        path = self._strip_protocol(path)
+        append_slash_to_dirname = ends_with_sep or path.endswith(
+            tuple(sep + "**" for sep in seps)
+        )
+        idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+        idx_qmark = path.find("?") if path.find("?") >= 0 else len(path)
+        idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+        min_idx = min(idx_star, idx_qmark, idx_brace)
+
+        detail = kwargs.pop("detail", False)
+
+        if not has_magic(path):
+            if await self._exists(path, **kwargs):
+                if not detail:
+                    return [path]
+                else:
+                    return {path: await self._info(path, **kwargs)}
+            else:
+                if not detail:
+                    return []  # glob of non-existent returns empty
+                else:
+                    return {}
+        elif "/" in path[:min_idx]:
+            min_idx = path[:min_idx].rindex("/")
+            root = path[: min_idx + 1]
+            depth = path[min_idx + 1 :].count("/") + 1
+        else:
+            root = ""
+            depth = path[min_idx + 1 :].count("/") + 1
+
+        if "**" in path:
+            if maxdepth is not None:
+                idx_double_stars = path.find("**")
+                depth_double_stars = path[idx_double_stars:].count("/") + 1
+                depth = depth - depth_double_stars + maxdepth
+            else:
+                depth = None
+
+        allpaths = await self._find(
+            root, maxdepth=depth, withdirs=True, detail=True, **kwargs
+        )
+
+        pattern = glob_translate(path + ("/" if ends_with_sep else ""))
+        pattern = re.compile(pattern)
+
+        out = {
+            p: info
+            for p, info in sorted(allpaths.items())
+            if pattern.match(
+                (
+                    p + "/"
+                    if append_slash_to_dirname and info["type"] == "directory"
+                    else p
+                )
+            )
+        }
+
+        if detail:
+            return out
+        else:
+            return list(out)
+
+    async def _du(self, path, total=True, maxdepth=None, **kwargs):
+        sizes = {}
+        # async for?
+        for f in await self._find(path, maxdepth=maxdepth, **kwargs):
+            info = await self._info(f)
+            sizes[info["name"]] = info["size"]
+        if total:
+            return sum(sizes.values())
+        else:
+            return sizes
+
+    async def _find(self, path, maxdepth=None, withdirs=False, **kwargs):
+        path = self._strip_protocol(path)
+        out = {}
+        detail = kwargs.pop("detail", False)
+
+        # Add the root directory if withdirs is requested
+        # This is needed for posix glob compliance
+        if withdirs and path != "" and await self._isdir(path):
+            out[path] = await self._info(path)
+
+        # async for?
+        async for _, dirs, files in self._walk(path, maxdepth, detail=True, **kwargs):
+            if withdirs:
+                files.update(dirs)
+            out.update({info["name"]: info for name, info in files.items()})
+        if not out and (await self._isfile(path)):
+            # walk works on directories, but find should also return [path]
+            # when path happens to be a file
+            out[path] = {}
+        names = sorted(out)
+        if not detail:
+            return names
+        else:
+            return {name: out[name] for name in names}
+
+    async def _expand_path(self, path, recursive=False, maxdepth=None):
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        if isinstance(path, str):
+            out = await self._expand_path([path], recursive, maxdepth)
+        else:
+            out = set()
+            path = [self._strip_protocol(p) for p in path]
+            for p in path:  # can gather here
+                if has_magic(p):
+                    bit = set(await self._glob(p, maxdepth=maxdepth))
+                    out |= bit
+                    if recursive:
+                        # glob call above expanded one depth so if maxdepth is defined
+                        # then decrement it in expand_path call below. If it is zero
+                        # after decrementing then avoid expand_path call.
+                        if maxdepth is not None and maxdepth <= 1:
+                            continue
+                        out |= set(
+                            await self._expand_path(
+                                list(bit),
+                                recursive=recursive,
+                                maxdepth=maxdepth - 1 if maxdepth is not None else None,
+                            )
+                        )
+                    continue
+                elif recursive:
+                    rec = set(await self._find(p, maxdepth=maxdepth, withdirs=True))
+                    out |= rec
+                if p not in out and (recursive is False or (await self._exists(p))):
+                    # should only check once, for the root
+                    out.add(p)
+        if not out:
+            raise FileNotFoundError(path)
+        return sorted(out)
+
+    async def _mkdir(self, path, create_parents=True, **kwargs):
+        pass  # not necessary to implement, may not have directories
+
+    async def _makedirs(self, path, exist_ok=False):
+        pass  # not necessary to implement, may not have directories
+
+    async def open_async(self, path, mode="rb", **kwargs):
+        if "b" not in mode or kwargs.get("compression"):
+            raise ValueError
+        raise NotImplementedError
+
+
+def mirror_sync_methods(obj):
+    """Populate sync and async methods for obj
+
+    For each method will create a sync version if the name refers to an async method
+    (coroutine) and there is no override in the child class; will create an async
+    method for the corresponding sync method if there is no implementation.
+
+    Uses the methods specified in
+    - async_methods: the set that an implementation is expected to provide
+    - default_async_methods: that can be derived from their sync version in
+      AbstractFileSystem
+    - AsyncFileSystem: async-specific default coroutines
+    """
+    from fsspec import AbstractFileSystem
+
+    for method in async_methods + dir(AsyncFileSystem):
+        if not method.startswith("_"):
+            continue
+        smethod = method[1:]
+        if private.match(method):
+            isco = inspect.iscoroutinefunction(getattr(obj, method, None))
+            unsync = getattr(getattr(obj, smethod, False), "__func__", None)
+            is_default = unsync is getattr(AbstractFileSystem, smethod, "")
+            if isco and is_default:
+                mth = sync_wrapper(getattr(obj, method), obj=obj)
+                setattr(obj, smethod, mth)
+                if not mth.__doc__:
+                    mth.__doc__ = getattr(
+                        getattr(AbstractFileSystem, smethod, None), "__doc__", ""
+                    )
+
+
+class FSSpecCoroutineCancel(Exception):
+    pass
+
+
+def _dump_running_tasks(
+    printout=True, cancel=True, exc=FSSpecCoroutineCancel, with_task=False
+):
+    import traceback
+
+    tasks = [t for t in asyncio.tasks.all_tasks(loop[0]) if not t.done()]
+    if printout:
+        [task.print_stack() for task in tasks]
+    out = [
+        {
+            "locals": task._coro.cr_frame.f_locals,
+            "file": task._coro.cr_frame.f_code.co_filename,
+            "firstline": task._coro.cr_frame.f_code.co_firstlineno,
+            "linelo": task._coro.cr_frame.f_lineno,
+            "stack": traceback.format_stack(task._coro.cr_frame),
+            "task": task if with_task else None,
+        }
+        for task in tasks
+    ]
+    if cancel:
+        for t in tasks:
+            cbs = t._callbacks
+            t.cancel()
+            asyncio.futures.Future.set_exception(t, exc)
+            asyncio.futures.Future.cancel(t)
+            [cb[0](t) for cb in cbs]  # cancels any dependent concurrent.futures
+            try:
+                t._coro.throw(exc)  # exits coro, unless explicitly handled
+            except exc:
+                pass
+    return out
+
+
+class AbstractAsyncStreamedFile(AbstractBufferedFile):
+    # no read buffering, and always auto-commit
+    # TODO: readahead might still be useful here, but needs async version
+
+    async def read(self, length=-1):
+        """
+        Return data from cache, or fetch pieces as necessary
+
+        Parameters
+        ----------
+        length: int (-1)
+            Number of bytes to read; if <0, all remaining bytes.
+        """
+        length = -1 if length is None else int(length)
+        if self.mode != "rb":
+            raise ValueError("File not in read mode")
+        if length < 0:
+            length = self.size - self.loc
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        if length == 0:
+            # don't even bother calling fetch
+            return b""
+        out = await self._fetch_range(self.loc, self.loc + length)
+        self.loc += len(out)
+        return out
+
+    async def write(self, data):
+        """
+        Write data to buffer.
+
+        Buffer only sent on flush() or if buffer is greater than
+        or equal to blocksize.
+
+        Parameters
+        ----------
+        data: bytes
+            Set of bytes to be written.
+        """
+        if self.mode not in {"wb", "ab"}:
+            raise ValueError("File not in write mode")
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        if self.forced:
+            raise ValueError("This file has been force-flushed, can only close")
+        out = self.buffer.write(data)
+        self.loc += out
+        if self.buffer.tell() >= self.blocksize:
+            await self.flush()
+        return out
+
+    async def close(self):
+        """Close file
+
+        Finalizes writes, discards cache
+        """
+        if getattr(self, "_unclosable", False):
+            return
+        if self.closed:
+            return
+        if self.mode == "rb":
+            self.cache = None
+        else:
+            if not self.forced:
+                await self.flush(force=True)
+
+            if self.fs is not None:
+                self.fs.invalidate_cache(self.path)
+                self.fs.invalidate_cache(self.fs._parent(self.path))
+
+        self.closed = True
+
+    async def flush(self, force=False):
+        if self.closed:
+            raise ValueError("Flush on closed file")
+        if force and self.forced:
+            raise ValueError("Force flush cannot be called more than once")
+        if force:
+            self.forced = True
+
+        if self.mode not in {"wb", "ab"}:
+            # no-op to flush on read-mode
+            return
+
+        if not force and self.buffer.tell() < self.blocksize:
+            # Defer write on small block
+            return
+
+        if self.offset is None:
+            # Initialize a multipart upload
+            self.offset = 0
+            try:
+                await self._initiate_upload()
+            except:  # noqa: E722
+                self.closed = True
+                raise
+
+        if await self._upload_chunk(final=force) is not False:
+            self.offset += self.buffer.seek(0, 2)
+            self.buffer = io.BytesIO()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def _fetch_range(self, start, end):
+        raise NotImplementedError
+
+    async def _initiate_upload(self):
+        pass
+
+    async def _upload_chunk(self, final=False):
+        raise NotImplementedError
diff --git a/lib/python3.11/site-packages/fsspec/caching.py b/lib/python3.11/site-packages/fsspec/caching.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d441fe465ad986b054431f276be0fee9fd5fd1d
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/caching.py
@@ -0,0 +1,875 @@
+from __future__ import annotations
+
+import collections
+import functools
+import logging
+import math
+import os
+import threading
+import warnings
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Generic,
+    NamedTuple,
+    OrderedDict,
+    TypeVar,
+)
+
+if TYPE_CHECKING:
+    import mmap
+
+    from typing_extensions import ParamSpec
+
+    P = ParamSpec("P")
+else:
+    P = TypeVar("P")
+
+T = TypeVar("T")
+
+
+logger = logging.getLogger("fsspec")
+
+Fetcher = Callable[[int, int], bytes]  # Maps (start, end) to bytes
+
+
+class BaseCache:
+    """Pass-though cache: doesn't keep anything, calls every time
+
+    Acts as base class for other cachers
+
+    Parameters
+    ----------
+    blocksize: int
+        How far to read ahead in numbers of bytes
+    fetcher: func
+        Function of the form f(start, end) which gets bytes from remote as
+        specified
+    size: int
+        How big this file is
+    """
+
+    name: ClassVar[str] = "none"
+
+    def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+        self.blocksize = blocksize
+        self.fetcher = fetcher
+        self.size = size
+
+    def _fetch(self, start: int | None, stop: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if stop is None:
+            stop = self.size
+        if start >= self.size or start >= stop:
+            return b""
+        return self.fetcher(start, stop)
+
+
+class MMapCache(BaseCache):
+    """memory-mapped sparse file cache
+
+    Opens temporary file, which is filled blocks-wise when data is requested.
+    Ensure there is enough disc space in the temporary location.
+
+    This cache method might only work on posix
+    """
+
+    name = "mmap"
+
+    def __init__(
+        self,
+        blocksize: int,
+        fetcher: Fetcher,
+        size: int,
+        location: str | None = None,
+        blocks: set[int] | None = None,
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.blocks = set() if blocks is None else blocks
+        self.location = location
+        self.cache = self._makefile()
+
+    def _makefile(self) -> mmap.mmap | bytearray:
+        import mmap
+        import tempfile
+
+        if self.size == 0:
+            return bytearray()
+
+        # posix version
+        if self.location is None or not os.path.exists(self.location):
+            if self.location is None:
+                fd = tempfile.TemporaryFile()
+                self.blocks = set()
+            else:
+                fd = open(self.location, "wb+")
+            fd.seek(self.size - 1)
+            fd.write(b"1")
+            fd.flush()
+        else:
+            fd = open(self.location, "r+b")
+
+        return mmap.mmap(fd.fileno(), self.size)
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        logger.debug(f"MMap cache fetching {start}-{end}")
+        if start is None:
+            start = 0
+        if end is None:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+        start_block = start // self.blocksize
+        end_block = end // self.blocksize
+        need = [i for i in range(start_block, end_block + 1) if i not in self.blocks]
+        while need:
+            # TODO: not a for loop so we can consolidate blocks later to
+            # make fewer fetch calls; this could be parallel
+            i = need.pop(0)
+            sstart = i * self.blocksize
+            send = min(sstart + self.blocksize, self.size)
+            logger.debug(f"MMap get block #{i} ({sstart}-{send}")
+            self.cache[sstart:send] = self.fetcher(sstart, send)
+            self.blocks.add(i)
+
+        return self.cache[start:end]
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        # Remove the unpicklable entries.
+        del state["cache"]
+        return state
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        # Restore instance attributes
+        self.__dict__.update(state)
+        self.cache = self._makefile()
+
+
+class ReadAheadCache(BaseCache):
+    """Cache which reads only when we get beyond a block of data
+
+    This is a much simpler version of BytesCache, and does not attempt to
+    fill holes in the cache or keep fragments alive. It is best suited to
+    many small reads in a sequential order (e.g., reading lines from a file).
+    """
+
+    name = "readahead"
+
+    def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.cache = b""
+        self.start = 0
+        self.end = 0
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if end is None or end > self.size:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+        l = end - start
+        if start >= self.start and end <= self.end:
+            # cache hit
+            return self.cache[start - self.start : end - self.start]
+        elif self.start <= start < self.end:
+            # partial hit
+            part = self.cache[start - self.start :]
+            l -= len(part)
+            start = self.end
+        else:
+            # miss
+            part = b""
+        end = min(self.size, end + self.blocksize)
+        self.cache = self.fetcher(start, end)  # new block replaces old
+        self.start = start
+        self.end = self.start + len(self.cache)
+        return part + self.cache[:l]
+
+
+class FirstChunkCache(BaseCache):
+    """Caches the first block of a file only
+
+    This may be useful for file types where the metadata is stored in the header,
+    but is randomly accessed.
+    """
+
+    name = "first"
+
+    def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.cache: bytes | None = None
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        start = start or 0
+        end = end or self.size
+        if start < self.blocksize:
+            if self.cache is None:
+                if end > self.blocksize:
+                    data = self.fetcher(0, end)
+                    self.cache = data[: self.blocksize]
+                    return data[start:]
+                self.cache = self.fetcher(0, self.blocksize)
+            part = self.cache[start:end]
+            if end > self.blocksize:
+                part += self.fetcher(self.blocksize, end)
+            return part
+        else:
+            return self.fetcher(start, end)
+
+
+class BlockCache(BaseCache):
+    """
+    Cache holding memory as a set of blocks.
+
+    Requests are only ever made ``blocksize`` at a time, and are
+    stored in an LRU cache. The least recently accessed block is
+    discarded when more than ``maxblocks`` are stored.
+
+    Parameters
+    ----------
+    blocksize : int
+        The number of bytes to store in each block.
+        Requests are only ever made for ``blocksize``, so this
+        should balance the overhead of making a request against
+        the granularity of the blocks.
+    fetcher : Callable
+    size : int
+        The total size of the file being cached.
+    maxblocks : int
+        The maximum number of blocks to cache for. The maximum memory
+        use for this cache is then ``blocksize * maxblocks``.
+    """
+
+    name = "blockcache"
+
+    def __init__(
+        self, blocksize: int, fetcher: Fetcher, size: int, maxblocks: int = 32
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.nblocks = math.ceil(size / blocksize)
+        self.maxblocks = maxblocks
+        self._fetch_block_cached = functools.lru_cache(maxblocks)(self._fetch_block)
+
+    def __repr__(self) -> str:
+        return (
+            f"<BlockCache blocksize={self.blocksize}, "
+            f"size={self.size}, nblocks={self.nblocks}>"
+        )
+
+    def cache_info(self):
+        """
+        The statistics on the block cache.
+
+        Returns
+        -------
+        NamedTuple
+            Returned directly from the LRU Cache used internally.
+        """
+        return self._fetch_block_cached.cache_info()
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__
+        del state["_fetch_block_cached"]
+        return state
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        self._fetch_block_cached = functools.lru_cache(state["maxblocks"])(
+            self._fetch_block
+        )
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if end is None:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+
+        # byte position -> block numbers
+        start_block_number = start // self.blocksize
+        end_block_number = end // self.blocksize
+
+        # these are cached, so safe to do multiple calls for the same start and end.
+        for block_number in range(start_block_number, end_block_number + 1):
+            self._fetch_block_cached(block_number)
+
+        return self._read_cache(
+            start,
+            end,
+            start_block_number=start_block_number,
+            end_block_number=end_block_number,
+        )
+
+    def _fetch_block(self, block_number: int) -> bytes:
+        """
+        Fetch the block of data for `block_number`.
+        """
+        if block_number > self.nblocks:
+            raise ValueError(
+                f"'block_number={block_number}' is greater than "
+                f"the number of blocks ({self.nblocks})"
+            )
+
+        start = block_number * self.blocksize
+        end = start + self.blocksize
+        logger.info("BlockCache fetching block %d", block_number)
+        block_contents = super()._fetch(start, end)
+        return block_contents
+
+    def _read_cache(
+        self, start: int, end: int, start_block_number: int, end_block_number: int
+    ) -> bytes:
+        """
+        Read from our block cache.
+
+        Parameters
+        ----------
+        start, end : int
+            The start and end byte positions.
+        start_block_number, end_block_number : int
+            The start and end block numbers.
+        """
+        start_pos = start % self.blocksize
+        end_pos = end % self.blocksize
+
+        if start_block_number == end_block_number:
+            block: bytes = self._fetch_block_cached(start_block_number)
+            return block[start_pos:end_pos]
+
+        else:
+            # read from the initial
+            out = []
+            out.append(self._fetch_block_cached(start_block_number)[start_pos:])
+
+            # intermediate blocks
+            # Note: it'd be nice to combine these into one big request. However
+            # that doesn't play nicely with our LRU cache.
+            for block_number in range(start_block_number + 1, end_block_number):
+                out.append(self._fetch_block_cached(block_number))
+
+            # final block
+            out.append(self._fetch_block_cached(end_block_number)[:end_pos])
+
+            return b"".join(out)
+
+
+class BytesCache(BaseCache):
+    """Cache which holds data in a in-memory bytes object
+
+    Implements read-ahead by the block size, for semi-random reads progressing
+    through the file.
+
+    Parameters
+    ----------
+    trim: bool
+        As we read more data, whether to discard the start of the buffer when
+        we are more than a blocksize ahead of it.
+    """
+
+    name: ClassVar[str] = "bytes"
+
+    def __init__(
+        self, blocksize: int, fetcher: Fetcher, size: int, trim: bool = True
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.cache = b""
+        self.start: int | None = None
+        self.end: int | None = None
+        self.trim = trim
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        # TODO: only set start/end after fetch, in case it fails?
+        # is this where retry logic might go?
+        if start is None:
+            start = 0
+        if end is None:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+        if (
+            self.start is not None
+            and start >= self.start
+            and self.end is not None
+            and end < self.end
+        ):
+            # cache hit: we have all the required data
+            offset = start - self.start
+            return self.cache[offset : offset + end - start]
+
+        if self.blocksize:
+            bend = min(self.size, end + self.blocksize)
+        else:
+            bend = end
+
+        if bend == start or start > self.size:
+            return b""
+
+        if (self.start is None or start < self.start) and (
+            self.end is None or end > self.end
+        ):
+            # First read, or extending both before and after
+            self.cache = self.fetcher(start, bend)
+            self.start = start
+        else:
+            assert self.start is not None
+            assert self.end is not None
+
+            if start < self.start:
+                if self.end is None or self.end - end > self.blocksize:
+                    self.cache = self.fetcher(start, bend)
+                    self.start = start
+                else:
+                    new = self.fetcher(start, self.start)
+                    self.start = start
+                    self.cache = new + self.cache
+            elif self.end is not None and bend > self.end:
+                if self.end > self.size:
+                    pass
+                elif end - self.end > self.blocksize:
+                    self.cache = self.fetcher(start, bend)
+                    self.start = start
+                else:
+                    new = self.fetcher(self.end, bend)
+                    self.cache = self.cache + new
+
+        self.end = self.start + len(self.cache)
+        offset = start - self.start
+        out = self.cache[offset : offset + end - start]
+        if self.trim:
+            num = (self.end - self.start) // (self.blocksize + 1)
+            if num > 1:
+                self.start += self.blocksize * num
+                self.cache = self.cache[self.blocksize * num :]
+        return out
+
+    def __len__(self) -> int:
+        return len(self.cache)
+
+
+class AllBytes(BaseCache):
+    """Cache entire contents of the file"""
+
+    name: ClassVar[str] = "all"
+
+    def __init__(
+        self,
+        blocksize: int | None = None,
+        fetcher: Fetcher | None = None,
+        size: int | None = None,
+        data: bytes | None = None,
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)  # type: ignore[arg-type]
+        if data is None:
+            data = self.fetcher(0, self.size)
+        self.data = data
+
+    def _fetch(self, start: int | None, stop: int | None) -> bytes:
+        return self.data[start:stop]
+
+
+class KnownPartsOfAFile(BaseCache):
+    """
+    Cache holding known file parts.
+
+    Parameters
+    ----------
+    blocksize: int
+        How far to read ahead in numbers of bytes
+    fetcher: func
+        Function of the form f(start, end) which gets bytes from remote as
+        specified
+    size: int
+        How big this file is
+    data: dict
+        A dictionary mapping explicit `(start, stop)` file-offset tuples
+        with known bytes.
+    strict: bool, default True
+        Whether to fetch reads that go beyond a known byte-range boundary.
+        If `False`, any read that ends outside a known part will be zero
+        padded. Note that zero padding will not be used for reads that
+        begin outside a known byte-range.
+    """
+
+    name: ClassVar[str] = "parts"
+
+    def __init__(
+        self,
+        blocksize: int,
+        fetcher: Fetcher,
+        size: int,
+        data: dict[tuple[int, int], bytes] = {},
+        strict: bool = True,
+        **_: Any,
+    ):
+        super().__init__(blocksize, fetcher, size)
+        self.strict = strict
+
+        # simple consolidation of contiguous blocks
+        if data:
+            old_offsets = sorted(data.keys())
+            offsets = [old_offsets[0]]
+            blocks = [data.pop(old_offsets[0])]
+            for start, stop in old_offsets[1:]:
+                start0, stop0 = offsets[-1]
+                if start == stop0:
+                    offsets[-1] = (start0, stop)
+                    blocks[-1] += data.pop((start, stop))
+                else:
+                    offsets.append((start, stop))
+                    blocks.append(data.pop((start, stop)))
+
+            self.data = dict(zip(offsets, blocks))
+        else:
+            self.data = data
+
+    def _fetch(self, start: int | None, stop: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if stop is None:
+            stop = self.size
+
+        out = b""
+        for (loc0, loc1), data in self.data.items():
+            # If self.strict=False, use zero-padded data
+            # for reads beyond the end of a "known" buffer
+            if loc0 <= start < loc1:
+                off = start - loc0
+                out = data[off : off + stop - start]
+                if not self.strict or loc0 <= stop <= loc1:
+                    # The request is within a known range, or
+                    # it begins within a known range, and we
+                    # are allowed to pad reads beyond the
+                    # buffer with zero
+                    out += b"\x00" * (stop - start - len(out))
+                    return out
+                else:
+                    # The request ends outside a known range,
+                    # and we are being "strict" about reads
+                    # beyond the buffer
+                    start = loc1
+                    break
+
+        # We only get here if there is a request outside the
+        # known parts of the file. In an ideal world, this
+        # should never happen
+        if self.fetcher is None:
+            # We cannot fetch the data, so raise an error
+            raise ValueError(f"Read is outside the known file parts: {(start, stop)}. ")
+        # We can fetch the data, but should warn the user
+        # that this may be slow
+        warnings.warn(
+            f"Read is outside the known file parts: {(start, stop)}. "
+            f"IO/caching performance may be poor!"
+        )
+        logger.debug(f"KnownPartsOfAFile cache fetching {start}-{stop}")
+        return out + super()._fetch(start, stop)
+
+
+class UpdatableLRU(Generic[P, T]):
+    """
+    Custom implementation of LRU cache that allows updating keys
+
+    Used by BackgroudBlockCache
+    """
+
+    class CacheInfo(NamedTuple):
+        hits: int
+        misses: int
+        maxsize: int
+        currsize: int
+
+    def __init__(self, func: Callable[P, T], max_size: int = 128) -> None:
+        self._cache: OrderedDict[Any, T] = collections.OrderedDict()
+        self._func = func
+        self._max_size = max_size
+        self._hits = 0
+        self._misses = 0
+        self._lock = threading.Lock()
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        if kwargs:
+            raise TypeError(f"Got unexpected keyword argument {kwargs.keys()}")
+        with self._lock:
+            if args in self._cache:
+                self._cache.move_to_end(args)
+                self._hits += 1
+                return self._cache[args]
+
+        result = self._func(*args, **kwargs)
+
+        with self._lock:
+            self._cache[args] = result
+            self._misses += 1
+            if len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+        return result
+
+    def is_key_cached(self, *args: Any) -> bool:
+        with self._lock:
+            return args in self._cache
+
+    def add_key(self, result: T, *args: Any) -> None:
+        with self._lock:
+            self._cache[args] = result
+            if len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+    def cache_info(self) -> UpdatableLRU.CacheInfo:
+        with self._lock:
+            return self.CacheInfo(
+                maxsize=self._max_size,
+                currsize=len(self._cache),
+                hits=self._hits,
+                misses=self._misses,
+            )
+
+
+class BackgroundBlockCache(BaseCache):
+    """
+    Cache holding memory as a set of blocks with pre-loading of
+    the next block in the background.
+
+    Requests are only ever made ``blocksize`` at a time, and are
+    stored in an LRU cache. The least recently accessed block is
+    discarded when more than ``maxblocks`` are stored. If the
+    next block is not in cache, it is loaded in a separate thread
+    in non-blocking way.
+
+    Parameters
+    ----------
+    blocksize : int
+        The number of bytes to store in each block.
+        Requests are only ever made for ``blocksize``, so this
+        should balance the overhead of making a request against
+        the granularity of the blocks.
+    fetcher : Callable
+    size : int
+        The total size of the file being cached.
+    maxblocks : int
+        The maximum number of blocks to cache for. The maximum memory
+        use for this cache is then ``blocksize * maxblocks``.
+    """
+
+    name: ClassVar[str] = "background"
+
+    def __init__(
+        self, blocksize: int, fetcher: Fetcher, size: int, maxblocks: int = 32
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.nblocks = math.ceil(size / blocksize)
+        self.maxblocks = maxblocks
+        self._fetch_block_cached = UpdatableLRU(self._fetch_block, maxblocks)
+
+        self._thread_executor = ThreadPoolExecutor(max_workers=1)
+        self._fetch_future_block_number: int | None = None
+        self._fetch_future: Future[bytes] | None = None
+        self._fetch_future_lock = threading.Lock()
+
+    def __repr__(self) -> str:
+        return (
+            f"<BackgroundBlockCache blocksize={self.blocksize}, "
+            f"size={self.size}, nblocks={self.nblocks}>"
+        )
+
+    def cache_info(self) -> UpdatableLRU.CacheInfo:
+        """
+        The statistics on the block cache.
+
+        Returns
+        -------
+        NamedTuple
+            Returned directly from the LRU Cache used internally.
+        """
+        return self._fetch_block_cached.cache_info()
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__
+        del state["_fetch_block_cached"]
+        del state["_thread_executor"]
+        del state["_fetch_future_block_number"]
+        del state["_fetch_future"]
+        del state["_fetch_future_lock"]
+        return state
+
+    def __setstate__(self, state) -> None:
+        self.__dict__.update(state)
+        self._fetch_block_cached = UpdatableLRU(self._fetch_block, state["maxblocks"])
+        self._thread_executor = ThreadPoolExecutor(max_workers=1)
+        self._fetch_future_block_number = None
+        self._fetch_future = None
+        self._fetch_future_lock = threading.Lock()
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if end is None:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+
+        # byte position -> block numbers
+        start_block_number = start // self.blocksize
+        end_block_number = end // self.blocksize
+
+        fetch_future_block_number = None
+        fetch_future = None
+        with self._fetch_future_lock:
+            # Background thread is running. Check we we can or must join it.
+            if self._fetch_future is not None:
+                assert self._fetch_future_block_number is not None
+                if self._fetch_future.done():
+                    logger.info("BlockCache joined background fetch without waiting.")
+                    self._fetch_block_cached.add_key(
+                        self._fetch_future.result(), self._fetch_future_block_number
+                    )
+                    # Cleanup the fetch variables. Done with fetching the block.
+                    self._fetch_future_block_number = None
+                    self._fetch_future = None
+                else:
+                    # Must join if we need the block for the current fetch
+                    must_join = bool(
+                        start_block_number
+                        <= self._fetch_future_block_number
+                        <= end_block_number
+                    )
+                    if must_join:
+                        # Copy to the local variables to release lock
+                        # before waiting for result
+                        fetch_future_block_number = self._fetch_future_block_number
+                        fetch_future = self._fetch_future
+
+                        # Cleanup the fetch variables. Have a local copy.
+                        self._fetch_future_block_number = None
+                        self._fetch_future = None
+
+        # Need to wait for the future for the current read
+        if fetch_future is not None:
+            logger.info("BlockCache waiting for background fetch.")
+            # Wait until result and put it in cache
+            self._fetch_block_cached.add_key(
+                fetch_future.result(), fetch_future_block_number
+            )
+
+        # these are cached, so safe to do multiple calls for the same start and end.
+        for block_number in range(start_block_number, end_block_number + 1):
+            self._fetch_block_cached(block_number)
+
+        # fetch next block in the background if nothing is running in the background,
+        # the block is within file and it is not already cached
+        end_block_plus_1 = end_block_number + 1
+        with self._fetch_future_lock:
+            if (
+                self._fetch_future is None
+                and end_block_plus_1 <= self.nblocks
+                and not self._fetch_block_cached.is_key_cached(end_block_plus_1)
+            ):
+                self._fetch_future_block_number = end_block_plus_1
+                self._fetch_future = self._thread_executor.submit(
+                    self._fetch_block, end_block_plus_1, "async"
+                )
+
+        return self._read_cache(
+            start,
+            end,
+            start_block_number=start_block_number,
+            end_block_number=end_block_number,
+        )
+
+    def _fetch_block(self, block_number: int, log_info: str = "sync") -> bytes:
+        """
+        Fetch the block of data for `block_number`.
+        """
+        if block_number > self.nblocks:
+            raise ValueError(
+                f"'block_number={block_number}' is greater than "
+                f"the number of blocks ({self.nblocks})"
+            )
+
+        start = block_number * self.blocksize
+        end = start + self.blocksize
+        logger.info("BlockCache fetching block (%s) %d", log_info, block_number)
+        block_contents = super()._fetch(start, end)
+        return block_contents
+
+    def _read_cache(
+        self, start: int, end: int, start_block_number: int, end_block_number: int
+    ) -> bytes:
+        """
+        Read from our block cache.
+
+        Parameters
+        ----------
+        start, end : int
+            The start and end byte positions.
+        start_block_number, end_block_number : int
+            The start and end block numbers.
+        """
+        start_pos = start % self.blocksize
+        end_pos = end % self.blocksize
+
+        if start_block_number == end_block_number:
+            block = self._fetch_block_cached(start_block_number)
+            return block[start_pos:end_pos]
+
+        else:
+            # read from the initial
+            out = []
+            out.append(self._fetch_block_cached(start_block_number)[start_pos:])
+
+            # intermediate blocks
+            # Note: it'd be nice to combine these into one big request. However
+            # that doesn't play nicely with our LRU cache.
+            for block_number in range(start_block_number + 1, end_block_number):
+                out.append(self._fetch_block_cached(block_number))
+
+            # final block
+            out.append(self._fetch_block_cached(end_block_number)[:end_pos])
+
+            return b"".join(out)
+
+
+caches: dict[str | None, type[BaseCache]] = {
+    # one custom case
+    None: BaseCache,
+}
+
+
+def register_cache(cls: type[BaseCache], clobber: bool = False) -> None:
+    """'Register' cache implementation.
+
+    Parameters
+    ----------
+    clobber: bool, optional
+        If set to True (default is False) - allow to overwrite existing
+        entry.
+
+    Raises
+    ------
+    ValueError
+    """
+    name = cls.name
+    if not clobber and name in caches:
+        raise ValueError(f"Cache with name {name!r} is already known: {caches[name]}")
+    caches[name] = cls
+
+
+for c in (
+    BaseCache,
+    MMapCache,
+    BytesCache,
+    ReadAheadCache,
+    BlockCache,
+    FirstChunkCache,
+    AllBytes,
+    KnownPartsOfAFile,
+    BackgroundBlockCache,
+):
+    register_cache(c)
diff --git a/lib/python3.11/site-packages/fsspec/callbacks.py b/lib/python3.11/site-packages/fsspec/callbacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..4500d02cbcae78d9cd764956d4cc46963b525213
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/callbacks.py
@@ -0,0 +1,238 @@
+class Callback:
+    """
+    Base class and interface for callback mechanism
+
+    This class can be used directly for monitoring file transfers by
+    providing ``callback=Callback(hooks=...)`` (see the ``hooks`` argument,
+    below), or subclassed for more specialised behaviour.
+
+    Parameters
+    ----------
+    size: int (optional)
+        Nominal quantity for the value that corresponds to a complete
+        transfer, e.g., total number of tiles or total number of
+        bytes
+    value: int (0)
+        Starting internal counter value
+    hooks: dict or None
+        A dict of named functions to be called on each update. The signature
+        of these must be ``f(size, value, **kwargs)``
+    """
+
+    def __init__(self, size=None, value=0, hooks=None, **kwargs):
+        self.size = size
+        self.value = value
+        self.hooks = hooks or {}
+        self.kw = kwargs
+
+    def set_size(self, size):
+        """
+        Set the internal maximum size attribute
+
+        Usually called if not initially set at instantiation. Note that this
+        triggers a ``call()``.
+
+        Parameters
+        ----------
+        size: int
+        """
+        self.size = size
+        self.call()
+
+    def absolute_update(self, value):
+        """
+        Set the internal value state
+
+        Triggers ``call()``
+
+        Parameters
+        ----------
+        value: int
+        """
+        self.value = value
+        self.call()
+
+    def relative_update(self, inc=1):
+        """
+        Delta increment the internal counter
+
+        Triggers ``call()``
+
+        Parameters
+        ----------
+        inc: int
+        """
+        self.value += inc
+        self.call()
+
+    def call(self, hook_name=None, **kwargs):
+        """
+        Execute hook(s) with current state
+
+        Each function is passed the internal size and current value
+
+        Parameters
+        ----------
+        hook_name: str or None
+            If given, execute on this hook
+        kwargs: passed on to (all) hook(s)
+        """
+        if not self.hooks:
+            return
+        kw = self.kw.copy()
+        kw.update(kwargs)
+        if hook_name:
+            if hook_name not in self.hooks:
+                return
+            return self.hooks[hook_name](self.size, self.value, **kw)
+        for hook in self.hooks.values() or []:
+            hook(self.size, self.value, **kw)
+
+    def wrap(self, iterable):
+        """
+        Wrap an iterable to call ``relative_update`` on each iterations
+
+        Parameters
+        ----------
+        iterable: Iterable
+            The iterable that is being wrapped
+        """
+        for item in iterable:
+            self.relative_update()
+            yield item
+
+    def branch(self, path_1, path_2, kwargs):
+        """
+        Set callbacks for child transfers
+
+        If this callback is operating at a higher level, e.g., put, which may
+        trigger transfers that can also be monitored. The passed kwargs are
+        to be *mutated* to add ``callback=``, if this class supports branching
+        to children.
+
+        Parameters
+        ----------
+        path_1: str
+            Child's source path
+        path_2: str
+            Child's destination path
+        kwargs: dict
+            arguments passed to child method, e.g., put_file.
+
+        Returns
+        -------
+
+        """
+        return None
+
+    def no_op(self, *_, **__):
+        pass
+
+    def __getattr__(self, item):
+        """
+        If undefined methods are called on this class, nothing happens
+        """
+        return self.no_op
+
+    @classmethod
+    def as_callback(cls, maybe_callback=None):
+        """Transform callback=... into Callback instance
+
+        For the special value of ``None``, return the global instance of
+        ``NoOpCallback``. This is an alternative to including
+        ``callback=_DEFAULT_CALLBACK`` directly in a method signature.
+        """
+        if maybe_callback is None:
+            return _DEFAULT_CALLBACK
+        return maybe_callback
+
+
+class NoOpCallback(Callback):
+    """
+    This implementation of Callback does exactly nothing
+    """
+
+    def call(self, *args, **kwargs):
+        return None
+
+
+class DotPrinterCallback(Callback):
+    """
+    Simple example Callback implementation
+
+    Almost identical to Callback with a hook that prints a char; here we
+    demonstrate how the outer layer may print "#" and the inner layer "."
+    """
+
+    def __init__(self, chr_to_print="#", **kwargs):
+        self.chr = chr_to_print
+        super().__init__(**kwargs)
+
+    def branch(self, path_1, path_2, kwargs):
+        """Mutate kwargs to add new instance with different print char"""
+        kwargs["callback"] = DotPrinterCallback(".")
+
+    def call(self, **kwargs):
+        """Just outputs a character"""
+        print(self.chr, end="")
+
+
+class TqdmCallback(Callback):
+    """
+    A callback to display a progress bar using tqdm
+
+    Parameters
+    ----------
+    tqdm_kwargs : dict, (optional)
+        Any argument accepted by the tqdm constructor.
+        See the `tqdm doc <https://tqdm.github.io/docs/tqdm/#__init__>`_.
+        Will be forwarded to tqdm.
+
+    Examples
+    --------
+    >>> import fsspec
+    >>> from fsspec.callbacks import TqdmCallback
+    >>> fs = fsspec.filesystem("memory")
+    >>> path2distant_data = "/your-path"
+    >>> fs.upload(
+            ".",
+            path2distant_data,
+            recursive=True,
+            callback=TqdmCallback(),
+        )
+
+    You can forward args to tqdm using the ``tqdm_kwargs`` parameter.
+
+    >>> fs.upload(
+            ".",
+            path2distant_data,
+            recursive=True,
+            callback=TqdmCallback(tqdm_kwargs={"desc": "Your tqdm description"}),
+        )
+    """
+
+    def __init__(self, tqdm_kwargs=None, *args, **kwargs):
+        try:
+            import tqdm
+
+            self._tqdm = tqdm
+        except ImportError as exce:
+            raise ImportError(
+                "Using TqdmCallback requires tqdm to be installed"
+            ) from exce
+
+        self._tqdm_kwargs = tqdm_kwargs or {}
+        super().__init__(*args, **kwargs)
+
+    def set_size(self, size):
+        self.tqdm = self._tqdm.tqdm(total=size, **self._tqdm_kwargs)
+
+    def relative_update(self, inc=1):
+        self.tqdm.update(inc)
+
+    def __del__(self):
+        self.tqdm.close()
+        self.tqdm = None
+
+
+_DEFAULT_CALLBACK = NoOpCallback()
diff --git a/lib/python3.11/site-packages/fsspec/compression.py b/lib/python3.11/site-packages/fsspec/compression.py
new file mode 100644
index 0000000000000000000000000000000000000000..53b7426e2a5d436cb64d28160bd2b32aee2f5966
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/compression.py
@@ -0,0 +1,174 @@
+"""Helper functions for a standard streaming compression API"""
+from zipfile import ZipFile
+
+import fsspec.utils
+from fsspec.spec import AbstractBufferedFile
+
+
+def noop_file(file, mode, **kwargs):
+    return file
+
+
+# TODO: files should also be available as contexts
+# should be functions of the form func(infile, mode=, **kwargs) -> file-like
+compr = {None: noop_file}
+
+
+def register_compression(name, callback, extensions, force=False):
+    """Register an "inferable" file compression type.
+
+    Registers transparent file compression type for use with fsspec.open.
+    Compression can be specified by name in open, or "infer"-ed for any files
+    ending with the given extensions.
+
+    Args:
+        name: (str) The compression type name. Eg. "gzip".
+        callback: A callable of form (infile, mode, **kwargs) -> file-like.
+            Accepts an input file-like object, the target mode and kwargs.
+            Returns a wrapped file-like object.
+        extensions: (str, Iterable[str]) A file extension, or list of file
+            extensions for which to infer this compression scheme. Eg. "gz".
+        force: (bool) Force re-registration of compression type or extensions.
+
+    Raises:
+        ValueError: If name or extensions already registered, and not force.
+
+    """
+    if isinstance(extensions, str):
+        extensions = [extensions]
+
+    # Validate registration
+    if name in compr and not force:
+        raise ValueError(f"Duplicate compression registration: {name}")
+
+    for ext in extensions:
+        if ext in fsspec.utils.compressions and not force:
+            raise ValueError(f"Duplicate compression file extension: {ext} ({name})")
+
+    compr[name] = callback
+
+    for ext in extensions:
+        fsspec.utils.compressions[ext] = name
+
+
+def unzip(infile, mode="rb", filename=None, **kwargs):
+    if "r" not in mode:
+        filename = filename or "file"
+        z = ZipFile(infile, mode="w", **kwargs)
+        fo = z.open(filename, mode="w")
+        fo.close = lambda closer=fo.close: closer() or z.close()
+        return fo
+    z = ZipFile(infile)
+    if filename is None:
+        filename = z.namelist()[0]
+    return z.open(filename, mode="r", **kwargs)
+
+
+register_compression("zip", unzip, "zip")
+
+try:
+    from bz2 import BZ2File
+except ImportError:
+    pass
+else:
+    register_compression("bz2", BZ2File, "bz2")
+
+try:  # pragma: no cover
+    from isal import igzip
+
+    def isal(infile, mode="rb", **kwargs):
+        return igzip.IGzipFile(fileobj=infile, mode=mode, **kwargs)
+
+    register_compression("gzip", isal, "gz")
+except ImportError:
+    from gzip import GzipFile
+
+    register_compression(
+        "gzip", lambda f, **kwargs: GzipFile(fileobj=f, **kwargs), "gz"
+    )
+
+try:
+    from lzma import LZMAFile
+
+    register_compression("lzma", LZMAFile, "xz")
+    register_compression("xz", LZMAFile, "xz", force=True)
+except ImportError:
+    pass
+
+try:
+    import lzmaffi
+
+    register_compression("lzma", lzmaffi.LZMAFile, "xz", force=True)
+    register_compression("xz", lzmaffi.LZMAFile, "xz", force=True)
+except ImportError:
+    pass
+
+
+class SnappyFile(AbstractBufferedFile):
+    def __init__(self, infile, mode, **kwargs):
+        import snappy
+
+        super().__init__(
+            fs=None, path="snappy", mode=mode.strip("b") + "b", size=999999999, **kwargs
+        )
+        self.infile = infile
+        if "r" in mode:
+            self.codec = snappy.StreamDecompressor()
+        else:
+            self.codec = snappy.StreamCompressor()
+
+    def _upload_chunk(self, final=False):
+        self.buffer.seek(0)
+        out = self.codec.add_chunk(self.buffer.read())
+        self.infile.write(out)
+        return True
+
+    def seek(self, loc, whence=0):
+        raise NotImplementedError("SnappyFile is not seekable")
+
+    def seekable(self):
+        return False
+
+    def _fetch_range(self, start, end):
+        """Get the specified set of bytes from remote"""
+        data = self.infile.read(end - start)
+        return self.codec.decompress(data)
+
+
+try:
+    import snappy
+
+    snappy.compress
+    # Snappy may use the .sz file extension, but this is not part of the
+    # standard implementation.
+    register_compression("snappy", SnappyFile, [])
+
+except (ImportError, NameError, AttributeError):
+    pass
+
+try:
+    import lz4.frame
+
+    register_compression("lz4", lz4.frame.open, "lz4")
+except ImportError:
+    pass
+
+try:
+    import zstandard as zstd
+
+    def zstandard_file(infile, mode="rb"):
+        if "r" in mode:
+            cctx = zstd.ZstdDecompressor()
+            return cctx.stream_reader(infile)
+        else:
+            cctx = zstd.ZstdCompressor(level=10)
+            return cctx.stream_writer(infile)
+
+    register_compression("zstd", zstandard_file, "zst")
+except ImportError:
+    pass
+
+
+def available_compressions():
+    """Return a list of the implemented compressions."""
+    return list(compr)
diff --git a/lib/python3.11/site-packages/fsspec/config.py b/lib/python3.11/site-packages/fsspec/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..76d9af14aaf7df47c4551c169f27b05abf9c269e
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/config.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import configparser
+import json
+import os
+import warnings
+from typing import Any
+
+conf: dict[str, dict[str, Any]] = {}
+default_conf_dir = os.path.join(os.path.expanduser("~"), ".config/fsspec")
+conf_dir = os.environ.get("FSSPEC_CONFIG_DIR", default_conf_dir)
+
+
+def set_conf_env(conf_dict, envdict=os.environ):
+    """Set config values from environment variables
+
+    Looks for variables of the form ``FSSPEC_<protocol>`` and
+    ``FSSPEC_<protocol>_<kwarg>``. For ``FSSPEC_<protocol>`` the value is parsed
+    as a json dictionary and used to ``update`` the config of the
+    corresponding protocol. For ``FSSPEC_<protocol>_<kwarg>`` there is no
+    attempt to convert the string value, but the kwarg keys will be lower-cased.
+
+    The ``FSSPEC_<protocol>_<kwarg>`` variables are applied after the
+    ``FSSPEC_<protocol>`` ones.
+
+    Parameters
+    ----------
+    conf_dict : dict(str, dict)
+        This dict will be mutated
+    envdict : dict-like(str, str)
+        Source for the values - usually the real environment
+    """
+    kwarg_keys = []
+    for key in envdict:
+        if key.startswith("FSSPEC_") and len(key) > 7 and key[7] != "_":
+            if key.count("_") > 1:
+                kwarg_keys.append(key)
+                continue
+            try:
+                value = json.loads(envdict[key])
+            except json.decoder.JSONDecodeError as ex:
+                warnings.warn(
+                    f"Ignoring environment variable {key} due to a parse failure: {ex}"
+                )
+            else:
+                if isinstance(value, dict):
+                    _, proto = key.split("_", 1)
+                    conf_dict.setdefault(proto.lower(), {}).update(value)
+                else:
+                    warnings.warn(
+                        f"Ignoring environment variable {key} due to not being a dict:"
+                        f" {type(value)}"
+                    )
+        elif key.startswith("FSSPEC"):
+            warnings.warn(
+                f"Ignoring environment variable {key} due to having an unexpected name"
+            )
+
+    for key in kwarg_keys:
+        _, proto, kwarg = key.split("_", 2)
+        conf_dict.setdefault(proto.lower(), {})[kwarg.lower()] = envdict[key]
+
+
+def set_conf_files(cdir, conf_dict):
+    """Set config values from files
+
+    Scans for INI and JSON files in the given dictionary, and uses their
+    contents to set the config. In case of repeated values, later values
+    win.
+
+    In the case of INI files, all values are strings, and these will not
+    be converted.
+
+    Parameters
+    ----------
+    cdir : str
+        Directory to search
+    conf_dict : dict(str, dict)
+        This dict will be mutated
+    """
+    if not os.path.isdir(cdir):
+        return
+    allfiles = sorted(os.listdir(cdir))
+    for fn in allfiles:
+        if fn.endswith(".ini"):
+            ini = configparser.ConfigParser()
+            ini.read(os.path.join(cdir, fn))
+            for key in ini:
+                if key == "DEFAULT":
+                    continue
+                conf_dict.setdefault(key, {}).update(dict(ini[key]))
+        if fn.endswith(".json"):
+            with open(os.path.join(cdir, fn)) as f:
+                js = json.load(f)
+            for key in js:
+                conf_dict.setdefault(key, {}).update(dict(js[key]))
+
+
+def apply_config(cls, kwargs, conf_dict=None):
+    """Supply default values for kwargs when instantiating class
+
+    Augments the passed kwargs, by finding entries in the config dict
+    which match the classes ``.protocol`` attribute (one or more str)
+
+    Parameters
+    ----------
+    cls : file system implementation
+    kwargs : dict
+    conf_dict : dict of dict
+        Typically this is the global configuration
+
+    Returns
+    -------
+    dict : the modified set of kwargs
+    """
+    if conf_dict is None:
+        conf_dict = conf
+    protos = cls.protocol if isinstance(cls.protocol, (tuple, list)) else [cls.protocol]
+    kw = {}
+    for proto in protos:
+        # default kwargs from the current state of the config
+        if proto in conf_dict:
+            kw.update(conf_dict[proto])
+    # explicit kwargs always win
+    kw.update(**kwargs)
+    kwargs = kw
+    return kwargs
+
+
+set_conf_files(conf_dir, conf)
+set_conf_env(conf)
diff --git a/lib/python3.11/site-packages/fsspec/conftest.py b/lib/python3.11/site-packages/fsspec/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..6874a42c4895c3c7b973dc5d63fd4488a4e60b44
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/conftest.py
@@ -0,0 +1,55 @@
+import os
+import shutil
+import subprocess
+import sys
+import time
+
+import pytest
+
+import fsspec
+from fsspec.implementations.cached import CachingFileSystem
+
+
+@pytest.fixture()
+def m():
+    """
+    Fixture providing a memory filesystem.
+    """
+    m = fsspec.filesystem("memory")
+    m.store.clear()
+    m.pseudo_dirs.clear()
+    m.pseudo_dirs.append("")
+    try:
+        yield m
+    finally:
+        m.store.clear()
+        m.pseudo_dirs.clear()
+        m.pseudo_dirs.append("")
+
+
+@pytest.fixture
+def ftp_writable(tmpdir):
+    """
+    Fixture providing a writable FTP filesystem.
+    """
+    pytest.importorskip("pyftpdlib")
+    from fsspec.implementations.ftp import FTPFileSystem
+
+    FTPFileSystem.clear_instance_cache()  # remove lingering connections
+    CachingFileSystem.clear_instance_cache()
+    d = str(tmpdir)
+    with open(os.path.join(d, "out"), "wb") as f:
+        f.write(b"hello" * 10000)
+    P = subprocess.Popen(
+        [sys.executable, "-m", "pyftpdlib", "-d", d, "-u", "user", "-P", "pass", "-w"]
+    )
+    try:
+        time.sleep(1)
+        yield "localhost", 2121, "user", "pass"
+    finally:
+        P.terminate()
+        P.wait()
+        try:
+            shutil.rmtree(tmpdir)
+        except Exception:
+            pass
diff --git a/lib/python3.11/site-packages/fsspec/core.py b/lib/python3.11/site-packages/fsspec/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bc8e8e9b40db2245c57684fe808c8757e27ccbb
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/core.py
@@ -0,0 +1,710 @@
+from __future__ import annotations
+
+import io
+import logging
+import os
+import re
+from glob import has_magic
+from pathlib import Path
+
+# for backwards compat, we export cache things from here too
+from .caching import (  # noqa: F401
+    BaseCache,
+    BlockCache,
+    BytesCache,
+    MMapCache,
+    ReadAheadCache,
+    caches,
+)
+from .compression import compr
+from .registry import filesystem, get_filesystem_class
+from .utils import (
+    _unstrip_protocol,
+    build_name_function,
+    infer_compression,
+    stringify_path,
+)
+
+logger = logging.getLogger("fsspec")
+
+
+class OpenFile:
+    """
+    File-like object to be used in a context
+
+    Can layer (buffered) text-mode and compression over any file-system, which
+    are typically binary-only.
+
+    These instances are safe to serialize, as the low-level file object
+    is not created until invoked using ``with``.
+
+    Parameters
+    ----------
+    fs: FileSystem
+        The file system to use for opening the file. Should be a subclass or duck-type
+        with ``fsspec.spec.AbstractFileSystem``
+    path: str
+        Location to open
+    mode: str like 'rb', optional
+        Mode of the opened file
+    compression: str or None, optional
+        Compression to apply
+    encoding: str or None, optional
+        The encoding to use if opened in text mode.
+    errors: str or None, optional
+        How to handle encoding errors if opened in text mode.
+    newline: None or str
+        Passed to TextIOWrapper in text mode, how to handle line endings.
+    autoopen: bool
+        If True, calls open() immediately. Mostly used by pickle
+    pos: int
+        If given and autoopen is True, seek to this location immediately
+    """
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        compression=None,
+        encoding=None,
+        errors=None,
+        newline=None,
+    ):
+        self.fs = fs
+        self.path = path
+        self.mode = mode
+        self.compression = get_compression(path, compression)
+        self.encoding = encoding
+        self.errors = errors
+        self.newline = newline
+        self.fobjects = []
+
+    def __reduce__(self):
+        return (
+            OpenFile,
+            (
+                self.fs,
+                self.path,
+                self.mode,
+                self.compression,
+                self.encoding,
+                self.errors,
+                self.newline,
+            ),
+        )
+
+    def __repr__(self):
+        return f"<OpenFile '{self.path}'>"
+
+    def __enter__(self):
+        mode = self.mode.replace("t", "").replace("b", "") + "b"
+
+        f = self.fs.open(self.path, mode=mode)
+
+        self.fobjects = [f]
+
+        if self.compression is not None:
+            compress = compr[self.compression]
+            f = compress(f, mode=mode[0])
+            self.fobjects.append(f)
+
+        if "b" not in self.mode:
+            # assume, for example, that 'r' is equivalent to 'rt' as in builtin
+            f = PickleableTextIOWrapper(
+                f, encoding=self.encoding, errors=self.errors, newline=self.newline
+            )
+            self.fobjects.append(f)
+
+        return self.fobjects[-1]
+
+    def __exit__(self, *args):
+        self.close()
+
+    @property
+    def full_name(self):
+        return _unstrip_protocol(self.path, self.fs)
+
+    def open(self):
+        """Materialise this as a real open file without context
+
+        The OpenFile object should be explicitly closed to avoid enclosed file
+        instances persisting. You must, therefore, keep a reference to the OpenFile
+        during the life of the file-like it generates.
+        """
+        return self.__enter__()
+
+    def close(self):
+        """Close all encapsulated file objects"""
+        for f in reversed(self.fobjects):
+            if "r" not in self.mode and not f.closed:
+                f.flush()
+            f.close()
+        self.fobjects.clear()
+
+
+class OpenFiles(list):
+    """List of OpenFile instances
+
+    Can be used in a single context, which opens and closes all of the
+    contained files. Normal list access to get the elements works as
+    normal.
+
+    A special case is made for caching filesystems - the files will
+    be down/uploaded together at the start or end of the context, and
+    this may happen concurrently, if the target filesystem supports it.
+    """
+
+    def __init__(self, *args, mode="rb", fs=None):
+        self.mode = mode
+        self.fs = fs
+        self.files = []
+        super().__init__(*args)
+
+    def __enter__(self):
+        if self.fs is None:
+            raise ValueError("Context has already been used")
+
+        fs = self.fs
+        while True:
+            if hasattr(fs, "open_many"):
+                # check for concurrent cache download; or set up for upload
+                self.files = fs.open_many(self)
+                return self.files
+            if hasattr(fs, "fs") and fs.fs is not None:
+                fs = fs.fs
+            else:
+                break
+        return [s.__enter__() for s in self]
+
+    def __exit__(self, *args):
+        fs = self.fs
+        [s.__exit__(*args) for s in self]
+        if "r" not in self.mode:
+            while True:
+                if hasattr(fs, "open_many"):
+                    # check for concurrent cache upload
+                    fs.commit_many(self.files)
+                    return
+                if hasattr(fs, "fs") and fs.fs is not None:
+                    fs = fs.fs
+                else:
+                    break
+
+    def __getitem__(self, item):
+        out = super().__getitem__(item)
+        if isinstance(item, slice):
+            return OpenFiles(out, mode=self.mode, fs=self.fs)
+        return out
+
+    def __repr__(self):
+        return f"<List of {len(self)} OpenFile instances>"
+
+
+def open_files(
+    urlpath,
+    mode="rb",
+    compression=None,
+    encoding="utf8",
+    errors=None,
+    name_function=None,
+    num=1,
+    protocol=None,
+    newline=None,
+    auto_mkdir=True,
+    expand=True,
+    **kwargs,
+):
+    """Given a path or paths, return a list of ``OpenFile`` objects.
+
+    For writing, a str path must contain the "*" character, which will be filled
+    in by increasing numbers, e.g., "part*" ->  "part1", "part2" if num=2.
+
+    For either reading or writing, can instead provide explicit list of paths.
+
+    Parameters
+    ----------
+    urlpath: string or list
+        Absolute or relative filepath(s). Prefix with a protocol like ``s3://``
+        to read from alternative filesystems. To read from multiple files you
+        can pass a globstring or a list of paths, with the caveat that they
+        must all have the same protocol.
+    mode: 'rb', 'wt', etc.
+    compression: string or None
+        If given, open file using compression codec. Can either be a compression
+        name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+        compression from the filename suffix.
+    encoding: str
+        For text mode only
+    errors: None or str
+        Passed to TextIOWrapper in text mode
+    name_function: function or None
+        if opening a set of files for writing, those files do not yet exist,
+        so we need to generate their names by formatting the urlpath for
+        each sequence number
+    num: int [1]
+        if writing mode, number of files we expect to create (passed to
+        name+function)
+    protocol: str or None
+        If given, overrides the protocol found in the URL.
+    newline: bytes or None
+        Used for line terminator in text mode. If None, uses system default;
+        if blank, uses no translation.
+    auto_mkdir: bool (True)
+        If in write mode, this will ensure the target directory exists before
+        writing, by calling ``fs.mkdirs(exist_ok=True)``.
+    expand: bool
+    **kwargs: dict
+        Extra options that make sense to a particular storage connection, e.g.
+        host, port, username, password, etc.
+
+    Examples
+    --------
+    >>> files = open_files('2015-*-*.csv')  # doctest: +SKIP
+    >>> files = open_files(
+    ...     's3://bucket/2015-*-*.csv.gz', compression='gzip'
+    ... )  # doctest: +SKIP
+
+    Returns
+    -------
+    An ``OpenFiles`` instance, which is a list of ``OpenFile`` objects that can
+    be used as a single context
+
+    Notes
+    -----
+    For a full list of the available protocols and the implementations that
+    they map across to see the latest online documentation:
+
+    - For implementations built into ``fsspec`` see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#built-in-implementations
+    - For implementations in separate packages see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#other-known-implementations
+    """
+    fs, fs_token, paths = get_fs_token_paths(
+        urlpath,
+        mode,
+        num=num,
+        name_function=name_function,
+        storage_options=kwargs,
+        protocol=protocol,
+        expand=expand,
+    )
+    if fs.protocol == "file":
+        fs.auto_mkdir = auto_mkdir
+    elif "r" not in mode and auto_mkdir:
+        parents = {fs._parent(path) for path in paths}
+        for parent in parents:
+            try:
+                fs.makedirs(parent, exist_ok=True)
+            except PermissionError:
+                pass
+    return OpenFiles(
+        [
+            OpenFile(
+                fs,
+                path,
+                mode=mode,
+                compression=compression,
+                encoding=encoding,
+                errors=errors,
+                newline=newline,
+            )
+            for path in paths
+        ],
+        mode=mode,
+        fs=fs,
+    )
+
+
+def _un_chain(path, kwargs):
+    x = re.compile(".*[^a-z]+.*")  # test for non protocol-like single word
+    bits = (
+        [p if "://" in p or x.match(p) else p + "://" for p in path.split("::")]
+        if "::" in path
+        else [path]
+    )
+    # [[url, protocol, kwargs], ...]
+    out = []
+    previous_bit = None
+    kwargs = kwargs.copy()
+    for bit in reversed(bits):
+        protocol = kwargs.pop("protocol", None) or split_protocol(bit)[0] or "file"
+        cls = get_filesystem_class(protocol)
+        extra_kwargs = cls._get_kwargs_from_urls(bit)
+        kws = kwargs.pop(protocol, {})
+        if bit is bits[0]:
+            kws.update(kwargs)
+        kw = dict(**extra_kwargs, **kws)
+        bit = cls._strip_protocol(bit)
+        if (
+            protocol in {"blockcache", "filecache", "simplecache"}
+            and "target_protocol" not in kw
+        ):
+            bit = previous_bit
+        out.append((bit, protocol, kw))
+        previous_bit = bit
+    out = list(reversed(out))
+    return out
+
+
+def url_to_fs(url, **kwargs):
+    """
+    Turn fully-qualified and potentially chained URL into filesystem instance
+
+    Parameters
+    ----------
+    url : str
+        The fsspec-compatible URL
+    **kwargs: dict
+        Extra options that make sense to a particular storage connection, e.g.
+        host, port, username, password, etc.
+
+    Returns
+    -------
+    filesystem : FileSystem
+        The new filesystem discovered from ``url`` and created with
+        ``**kwargs``.
+    urlpath : str
+        The file-systems-specific URL for ``url``.
+    """
+    # non-FS arguments that appear in fsspec.open()
+    # inspect could keep this in sync with open()'s signature
+    known_kwargs = {
+        "compression",
+        "encoding",
+        "errors",
+        "expand",
+        "mode",
+        "name_function",
+        "newline",
+        "num",
+    }
+    kwargs = {k: v for k, v in kwargs.items() if k not in known_kwargs}
+    chain = _un_chain(url, kwargs)
+    inkwargs = {}
+    # Reverse iterate the chain, creating a nested target_* structure
+    for i, ch in enumerate(reversed(chain)):
+        urls, protocol, kw = ch
+        if i == len(chain) - 1:
+            inkwargs = dict(**kw, **inkwargs)
+            continue
+        inkwargs["target_options"] = dict(**kw, **inkwargs)
+        inkwargs["target_protocol"] = protocol
+        inkwargs["fo"] = urls
+    urlpath, protocol, _ = chain[0]
+    fs = filesystem(protocol, **inkwargs)
+    return fs, urlpath
+
+
+def open(
+    urlpath,
+    mode="rb",
+    compression=None,
+    encoding="utf8",
+    errors=None,
+    protocol=None,
+    newline=None,
+    **kwargs,
+):
+    """Given a path or paths, return one ``OpenFile`` object.
+
+    Parameters
+    ----------
+    urlpath: string or list
+        Absolute or relative filepath. Prefix with a protocol like ``s3://``
+        to read from alternative filesystems. Should not include glob
+        character(s).
+    mode: 'rb', 'wt', etc.
+    compression: string or None
+        If given, open file using compression codec. Can either be a compression
+        name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+        compression from the filename suffix.
+    encoding: str
+        For text mode only
+    errors: None or str
+        Passed to TextIOWrapper in text mode
+    protocol: str or None
+        If given, overrides the protocol found in the URL.
+    newline: bytes or None
+        Used for line terminator in text mode. If None, uses system default;
+        if blank, uses no translation.
+    **kwargs: dict
+        Extra options that make sense to a particular storage connection, e.g.
+        host, port, username, password, etc.
+
+    Examples
+    --------
+    >>> openfile = open('2015-01-01.csv')  # doctest: +SKIP
+    >>> openfile = open(
+    ...     's3://bucket/2015-01-01.csv.gz', compression='gzip'
+    ... )  # doctest: +SKIP
+    >>> with openfile as f:
+    ...     df = pd.read_csv(f)  # doctest: +SKIP
+    ...
+
+    Returns
+    -------
+    ``OpenFile`` object.
+
+    Notes
+    -----
+    For a full list of the available protocols and the implementations that
+    they map across to see the latest online documentation:
+
+    - For implementations built into ``fsspec`` see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#built-in-implementations
+    - For implementations in separate packages see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#other-known-implementations
+    """
+    out = open_files(
+        urlpath=[urlpath],
+        mode=mode,
+        compression=compression,
+        encoding=encoding,
+        errors=errors,
+        protocol=protocol,
+        newline=newline,
+        expand=False,
+        **kwargs,
+    )
+    if not out:
+        raise FileNotFoundError(urlpath)
+    return out[0]
+
+
+def open_local(
+    url: str | list[str] | Path | list[Path],
+    mode: str = "rb",
+    **storage_options: dict,
+) -> str | list[str]:
+    """Open file(s) which can be resolved to local
+
+    For files which either are local, or get downloaded upon open
+    (e.g., by file caching)
+
+    Parameters
+    ----------
+    url: str or list(str)
+    mode: str
+        Must be read mode
+    storage_options:
+        passed on to FS for or used by open_files (e.g., compression)
+    """
+    if "r" not in mode:
+        raise ValueError("Can only ensure local files when reading")
+    of = open_files(url, mode=mode, **storage_options)
+    if not getattr(of[0].fs, "local_file", False):
+        raise ValueError(
+            "open_local can only be used on a filesystem which"
+            " has attribute local_file=True"
+        )
+    with of as files:
+        paths = [f.name for f in files]
+    if (isinstance(url, str) and not has_magic(url)) or isinstance(url, Path):
+        return paths[0]
+    return paths
+
+
+def get_compression(urlpath, compression):
+    if compression == "infer":
+        compression = infer_compression(urlpath)
+    if compression is not None and compression not in compr:
+        raise ValueError(f"Compression type {compression} not supported")
+    return compression
+
+
+def split_protocol(urlpath):
+    """Return protocol, path pair"""
+    urlpath = stringify_path(urlpath)
+    if "://" in urlpath:
+        protocol, path = urlpath.split("://", 1)
+        if len(protocol) > 1:
+            # excludes Windows paths
+            return protocol, path
+    if urlpath.startswith("data:"):
+        return urlpath.split(":", 1)
+    return None, urlpath
+
+
+def strip_protocol(urlpath):
+    """Return only path part of full URL, according to appropriate backend"""
+    protocol, _ = split_protocol(urlpath)
+    cls = get_filesystem_class(protocol)
+    return cls._strip_protocol(urlpath)
+
+
+def expand_paths_if_needed(paths, mode, num, fs, name_function):
+    """Expand paths if they have a ``*`` in them (write mode) or any of ``*?[]``
+    in them (read mode).
+
+    :param paths: list of paths
+    mode: str
+        Mode in which to open files.
+    num: int
+        If opening in writing mode, number of files we expect to create.
+    fs: filesystem object
+    name_function: callable
+        If opening in writing mode, this callable is used to generate path
+        names. Names are generated for each partition by
+        ``urlpath.replace('*', name_function(partition_index))``.
+    :return: list of paths
+    """
+    expanded_paths = []
+    paths = list(paths)
+
+    if "w" in mode:  # read mode
+        if sum([1 for p in paths if "*" in p]) > 1:
+            raise ValueError(
+                "When writing data, only one filename mask can be specified."
+            )
+        num = max(num, len(paths))
+
+        for curr_path in paths:
+            if "*" in curr_path:
+                # expand using name_function
+                expanded_paths.extend(_expand_paths(curr_path, name_function, num))
+            else:
+                expanded_paths.append(curr_path)
+        # if we generated more paths that asked for, trim the list
+        if len(expanded_paths) > num:
+            expanded_paths = expanded_paths[:num]
+
+    else:  # read mode
+        for curr_path in paths:
+            if has_magic(curr_path):
+                # expand using glob
+                expanded_paths.extend(fs.glob(curr_path))
+            else:
+                expanded_paths.append(curr_path)
+
+    return expanded_paths
+
+
+def get_fs_token_paths(
+    urlpath,
+    mode="rb",
+    num=1,
+    name_function=None,
+    storage_options=None,
+    protocol=None,
+    expand=True,
+):
+    """Filesystem, deterministic token, and paths from a urlpath and options.
+
+    Parameters
+    ----------
+    urlpath: string or iterable
+        Absolute or relative filepath, URL (may include protocols like
+        ``s3://``), or globstring pointing to data.
+    mode: str, optional
+        Mode in which to open files.
+    num: int, optional
+        If opening in writing mode, number of files we expect to create.
+    name_function: callable, optional
+        If opening in writing mode, this callable is used to generate path
+        names. Names are generated for each partition by
+        ``urlpath.replace('*', name_function(partition_index))``.
+    storage_options: dict, optional
+        Additional keywords to pass to the filesystem class.
+    protocol: str or None
+        To override the protocol specifier in the URL
+    expand: bool
+        Expand string paths for writing, assuming the path is a directory
+    """
+    if isinstance(urlpath, (list, tuple, set)):
+        if not urlpath:
+            raise ValueError("empty urlpath sequence")
+        urlpath0 = stringify_path(list(urlpath)[0])
+    else:
+        urlpath0 = stringify_path(urlpath)
+    storage_options = storage_options or {}
+    if protocol:
+        storage_options["protocol"] = protocol
+    chain = _un_chain(urlpath0, storage_options or {})
+    inkwargs = {}
+    # Reverse iterate the chain, creating a nested target_* structure
+    for i, ch in enumerate(reversed(chain)):
+        urls, nested_protocol, kw = ch
+        if i == len(chain) - 1:
+            inkwargs = dict(**kw, **inkwargs)
+            continue
+        inkwargs["target_options"] = dict(**kw, **inkwargs)
+        inkwargs["target_protocol"] = nested_protocol
+        inkwargs["fo"] = urls
+    paths, protocol, _ = chain[0]
+    fs = filesystem(protocol, **inkwargs)
+    if isinstance(urlpath, (list, tuple, set)):
+        pchains = [
+            _un_chain(stringify_path(u), storage_options or {})[0] for u in urlpath
+        ]
+        if len({pc[1] for pc in pchains}) > 1:
+            raise ValueError("Protocol mismatch getting fs from %s", urlpath)
+        paths = [pc[0] for pc in pchains]
+    else:
+        paths = fs._strip_protocol(paths)
+    if isinstance(paths, (list, tuple, set)):
+        paths = expand_paths_if_needed(paths, mode, num, fs, name_function)
+    else:
+        if "w" in mode and expand:
+            paths = _expand_paths(paths, name_function, num)
+        elif "x" in mode and expand:
+            paths = _expand_paths(paths, name_function, num)
+        elif "*" in paths:
+            paths = [f for f in sorted(fs.glob(paths)) if not fs.isdir(f)]
+        else:
+            paths = [paths]
+
+    return fs, fs._fs_token, paths
+
+
+def _expand_paths(path, name_function, num):
+    if isinstance(path, str):
+        if path.count("*") > 1:
+            raise ValueError("Output path spec must contain exactly one '*'.")
+        elif "*" not in path:
+            path = os.path.join(path, "*.part")
+
+        if name_function is None:
+            name_function = build_name_function(num - 1)
+
+        paths = [path.replace("*", name_function(i)) for i in range(num)]
+        if paths != sorted(paths):
+            logger.warning(
+                "In order to preserve order between partitions"
+                " paths created with ``name_function`` should "
+                "sort to partition order"
+            )
+    elif isinstance(path, (tuple, list)):
+        assert len(path) == num
+        paths = list(path)
+    else:
+        raise ValueError(
+            "Path should be either\n"
+            "1. A list of paths: ['foo.json', 'bar.json', ...]\n"
+            "2. A directory: 'foo/\n"
+            "3. A path with a '*' in it: 'foo.*.json'"
+        )
+    return paths
+
+
+class PickleableTextIOWrapper(io.TextIOWrapper):
+    """TextIOWrapper cannot be pickled. This solves it.
+
+    Requires that ``buffer`` be pickleable, which all instances of
+    AbstractBufferedFile are.
+    """
+
+    def __init__(
+        self,
+        buffer,
+        encoding=None,
+        errors=None,
+        newline=None,
+        line_buffering=False,
+        write_through=False,
+    ):
+        self.args = buffer, encoding, errors, newline, line_buffering, write_through
+        super().__init__(*self.args)
+
+    def __reduce__(self):
+        return PickleableTextIOWrapper, self.args
diff --git a/lib/python3.11/site-packages/fsspec/dircache.py b/lib/python3.11/site-packages/fsspec/dircache.py
new file mode 100644
index 0000000000000000000000000000000000000000..eca19566b135e5a7a4f6e7407d56411ec58bfe44
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/dircache.py
@@ -0,0 +1,98 @@
+import time
+from collections.abc import MutableMapping
+from functools import lru_cache
+
+
+class DirCache(MutableMapping):
+    """
+    Caching of directory listings, in a structure like::
+
+        {"path0": [
+            {"name": "path0/file0",
+             "size": 123,
+             "type": "file",
+             ...
+            },
+            {"name": "path0/file1",
+            },
+            ...
+            ],
+         "path1": [...]
+        }
+
+    Parameters to this class control listing expiry or indeed turn
+    caching off
+    """
+
+    def __init__(
+        self,
+        use_listings_cache=True,
+        listings_expiry_time=None,
+        max_paths=None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        use_listings_cache: bool
+            If False, this cache never returns items, but always reports KeyError,
+            and setting items has no effect
+        listings_expiry_time: int or float (optional)
+            Time in seconds that a listing is considered valid. If None,
+            listings do not expire.
+        max_paths: int (optional)
+            The number of most recent listings that are considered valid; 'recent'
+            refers to when the entry was set.
+        """
+        self._cache = {}
+        self._times = {}
+        if max_paths:
+            self._q = lru_cache(max_paths + 1)(lambda key: self._cache.pop(key, None))
+        self.use_listings_cache = use_listings_cache
+        self.listings_expiry_time = listings_expiry_time
+        self.max_paths = max_paths
+
+    def __getitem__(self, item):
+        if self.listings_expiry_time is not None:
+            if self._times.get(item, 0) - time.time() < -self.listings_expiry_time:
+                del self._cache[item]
+        if self.max_paths:
+            self._q(item)
+        return self._cache[item]  # maybe raises KeyError
+
+    def clear(self):
+        self._cache.clear()
+
+    def __len__(self):
+        return len(self._cache)
+
+    def __contains__(self, item):
+        try:
+            self[item]
+            return True
+        except KeyError:
+            return False
+
+    def __setitem__(self, key, value):
+        if not self.use_listings_cache:
+            return
+        if self.max_paths:
+            self._q(key)
+        self._cache[key] = value
+        if self.listings_expiry_time is not None:
+            self._times[key] = time.time()
+
+    def __delitem__(self, key):
+        del self._cache[key]
+
+    def __iter__(self):
+        entries = list(self._cache)
+
+        return (k for k in entries if k in self)
+
+    def __reduce__(self):
+        return (
+            DirCache,
+            (self.use_listings_cache, self.listings_expiry_time, self.max_paths),
+        )
diff --git a/lib/python3.11/site-packages/fsspec/exceptions.py b/lib/python3.11/site-packages/fsspec/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d6e1a44b6a1667d1c302869ff2a332634fda47e
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/exceptions.py
@@ -0,0 +1,21 @@
+"""
+fsspec user-defined exception classes
+"""
+import asyncio
+
+
+class BlocksizeMismatchError(ValueError):
+    """
+    Raised when a cached file is opened with a different blocksize than it was
+    written with
+    """
+
+    ...
+
+
+class FSTimeoutError(asyncio.TimeoutError):
+    """
+    Raised when a fsspec function timed out occurs
+    """
+
+    ...
diff --git a/lib/python3.11/site-packages/fsspec/fuse.py b/lib/python3.11/site-packages/fsspec/fuse.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ca8c973c1993ac00016bb46e3ae7a3e44bc8d15
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/fuse.py
@@ -0,0 +1,324 @@
+import argparse
+import logging
+import os
+import stat
+import threading
+import time
+from errno import EIO, ENOENT
+
+from fuse import FUSE, FuseOSError, LoggingMixIn, Operations
+
+from fsspec import __version__
+from fsspec.core import url_to_fs
+
+logger = logging.getLogger("fsspec.fuse")
+
+
+class FUSEr(Operations):
+    def __init__(self, fs, path, ready_file=False):
+        self.fs = fs
+        self.cache = {}
+        self.root = path.rstrip("/") + "/"
+        self.counter = 0
+        logger.info("Starting FUSE at %s", path)
+        self._ready_file = ready_file
+
+    def getattr(self, path, fh=None):
+        logger.debug("getattr %s", path)
+        if self._ready_file and path in ["/.fuse_ready", ".fuse_ready"]:
+            return {"type": "file", "st_size": 5}
+
+        path = "".join([self.root, path.lstrip("/")]).rstrip("/")
+        try:
+            info = self.fs.info(path)
+        except FileNotFoundError:
+            raise FuseOSError(ENOENT)
+
+        data = {"st_uid": info.get("uid", 1000), "st_gid": info.get("gid", 1000)}
+        perm = info.get("mode", 0o777)
+
+        if info["type"] != "file":
+            data["st_mode"] = stat.S_IFDIR | perm
+            data["st_size"] = 0
+            data["st_blksize"] = 0
+        else:
+            data["st_mode"] = stat.S_IFREG | perm
+            data["st_size"] = info["size"]
+            data["st_blksize"] = 5 * 2**20
+            data["st_nlink"] = 1
+        data["st_atime"] = info["atime"] if "atime" in info else time.time()
+        data["st_ctime"] = info["ctime"] if "ctime" in info else time.time()
+        data["st_mtime"] = info["mtime"] if "mtime" in info else time.time()
+        return data
+
+    def readdir(self, path, fh):
+        logger.debug("readdir %s", path)
+        path = "".join([self.root, path.lstrip("/")])
+        files = self.fs.ls(path, False)
+        files = [os.path.basename(f.rstrip("/")) for f in files]
+        return [".", ".."] + files
+
+    def mkdir(self, path, mode):
+        path = "".join([self.root, path.lstrip("/")])
+        self.fs.mkdir(path)
+        return 0
+
+    def rmdir(self, path):
+        path = "".join([self.root, path.lstrip("/")])
+        self.fs.rmdir(path)
+        return 0
+
+    def read(self, path, size, offset, fh):
+        logger.debug("read %s", (path, size, offset))
+        if self._ready_file and path in ["/.fuse_ready", ".fuse_ready"]:
+            # status indicator
+            return b"ready"
+
+        f = self.cache[fh]
+        f.seek(offset)
+        out = f.read(size)
+        return out
+
+    def write(self, path, data, offset, fh):
+        logger.debug("write %s", (path, offset))
+        f = self.cache[fh]
+        f.seek(offset)
+        f.write(data)
+        return len(data)
+
+    def create(self, path, flags, fi=None):
+        logger.debug("create %s", (path, flags))
+        fn = "".join([self.root, path.lstrip("/")])
+        self.fs.touch(fn)  # OS will want to get attributes immediately
+        f = self.fs.open(fn, "wb")
+        self.cache[self.counter] = f
+        self.counter += 1
+        return self.counter - 1
+
+    def open(self, path, flags):
+        logger.debug("open %s", (path, flags))
+        fn = "".join([self.root, path.lstrip("/")])
+        if flags % 2 == 0:
+            # read
+            mode = "rb"
+        else:
+            # write/create
+            mode = "wb"
+        self.cache[self.counter] = self.fs.open(fn, mode)
+        self.counter += 1
+        return self.counter - 1
+
+    def truncate(self, path, length, fh=None):
+        fn = "".join([self.root, path.lstrip("/")])
+        if length != 0:
+            raise NotImplementedError
+        # maybe should be no-op since open with write sets size to zero anyway
+        self.fs.touch(fn)
+
+    def unlink(self, path):
+        fn = "".join([self.root, path.lstrip("/")])
+        try:
+            self.fs.rm(fn, False)
+        except (OSError, FileNotFoundError):
+            raise FuseOSError(EIO)
+
+    def release(self, path, fh):
+        try:
+            if fh in self.cache:
+                f = self.cache[fh]
+                f.close()
+                self.cache.pop(fh)
+        except Exception as e:
+            print(e)
+        return 0
+
+    def chmod(self, path, mode):
+        if hasattr(self.fs, "chmod"):
+            path = "".join([self.root, path.lstrip("/")])
+            return self.fs.chmod(path, mode)
+        raise NotImplementedError
+
+
+def run(
+    fs,
+    path,
+    mount_point,
+    foreground=True,
+    threads=False,
+    ready_file=False,
+    ops_class=FUSEr,
+):
+    """Mount stuff in a local directory
+
+    This uses fusepy to make it appear as if a given path on an fsspec
+    instance is in fact resident within the local file-system.
+
+    This requires that fusepy by installed, and that FUSE be available on
+    the system (typically requiring a package to be installed with
+    apt, yum, brew, etc.).
+
+    Parameters
+    ----------
+    fs: file-system instance
+        From one of the compatible implementations
+    path: str
+        Location on that file-system to regard as the root directory to
+        mount. Note that you typically should include the terminating "/"
+        character.
+    mount_point: str
+        An empty directory on the local file-system where the contents of
+        the remote path will appear.
+    foreground: bool
+        Whether or not calling this function will block. Operation will
+        typically be more stable if True.
+    threads: bool
+        Whether or not to create threads when responding to file operations
+        within the mounter directory. Operation will typically be more
+        stable if False.
+    ready_file: bool
+        Whether the FUSE process is ready. The ``.fuse_ready`` file will
+        exist in the ``mount_point`` directory if True. Debugging purpose.
+    ops_class: FUSEr or Subclass of FUSEr
+        To override the default behavior of FUSEr. For Example, logging
+        to file.
+
+    """
+    func = lambda: FUSE(
+        ops_class(fs, path, ready_file=ready_file),
+        mount_point,
+        nothreads=not threads,
+        foreground=foreground,
+    )
+    if not foreground:
+        th = threading.Thread(target=func)
+        th.daemon = True
+        th.start()
+        return th
+    else:  # pragma: no cover
+        try:
+            func()
+        except KeyboardInterrupt:
+            pass
+
+
+def main(args):
+    """Mount filesystem from chained URL to MOUNT_POINT.
+
+    Examples:
+
+    python3 -m fsspec.fuse memory /usr/share /tmp/mem
+
+    python3 -m fsspec.fuse local /tmp/source /tmp/local \\
+            -l /tmp/fsspecfuse.log
+
+    You can also mount chained-URLs and use special settings:
+
+    python3 -m fsspec.fuse 'filecache::zip::file://data.zip' \\
+            / /tmp/zip \\
+            -o 'filecache-cache_storage=/tmp/simplecache'
+
+    You can specify the type of the setting by using `[int]` or `[bool]`,
+    (`true`, `yes`, `1` represents the Boolean value `True`):
+
+    python3 -m fsspec.fuse 'simplecache::ftp://ftp1.at.proftpd.org' \\
+            /historic/packages/RPMS /tmp/ftp \\
+            -o 'simplecache-cache_storage=/tmp/simplecache' \\
+            -o 'simplecache-check_files=false[bool]' \\
+            -o 'ftp-listings_expiry_time=60[int]' \\
+            -o 'ftp-username=anonymous' \\
+            -o 'ftp-password=xieyanbo'
+    """
+
+    class RawDescriptionArgumentParser(argparse.ArgumentParser):
+        def format_help(self):
+            usage = super().format_help()
+            parts = usage.split("\n\n")
+            parts[1] = self.description.rstrip()
+            return "\n\n".join(parts)
+
+    parser = RawDescriptionArgumentParser(prog="fsspec.fuse", description=main.__doc__)
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument("url", type=str, help="fs url")
+    parser.add_argument("source_path", type=str, help="source directory in fs")
+    parser.add_argument("mount_point", type=str, help="local directory")
+    parser.add_argument(
+        "-o",
+        "--option",
+        action="append",
+        help="Any options of protocol included in the chained URL",
+    )
+    parser.add_argument(
+        "-l", "--log-file", type=str, help="Logging FUSE debug info (Default: '')"
+    )
+    parser.add_argument(
+        "-f",
+        "--foreground",
+        action="store_false",
+        help="Running in foreground or not (Default: False)",
+    )
+    parser.add_argument(
+        "-t",
+        "--threads",
+        action="store_false",
+        help="Running with threads support (Default: False)",
+    )
+    parser.add_argument(
+        "-r",
+        "--ready-file",
+        action="store_false",
+        help="The `.fuse_ready` file will exist after FUSE is ready. "
+        "(Debugging purpose, Default: False)",
+    )
+    args = parser.parse_args(args)
+
+    kwargs = {}
+    for item in args.option or []:
+        key, sep, value = item.partition("=")
+        if not sep:
+            parser.error(message=f"Wrong option: {item!r}")
+        val = value.lower()
+        if val.endswith("[int]"):
+            value = int(value[: -len("[int]")])
+        elif val.endswith("[bool]"):
+            value = val[: -len("[bool]")] in ["1", "yes", "true"]
+
+        if "-" in key:
+            fs_name, setting_name = key.split("-", 1)
+            if fs_name in kwargs:
+                kwargs[fs_name][setting_name] = value
+            else:
+                kwargs[fs_name] = {setting_name: value}
+        else:
+            kwargs[key] = value
+
+    if args.log_file:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            filename=args.log_file,
+            format="%(asctime)s %(message)s",
+        )
+
+        class LoggingFUSEr(FUSEr, LoggingMixIn):
+            pass
+
+        fuser = LoggingFUSEr
+    else:
+        fuser = FUSEr
+
+    fs, url_path = url_to_fs(args.url, **kwargs)
+    logger.debug("Mounting %s to %s", url_path, str(args.mount_point))
+    run(
+        fs,
+        args.source_path,
+        args.mount_point,
+        foreground=args.foreground,
+        threads=args.threads,
+        ready_file=args.ready_file,
+        ops_class=fuser,
+    )
+
+
+if __name__ == "__main__":
+    import sys
+
+    main(sys.argv[1:])
diff --git a/lib/python3.11/site-packages/fsspec/generic.py b/lib/python3.11/site-packages/fsspec/generic.py
new file mode 100644
index 0000000000000000000000000000000000000000..20534cf40c2cde48e37d4ede8b28985150d6da9c
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/generic.py
@@ -0,0 +1,403 @@
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+import shutil
+import uuid
+from typing import Optional
+
+from .asyn import AsyncFileSystem, _run_coros_in_chunks, sync_wrapper
+from .callbacks import _DEFAULT_CALLBACK
+from .core import filesystem, get_filesystem_class, split_protocol, url_to_fs
+
+_generic_fs = {}
+logger = logging.getLogger("fsspec.generic")
+
+
+def set_generic_fs(protocol, **storage_options):
+    _generic_fs[protocol] = filesystem(protocol, **storage_options)
+
+
+default_method = "default"
+
+
+def _resolve_fs(url, method=None, protocol=None, storage_options=None):
+    """Pick instance of backend FS"""
+    method = method or default_method
+    protocol = protocol or split_protocol(url)[0]
+    storage_options = storage_options or {}
+    if method == "default":
+        return filesystem(protocol)
+    if method == "generic":
+        return _generic_fs[protocol]
+    if method == "current":
+        cls = get_filesystem_class(protocol)
+        return cls.current()
+    if method == "options":
+        fs, _ = url_to_fs(url, **storage_options.get(protocol, {}))
+        return fs
+    raise ValueError(f"Unknown FS resolution method: {method}")
+
+
+def rsync(
+    source,
+    destination,
+    delete_missing=False,
+    source_field="size",
+    dest_field="size",
+    update_cond="different",
+    inst_kwargs=None,
+    fs=None,
+    **kwargs,
+):
+    """Sync files between two directory trees
+
+    (experimental)
+
+    Parameters
+    ----------
+    source: str
+        Root of the directory tree to take files from. This must be a directory, but
+        do not include any terminating "/" character
+    destination: str
+        Root path to copy into. The contents of this location should be
+        identical to the contents of ``source`` when done. This will be made a
+        directory, and the terminal "/" should not be included.
+    delete_missing: bool
+        If there are paths in the destination that don't exist in the
+        source and this is True, delete them. Otherwise, leave them alone.
+    source_field: str | callable
+        If ``update_field`` is "different", this is the key in the info
+        of source files to consider for difference. Maybe a function of the
+        info dict.
+    dest_field: str | callable
+        If ``update_field`` is "different", this is the key in the info
+        of destination files to consider for difference. May be a function of
+        the info dict.
+    update_cond: "different"|"always"|"never"
+        If "always", every file is copied, regardless of whether it exists in
+        the destination. If "never", files that exist in the destination are
+        not copied again. If "different" (default), only copy if the info
+        fields given by ``source_field`` and ``dest_field`` (usually "size")
+        are different. Other comparisons may be added in the future.
+    inst_kwargs: dict|None
+        If ``fs`` is None, use this set of keyword arguments to make a
+        GenericFileSystem instance
+    fs: GenericFileSystem|None
+        Instance to use if explicitly given. The instance defines how to
+        to make downstream file system instances from paths.
+    """
+    fs = fs or GenericFileSystem(**(inst_kwargs or {}))
+    source = fs._strip_protocol(source)
+    destination = fs._strip_protocol(destination)
+    allfiles = fs.find(source, withdirs=True, detail=True)
+    if not fs.isdir(source):
+        raise ValueError("Can only rsync on a directory")
+    otherfiles = fs.find(destination, withdirs=True, detail=True)
+    dirs = [
+        a
+        for a, v in allfiles.items()
+        if v["type"] == "directory" and a.replace(source, destination) not in otherfiles
+    ]
+    logger.debug(f"{len(dirs)} directories to create")
+    if dirs:
+        fs.make_many_dirs(
+            [dirn.replace(source, destination) for dirn in dirs], exist_ok=True
+        )
+    allfiles = {a: v for a, v in allfiles.items() if v["type"] == "file"}
+    logger.debug(f"{len(allfiles)} files to consider for copy")
+    to_delete = [
+        o
+        for o, v in otherfiles.items()
+        if o.replace(destination, source) not in allfiles and v["type"] == "file"
+    ]
+    for k, v in allfiles.copy().items():
+        otherfile = k.replace(source, destination)
+        if otherfile in otherfiles:
+            if update_cond == "always":
+                allfiles[k] = otherfile
+            elif update_cond == "different":
+                inf1 = source_field(v) if callable(source_field) else v[source_field]
+                v2 = otherfiles[otherfile]
+                inf2 = dest_field(v2) if callable(dest_field) else v2[dest_field]
+                if inf1 != inf2:
+                    # details mismatch, make copy
+                    allfiles[k] = otherfile
+                else:
+                    # details match, don't copy
+                    allfiles.pop(k)
+        else:
+            # file not in target yet
+            allfiles[k] = otherfile
+    logger.debug(f"{len(allfiles)} files to copy")
+    if allfiles:
+        source_files, target_files = zip(*allfiles.items())
+        fs.cp(source_files, target_files, **kwargs)
+    logger.debug(f"{len(to_delete)} files to delete")
+    if delete_missing:
+        fs.rm(to_delete)
+
+
+class GenericFileSystem(AsyncFileSystem):
+    """Wrapper over all other FS types
+
+    <experimental!>
+
+    This implementation is a single unified interface to be able to run FS operations
+    over generic URLs, and dispatch to the specific implementations using the URL
+    protocol prefix.
+
+    Note: instances of this FS are always async, even if you never use it with any async
+    backend.
+    """
+
+    protocol = "generic"  # there is no real reason to ever use a protocol with this FS
+
+    def __init__(self, default_method="default", **kwargs):
+        """
+
+        Parameters
+        ----------
+        default_method: str (optional)
+            Defines how to configure backend FS instances. Options are:
+            - "default": instantiate like FSClass(), with no
+              extra arguments; this is the default instance of that FS, and can be
+              configured via the config system
+            - "generic": takes instances from the `_generic_fs` dict in this module,
+              which you must populate before use. Keys are by protocol
+            - "current": takes the most recently instantiated version of each FS
+        """
+        self.method = default_method
+        super().__init__(**kwargs)
+
+    def _parent(self, path):
+        fs = _resolve_fs(path, self.method)
+        return fs.unstrip_protocol(fs._parent(path))
+
+    def _strip_protocol(self, path):
+        # normalization only
+        fs = _resolve_fs(path, self.method)
+        return fs.unstrip_protocol(fs._strip_protocol(path))
+
+    async def _find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        fs = _resolve_fs(path, self.method)
+        if fs.async_impl:
+            out = await fs._find(
+                path, maxdepth=maxdepth, withdirs=withdirs, detail=True, **kwargs
+            )
+        else:
+            out = fs.find(
+                path, maxdepth=maxdepth, withdirs=withdirs, detail=True, **kwargs
+            )
+        result = {}
+        for k, v in out.items():
+            name = fs.unstrip_protocol(k)
+            v["name"] = name
+            result[name] = v
+        if detail:
+            return result
+        return list(result)
+
+    async def _info(self, url, **kwargs):
+        fs = _resolve_fs(url, self.method)
+        if fs.async_impl:
+            out = await fs._info(url, **kwargs)
+        else:
+            out = fs.info(url, **kwargs)
+        out["name"] = fs.unstrip_protocol(out["name"])
+        return out
+
+    async def _ls(
+        self,
+        url,
+        detail=True,
+        **kwargs,
+    ):
+        fs = _resolve_fs(url, self.method)
+        if fs.async_impl:
+            out = await fs._ls(url, detail=True, **kwargs)
+        else:
+            out = fs.ls(url, detail=True, **kwargs)
+        for o in out:
+            o["name"] = fs.unstrip_protocol(o["name"])
+        if detail:
+            return out
+        else:
+            return [o["name"] for o in out]
+
+    async def _cat_file(
+        self,
+        url,
+        **kwargs,
+    ):
+        fs = _resolve_fs(url, self.method)
+        if fs.async_impl:
+            return await fs._cat_file(url, **kwargs)
+        else:
+            return fs.cat_file(url, **kwargs)
+
+    async def _pipe_file(
+        self,
+        path,
+        value,
+        **kwargs,
+    ):
+        fs = _resolve_fs(path, self.method)
+        if fs.async_impl:
+            return await fs._pipe_file(path, value, **kwargs)
+        else:
+            return fs.pipe_file(path, value, **kwargs)
+
+    async def _rm(self, url, **kwargs):
+        urls = url
+        if isinstance(urls, str):
+            urls = [urls]
+        fs = _resolve_fs(urls[0], self.method)
+        if fs.async_impl:
+            await fs._rm(urls, **kwargs)
+        else:
+            fs.rm(url, **kwargs)
+
+    async def _makedirs(self, path, exist_ok=False):
+        logger.debug("Make dir %s", path)
+        fs = _resolve_fs(path, self.method)
+        if fs.async_impl:
+            await fs._makedirs(path, exist_ok=exist_ok)
+        else:
+            fs.makedirs(path, exist_ok=exist_ok)
+
+    def rsync(self, source, destination, **kwargs):
+        """Sync files between two directory trees
+
+        See `func:rsync` for more details.
+        """
+        rsync(source, destination, fs=self, **kwargs)
+
+    async def _cp_file(
+        self,
+        url,
+        url2,
+        blocksize=2**20,
+        callback=_DEFAULT_CALLBACK,
+        **kwargs,
+    ):
+        fs = _resolve_fs(url, self.method)
+        fs2 = _resolve_fs(url2, self.method)
+        if fs is fs2:
+            # pure remote
+            if fs.async_impl:
+                return await fs._cp_file(url, url2, **kwargs)
+            else:
+                return fs.cp_file(url, url2, **kwargs)
+        kw = {"blocksize": 0, "cache_type": "none"}
+        try:
+            f1 = (
+                await fs.open_async(url, "rb")
+                if hasattr(fs, "open_async")
+                else fs.open(url, "rb", **kw)
+            )
+            callback.set_size(await maybe_await(f1.size))
+            f2 = (
+                await fs2.open_async(url2, "wb")
+                if hasattr(fs2, "open_async")
+                else fs2.open(url2, "wb", **kw)
+            )
+            while f1.size is None or f2.tell() < f1.size:
+                data = await maybe_await(f1.read(blocksize))
+                if f1.size is None and not data:
+                    break
+                await maybe_await(f2.write(data))
+                callback.absolute_update(f2.tell())
+        finally:
+            try:
+                await maybe_await(f2.close())
+                await maybe_await(f1.close())
+            except NameError:
+                # fail while opening f1 or f2
+                pass
+
+    async def _make_many_dirs(self, urls, exist_ok=True):
+        fs = _resolve_fs(urls[0], self.method)
+        if fs.async_impl:
+            coros = [fs._makedirs(u, exist_ok=exist_ok) for u in urls]
+            await _run_coros_in_chunks(coros)
+        else:
+            for u in urls:
+                fs.makedirs(u, exist_ok=exist_ok)
+
+    make_many_dirs = sync_wrapper(_make_many_dirs)
+
+    async def _copy(
+        self,
+        path1: list[str],
+        path2: list[str],
+        recursive: bool = False,
+        on_error: str = "ignore",
+        maxdepth: Optional[int] = None,
+        batch_size: Optional[int] = None,
+        tempdir: Optional[str] = None,
+        **kwargs,
+    ):
+        if recursive:
+            raise NotImplementedError
+        fs = _resolve_fs(path1[0], self.method)
+        fs2 = _resolve_fs(path2[0], self.method)
+        # not expanding paths atm., assume call is from rsync()
+        if fs is fs2:
+            # pure remote
+            if fs.async_impl:
+                return await fs._copy(path1, path2, **kwargs)
+            else:
+                return fs.copy(path1, path2, **kwargs)
+        await copy_file_op(
+            fs, path1, fs2, path2, tempdir, batch_size, on_error=on_error
+        )
+
+
+async def copy_file_op(
+    fs1, url1, fs2, url2, tempdir=None, batch_size=20, on_error="ignore"
+):
+    import tempfile
+
+    tempdir = tempdir or tempfile.mkdtemp()
+    try:
+        coros = [
+            _copy_file_op(
+                fs1,
+                u1,
+                fs2,
+                u2,
+                os.path.join(tempdir, uuid.uuid4().hex),
+                on_error=on_error,
+            )
+            for u1, u2 in zip(url1, url2)
+        ]
+        await _run_coros_in_chunks(coros, batch_size=batch_size)
+    finally:
+        shutil.rmtree(tempdir)
+
+
+async def _copy_file_op(fs1, url1, fs2, url2, local, on_error="ignore"):
+    ex = () if on_error == "raise" else Exception
+    logger.debug("Copy %s -> %s", url1, url2)
+    try:
+        if fs1.async_impl:
+            await fs1._get_file(url1, local)
+        else:
+            fs1.get_file(url1, local)
+        if fs2.async_impl:
+            await fs2._put_file(local, url2)
+        else:
+            fs2.put_file(local, url2)
+        os.unlink(local)
+        logger.debug("Copy %s -> %s; done", url1, url2)
+    except ex as e:
+        logger.debug("ignoring cp exception for %s: %s", url1, e)
+
+
+async def maybe_await(cor):
+    if inspect.iscoroutine(cor):
+        return await cor
+    else:
+        return cor
diff --git a/lib/python3.11/site-packages/fsspec/gui.py b/lib/python3.11/site-packages/fsspec/gui.py
new file mode 100644
index 0000000000000000000000000000000000000000..efa5b5f860e596ab6791f06305e66316ed266082
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/gui.py
@@ -0,0 +1,413 @@
+import ast
+import contextlib
+import logging
+import os
+import re
+from typing import ClassVar, Sequence
+
+import panel as pn
+
+from .core import OpenFile, get_filesystem_class, split_protocol
+from .registry import known_implementations
+
+pn.extension()
+logger = logging.getLogger("fsspec.gui")
+
+
+class SigSlot:
+    """Signal-slot mixin, for Panel event passing
+
+    Include this class in a widget manager's superclasses to be able to
+    register events and callbacks on Panel widgets managed by that class.
+
+    The method ``_register`` should be called as widgets are added, and external
+    code should call ``connect`` to associate callbacks.
+
+    By default, all signals emit a DEBUG logging statement.
+    """
+
+    # names of signals that this class may emit each of which must be
+    # set by _register for any new instance
+    signals: ClassVar[Sequence[str]] = []
+    # names of actions that this class may respond to
+    slots: ClassVar[Sequence[str]] = []
+
+    # each of which must be a method name
+
+    def __init__(self):
+        self._ignoring_events = False
+        self._sigs = {}
+        self._map = {}
+        self._setup()
+
+    def _setup(self):
+        """Create GUI elements and register signals"""
+        self.panel = pn.pane.PaneBase()
+        # no signals to set up in the base class
+
+    def _register(
+        self, widget, name, thing="value", log_level=logging.DEBUG, auto=False
+    ):
+        """Watch the given attribute of a widget and assign it a named event
+
+        This is normally called at the time a widget is instantiated, in the
+        class which owns it.
+
+        Parameters
+        ----------
+        widget : pn.layout.Panel or None
+            Widget to watch. If None, an anonymous signal not associated with
+            any widget.
+        name : str
+            Name of this event
+        thing : str
+            Attribute of the given widget to watch
+        log_level : int
+            When the signal is triggered, a logging event of the given level
+            will be fired in the dfviz logger.
+        auto : bool
+            If True, automatically connects with a method in this class of the
+            same name.
+        """
+        if name not in self.signals:
+            raise ValueError(f"Attempt to assign an undeclared signal: {name}")
+        self._sigs[name] = {
+            "widget": widget,
+            "callbacks": [],
+            "thing": thing,
+            "log": log_level,
+        }
+        wn = "-".join(
+            [
+                getattr(widget, "name", str(widget)) if widget is not None else "none",
+                thing,
+            ]
+        )
+        self._map[wn] = name
+        if widget is not None:
+            widget.param.watch(self._signal, thing, onlychanged=True)
+        if auto and hasattr(self, name):
+            self.connect(name, getattr(self, name))
+
+    def _repr_mimebundle_(self, *args, **kwargs):
+        """Display in a notebook or a server"""
+        try:
+            return self.panel._repr_mimebundle_(*args, **kwargs)
+        except (ValueError, AttributeError):
+            raise NotImplementedError("Panel does not seem to be set " "up properly")
+
+    def connect(self, signal, slot):
+        """Associate call back with given event
+
+        The callback must be a function which takes the "new" value of the
+        watched attribute as the only parameter. If the callback return False,
+        this cancels any further processing of the given event.
+
+        Alternatively, the callback can be a string, in which case it means
+        emitting the correspondingly-named event (i.e., connect to self)
+        """
+        self._sigs[signal]["callbacks"].append(slot)
+
+    def _signal(self, event):
+        """This is called by a an action on a widget
+
+        Within an self.ignore_events context, nothing happens.
+
+        Tests can execute this method by directly changing the values of
+        widget components.
+        """
+        if not self._ignoring_events:
+            wn = "-".join([event.obj.name, event.name])
+            if wn in self._map and self._map[wn] in self._sigs:
+                self._emit(self._map[wn], event.new)
+
+    @contextlib.contextmanager
+    def ignore_events(self):
+        """Temporarily turn off events processing in this instance
+
+        (does not propagate to children)
+        """
+        self._ignoring_events = True
+        try:
+            yield
+        finally:
+            self._ignoring_events = False
+
+    def _emit(self, sig, value=None):
+        """An event happened, call its callbacks
+
+        This method can be used in tests to simulate message passing without
+        directly changing visual elements.
+
+        Calling of callbacks will halt whenever one returns False.
+        """
+        logger.log(self._sigs[sig]["log"], f"{sig}: {value}")
+        for callback in self._sigs[sig]["callbacks"]:
+            if isinstance(callback, str):
+                self._emit(callback)
+            else:
+                try:
+                    # running callbacks should not break the interface
+                    ret = callback(value)
+                    if ret is False:
+                        break
+                except Exception as e:
+                    logger.exception(
+                        "Exception (%s) while executing callback for signal: %s"
+                        "" % (e, sig)
+                    )
+
+    def show(self, threads=False):
+        """Open a new browser tab and display this instance's interface"""
+        self.panel.show(threads=threads, verbose=False)
+        return self
+
+
+class SingleSelect(SigSlot):
+    """A multiselect which only allows you to select one item for an event"""
+
+    signals = ["_selected", "selected"]  # the first is internal
+    slots = ["set_options", "set_selection", "add", "clear", "select"]
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        super().__init__()
+
+    def _setup(self):
+        self.panel = pn.widgets.MultiSelect(**self.kwargs)
+        self._register(self.panel, "_selected", "value")
+        self._register(None, "selected")
+        self.connect("_selected", self.select_one)
+
+    def _signal(self, *args, **kwargs):
+        super()._signal(*args, **kwargs)
+
+    def select_one(self, *_):
+        with self.ignore_events():
+            val = [self.panel.value[-1]] if self.panel.value else []
+            self.panel.value = val
+        self._emit("selected", self.panel.value)
+
+    def set_options(self, options):
+        self.panel.options = options
+
+    def clear(self):
+        self.panel.options = []
+
+    @property
+    def value(self):
+        return self.panel.value
+
+    def set_selection(self, selection):
+        self.panel.value = [selection]
+
+
+class FileSelector(SigSlot):
+    """Panel-based graphical file selector widget
+
+    Instances of this widget are interactive and can be displayed in jupyter by having
+    them as the output of a cell,  or in a separate browser tab using ``.show()``.
+    """
+
+    signals = [
+        "protocol_changed",
+        "selection_changed",
+        "directory_entered",
+        "home_clicked",
+        "up_clicked",
+        "go_clicked",
+        "filters_changed",
+    ]
+    slots = ["set_filters", "go_home"]
+
+    def __init__(self, url=None, filters=None, ignore=None, kwargs=None):
+        """
+
+        Parameters
+        ----------
+        url : str (optional)
+            Initial value of the URL to populate the dialog; should include protocol
+        filters : list(str) (optional)
+            File endings to include in the listings. If not included, all files are
+            allowed. Does not affect directories.
+            If given, the endings will appear as checkboxes in the interface
+        ignore : list(str) (optional)
+            Regex(s) of file basename patterns to ignore, e.g., "\\." for typical
+            hidden files on posix
+        kwargs : dict (optional)
+            To pass to file system instance
+        """
+        if url:
+            self.init_protocol, url = split_protocol(url)
+        else:
+            self.init_protocol, url = "file", os.getcwd()
+        self.init_url = url
+        self.init_kwargs = (kwargs if isinstance(kwargs, str) else str(kwargs)) or "{}"
+        self.filters = filters
+        self.ignore = [re.compile(i) for i in ignore or []]
+        self._fs = None
+        super().__init__()
+
+    def _setup(self):
+        self.url = pn.widgets.TextInput(
+            name="url",
+            value=self.init_url,
+            align="end",
+            sizing_mode="stretch_width",
+            width_policy="max",
+        )
+        self.protocol = pn.widgets.Select(
+            options=sorted(known_implementations),
+            value=self.init_protocol,
+            name="protocol",
+            align="center",
+        )
+        self.kwargs = pn.widgets.TextInput(
+            name="kwargs", value=self.init_kwargs, align="center"
+        )
+        self.go = pn.widgets.Button(name="⇨", align="end", width=45)
+        self.main = SingleSelect(size=10)
+        self.home = pn.widgets.Button(name="🏠", width=40, height=30, align="end")
+        self.up = pn.widgets.Button(name="‹", width=30, height=30, align="end")
+
+        self._register(self.protocol, "protocol_changed", auto=True)
+        self._register(self.go, "go_clicked", "clicks", auto=True)
+        self._register(self.up, "up_clicked", "clicks", auto=True)
+        self._register(self.home, "home_clicked", "clicks", auto=True)
+        self._register(None, "selection_changed")
+        self.main.connect("selected", self.selection_changed)
+        self._register(None, "directory_entered")
+        self.prev_protocol = self.protocol.value
+        self.prev_kwargs = self.storage_options
+
+        self.filter_sel = pn.widgets.CheckBoxGroup(
+            value=[], options=[], inline=False, align="end", width_policy="min"
+        )
+        self._register(self.filter_sel, "filters_changed", auto=True)
+
+        self.panel = pn.Column(
+            pn.Row(self.protocol, self.kwargs),
+            pn.Row(self.home, self.up, self.url, self.go, self.filter_sel),
+            self.main.panel,
+        )
+        self.set_filters(self.filters)
+        self.go_clicked()
+
+    def set_filters(self, filters=None):
+        self.filters = filters
+        if filters:
+            self.filter_sel.options = filters
+            self.filter_sel.value = filters
+        else:
+            self.filter_sel.options = []
+            self.filter_sel.value = []
+
+    @property
+    def storage_options(self):
+        """Value of the kwargs box as a dictionary"""
+        return ast.literal_eval(self.kwargs.value) or {}
+
+    @property
+    def fs(self):
+        """Current filesystem instance"""
+        if self._fs is None:
+            cls = get_filesystem_class(self.protocol.value)
+            self._fs = cls(**self.storage_options)
+        return self._fs
+
+    @property
+    def urlpath(self):
+        """URL of currently selected item"""
+        return (
+            (f"{self.protocol.value}://{self.main.value[0]}")
+            if self.main.value
+            else None
+        )
+
+    def open_file(self, mode="rb", compression=None, encoding=None):
+        """Create OpenFile instance for the currently selected item
+
+        For example, in a notebook you might do something like
+
+        .. code-block::
+
+            [ ]: sel = FileSelector(); sel
+
+            # user selects their file
+
+            [ ]: with sel.open_file('rb') as f:
+            ...      out = f.read()
+
+        Parameters
+        ----------
+        mode: str (optional)
+            Open mode for the file.
+        compression: str (optional)
+            The interact with the file as compressed. Set to 'infer' to guess
+            compression from the file ending
+        encoding: str (optional)
+            If using text mode, use this encoding; defaults to UTF8.
+        """
+        if self.urlpath is None:
+            raise ValueError("No file selected")
+        return OpenFile(self.fs, self.urlpath, mode, compression, encoding)
+
+    def filters_changed(self, values):
+        self.filters = values
+        self.go_clicked()
+
+    def selection_changed(self, *_):
+        if self.urlpath is None:
+            return
+        if self.fs.isdir(self.urlpath):
+            self.url.value = self.fs._strip_protocol(self.urlpath)
+        self.go_clicked()
+
+    def go_clicked(self, *_):
+        if (
+            self.prev_protocol != self.protocol.value
+            or self.prev_kwargs != self.storage_options
+        ):
+            self._fs = None  # causes fs to be recreated
+            self.prev_protocol = self.protocol.value
+            self.prev_kwargs = self.storage_options
+        listing = sorted(
+            self.fs.ls(self.url.value, detail=True), key=lambda x: x["name"]
+        )
+        listing = [
+            l
+            for l in listing
+            if not any(i.match(l["name"].rsplit("/", 1)[-1]) for i in self.ignore)
+        ]
+        folders = {
+            "📁 " + o["name"].rsplit("/", 1)[-1]: o["name"]
+            for o in listing
+            if o["type"] == "directory"
+        }
+        files = {
+            "📄 " + o["name"].rsplit("/", 1)[-1]: o["name"]
+            for o in listing
+            if o["type"] == "file"
+        }
+        if self.filters:
+            files = {
+                k: v
+                for k, v in files.items()
+                if any(v.endswith(ext) for ext in self.filters)
+            }
+        self.main.set_options(dict(**folders, **files))
+
+    def protocol_changed(self, *_):
+        self._fs = None
+        self.main.options = []
+        self.url.value = ""
+
+    def home_clicked(self, *_):
+        self.protocol.value = self.init_protocol
+        self.kwargs.value = self.init_kwargs
+        self.url.value = self.init_url
+        self.go_clicked()
+
+    def up_clicked(self, *_):
+        self.url.value = self.fs._parent(self.url.value)
+        self.go_clicked()
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__init__.py b/lib/python3.11/site-packages/fsspec/implementations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c898dc46fe28b224e7cd188d89a1906c1db1c57
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/arrow.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/arrow.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5780bebc6506fc38372dd86c7dc341d9482f2214
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/arrow.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13f012db7360d09c8581a1b29779721ddbb074d1
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8850709c1947895d251bafc02809f10818b467e
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cached.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cached.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed119b7288c5e2f79422836b92a943564a17cad0
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cached.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dask.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dask.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..961720075a612b895d43ea89edfedd1ac1be7f79
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dask.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/data.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/data.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f16cbfb9db7a7141a660fd01875fcbfcf32487a0
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/data.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dbfs.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dbfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6192f7be79a33053596aa752f87d59e98868fb52
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dbfs.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dirfs.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dirfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7cc566f7f64df08478ba35366f8426be55d6c6a7
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dirfs.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/ftp.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/ftp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ed2c6c93a72f25ad258b95a28c3296325d52a4d
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/ftp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/git.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/git.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..34f5e23b3abf5113be822b4344e64c2b0ea8a25a
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/git.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/github.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/github.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a680b317ce79c70ef180d8dba222f666c07515b
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/github.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..654c0bb4bba8d41ab96684c879dad8f40cca5916
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/jupyter.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/jupyter.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76c7bcb63fb813c9d74db72915c48bf1282ca957
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/jupyter.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/libarchive.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/libarchive.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..79ae30e4e72f6d8c9f208579354b954561c9dd57
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/libarchive.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/local.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/local.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..513b4659170014939055cfed713573a5367493de
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/local.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/memory.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/memory.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9009325516a90d97c9d19de8d022f1669be5462
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/memory.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/reference.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/reference.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f338da329c1fc2dd4086934c0835125bcefeb84
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/reference.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/sftp.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/sftp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..56a56dac6836f1b7b6ef18365116df9a3b2c32df
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/sftp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/smb.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/smb.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..de86a16f71855e3ad1b452e2fa5e70206f8c26a2
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/smb.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/tar.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/tar.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cd6d27856882d339b9ada485eab1a269d4aa6750
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/tar.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d45b7ffb9704dbe97ec18420a5ad377c380ec9c
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/__pycache__/zip.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/zip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ce49b119222c84c458f98712d96c8ba856e404b
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/implementations/__pycache__/zip.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/implementations/arrow.py b/lib/python3.11/site-packages/fsspec/implementations/arrow.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b1048acdec34d4f5eeff90e30e3629023c6099d
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/arrow.py
@@ -0,0 +1,297 @@
+import errno
+import io
+import os
+import secrets
+import shutil
+from contextlib import suppress
+from functools import cached_property, wraps
+
+from fsspec.spec import AbstractFileSystem
+from fsspec.utils import (
+    get_package_version_without_import,
+    infer_storage_options,
+    mirror_from,
+    tokenize,
+)
+
+
+def wrap_exceptions(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except OSError as exception:
+            if not exception.args:
+                raise
+
+            message, *args = exception.args
+            if isinstance(message, str) and "does not exist" in message:
+                raise FileNotFoundError(errno.ENOENT, message) from exception
+            else:
+                raise
+
+    return wrapper
+
+
+PYARROW_VERSION = None
+
+
+class ArrowFSWrapper(AbstractFileSystem):
+    """FSSpec-compatible wrapper of pyarrow.fs.FileSystem.
+
+    Parameters
+    ----------
+    fs : pyarrow.fs.FileSystem
+
+    """
+
+    root_marker = "/"
+
+    def __init__(self, fs, **kwargs):
+        global PYARROW_VERSION
+        PYARROW_VERSION = get_package_version_without_import("pyarrow")
+        self.fs = fs
+        super().__init__(**kwargs)
+
+    @property
+    def protocol(self):
+        return self.fs.type_name
+
+    @cached_property
+    def fsid(self):
+        return "hdfs_" + tokenize(self.fs.host, self.fs.port)
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        ops = infer_storage_options(path)
+        path = ops["path"]
+        if path.startswith("//"):
+            # special case for "hdfs://path" (without the triple slash)
+            path = path[1:]
+        return path
+
+    def ls(self, path, detail=False, **kwargs):
+        path = self._strip_protocol(path)
+        from pyarrow.fs import FileSelector
+
+        entries = [
+            self._make_entry(entry)
+            for entry in self.fs.get_file_info(FileSelector(path))
+        ]
+        if detail:
+            return entries
+        else:
+            return [entry["name"] for entry in entries]
+
+    def info(self, path, **kwargs):
+        path = self._strip_protocol(path)
+        [info] = self.fs.get_file_info([path])
+        return self._make_entry(info)
+
+    def exists(self, path):
+        path = self._strip_protocol(path)
+        try:
+            self.info(path)
+        except FileNotFoundError:
+            return False
+        else:
+            return True
+
+    def _make_entry(self, info):
+        from pyarrow.fs import FileType
+
+        if info.type is FileType.Directory:
+            kind = "directory"
+        elif info.type is FileType.File:
+            kind = "file"
+        elif info.type is FileType.NotFound:
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), info.path)
+        else:
+            kind = "other"
+
+        return {
+            "name": info.path,
+            "size": info.size,
+            "type": kind,
+            "mtime": info.mtime,
+        }
+
+    @wrap_exceptions
+    def cp_file(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1).rstrip("/")
+        path2 = self._strip_protocol(path2).rstrip("/")
+
+        with self._open(path1, "rb") as lstream:
+            tmp_fname = f"{path2}.tmp.{secrets.token_hex(6)}"
+            try:
+                with self.open(tmp_fname, "wb") as rstream:
+                    shutil.copyfileobj(lstream, rstream)
+                self.fs.move(tmp_fname, path2)
+            except BaseException:  # noqa
+                with suppress(FileNotFoundError):
+                    self.fs.delete_file(tmp_fname)
+                raise
+
+    @wrap_exceptions
+    def mv(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1).rstrip("/")
+        path2 = self._strip_protocol(path2).rstrip("/")
+        self.fs.move(path1, path2)
+
+    mv_file = mv
+
+    @wrap_exceptions
+    def rm_file(self, path):
+        path = self._strip_protocol(path)
+        self.fs.delete_file(path)
+
+    @wrap_exceptions
+    def rm(self, path, recursive=False, maxdepth=None):
+        path = self._strip_protocol(path).rstrip("/")
+        if self.isdir(path):
+            if recursive:
+                self.fs.delete_dir(path)
+            else:
+                raise ValueError("Can't delete directories without recursive=False")
+        else:
+            self.fs.delete_file(path)
+
+    @wrap_exceptions
+    def _open(self, path, mode="rb", block_size=None, seekable=True, **kwargs):
+        if mode == "rb":
+            if seekable:
+                method = self.fs.open_input_file
+            else:
+                method = self.fs.open_input_stream
+        elif mode == "wb":
+            method = self.fs.open_output_stream
+        elif mode == "ab":
+            method = self.fs.open_append_stream
+        else:
+            raise ValueError(f"unsupported mode for Arrow filesystem: {mode!r}")
+
+        _kwargs = {}
+        if mode != "rb" or not seekable:
+            if int(PYARROW_VERSION.split(".")[0]) >= 4:
+                # disable compression auto-detection
+                _kwargs["compression"] = None
+        stream = method(path, **_kwargs)
+
+        return ArrowFile(self, stream, path, mode, block_size, **kwargs)
+
+    @wrap_exceptions
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if create_parents:
+            self.makedirs(path, exist_ok=True)
+        else:
+            self.fs.create_dir(path, recursive=False)
+
+    @wrap_exceptions
+    def makedirs(self, path, exist_ok=False):
+        path = self._strip_protocol(path)
+        self.fs.create_dir(path, recursive=True)
+
+    @wrap_exceptions
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        self.fs.delete_dir(path)
+
+    @wrap_exceptions
+    def modified(self, path):
+        path = self._strip_protocol(path)
+        return self.fs.get_file_info(path).mtime
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        kwargs["seekable"] = start not in [None, 0]
+        return super().cat_file(path, start=None, end=None, **kwargs)
+
+    def get_file(self, rpath, lpath, **kwargs):
+        kwargs["seekable"] = False
+        super().get_file(rpath, lpath, **kwargs)
+
+
+@mirror_from(
+    "stream",
+    [
+        "read",
+        "seek",
+        "tell",
+        "write",
+        "readable",
+        "writable",
+        "close",
+        "size",
+        "seekable",
+    ],
+)
+class ArrowFile(io.IOBase):
+    def __init__(self, fs, stream, path, mode, block_size=None, **kwargs):
+        self.path = path
+        self.mode = mode
+
+        self.fs = fs
+        self.stream = stream
+
+        self.blocksize = self.block_size = block_size
+        self.kwargs = kwargs
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        return self.close()
+
+
+class HadoopFileSystem(ArrowFSWrapper):
+    """A wrapper on top of the pyarrow.fs.HadoopFileSystem
+    to connect it's interface with fsspec"""
+
+    protocol = "hdfs"
+
+    def __init__(
+        self,
+        host="default",
+        port=0,
+        user=None,
+        kerb_ticket=None,
+        extra_conf=None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        host: str
+            Hostname, IP or "default" to try to read from Hadoop config
+        port: int
+            Port to connect on, or default from Hadoop config if 0
+        user: str or None
+            If given, connect as this username
+        kerb_ticket: str or None
+            If given, use this ticket for authentication
+        extra_conf: None or dict
+            Passed on to HadoopFileSystem
+        """
+        from pyarrow.fs import HadoopFileSystem
+
+        fs = HadoopFileSystem(
+            host=host,
+            port=port,
+            user=user,
+            kerb_ticket=kerb_ticket,
+            extra_conf=extra_conf,
+        )
+        super().__init__(fs=fs, **kwargs)
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        ops = infer_storage_options(path)
+        out = {}
+        if ops.get("host", None):
+            out["host"] = ops["host"]
+        if ops.get("username", None):
+            out["user"] = ops["username"]
+        if ops.get("port", None):
+            out["port"] = ops["port"]
+        return out
diff --git a/lib/python3.11/site-packages/fsspec/implementations/cache_mapper.py b/lib/python3.11/site-packages/fsspec/implementations/cache_mapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..000ccebc83304369cd00fcd8b3458b852c366530
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/cache_mapper.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import abc
+import hashlib
+from typing import TYPE_CHECKING
+
+from fsspec.implementations.local import make_path_posix
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+class AbstractCacheMapper(abc.ABC):
+    """Abstract super-class for mappers from remote URLs to local cached
+    basenames.
+    """
+
+    @abc.abstractmethod
+    def __call__(self, path: str) -> str:
+        ...
+
+    def __eq__(self, other: Any) -> bool:
+        # Identity only depends on class. When derived classes have attributes
+        # they will need to be included.
+        return isinstance(other, type(self))
+
+    def __hash__(self) -> int:
+        # Identity only depends on class. When derived classes have attributes
+        # they will need to be included.
+        return hash(type(self))
+
+
+class BasenameCacheMapper(AbstractCacheMapper):
+    """Cache mapper that uses the basename of the remote URL and a fixed number
+    of directory levels above this.
+
+    The default is zero directory levels, meaning different paths with the same
+    basename will have the same cached basename.
+    """
+
+    def __init__(self, directory_levels: int = 0):
+        if directory_levels < 0:
+            raise ValueError(
+                "BasenameCacheMapper requires zero or positive directory_levels"
+            )
+        self.directory_levels = directory_levels
+
+        # Separator for directories when encoded as strings.
+        self._separator = "_@_"
+
+    def __call__(self, path: str) -> str:
+        path = make_path_posix(path)
+        prefix, *bits = path.rsplit("/", self.directory_levels + 1)
+        if bits:
+            return self._separator.join(bits)
+        else:
+            return prefix  # No separator found, simple filename
+
+    def __eq__(self, other: Any) -> bool:
+        return super().__eq__(other) and self.directory_levels == other.directory_levels
+
+    def __hash__(self) -> int:
+        return super().__hash__() ^ hash(self.directory_levels)
+
+
+class HashCacheMapper(AbstractCacheMapper):
+    """Cache mapper that uses a hash of the remote URL."""
+
+    def __call__(self, path: str) -> str:
+        return hashlib.sha256(path.encode()).hexdigest()
+
+
+def create_cache_mapper(same_names: bool) -> AbstractCacheMapper:
+    """Factory method to create cache mapper for backward compatibility with
+    ``CachingFileSystem`` constructor using ``same_names`` kwarg.
+    """
+    if same_names:
+        return BasenameCacheMapper()
+    else:
+        return HashCacheMapper()
diff --git a/lib/python3.11/site-packages/fsspec/implementations/cache_metadata.py b/lib/python3.11/site-packages/fsspec/implementations/cache_metadata.py
new file mode 100644
index 0000000000000000000000000000000000000000..16964c2a7153d40b480dd47513d1129ed27e307b
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/cache_metadata.py
@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import os
+import pickle
+import time
+from typing import TYPE_CHECKING
+
+from fsspec.utils import atomic_write
+
+try:
+    import ujson as json
+except ImportError:
+    if not TYPE_CHECKING:
+        import json
+
+if TYPE_CHECKING:
+    from typing import Any, Dict, Iterator, Literal
+
+    from typing_extensions import TypeAlias
+
+    from .cached import CachingFileSystem
+
+    Detail: TypeAlias = Dict[str, Any]
+
+
+class CacheMetadata:
+    """Cache metadata.
+
+    All reading and writing of cache metadata is performed by this class,
+    accessing the cached files and blocks is not.
+
+    Metadata is stored in a single file per storage directory in JSON format.
+    For backward compatibility, also reads metadata stored in pickle format
+    which is converted to JSON when next saved.
+    """
+
+    def __init__(self, storage: list[str]):
+        """
+
+        Parameters
+        ----------
+        storage: list[str]
+            Directories containing cached files, must be at least one. Metadata
+            is stored in the last of these directories by convention.
+        """
+        if not storage:
+            raise ValueError("CacheMetadata expects at least one storage location")
+
+        self._storage = storage
+        self.cached_files: list[Detail] = [{}]
+
+        # Private attribute to force saving of metadata in pickle format rather than
+        # JSON for use in tests to confirm can read both pickle and JSON formats.
+        self._force_save_pickle = False
+
+    def _load(self, fn: str) -> Detail:
+        """Low-level function to load metadata from specific file"""
+        try:
+            with open(fn, "r") as f:
+                return json.load(f)
+        except ValueError:
+            with open(fn, "rb") as f:
+                return pickle.load(f)
+
+    def _save(self, metadata_to_save: Detail, fn: str) -> None:
+        """Low-level function to save metadata to specific file"""
+        if self._force_save_pickle:
+            with atomic_write(fn) as f:
+                pickle.dump(metadata_to_save, f)
+        else:
+            with atomic_write(fn, mode="w") as f:
+                json.dump(metadata_to_save, f)
+
+    def _scan_locations(
+        self, writable_only: bool = False
+    ) -> Iterator[tuple[str, str, bool]]:
+        """Yield locations (filenames) where metadata is stored, and whether
+        writable or not.
+
+        Parameters
+        ----------
+        writable: bool
+            Set to True to only yield writable locations.
+
+        Returns
+        -------
+        Yields (str, str, bool)
+        """
+        n = len(self._storage)
+        for i, storage in enumerate(self._storage):
+            writable = i == n - 1
+            if writable_only and not writable:
+                continue
+            yield os.path.join(storage, "cache"), storage, writable
+
+    def check_file(
+        self, path: str, cfs: CachingFileSystem | None
+    ) -> Literal[False] | tuple[Detail, str]:
+        """If path is in cache return its details, otherwise return ``False``.
+
+        If the optional CachingFileSystem is specified then it is used to
+        perform extra checks to reject possible matches, such as if they are
+        too old.
+        """
+        for (fn, base, _), cache in zip(self._scan_locations(), self.cached_files):
+            if path not in cache:
+                continue
+            detail = cache[path].copy()
+
+            if cfs is not None:
+                if cfs.check_files and detail["uid"] != cfs.fs.ukey(path):
+                    # Wrong file as determined by hash of file properties
+                    continue
+                if cfs.expiry and time.time() - detail["time"] > cfs.expiry:
+                    # Cached file has expired
+                    continue
+
+            fn = os.path.join(base, detail["fn"])
+            if os.path.exists(fn):
+                return detail, fn
+        return False
+
+    def clear_expired(self, expiry_time: int) -> tuple[list[str], bool]:
+        """Remove expired metadata from the cache.
+
+        Returns names of files corresponding to expired metadata and a boolean
+        flag indicating whether the writable cache is empty. Caller is
+        responsible for deleting the expired files.
+        """
+        expired_files = []
+        for path, detail in self.cached_files[-1].copy().items():
+            if time.time() - detail["time"] > expiry_time:
+                fn = detail.get("fn", "")
+                if not fn:
+                    raise RuntimeError(
+                        f"Cache metadata does not contain 'fn' for {path}"
+                    )
+                fn = os.path.join(self._storage[-1], fn)
+                expired_files.append(fn)
+                self.cached_files[-1].pop(path)
+
+        if self.cached_files[-1]:
+            cache_path = os.path.join(self._storage[-1], "cache")
+            self._save(self.cached_files[-1], cache_path)
+
+        writable_cache_empty = not self.cached_files[-1]
+        return expired_files, writable_cache_empty
+
+    def load(self) -> None:
+        """Load all metadata from disk and store in ``self.cached_files``"""
+        cached_files = []
+        for fn, _, _ in self._scan_locations():
+            if os.path.exists(fn):
+                # TODO: consolidate blocks here
+                loaded_cached_files = self._load(fn)
+                for c in loaded_cached_files.values():
+                    if isinstance(c["blocks"], list):
+                        c["blocks"] = set(c["blocks"])
+                cached_files.append(loaded_cached_files)
+            else:
+                cached_files.append({})
+        self.cached_files = cached_files or [{}]
+
+    def on_close_cached_file(self, f: Any, path: str) -> None:
+        """Perform side-effect actions on closing a cached file.
+
+        The actual closing of the file is the responsibility of the caller.
+        """
+        # File must be writeble, so in self.cached_files[-1]
+        c = self.cached_files[-1][path]
+        if c["blocks"] is not True and len(c["blocks"]) * f.blocksize >= f.size:
+            c["blocks"] = True
+
+    def pop_file(self, path: str) -> str | None:
+        """Remove metadata of cached file.
+
+        If path is in the cache, return the filename of the cached file,
+        otherwise return ``None``.  Caller is responsible for deleting the
+        cached file.
+        """
+        details = self.check_file(path, None)
+        if not details:
+            return None
+        _, fn = details
+        if fn.startswith(self._storage[-1]):
+            self.cached_files[-1].pop(path)
+            self.save()
+        else:
+            raise PermissionError(
+                "Can only delete cached file in last, writable cache location"
+            )
+        return fn
+
+    def save(self) -> None:
+        """Save metadata to disk"""
+        for (fn, _, writable), cache in zip(self._scan_locations(), self.cached_files):
+            if not writable:
+                continue
+
+            if os.path.exists(fn):
+                cached_files = self._load(fn)
+                for k, c in cached_files.items():
+                    if k in cache:
+                        if c["blocks"] is True or cache[k]["blocks"] is True:
+                            c["blocks"] = True
+                        else:
+                            # self.cached_files[*][*]["blocks"] must continue to
+                            # point to the same set object so that updates
+                            # performed by MMapCache are propagated back to
+                            # self.cached_files.
+                            blocks = cache[k]["blocks"]
+                            blocks.update(c["blocks"])
+                            c["blocks"] = blocks
+                        c["time"] = max(c["time"], cache[k]["time"])
+                        c["uid"] = cache[k]["uid"]
+
+                # Files can be added to cache after it was written once
+                for k, c in cache.items():
+                    if k not in cached_files:
+                        cached_files[k] = c
+            else:
+                cached_files = cache
+            cache = {k: v.copy() for k, v in cached_files.items()}
+            for c in cache.values():
+                if isinstance(c["blocks"], set):
+                    c["blocks"] = list(c["blocks"])
+            self._save(cache, fn)
+            self.cached_files[-1] = cached_files
+
+    def update_file(self, path: str, detail: Detail) -> None:
+        """Update metadata for specific file in memory, do not save"""
+        self.cached_files[-1][path] = detail
diff --git a/lib/python3.11/site-packages/fsspec/implementations/cached.py b/lib/python3.11/site-packages/fsspec/implementations/cached.py
new file mode 100644
index 0000000000000000000000000000000000000000..7df86876349549c6a96cee89fb3870cbd9651b21
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/cached.py
@@ -0,0 +1,864 @@
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+import tempfile
+import time
+import weakref
+from shutil import rmtree
+from typing import TYPE_CHECKING, Any, Callable, ClassVar
+
+from fsspec import AbstractFileSystem, filesystem
+from fsspec.callbacks import _DEFAULT_CALLBACK
+from fsspec.compression import compr
+from fsspec.core import BaseCache, MMapCache
+from fsspec.exceptions import BlocksizeMismatchError
+from fsspec.implementations.cache_mapper import create_cache_mapper
+from fsspec.implementations.cache_metadata import CacheMetadata
+from fsspec.spec import AbstractBufferedFile
+from fsspec.transaction import Transaction
+from fsspec.utils import infer_compression
+
+if TYPE_CHECKING:
+    from fsspec.implementations.cache_mapper import AbstractCacheMapper
+
+logger = logging.getLogger("fsspec.cached")
+
+
+class WriteCachedTransaction(Transaction):
+    def complete(self, commit=True):
+        rpaths = [f.path for f in self.files]
+        lpaths = [f.fn for f in self.files]
+        if commit:
+            self.fs.put(lpaths, rpaths)
+        # else remove?
+        self.fs._intrans = False
+
+
+class CachingFileSystem(AbstractFileSystem):
+    """Locally caching filesystem, layer over any other FS
+
+    This class implements chunk-wise local storage of remote files, for quick
+    access after the initial download. The files are stored in a given
+    directory with hashes of URLs for the filenames. If no directory is given,
+    a temporary one is used, which should be cleaned up by the OS after the
+    process ends. The files themselves are sparse (as implemented in
+    :class:`~fsspec.caching.MMapCache`), so only the data which is accessed
+    takes up space.
+
+    Restrictions:
+
+    - the block-size must be the same for each access of a given file, unless
+      all blocks of the file have already been read
+    - caching can only be applied to file-systems which produce files
+      derived from fsspec.spec.AbstractBufferedFile ; LocalFileSystem is also
+      allowed, for testing
+    """
+
+    protocol: ClassVar[str | tuple[str, ...]] = ("blockcache", "cached")
+
+    def __init__(
+        self,
+        target_protocol=None,
+        cache_storage="TMP",
+        cache_check=10,
+        check_files=False,
+        expiry_time=604800,
+        target_options=None,
+        fs=None,
+        same_names: bool | None = None,
+        compression=None,
+        cache_mapper: AbstractCacheMapper | None = None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        target_protocol: str (optional)
+            Target filesystem protocol. Provide either this or ``fs``.
+        cache_storage: str or list(str)
+            Location to store files. If "TMP", this is a temporary directory,
+            and will be cleaned up by the OS when this process ends (or later).
+            If a list, each location will be tried in the order given, but
+            only the last will be considered writable.
+        cache_check: int
+            Number of seconds between reload of cache metadata
+        check_files: bool
+            Whether to explicitly see if the UID of the remote file matches
+            the stored one before using. Warning: some file systems such as
+            HTTP cannot reliably give a unique hash of the contents of some
+            path, so be sure to set this option to False.
+        expiry_time: int
+            The time in seconds after which a local copy is considered useless.
+            Set to falsy to prevent expiry. The default is equivalent to one
+            week.
+        target_options: dict or None
+            Passed to the instantiation of the FS, if fs is None.
+        fs: filesystem instance
+            The target filesystem to run against. Provide this or ``protocol``.
+        same_names: bool (optional)
+            By default, target URLs are hashed using a ``HashCacheMapper`` so
+            that files from different backends with the same basename do not
+            conflict. If this argument is ``true``, a ``BasenameCacheMapper``
+            is used instead. Other cache mapper options are available by using
+            the ``cache_mapper`` keyword argument. Only one of this and
+            ``cache_mapper`` should be specified.
+        compression: str (optional)
+            To decompress on download. Can be 'infer' (guess from the URL name),
+            one of the entries in ``fsspec.compression.compr``, or None for no
+            decompression.
+        cache_mapper: AbstractCacheMapper (optional)
+            The object use to map from original filenames to cached filenames.
+            Only one of this and ``same_names`` should be specified.
+        """
+        super().__init__(**kwargs)
+        if fs is None and target_protocol is None:
+            raise ValueError(
+                "Please provide filesystem instance(fs) or target_protocol"
+            )
+        if not (fs is None) ^ (target_protocol is None):
+            raise ValueError(
+                "Both filesystems (fs) and target_protocol may not be both given."
+            )
+        if cache_storage == "TMP":
+            tempdir = tempfile.mkdtemp()
+            storage = [tempdir]
+            weakref.finalize(self, self._remove_tempdir, tempdir)
+        else:
+            if isinstance(cache_storage, str):
+                storage = [cache_storage]
+            else:
+                storage = cache_storage
+        os.makedirs(storage[-1], exist_ok=True)
+        self.storage = storage
+        self.kwargs = target_options or {}
+        self.cache_check = cache_check
+        self.check_files = check_files
+        self.expiry = expiry_time
+        self.compression = compression
+
+        # Size of cache in bytes. If None then the size is unknown and will be
+        # recalculated the next time cache_size() is called. On writes to the
+        # cache this is reset to None.
+        self._cache_size = None
+
+        if same_names is not None and cache_mapper is not None:
+            raise ValueError(
+                "Cannot specify both same_names and cache_mapper in "
+                "CachingFileSystem.__init__"
+            )
+        if cache_mapper is not None:
+            self._mapper = cache_mapper
+        else:
+            self._mapper = create_cache_mapper(
+                same_names if same_names is not None else False
+            )
+
+        self.target_protocol = (
+            target_protocol
+            if isinstance(target_protocol, str)
+            else (fs.protocol if isinstance(fs.protocol, str) else fs.protocol[0])
+        )
+        self._metadata = CacheMetadata(self.storage)
+        self.load_cache()
+        self.fs = fs if fs is not None else filesystem(target_protocol, **self.kwargs)
+
+        def _strip_protocol(path):
+            # acts as a method, since each instance has a difference target
+            return self.fs._strip_protocol(type(self)._strip_protocol(path))
+
+        self._strip_protocol: Callable = _strip_protocol
+
+    @staticmethod
+    def _remove_tempdir(tempdir):
+        try:
+            rmtree(tempdir)
+        except Exception:
+            pass
+
+    def _mkcache(self):
+        os.makedirs(self.storage[-1], exist_ok=True)
+
+    def cache_size(self):
+        """Return size of cache in bytes.
+
+        If more than one cache directory is in use, only the size of the last
+        one (the writable cache directory) is returned.
+        """
+        if self._cache_size is None:
+            cache_dir = self.storage[-1]
+            self._cache_size = filesystem("file").du(cache_dir, withdirs=True)
+        return self._cache_size
+
+    def load_cache(self):
+        """Read set of stored blocks from file"""
+        self._metadata.load()
+        self._mkcache()
+        self.last_cache = time.time()
+
+    def save_cache(self):
+        """Save set of stored blocks from file"""
+        self._mkcache()
+        self._metadata.save()
+        self.last_cache = time.time()
+        self._cache_size = None
+
+    def _check_cache(self):
+        """Reload caches if time elapsed or any disappeared"""
+        self._mkcache()
+        if not self.cache_check:
+            # explicitly told not to bother checking
+            return
+        timecond = time.time() - self.last_cache > self.cache_check
+        existcond = all(os.path.exists(storage) for storage in self.storage)
+        if timecond or not existcond:
+            self.load_cache()
+
+    def _check_file(self, path):
+        """Is path in cache and still valid"""
+        path = self._strip_protocol(path)
+        self._check_cache()
+        return self._metadata.check_file(path, self)
+
+    def clear_cache(self):
+        """Remove all files and metadata from the cache
+
+        In the case of multiple cache locations, this clears only the last one,
+        which is assumed to be the read/write one.
+        """
+        rmtree(self.storage[-1])
+        self.load_cache()
+        self._cache_size = None
+
+    def clear_expired_cache(self, expiry_time=None):
+        """Remove all expired files and metadata from the cache
+
+        In the case of multiple cache locations, this clears only the last one,
+        which is assumed to be the read/write one.
+
+        Parameters
+        ----------
+        expiry_time: int
+            The time in seconds after which a local copy is considered useless.
+            If not defined the default is equivalent to the attribute from the
+            file caching instantiation.
+        """
+
+        if not expiry_time:
+            expiry_time = self.expiry
+
+        self._check_cache()
+
+        expired_files, writable_cache_empty = self._metadata.clear_expired(expiry_time)
+        for fn in expired_files:
+            if os.path.exists(fn):
+                os.remove(fn)
+
+        if writable_cache_empty:
+            rmtree(self.storage[-1])
+            self.load_cache()
+
+        self._cache_size = None
+
+    def pop_from_cache(self, path):
+        """Remove cached version of given file
+
+        Deletes local copy of the given (remote) path. If it is found in a cache
+        location which is not the last, it is assumed to be read-only, and
+        raises PermissionError
+        """
+        path = self._strip_protocol(path)
+        fn = self._metadata.pop_file(path)
+        if fn is not None:
+            os.remove(fn)
+        self._cache_size = None
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        """Wrap the target _open
+
+        If the whole file exists in the cache, just open it locally and
+        return that.
+
+        Otherwise, open the file on the target FS, and make it have a mmap
+        cache pointing to the location which we determine, in our cache.
+        The ``blocks`` instance is shared, so as the mmap cache instance
+        updates, so does the entry in our ``cached_files`` attribute.
+        We monkey-patch this file, so that when it closes, we call
+        ``close_and_update`` to save the state of the blocks.
+        """
+        path = self._strip_protocol(path)
+
+        path = self.fs._strip_protocol(path)
+        if "r" not in mode:
+            return self.fs._open(
+                path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=autocommit,
+                cache_options=cache_options,
+                **kwargs,
+            )
+        detail = self._check_file(path)
+        if detail:
+            # file is in cache
+            detail, fn = detail
+            hash, blocks = detail["fn"], detail["blocks"]
+            if blocks is True:
+                # stored file is complete
+                logger.debug("Opening local copy of %s", path)
+                return open(fn, mode)
+            # TODO: action where partial file exists in read-only cache
+            logger.debug("Opening partially cached copy of %s", path)
+        else:
+            hash = self._mapper(path)
+            fn = os.path.join(self.storage[-1], hash)
+            blocks = set()
+            detail = {
+                "original": path,
+                "fn": hash,
+                "blocks": blocks,
+                "time": time.time(),
+                "uid": self.fs.ukey(path),
+            }
+            self._metadata.update_file(path, detail)
+            logger.debug("Creating local sparse file for %s", path)
+
+        # call target filesystems open
+        self._mkcache()
+        f = self.fs._open(
+            path,
+            mode=mode,
+            block_size=block_size,
+            autocommit=autocommit,
+            cache_options=cache_options,
+            cache_type="none",
+            **kwargs,
+        )
+        if self.compression:
+            comp = (
+                infer_compression(path)
+                if self.compression == "infer"
+                else self.compression
+            )
+            f = compr[comp](f, mode="rb")
+        if "blocksize" in detail:
+            if detail["blocksize"] != f.blocksize:
+                raise BlocksizeMismatchError(
+                    f"Cached file must be reopened with same block"
+                    f" size as original (old: {detail['blocksize']},"
+                    f" new {f.blocksize})"
+                )
+        else:
+            detail["blocksize"] = f.blocksize
+        f.cache = MMapCache(f.blocksize, f._fetch_range, f.size, fn, blocks)
+        close = f.close
+        f.close = lambda: self.close_and_update(f, close)
+        self.save_cache()
+        return f
+
+    def _parent(self, path):
+        return self.fs._parent(path)
+
+    def hash_name(self, path: str, *args: Any) -> str:
+        # Kept for backward compatibility with downstream libraries.
+        # Ignores extra arguments, previously same_name boolean.
+        return self._mapper(path)
+
+    def close_and_update(self, f, close):
+        """Called when a file is closing, so store the set of blocks"""
+        if f.closed:
+            return
+        path = self._strip_protocol(f.path)
+        self._metadata.on_close_cached_file(f, path)
+        try:
+            logger.debug("going to save")
+            self.save_cache()
+            logger.debug("saved")
+        except OSError:
+            logger.debug("Cache saving failed while closing file")
+        except NameError:
+            logger.debug("Cache save failed due to interpreter shutdown")
+        close()
+        f.closed = True
+
+    def __getattribute__(self, item):
+        if item in [
+            "load_cache",
+            "_open",
+            "save_cache",
+            "close_and_update",
+            "__init__",
+            "__getattribute__",
+            "__reduce__",
+            "_make_local_details",
+            "open",
+            "cat",
+            "cat_file",
+            "cat_ranges",
+            "get",
+            "read_block",
+            "tail",
+            "head",
+            "_check_file",
+            "_check_cache",
+            "_mkcache",
+            "clear_cache",
+            "clear_expired_cache",
+            "pop_from_cache",
+            "_mkcache",
+            "local_file",
+            "_paths_from_path",
+            "get_mapper",
+            "open_many",
+            "commit_many",
+            "hash_name",
+            "__hash__",
+            "__eq__",
+            "to_json",
+            "cache_size",
+            "pipe_file",
+            "pipe",
+            "start_transaction",
+            "end_transaction",
+        ]:
+            # all the methods defined in this class. Note `open` here, since
+            # it calls `_open`, but is actually in superclass
+            return lambda *args, **kw: getattr(type(self), item).__get__(self)(
+                *args, **kw
+            )
+        if item in ["__reduce_ex__"]:
+            raise AttributeError
+        if item in ["transaction"]:
+            # property
+            return type(self).transaction.__get__(self)
+        if item in ["_cache", "transaction_type"]:
+            # class attributes
+            return getattr(type(self), item)
+        if item == "__class__":
+            return type(self)
+        d = object.__getattribute__(self, "__dict__")
+        fs = d.get("fs", None)  # fs is not immediately defined
+        if item in d:
+            return d[item]
+        elif fs is not None:
+            if item in fs.__dict__:
+                # attribute of instance
+                return fs.__dict__[item]
+            # attributed belonging to the target filesystem
+            cls = type(fs)
+            m = getattr(cls, item)
+            if (inspect.isfunction(m) or inspect.isdatadescriptor(m)) and (
+                not hasattr(m, "__self__") or m.__self__ is None
+            ):
+                # instance method
+                return m.__get__(fs, cls)
+            return m  # class method or attribute
+        else:
+            # attributes of the superclass, while target is being set up
+            return super().__getattribute__(item)
+
+    def __eq__(self, other):
+        """Test for equality."""
+        if self is other:
+            return True
+        if not isinstance(other, type(self)):
+            return False
+        return (
+            self.storage == other.storage
+            and self.kwargs == other.kwargs
+            and self.cache_check == other.cache_check
+            and self.check_files == other.check_files
+            and self.expiry == other.expiry
+            and self.compression == other.compression
+            and self._mapper == other._mapper
+            and self.target_protocol == other.target_protocol
+        )
+
+    def __hash__(self):
+        """Calculate hash."""
+        return (
+            hash(tuple(self.storage))
+            ^ hash(str(self.kwargs))
+            ^ hash(self.cache_check)
+            ^ hash(self.check_files)
+            ^ hash(self.expiry)
+            ^ hash(self.compression)
+            ^ hash(self._mapper)
+            ^ hash(self.target_protocol)
+        )
+
+    def to_json(self):
+        """Calculate JSON representation.
+
+        Not implemented yet for CachingFileSystem.
+        """
+        raise NotImplementedError(
+            "CachingFileSystem JSON representation not implemented"
+        )
+
+
+class WholeFileCacheFileSystem(CachingFileSystem):
+    """Caches whole remote files on first access
+
+    This class is intended as a layer over any other file system, and
+    will make a local copy of each file accessed, so that all subsequent
+    reads are local. This is similar to ``CachingFileSystem``, but without
+    the block-wise functionality and so can work even when sparse files
+    are not allowed. See its docstring for definition of the init
+    arguments.
+
+    The class still needs access to the remote store for listing files,
+    and may refresh cached files.
+    """
+
+    protocol = "filecache"
+    local_file = True
+
+    def open_many(self, open_files):
+        paths = [of.path for of in open_files]
+        if "r" in open_files.mode:
+            self._mkcache()
+        else:
+            return [
+                LocalTempFile(
+                    self.fs,
+                    path,
+                    mode=open_files.mode,
+                    fn=os.path.join(self.storage[-1], self._mapper(path)),
+                )
+                for path in paths
+            ]
+
+        if self.compression:
+            raise NotImplementedError
+        details = [self._check_file(sp) for sp in paths]
+        downpath = [p for p, d in zip(paths, details) if not d]
+        downfn0 = [
+            os.path.join(self.storage[-1], self._mapper(p))
+            for p, d in zip(paths, details)
+        ]  # keep these path names for opening later
+        downfn = [fn for fn, d in zip(downfn0, details) if not d]
+        if downpath:
+            # skip if all files are already cached and up to date
+            self.fs.get(downpath, downfn)
+
+            # update metadata - only happens when downloads are successful
+            newdetail = [
+                {
+                    "original": path,
+                    "fn": self._mapper(path),
+                    "blocks": True,
+                    "time": time.time(),
+                    "uid": self.fs.ukey(path),
+                }
+                for path in downpath
+            ]
+            for path, detail in zip(downpath, newdetail):
+                self._metadata.update_file(path, detail)
+            self.save_cache()
+
+        def firstpart(fn):
+            # helper to adapt both whole-file and simple-cache
+            return fn[1] if isinstance(fn, tuple) else fn
+
+        return [
+            open(firstpart(fn0) if fn0 else fn1, mode=open_files.mode)
+            for fn0, fn1 in zip(details, downfn0)
+        ]
+
+    def commit_many(self, open_files):
+        self.fs.put([f.fn for f in open_files], [f.path for f in open_files])
+        [f.close() for f in open_files]
+        for f in open_files:
+            # in case autocommit is off, and so close did not already delete
+            try:
+                os.remove(f.name)
+            except FileNotFoundError:
+                pass
+        self._cache_size = None
+
+    def _make_local_details(self, path):
+        hash = self._mapper(path)
+        fn = os.path.join(self.storage[-1], hash)
+        detail = {
+            "original": path,
+            "fn": hash,
+            "blocks": True,
+            "time": time.time(),
+            "uid": self.fs.ukey(path),
+        }
+        self._metadata.update_file(path, detail)
+        logger.debug("Copying %s to local cache", path)
+        return fn
+
+    def cat(
+        self,
+        path,
+        recursive=False,
+        on_error="raise",
+        callback=_DEFAULT_CALLBACK,
+        **kwargs,
+    ):
+        paths = self.expand_path(
+            path, recursive=recursive, maxdepth=kwargs.get("maxdepth", None)
+        )
+        getpaths = []
+        storepaths = []
+        fns = []
+        out = {}
+        for p in paths.copy():
+            try:
+                detail = self._check_file(p)
+                if not detail:
+                    fn = self._make_local_details(p)
+                    getpaths.append(p)
+                    storepaths.append(fn)
+                else:
+                    detail, fn = detail if isinstance(detail, tuple) else (None, detail)
+                fns.append(fn)
+            except Exception as e:
+                if on_error == "raise":
+                    raise
+                if on_error == "return":
+                    out[p] = e
+                paths.remove(p)
+
+        if getpaths:
+            self.fs.get(getpaths, storepaths)
+            self.save_cache()
+
+        callback.set_size(len(paths))
+        for p, fn in zip(paths, fns):
+            with open(fn, "rb") as f:
+                out[p] = f.read()
+            callback.relative_update(1)
+        if isinstance(path, str) and len(paths) == 1 and recursive is False:
+            out = out[paths[0]]
+        return out
+
+    def _open(self, path, mode="rb", **kwargs):
+        path = self._strip_protocol(path)
+        if "r" not in mode:
+            fn = self._make_local_details(path)
+            return LocalTempFile(self, path, mode=mode, fn=fn)
+        detail = self._check_file(path)
+        if detail:
+            detail, fn = detail
+            _, blocks = detail["fn"], detail["blocks"]
+            if blocks is True:
+                logger.debug("Opening local copy of %s", path)
+
+                # In order to support downstream filesystems to be able to
+                # infer the compression from the original filename, like
+                # the `TarFileSystem`, let's extend the `io.BufferedReader`
+                # fileobject protocol by adding a dedicated attribute
+                # `original`.
+                f = open(fn, mode)
+                f.original = detail.get("original")
+                return f
+            else:
+                raise ValueError(
+                    f"Attempt to open partially cached file {path}"
+                    f" as a wholly cached file"
+                )
+        else:
+            fn = self._make_local_details(path)
+        kwargs["mode"] = mode
+
+        # call target filesystems open
+        self._mkcache()
+        if self.compression:
+            with self.fs._open(path, **kwargs) as f, open(fn, "wb") as f2:
+                if isinstance(f, AbstractBufferedFile):
+                    # want no type of caching if just downloading whole thing
+                    f.cache = BaseCache(0, f.cache.fetcher, f.size)
+                comp = (
+                    infer_compression(path)
+                    if self.compression == "infer"
+                    else self.compression
+                )
+                f = compr[comp](f, mode="rb")
+                data = True
+                while data:
+                    block = getattr(f, "blocksize", 5 * 2**20)
+                    data = f.read(block)
+                    f2.write(data)
+        else:
+            self.fs.get_file(path, fn)
+        self.save_cache()
+        return self._open(path, mode)
+
+
+class SimpleCacheFileSystem(WholeFileCacheFileSystem):
+    """Caches whole remote files on first access
+
+    This class is intended as a layer over any other file system, and
+    will make a local copy of each file accessed, so that all subsequent
+    reads are local. This implementation only copies whole files, and
+    does not keep any metadata about the download time or file details.
+    It is therefore safer to use in multi-threaded/concurrent situations.
+
+    This is the only of the caching filesystems that supports write: you will
+    be given a real local open file, and upon close and commit, it will be
+    uploaded to the target filesystem; the writability or the target URL is
+    not checked until that time.
+
+    """
+
+    protocol = "simplecache"
+    local_file = True
+    transaction_type = WriteCachedTransaction
+
+    def __init__(self, **kwargs):
+        kw = kwargs.copy()
+        for key in ["cache_check", "expiry_time", "check_files"]:
+            kw[key] = False
+        super().__init__(**kw)
+        for storage in self.storage:
+            if not os.path.exists(storage):
+                os.makedirs(storage, exist_ok=True)
+
+    def _check_file(self, path):
+        self._check_cache()
+        sha = self._mapper(path)
+        for storage in self.storage:
+            fn = os.path.join(storage, sha)
+            if os.path.exists(fn):
+                return fn
+
+    def save_cache(self):
+        pass
+
+    def load_cache(self):
+        pass
+
+    def pipe_file(self, path, value=None, **kwargs):
+        if self._intrans:
+            with self.open(path, "wb") as f:
+                f.write(value)
+        else:
+            super().pipe_file(path, value)
+
+    def pipe(self, path, value=None, **kwargs):
+        if isinstance(path, str):
+            self.pipe_file(self._strip_protocol(path), value, **kwargs)
+        elif isinstance(path, dict):
+            for k, v in path.items():
+                self.pipe_file(self._strip_protocol(k), v, **kwargs)
+        else:
+            raise ValueError("path must be str or dict")
+
+    def cat_ranges(
+        self, paths, starts, ends, max_gap=None, on_error="return", **kwargs
+    ):
+        lpaths = [self._check_file(p) for p in paths]
+        rpaths = [p for l, p in zip(lpaths, paths) if l is False]
+        lpaths = [l for l, p in zip(lpaths, paths) if l is False]
+        self.fs.get(rpaths, lpaths)
+        return super().cat_ranges(
+            paths, starts, ends, max_gap=max_gap, on_error=on_error, **kwargs
+        )
+
+    def _open(self, path, mode="rb", **kwargs):
+        path = self._strip_protocol(path)
+        sha = self._mapper(path)
+
+        if "r" not in mode:
+            fn = os.path.join(self.storage[-1], sha)
+            return LocalTempFile(
+                self, path, mode=mode, autocommit=not self._intrans, fn=fn
+            )
+        fn = self._check_file(path)
+        if fn:
+            return open(fn, mode)
+
+        fn = os.path.join(self.storage[-1], sha)
+        logger.debug("Copying %s to local cache", path)
+        kwargs["mode"] = mode
+
+        self._mkcache()
+        self._cache_size = None
+        if self.compression:
+            with self.fs._open(path, **kwargs) as f, open(fn, "wb") as f2:
+                if isinstance(f, AbstractBufferedFile):
+                    # want no type of caching if just downloading whole thing
+                    f.cache = BaseCache(0, f.cache.fetcher, f.size)
+                comp = (
+                    infer_compression(path)
+                    if self.compression == "infer"
+                    else self.compression
+                )
+                f = compr[comp](f, mode="rb")
+                data = True
+                while data:
+                    block = getattr(f, "blocksize", 5 * 2**20)
+                    data = f.read(block)
+                    f2.write(data)
+        else:
+            self.fs.get_file(path, fn)
+        return self._open(path, mode)
+
+
+class LocalTempFile:
+    """A temporary local file, which will be uploaded on commit"""
+
+    def __init__(self, fs, path, fn, mode="wb", autocommit=True, seek=0):
+        self.fn = fn
+        self.fh = open(fn, mode)
+        self.mode = mode
+        if seek:
+            self.fh.seek(seek)
+        self.path = path
+        self.fs = fs
+        self.closed = False
+        self.autocommit = autocommit
+
+    def __reduce__(self):
+        # always open in r+b to allow continuing writing at a location
+        return (
+            LocalTempFile,
+            (self.fs, self.path, self.fn, "r+b", self.autocommit, self.tell()),
+        )
+
+    def __enter__(self):
+        return self.fh
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        if self.closed:
+            return
+        self.fh.close()
+        self.closed = True
+        if self.autocommit:
+            self.commit()
+
+    def discard(self):
+        self.fh.close()
+        os.remove(self.fn)
+
+    def commit(self):
+        self.fs.put(self.fn, self.path)
+        try:
+            os.remove(self.fn)
+        except (PermissionError, FileNotFoundError):
+            # file path may be held by new version of the file on windows
+            pass
+
+    @property
+    def name(self):
+        return self.fn
+
+    def __getattr__(self, item):
+        return getattr(self.fh, item)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/dask.py b/lib/python3.11/site-packages/fsspec/implementations/dask.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e1276463db6866665e6a0fe114efc247971b57e
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/dask.py
@@ -0,0 +1,152 @@
+import dask
+from distributed.client import Client, _get_global_client
+from distributed.worker import Worker
+
+from fsspec import filesystem
+from fsspec.spec import AbstractBufferedFile, AbstractFileSystem
+from fsspec.utils import infer_storage_options
+
+
+def _get_client(client):
+    if client is None:
+        return _get_global_client()
+    elif isinstance(client, Client):
+        return client
+    else:
+        # e.g., connection string
+        return Client(client)
+
+
+def _in_worker():
+    return bool(Worker._instances)
+
+
+class DaskWorkerFileSystem(AbstractFileSystem):
+    """View files accessible to a worker as any other remote file-system
+
+    When instances are run on the worker, uses the real filesystem. When
+    run on the client, they call the worker to provide information or data.
+
+    **Warning** this implementation is experimental, and read-only for now.
+    """
+
+    def __init__(
+        self, target_protocol=None, target_options=None, fs=None, client=None, **kwargs
+    ):
+        super().__init__(**kwargs)
+        if not (fs is None) ^ (target_protocol is None):
+            raise ValueError(
+                "Please provide one of filesystem instance (fs) or"
+                " target_protocol, not both"
+            )
+        self.target_protocol = target_protocol
+        self.target_options = target_options
+        self.worker = None
+        self.client = client
+        self.fs = fs
+        self._determine_worker()
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        so = infer_storage_options(path)
+        if "host" in so and "port" in so:
+            return {"client": f"{so['host']}:{so['port']}"}
+        else:
+            return {}
+
+    def _determine_worker(self):
+        if _in_worker():
+            self.worker = True
+            if self.fs is None:
+                self.fs = filesystem(
+                    self.target_protocol, **(self.target_options or {})
+                )
+        else:
+            self.worker = False
+            self.client = _get_client(self.client)
+            self.rfs = dask.delayed(self)
+
+    def mkdir(self, *args, **kwargs):
+        if self.worker:
+            self.fs.mkdir(*args, **kwargs)
+        else:
+            self.rfs.mkdir(*args, **kwargs).compute()
+
+    def rm(self, *args, **kwargs):
+        if self.worker:
+            self.fs.rm(*args, **kwargs)
+        else:
+            self.rfs.rm(*args, **kwargs).compute()
+
+    def copy(self, *args, **kwargs):
+        if self.worker:
+            self.fs.copy(*args, **kwargs)
+        else:
+            self.rfs.copy(*args, **kwargs).compute()
+
+    def mv(self, *args, **kwargs):
+        if self.worker:
+            self.fs.mv(*args, **kwargs)
+        else:
+            self.rfs.mv(*args, **kwargs).compute()
+
+    def ls(self, *args, **kwargs):
+        if self.worker:
+            return self.fs.ls(*args, **kwargs)
+        else:
+            return self.rfs.ls(*args, **kwargs).compute()
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        if self.worker:
+            return self.fs._open(
+                path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=autocommit,
+                cache_options=cache_options,
+                **kwargs,
+            )
+        else:
+            return DaskFile(
+                fs=self,
+                path=path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=autocommit,
+                cache_options=cache_options,
+                **kwargs,
+            )
+
+    def fetch_range(self, path, mode, start, end):
+        if self.worker:
+            with self._open(path, mode) as f:
+                f.seek(start)
+                return f.read(end - start)
+        else:
+            return self.rfs.fetch_range(path, mode, start, end).compute()
+
+
+class DaskFile(AbstractBufferedFile):
+    def __init__(self, mode="rb", **kwargs):
+        if mode != "rb":
+            raise ValueError('Remote dask files can only be opened in "rb" mode')
+        super().__init__(**kwargs)
+
+    def _upload_chunk(self, final=False):
+        pass
+
+    def _initiate_upload(self):
+        """Create remote file/upload"""
+        pass
+
+    def _fetch_range(self, start, end):
+        """Get the specified set of bytes from remote"""
+        return self.fs.fetch_range(self.path, self.mode, start, end)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/data.py b/lib/python3.11/site-packages/fsspec/implementations/data.py
new file mode 100644
index 0000000000000000000000000000000000000000..67d16ec387e24c63ecbd3464c6f4f8e223821651
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/data.py
@@ -0,0 +1,48 @@
+import base64
+import io
+from urllib.parse import unquote
+
+from fsspec import AbstractFileSystem
+
+
+class DataFileSystem(AbstractFileSystem):
+    """A handy decoder for data-URLs
+
+    Example
+    -------
+    >>> with fsspec.open("data:,Hello%2C%20World%21") as f:
+    ...     print(f.read())
+    b"Hello, World!"
+
+    """
+
+    protocol = "data"
+
+    def __init__(self, **kwargs):
+        """No parameters for this filesystem"""
+        super().__init__(**kwargs)
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        pref, data = path.split(",", 1)
+        if pref.endswith("base64"):
+            return base64.b64decode(data)[start:end]
+        return unquote(data).encode()[start:end]
+
+    def info(self, path, **kwargs):
+        pref, name = path.split(",", 1)
+        data = self.cat_file(path)
+        mime = pref.split(":", 1)[1].split(";", 1)[0]
+        return {"name": name, "size": len(data), "type": "file", "mimetype": mime}
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        if "r" not in mode:
+            raise ValueError("Read only filesystem")
+        return io.BytesIO(self.cat_file(path))
diff --git a/lib/python3.11/site-packages/fsspec/implementations/dbfs.py b/lib/python3.11/site-packages/fsspec/implementations/dbfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f5b330cab9e751142794253d1072bab48b8bc29
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/dbfs.py
@@ -0,0 +1,457 @@
+import base64
+import urllib
+
+import requests
+
+from fsspec import AbstractFileSystem
+from fsspec.spec import AbstractBufferedFile
+
+
+class DatabricksException(Exception):
+    """
+    Helper class for exceptions raised in this module.
+    """
+
+    def __init__(self, error_code, message):
+        """Create a new DatabricksException"""
+        super().__init__(message)
+
+        self.error_code = error_code
+        self.message = message
+
+
+class DatabricksFileSystem(AbstractFileSystem):
+    """
+    Get access to the Databricks filesystem implementation over HTTP.
+    Can be used inside and outside of a databricks cluster.
+    """
+
+    def __init__(self, instance, token, **kwargs):
+        """
+        Create a new DatabricksFileSystem.
+
+        Parameters
+        ----------
+        instance: str
+            The instance URL of the databricks cluster.
+            For example for an Azure databricks cluster, this
+            has the form adb-<some-number>.<two digits>.azuredatabricks.net.
+        token: str
+            Your personal token. Find out more
+            here: https://docs.databricks.com/dev-tools/api/latest/authentication.html
+        """
+        self.instance = instance
+        self.token = token
+
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Bearer {self.token}"})
+
+        super().__init__(**kwargs)
+
+    def ls(self, path, detail=True):
+        """
+        List the contents of the given path.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path
+        detail: bool
+            Return not only the list of filenames,
+            but also additional information on file sizes
+            and types.
+        """
+        out = self._ls_from_cache(path)
+        if not out:
+            try:
+                r = self._send_to_api(
+                    method="get", endpoint="list", json={"path": path}
+                )
+            except DatabricksException as e:
+                if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                    raise FileNotFoundError(e.message)
+
+                raise e
+            files = r["files"]
+            out = [
+                {
+                    "name": o["path"],
+                    "type": "directory" if o["is_dir"] else "file",
+                    "size": o["file_size"],
+                }
+                for o in files
+            ]
+            self.dircache[path] = out
+
+        if detail:
+            return out
+        return [o["name"] for o in out]
+
+    def makedirs(self, path, exist_ok=True):
+        """
+        Create a given absolute path and all of its parents.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path to create
+        exist_ok: bool
+            If false, checks if the folder
+            exists before creating it (and raises an
+            Exception if this is the case)
+        """
+        if not exist_ok:
+            try:
+                # If the following succeeds, the path is already present
+                self._send_to_api(
+                    method="get", endpoint="get-status", json={"path": path}
+                )
+                raise FileExistsError(f"Path {path} already exists")
+            except DatabricksException as e:
+                if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                    pass
+
+        try:
+            self._send_to_api(method="post", endpoint="mkdirs", json={"path": path})
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_ALREADY_EXISTS":
+                raise FileExistsError(e.message)
+
+            raise e
+        self.invalidate_cache(self._parent(path))
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        """
+        Create a given absolute path and all of its parents.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path to create
+        create_parents: bool
+            Whether to create all parents or not.
+            "False" is not implemented so far.
+        """
+        if not create_parents:
+            raise NotImplementedError
+
+        self.mkdirs(path, **kwargs)
+
+    def rm(self, path, recursive=False):
+        """
+        Remove the file or folder at the given absolute path.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path what to remove
+        recursive: bool
+            Recursively delete all files in a folder.
+        """
+        try:
+            self._send_to_api(
+                method="post",
+                endpoint="delete",
+                json={"path": path, "recursive": recursive},
+            )
+        except DatabricksException as e:
+            # This is not really an exception, it just means
+            # not everything was deleted so far
+            if e.error_code == "PARTIAL_DELETE":
+                self.rm(path=path, recursive=recursive)
+            elif e.error_code == "IO_ERROR":
+                # Using the same exception as the os module would use here
+                raise OSError(e.message)
+
+            raise e
+        self.invalidate_cache(self._parent(path))
+
+    def mv(self, source_path, destination_path, recursive=False, maxdepth=None):
+        """
+        Move a source to a destination path.
+
+        A note from the original [databricks API manual]
+        (https://docs.databricks.com/dev-tools/api/latest/dbfs.html#move).
+
+        When moving a large number of files the API call will time out after
+        approximately 60s, potentially resulting in partially moved data.
+        Therefore, for operations that move more than 10k files, we strongly
+        discourage using the DBFS REST API.
+
+        Parameters
+        ----------
+        source_path: str
+            From where to move (absolute path)
+        destination_path: str
+            To where to move (absolute path)
+        recursive: bool
+            Not implemented to far.
+        maxdepth:
+            Not implemented to far.
+        """
+        if recursive:
+            raise NotImplementedError
+        if maxdepth:
+            raise NotImplementedError
+
+        try:
+            self._send_to_api(
+                method="post",
+                endpoint="move",
+                json={"source_path": source_path, "destination_path": destination_path},
+            )
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message)
+            elif e.error_code == "RESOURCE_ALREADY_EXISTS":
+                raise FileExistsError(e.message)
+
+            raise e
+        self.invalidate_cache(self._parent(source_path))
+        self.invalidate_cache(self._parent(destination_path))
+
+    def _open(self, path, mode="rb", block_size="default", **kwargs):
+        """
+        Overwrite the base class method to make sure to create a DBFile.
+        All arguments are copied from the base method.
+
+        Only the default blocksize is allowed.
+        """
+        return DatabricksFile(self, path, mode=mode, block_size=block_size, **kwargs)
+
+    def _send_to_api(self, method, endpoint, json):
+        """
+        Send the given json to the DBFS API
+        using a get or post request (specified by the argument `method`).
+
+        Parameters
+        ----------
+        method: str
+            Which http method to use for communication; "get" or "post".
+        endpoint: str
+            Where to send the request to (last part of the API URL)
+        json: dict
+            Dictionary of information to send
+        """
+        if method == "post":
+            session_call = self.session.post
+        elif method == "get":
+            session_call = self.session.get
+        else:
+            raise ValueError(f"Do not understand method {method}")
+
+        url = urllib.parse.urljoin(f"https://{self.instance}/api/2.0/dbfs/", endpoint)
+
+        r = session_call(url, json=json)
+
+        # The DBFS API will return a json, also in case of an exception.
+        # We want to preserve this information as good as possible.
+        try:
+            r.raise_for_status()
+        except requests.HTTPError as e:
+            # try to extract json error message
+            # if that fails, fall back to the original exception
+            try:
+                exception_json = e.response.json()
+            except Exception:
+                raise e
+
+            raise DatabricksException(**exception_json)
+
+        return r.json()
+
+    def _create_handle(self, path, overwrite=True):
+        """
+        Internal function to create a handle, which can be used to
+        write blocks of a file to DBFS.
+        A handle has a unique identifier which needs to be passed
+        whenever written during this transaction.
+        The handle is active for 10 minutes - after that a new
+        write transaction needs to be created.
+        Make sure to close the handle after you are finished.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path for this file.
+        overwrite: bool
+            If a file already exist at this location, either overwrite
+            it or raise an exception.
+        """
+        try:
+            r = self._send_to_api(
+                method="post",
+                endpoint="create",
+                json={"path": path, "overwrite": overwrite},
+            )
+            return r["handle"]
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_ALREADY_EXISTS":
+                raise FileExistsError(e.message)
+
+            raise e
+
+    def _close_handle(self, handle):
+        """
+        Close a handle, which was opened by :func:`_create_handle`.
+
+        Parameters
+        ----------
+        handle: str
+            Which handle to close.
+        """
+        try:
+            self._send_to_api(method="post", endpoint="close", json={"handle": handle})
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message)
+
+            raise e
+
+    def _add_data(self, handle, data):
+        """
+        Upload data to an already opened file handle
+        (opened by :func:`_create_handle`).
+        The maximal allowed data size is 1MB after
+        conversion to base64.
+        Remember to close the handle when you are finished.
+
+        Parameters
+        ----------
+        handle: str
+            Which handle to upload data to.
+        data: bytes
+            Block of data to add to the handle.
+        """
+        data = base64.b64encode(data).decode()
+        try:
+            self._send_to_api(
+                method="post",
+                endpoint="add-block",
+                json={"handle": handle, "data": data},
+            )
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message)
+            elif e.error_code == "MAX_BLOCK_SIZE_EXCEEDED":
+                raise ValueError(e.message)
+
+            raise e
+
+    def _get_data(self, path, start, end):
+        """
+        Download data in bytes from a given absolute path in a block
+        from [start, start+length].
+        The maximum number of allowed bytes to read is 1MB.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path to download data from
+        start: int
+            Start position of the block
+        end: int
+            End position of the block
+        """
+        try:
+            r = self._send_to_api(
+                method="get",
+                endpoint="read",
+                json={"path": path, "offset": start, "length": end - start},
+            )
+            return base64.b64decode(r["data"])
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message)
+            elif e.error_code in ["INVALID_PARAMETER_VALUE", "MAX_READ_SIZE_EXCEEDED"]:
+                raise ValueError(e.message)
+
+            raise e
+
+    def invalidate_cache(self, path=None):
+        if path is None:
+            self.dircache.clear()
+        else:
+            self.dircache.pop(path, None)
+        super().invalidate_cache(path)
+
+
+class DatabricksFile(AbstractBufferedFile):
+    """
+    Helper class for files referenced in the DatabricksFileSystem.
+    """
+
+    DEFAULT_BLOCK_SIZE = 1 * 2**20  # only allowed block size
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        block_size="default",
+        autocommit=True,
+        cache_type="readahead",
+        cache_options=None,
+        **kwargs,
+    ):
+        """
+        Create a new instance of the DatabricksFile.
+
+        The blocksize needs to be the default one.
+        """
+        if block_size is None or block_size == "default":
+            block_size = self.DEFAULT_BLOCK_SIZE
+
+        assert (
+            block_size == self.DEFAULT_BLOCK_SIZE
+        ), f"Only the default block size is allowed, not {block_size}"
+
+        super().__init__(
+            fs,
+            path,
+            mode=mode,
+            block_size=block_size,
+            autocommit=autocommit,
+            cache_type=cache_type,
+            cache_options=cache_options or {},
+            **kwargs,
+        )
+
+    def _initiate_upload(self):
+        """Internal function to start a file upload"""
+        self.handle = self.fs._create_handle(self.path)
+
+    def _upload_chunk(self, final=False):
+        """Internal function to add a chunk of data to a started upload"""
+        self.buffer.seek(0)
+        data = self.buffer.getvalue()
+
+        data_chunks = [
+            data[start:end] for start, end in self._to_sized_blocks(len(data))
+        ]
+
+        for data_chunk in data_chunks:
+            self.fs._add_data(handle=self.handle, data=data_chunk)
+
+        if final:
+            self.fs._close_handle(handle=self.handle)
+            return True
+
+    def _fetch_range(self, start, end):
+        """Internal function to download a block of data"""
+        return_buffer = b""
+        length = end - start
+        for chunk_start, chunk_end in self._to_sized_blocks(length, start):
+            return_buffer += self.fs._get_data(
+                path=self.path, start=chunk_start, end=chunk_end
+            )
+
+        return return_buffer
+
+    def _to_sized_blocks(self, length, start=0):
+        """Helper function to split a range from 0 to total_length into bloksizes"""
+        end = start + length
+        for data_chunk in range(start, end, self.blocksize):
+            data_start = data_chunk
+            data_end = min(end, data_chunk + self.blocksize)
+            yield data_start, data_end
diff --git a/lib/python3.11/site-packages/fsspec/implementations/dirfs.py b/lib/python3.11/site-packages/fsspec/implementations/dirfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3eac87efa2414d85bf9eec59b2f35722418ed71
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/dirfs.py
@@ -0,0 +1,358 @@
+from .. import filesystem
+from ..asyn import AsyncFileSystem
+
+
+class DirFileSystem(AsyncFileSystem):
+    """Directory prefix filesystem
+
+    The DirFileSystem is a filesystem-wrapper. It assumes every path it is dealing with
+    is relative to the `path`. After performing the necessary paths operation it
+    delegates everything to the wrapped filesystem.
+    """
+
+    protocol = "dir"
+
+    def __init__(
+        self,
+        path=None,
+        fs=None,
+        fo=None,
+        target_protocol=None,
+        target_options=None,
+        **storage_options,
+    ):
+        """
+        Parameters
+        ----------
+        path: str
+            Path to the directory.
+        fs: AbstractFileSystem
+            An instantiated filesystem to wrap.
+        target_protocol, target_options:
+            if fs is none, construct it from these
+        fo: str
+            Alternate for path; do not provide both
+        """
+        super().__init__(**storage_options)
+        if fs is None:
+            fs = filesystem(protocol=target_protocol, **(target_options or {}))
+        if (path is not None) ^ (fo is not None) is False:
+            raise ValueError("Provide path or fo, not both")
+        path = path or fo
+
+        if self.asynchronous and not fs.async_impl:
+            raise ValueError("can't use asynchronous with non-async fs")
+
+        if fs.async_impl and self.asynchronous != fs.asynchronous:
+            raise ValueError("both dirfs and fs should be in the same sync/async mode")
+
+        self.path = fs._strip_protocol(path)
+        self.fs = fs
+
+    def _join(self, path):
+        if isinstance(path, str):
+            if not self.path:
+                return path
+            if not path:
+                return self.path
+            return self.fs.sep.join((self.path, self._strip_protocol(path)))
+        return [self._join(_path) for _path in path]
+
+    def _relpath(self, path):
+        if isinstance(path, str):
+            if not self.path:
+                return path
+            if path == self.path:
+                return ""
+            prefix = self.path + self.fs.sep
+            assert path.startswith(prefix)
+            return path[len(prefix) :]
+        return [self._relpath(_path) for _path in path]
+
+    # Wrappers below
+
+    @property
+    def sep(self):
+        return self.fs.sep
+
+    async def set_session(self, *args, **kwargs):
+        return await self.fs.set_session(*args, **kwargs)
+
+    async def _rm_file(self, path, **kwargs):
+        return await self.fs._rm_file(self._join(path), **kwargs)
+
+    def rm_file(self, path, **kwargs):
+        return self.fs.rm_file(self._join(path), **kwargs)
+
+    async def _rm(self, path, *args, **kwargs):
+        return await self.fs._rm(self._join(path), *args, **kwargs)
+
+    def rm(self, path, *args, **kwargs):
+        return self.fs.rm(self._join(path), *args, **kwargs)
+
+    async def _cp_file(self, path1, path2, **kwargs):
+        return await self.fs._cp_file(self._join(path1), self._join(path2), **kwargs)
+
+    def cp_file(self, path1, path2, **kwargs):
+        return self.fs.cp_file(self._join(path1), self._join(path2), **kwargs)
+
+    async def _copy(
+        self,
+        path1,
+        path2,
+        *args,
+        **kwargs,
+    ):
+        return await self.fs._copy(
+            self._join(path1),
+            self._join(path2),
+            *args,
+            **kwargs,
+        )
+
+    def copy(self, path1, path2, *args, **kwargs):
+        return self.fs.copy(
+            self._join(path1),
+            self._join(path2),
+            *args,
+            **kwargs,
+        )
+
+    async def _pipe(self, path, *args, **kwargs):
+        return await self.fs._pipe(self._join(path), *args, **kwargs)
+
+    def pipe(self, path, *args, **kwargs):
+        return self.fs.pipe(self._join(path), *args, **kwargs)
+
+    async def _cat_file(self, path, *args, **kwargs):
+        return await self.fs._cat_file(self._join(path), *args, **kwargs)
+
+    def cat_file(self, path, *args, **kwargs):
+        return self.fs.cat_file(self._join(path), *args, **kwargs)
+
+    async def _cat(self, path, *args, **kwargs):
+        ret = await self.fs._cat(
+            self._join(path),
+            *args,
+            **kwargs,
+        )
+
+        if isinstance(ret, dict):
+            return {self._relpath(key): value for key, value in ret.items()}
+
+        return ret
+
+    def cat(self, path, *args, **kwargs):
+        ret = self.fs.cat(
+            self._join(path),
+            *args,
+            **kwargs,
+        )
+
+        if isinstance(ret, dict):
+            return {self._relpath(key): value for key, value in ret.items()}
+
+        return ret
+
+    async def _put_file(self, lpath, rpath, **kwargs):
+        return await self.fs._put_file(lpath, self._join(rpath), **kwargs)
+
+    def put_file(self, lpath, rpath, **kwargs):
+        return self.fs.put_file(lpath, self._join(rpath), **kwargs)
+
+    async def _put(
+        self,
+        lpath,
+        rpath,
+        *args,
+        **kwargs,
+    ):
+        return await self.fs._put(
+            lpath,
+            self._join(rpath),
+            *args,
+            **kwargs,
+        )
+
+    def put(self, lpath, rpath, *args, **kwargs):
+        return self.fs.put(
+            lpath,
+            self._join(rpath),
+            *args,
+            **kwargs,
+        )
+
+    async def _get_file(self, rpath, lpath, **kwargs):
+        return await self.fs._get_file(self._join(rpath), lpath, **kwargs)
+
+    def get_file(self, rpath, lpath, **kwargs):
+        return self.fs.get_file(self._join(rpath), lpath, **kwargs)
+
+    async def _get(self, rpath, *args, **kwargs):
+        return await self.fs._get(self._join(rpath), *args, **kwargs)
+
+    def get(self, rpath, *args, **kwargs):
+        return self.fs.get(self._join(rpath), *args, **kwargs)
+
+    async def _isfile(self, path):
+        return await self.fs._isfile(self._join(path))
+
+    def isfile(self, path):
+        return self.fs.isfile(self._join(path))
+
+    async def _isdir(self, path):
+        return await self.fs._isdir(self._join(path))
+
+    def isdir(self, path):
+        return self.fs.isdir(self._join(path))
+
+    async def _size(self, path):
+        return await self.fs._size(self._join(path))
+
+    def size(self, path):
+        return self.fs.size(self._join(path))
+
+    async def _exists(self, path):
+        return await self.fs._exists(self._join(path))
+
+    def exists(self, path):
+        return self.fs.exists(self._join(path))
+
+    async def _info(self, path, **kwargs):
+        return await self.fs._info(self._join(path), **kwargs)
+
+    def info(self, path, **kwargs):
+        return self.fs.info(self._join(path), **kwargs)
+
+    async def _ls(self, path, detail=True, **kwargs):
+        ret = (await self.fs._ls(self._join(path), detail=detail, **kwargs)).copy()
+        if detail:
+            out = []
+            for entry in ret:
+                entry = entry.copy()
+                entry["name"] = self._relpath(entry["name"])
+                out.append(entry)
+            return out
+
+        return self._relpath(ret)
+
+    def ls(self, path, detail=True, **kwargs):
+        ret = self.fs.ls(self._join(path), detail=detail, **kwargs).copy()
+        if detail:
+            out = []
+            for entry in ret:
+                entry = entry.copy()
+                entry["name"] = self._relpath(entry["name"])
+                out.append(entry)
+            return out
+
+        return self._relpath(ret)
+
+    async def _walk(self, path, *args, **kwargs):
+        async for root, dirs, files in self.fs._walk(self._join(path), *args, **kwargs):
+            yield self._relpath(root), dirs, files
+
+    def walk(self, path, *args, **kwargs):
+        for root, dirs, files in self.fs.walk(self._join(path), *args, **kwargs):
+            yield self._relpath(root), dirs, files
+
+    async def _glob(self, path, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = await self.fs._glob(self._join(path), **kwargs)
+        if detail:
+            return {self._relpath(path): info for path, info in ret.items()}
+        return self._relpath(ret)
+
+    def glob(self, path, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = self.fs.glob(self._join(path), **kwargs)
+        if detail:
+            return {self._relpath(path): info for path, info in ret.items()}
+        return self._relpath(ret)
+
+    async def _du(self, path, *args, **kwargs):
+        total = kwargs.get("total", True)
+        ret = await self.fs._du(self._join(path), *args, **kwargs)
+        if total:
+            return ret
+
+        return {self._relpath(path): size for path, size in ret.items()}
+
+    def du(self, path, *args, **kwargs):
+        total = kwargs.get("total", True)
+        ret = self.fs.du(self._join(path), *args, **kwargs)
+        if total:
+            return ret
+
+        return {self._relpath(path): size for path, size in ret.items()}
+
+    async def _find(self, path, *args, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = await self.fs._find(self._join(path), *args, **kwargs)
+        if detail:
+            return {self._relpath(path): info for path, info in ret.items()}
+        return self._relpath(ret)
+
+    def find(self, path, *args, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = self.fs.find(self._join(path), *args, **kwargs)
+        if detail:
+            return {self._relpath(path): info for path, info in ret.items()}
+        return self._relpath(ret)
+
+    async def _expand_path(self, path, *args, **kwargs):
+        return self._relpath(
+            await self.fs._expand_path(self._join(path), *args, **kwargs)
+        )
+
+    def expand_path(self, path, *args, **kwargs):
+        return self._relpath(self.fs.expand_path(self._join(path), *args, **kwargs))
+
+    async def _mkdir(self, path, *args, **kwargs):
+        return await self.fs._mkdir(self._join(path), *args, **kwargs)
+
+    def mkdir(self, path, *args, **kwargs):
+        return self.fs.mkdir(self._join(path), *args, **kwargs)
+
+    async def _makedirs(self, path, *args, **kwargs):
+        return await self.fs._makedirs(self._join(path), *args, **kwargs)
+
+    def makedirs(self, path, *args, **kwargs):
+        return self.fs.makedirs(self._join(path), *args, **kwargs)
+
+    def rmdir(self, path):
+        return self.fs.rmdir(self._join(path))
+
+    def mv_file(self, path1, path2, **kwargs):
+        return self.fs.mv_file(
+            self._join(path1),
+            self._join(path2),
+            **kwargs,
+        )
+
+    def touch(self, path, **kwargs):
+        return self.fs.touch(self._join(path), **kwargs)
+
+    def created(self, path):
+        return self.fs.created(self._join(path))
+
+    def modified(self, path):
+        return self.fs.modified(self._join(path))
+
+    def sign(self, path, *args, **kwargs):
+        return self.fs.sign(self._join(path), *args, **kwargs)
+
+    def __repr__(self):
+        return f"{self.__class__.__qualname__}(path='{self.path}', fs={self.fs})"
+
+    def open(
+        self,
+        path,
+        *args,
+        **kwargs,
+    ):
+        return self.fs.open(
+            self._join(path),
+            *args,
+            **kwargs,
+        )
diff --git a/lib/python3.11/site-packages/fsspec/implementations/ftp.py b/lib/python3.11/site-packages/fsspec/implementations/ftp.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c545da8d1a3cacdceac1c67485077790d754220
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/ftp.py
@@ -0,0 +1,380 @@
+import os
+import sys
+import uuid
+import warnings
+from ftplib import FTP, Error, error_perm
+from typing import Any
+
+from ..spec import AbstractBufferedFile, AbstractFileSystem
+from ..utils import infer_storage_options, isfilelike
+
+
+class FTPFileSystem(AbstractFileSystem):
+    """A filesystem over classic FTP"""
+
+    root_marker = "/"
+    cachable = False
+    protocol = "ftp"
+
+    def __init__(
+        self,
+        host,
+        port=21,
+        username=None,
+        password=None,
+        acct=None,
+        block_size=None,
+        tempdir=None,
+        timeout=30,
+        encoding="utf-8",
+        **kwargs,
+    ):
+        """
+        You can use _get_kwargs_from_urls to get some kwargs from
+        a reasonable FTP url.
+
+        Authentication will be anonymous if username/password are not
+        given.
+
+        Parameters
+        ----------
+        host: str
+            The remote server name/ip to connect to
+        port: int
+            Port to connect with
+        username: str or None
+            If authenticating, the user's identifier
+        password: str of None
+            User's password on the server, if using
+        acct: str or None
+            Some servers also need an "account" string for auth
+        block_size: int or None
+            If given, the read-ahead or write buffer size.
+        tempdir: str
+            Directory on remote to put temporary files when in a transaction
+        timeout: int
+            Timeout of the ftp connection in seconds
+        encoding: str
+            Encoding to use for directories and filenames in FTP connection
+        """
+        super().__init__(**kwargs)
+        self.host = host
+        self.port = port
+        self.tempdir = tempdir or "/tmp"
+        self.cred = username, password, acct
+        self.timeout = timeout
+        self.encoding = encoding
+        if block_size is not None:
+            self.blocksize = block_size
+        else:
+            self.blocksize = 2**16
+        self._connect()
+
+    def _connect(self):
+        if sys.version_info >= (3, 9):
+            self.ftp = FTP(timeout=self.timeout, encoding=self.encoding)
+        elif self.encoding:
+            warnings.warn("`encoding` not supported for python<3.9, ignoring")
+            self.ftp = FTP(timeout=self.timeout)
+        else:
+            self.ftp = FTP(timeout=self.timeout)
+        self.ftp.connect(self.host, self.port)
+        self.ftp.login(*self.cred)
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return "/" + infer_storage_options(path)["path"].lstrip("/").rstrip("/")
+
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        out = infer_storage_options(urlpath)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        return out
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        out = []
+        if path not in self.dircache:
+            try:
+                try:
+                    out = [
+                        (fn, details)
+                        for (fn, details) in self.ftp.mlsd(path)
+                        if fn not in [".", ".."]
+                        and details["type"] not in ["pdir", "cdir"]
+                    ]
+                except error_perm:
+                    out = _mlsd2(self.ftp, path)  # Not platform independent
+                for fn, details in out:
+                    if path == "/":
+                        path = ""  # just for forming the names, below
+                    details["name"] = "/".join([path, fn.lstrip("/")])
+                    if details["type"] == "file":
+                        details["size"] = int(details["size"])
+                    else:
+                        details["size"] = 0
+                    if details["type"] == "dir":
+                        details["type"] = "directory"
+                self.dircache[path] = out
+            except Error:
+                try:
+                    info = self.info(path)
+                    if info["type"] == "file":
+                        out = [(path, info)]
+                except (Error, IndexError):
+                    raise FileNotFoundError(path)
+        files = self.dircache.get(path, out)
+        if not detail:
+            return sorted([fn for fn, details in files])
+        return [details for fn, details in files]
+
+    def info(self, path, **kwargs):
+        # implement with direct method
+        path = self._strip_protocol(path)
+        if path == "/":
+            # special case, since this dir has no real entry
+            return {"name": "/", "size": 0, "type": "directory"}
+        files = self.ls(self._parent(path).lstrip("/"), True)
+        try:
+            out = [f for f in files if f["name"] == path][0]
+        except IndexError:
+            raise FileNotFoundError(path)
+        return out
+
+    def get_file(self, rpath, lpath, **kwargs):
+        if self.isdir(rpath):
+            if not os.path.exists(lpath):
+                os.mkdir(lpath)
+            return
+        if isfilelike(lpath):
+            outfile = lpath
+        else:
+            outfile = open(lpath, "wb")
+
+        def cb(x):
+            outfile.write(x)
+
+        self.ftp.retrbinary(
+            f"RETR {rpath}",
+            blocksize=self.blocksize,
+            callback=cb,
+        )
+        if not isfilelike(lpath):
+            outfile.close()
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        if end is not None:
+            return super().cat_file(path, start, end, **kwargs)
+        out = []
+
+        def cb(x):
+            out.append(x)
+
+        self.ftp.retrbinary(
+            f"RETR {path}",
+            blocksize=self.blocksize,
+            rest=start,
+            callback=cb,
+        )
+        return b"".join(out)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        cache_options=None,
+        autocommit=True,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        block_size = block_size or self.blocksize
+        return FTPFile(
+            self,
+            path,
+            mode=mode,
+            block_size=block_size,
+            tempdir=self.tempdir,
+            autocommit=autocommit,
+            cache_options=cache_options,
+        )
+
+    def _rm(self, path):
+        path = self._strip_protocol(path)
+        self.ftp.delete(path)
+        self.invalidate_cache(self._parent(path))
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        paths = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        for p in reversed(paths):
+            if self.isfile(p):
+                self.rm_file(p)
+            else:
+                self.rmdir(p)
+
+    def mkdir(self, path: str, create_parents: bool = True, **kwargs: Any) -> None:
+        path = self._strip_protocol(path)
+        parent = self._parent(path)
+        if parent != self.root_marker and not self.exists(parent) and create_parents:
+            self.mkdir(parent, create_parents=create_parents)
+
+        self.ftp.mkd(path)
+        self.invalidate_cache(self._parent(path))
+
+    def makedirs(self, path: str, exist_ok: bool = False) -> None:
+        path = self._strip_protocol(path)
+        if self.exists(path):
+            # NB: "/" does not "exist" as it has no directory entry
+            if not exist_ok:
+                raise FileExistsError(f"{path} exists without `exist_ok`")
+            # exists_ok=True -> no-op
+        else:
+            self.mkdir(path, create_parents=True)
+
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        self.ftp.rmd(path)
+        self.invalidate_cache(self._parent(path))
+
+    def mv(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1)
+        path2 = self._strip_protocol(path2)
+        self.ftp.rename(path1, path2)
+        self.invalidate_cache(self._parent(path1))
+        self.invalidate_cache(self._parent(path2))
+
+    def __del__(self):
+        self.ftp.close()
+
+    def invalidate_cache(self, path=None):
+        if path is None:
+            self.dircache.clear()
+        else:
+            self.dircache.pop(path, None)
+        super().invalidate_cache(path)
+
+
+class TransferDone(Exception):
+    """Internal exception to break out of transfer"""
+
+    pass
+
+
+class FTPFile(AbstractBufferedFile):
+    """Interact with a remote FTP file with read/write buffering"""
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        block_size="default",
+        autocommit=True,
+        cache_type="readahead",
+        cache_options=None,
+        **kwargs,
+    ):
+        super().__init__(
+            fs,
+            path,
+            mode=mode,
+            block_size=block_size,
+            autocommit=autocommit,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            **kwargs,
+        )
+        if not autocommit:
+            self.target = self.path
+            self.path = "/".join([kwargs["tempdir"], str(uuid.uuid4())])
+
+    def commit(self):
+        self.fs.mv(self.path, self.target)
+
+    def discard(self):
+        self.fs.rm(self.path)
+
+    def _fetch_range(self, start, end):
+        """Get bytes between given byte limits
+
+        Implemented by raising an exception in the fetch callback when the
+        number of bytes received reaches the requested amount.
+
+        Will fail if the server does not respect the REST command on
+        retrieve requests.
+        """
+        out = []
+        total = [0]
+
+        def callback(x):
+            total[0] += len(x)
+            if total[0] > end - start:
+                out.append(x[: (end - start) - total[0]])
+                if end < self.size:
+                    raise TransferDone
+            else:
+                out.append(x)
+
+            if total[0] == end - start and end < self.size:
+                raise TransferDone
+
+        try:
+            self.fs.ftp.retrbinary(
+                f"RETR {self.path}",
+                blocksize=self.blocksize,
+                rest=start,
+                callback=callback,
+            )
+        except TransferDone:
+            try:
+                # stop transfer, we got enough bytes for this block
+                self.fs.ftp.abort()
+                self.fs.ftp.getmultiline()
+            except Error:
+                self.fs._connect()
+
+        return b"".join(out)
+
+    def _upload_chunk(self, final=False):
+        self.buffer.seek(0)
+        self.fs.ftp.storbinary(
+            f"STOR {self.path}", self.buffer, blocksize=self.blocksize, rest=self.offset
+        )
+        return True
+
+
+def _mlsd2(ftp, path="."):
+    """
+    Fall back to using `dir` instead of `mlsd` if not supported.
+
+    This parses a Linux style `ls -l` response to `dir`, but the response may
+    be platform dependent.
+
+    Parameters
+    ----------
+    ftp: ftplib.FTP
+    path: str
+        Expects to be given path, but defaults to ".".
+    """
+    lines = []
+    minfo = []
+    ftp.dir(path, lines.append)
+    for line in lines:
+        line = line.split()
+        this = (
+            line[-1],
+            {
+                "modify": " ".join(line[5:8]),
+                "unix.owner": line[2],
+                "unix.group": line[3],
+                "unix.mode": line[0],
+                "size": line[4],
+            },
+        )
+        if "d" == this[1]["unix.mode"][0]:
+            this[1]["type"] = "dir"
+        else:
+            this[1]["type"] = "file"
+        minfo.append(this)
+    return minfo
diff --git a/lib/python3.11/site-packages/fsspec/implementations/git.py b/lib/python3.11/site-packages/fsspec/implementations/git.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c34d93e08c20fc65421e5aa4bab53e8c683fee7
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/git.py
@@ -0,0 +1,127 @@
+import os
+
+import pygit2
+
+from fsspec.spec import AbstractFileSystem
+
+from .memory import MemoryFile
+
+
+class GitFileSystem(AbstractFileSystem):
+    """Browse the files of a local git repo at any hash/tag/branch
+
+    (experimental backend)
+    """
+
+    root_marker = ""
+    cachable = True
+
+    def __init__(self, path=None, fo=None, ref=None, **kwargs):
+        """
+
+        Parameters
+        ----------
+        path: str (optional)
+            Local location of the repo (uses current directory if not given).
+            May be deprecated in favour of ``fo``. When used with a higher
+            level function such as fsspec.open(), may be of the form
+            "git://[path-to-repo[:]][ref@]path/to/file" (but the actual
+            file path should not contain "@" or ":").
+        fo: str (optional)
+            Same as ``path``, but passed as part of a chained URL. This one
+            takes precedence if both are given.
+        ref: str (optional)
+            Reference to work with, could be a hash, tag or branch name. Defaults
+            to current working tree. Note that ``ls`` and ``open`` also take hash,
+            so this becomes the default for those operations
+        kwargs
+        """
+        super().__init__(**kwargs)
+        self.repo = pygit2.Repository(fo or path or os.getcwd())
+        self.ref = ref or "master"
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        path = super()._strip_protocol(path).lstrip("/")
+        if ":" in path:
+            path = path.split(":", 1)[1]
+        if "@" in path:
+            path = path.split("@", 1)[1]
+        return path.lstrip("/")
+
+    def _path_to_object(self, path, ref):
+        comm, ref = self.repo.resolve_refish(ref or self.ref)
+        parts = path.split("/")
+        tree = comm.tree
+        for part in parts:
+            if part and isinstance(tree, pygit2.Tree):
+                tree = tree[part]
+        return tree
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        if path.startswith("git://"):
+            path = path[6:]
+        out = {}
+        if ":" in path:
+            out["path"], path = path.split(":", 1)
+        if "@" in path:
+            out["ref"], path = path.split("@", 1)
+        return out
+
+    def ls(self, path, detail=True, ref=None, **kwargs):
+        path = self._strip_protocol(path)
+        tree = self._path_to_object(path, ref)
+        if isinstance(tree, pygit2.Tree):
+            out = []
+            for obj in tree:
+                if isinstance(obj, pygit2.Tree):
+                    out.append(
+                        {
+                            "type": "directory",
+                            "name": "/".join([path, obj.name]).lstrip("/"),
+                            "hex": obj.hex,
+                            "mode": f"{obj.filemode:o}",
+                            "size": 0,
+                        }
+                    )
+                else:
+                    out.append(
+                        {
+                            "type": "file",
+                            "name": "/".join([path, obj.name]).lstrip("/"),
+                            "hex": obj.hex,
+                            "mode": f"{obj.filemode:o}",
+                            "size": obj.size,
+                        }
+                    )
+        else:
+            obj = tree
+            out = [
+                {
+                    "type": "file",
+                    "name": obj.name,
+                    "hex": obj.hex,
+                    "mode": f"{obj.filemode:o}",
+                    "size": obj.size,
+                }
+            ]
+        if detail:
+            return out
+        return [o["name"] for o in out]
+
+    def ukey(self, path, ref=None):
+        return self.info(path, ref=ref)["hex"]
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        ref=None,
+        **kwargs,
+    ):
+        obj = self._path_to_object(path, ref or self.ref)
+        return MemoryFile(data=obj.data)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/github.py b/lib/python3.11/site-packages/fsspec/implementations/github.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5df3f7abdcf8431619baf0fa5c64b0e6281f45b
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/github.py
@@ -0,0 +1,215 @@
+import requests
+
+from ..spec import AbstractFileSystem
+from ..utils import infer_storage_options
+from .memory import MemoryFile
+
+# TODO: add GIST backend, would be very similar
+
+
+class GithubFileSystem(AbstractFileSystem):
+    """Interface to files in github
+
+    An instance of this class provides the files residing within a remote github
+    repository. You may specify a point in the repos history, by SHA, branch
+    or tag (default is current master).
+
+    Given that code files tend to be small, and that github does not support
+    retrieving partial content, we always fetch whole files.
+
+    When using fsspec.open, allows URIs of the form:
+
+    - "github://path/file", in which case you must specify org, repo and
+      may specify sha in the extra args
+    - 'github://org:repo@/precip/catalog.yml', where the org and repo are
+      part of the URI
+    - 'github://org:repo@sha/precip/catalog.yml', where the sha is also included
+
+    ``sha`` can be the full or abbreviated hex of the commit you want to fetch
+    from, or a branch or tag name (so long as it doesn't contain special characters
+    like "/", "?", which would have to be HTTP-encoded).
+
+    For authorised access, you must provide username and token, which can be made
+    at https://github.com/settings/tokens
+    """
+
+    url = "https://api.github.com/repos/{org}/{repo}/git/trees/{sha}"
+    rurl = "https://raw.githubusercontent.com/{org}/{repo}/{sha}/{path}"
+    protocol = "github"
+
+    def __init__(self, org, repo, sha=None, username=None, token=None, **kwargs):
+        super().__init__(**kwargs)
+        self.org = org
+        self.repo = repo
+        if (username is None) ^ (token is None):
+            raise ValueError("Auth required both username and token")
+        self.username = username
+        self.token = token
+        if sha is None:
+            # look up default branch (not necessarily "master")
+            u = "https://api.github.com/repos/{org}/{repo}"
+            r = requests.get(u.format(org=org, repo=repo), **self.kw)
+            r.raise_for_status()
+            sha = r.json()["default_branch"]
+
+        self.root = sha
+        self.ls("")
+
+    @property
+    def kw(self):
+        if self.username:
+            return {"auth": (self.username, self.token)}
+        return {}
+
+    @classmethod
+    def repos(cls, org_or_user, is_org=True):
+        """List repo names for given org or user
+
+        This may become the top level of the FS
+
+        Parameters
+        ----------
+        org_or_user: str
+            Name of the github org or user to query
+        is_org: bool (default True)
+            Whether the name is an organisation (True) or user (False)
+
+        Returns
+        -------
+        List of string
+        """
+        r = requests.get(
+            f"https://api.github.com/{['users', 'orgs'][is_org]}/{org_or_user}/repos"
+        )
+        r.raise_for_status()
+        return [repo["name"] for repo in r.json()]
+
+    @property
+    def tags(self):
+        """Names of tags in the repo"""
+        r = requests.get(
+            f"https://api.github.com/repos/{self.org}/{self.repo}/tags",
+            **self.kw,
+        )
+        r.raise_for_status()
+        return [t["name"] for t in r.json()]
+
+    @property
+    def branches(self):
+        """Names of branches in the repo"""
+        r = requests.get(
+            f"https://api.github.com/repos/{self.org}/{self.repo}/branches",
+            **self.kw,
+        )
+        r.raise_for_status()
+        return [t["name"] for t in r.json()]
+
+    @property
+    def refs(self):
+        """Named references, tags and branches"""
+        return {"tags": self.tags, "branches": self.branches}
+
+    def ls(self, path, detail=False, sha=None, _sha=None, **kwargs):
+        """List files at given path
+
+        Parameters
+        ----------
+        path: str
+            Location to list, relative to repo root
+        detail: bool
+            If True, returns list of dicts, one per file; if False, returns
+            list of full filenames only
+        sha: str (optional)
+            List at the given point in the repo history, branch or tag name or commit
+            SHA
+        _sha: str (optional)
+            List this specific tree object (used internally to descend into trees)
+        """
+        path = self._strip_protocol(path)
+        if path == "":
+            _sha = sha or self.root
+        if _sha is None:
+            parts = path.rstrip("/").split("/")
+            so_far = ""
+            _sha = sha or self.root
+            for part in parts:
+                out = self.ls(so_far, True, sha=sha, _sha=_sha)
+                so_far += "/" + part if so_far else part
+                out = [o for o in out if o["name"] == so_far]
+                if not out:
+                    raise FileNotFoundError(path)
+                out = out[0]
+                if out["type"] == "file":
+                    if detail:
+                        return [out]
+                    else:
+                        return path
+                _sha = out["sha"]
+        if path not in self.dircache or sha not in [self.root, None]:
+            r = requests.get(
+                self.url.format(org=self.org, repo=self.repo, sha=_sha), **self.kw
+            )
+            if r.status_code == 404:
+                raise FileNotFoundError(path)
+            r.raise_for_status()
+            types = {"blob": "file", "tree": "directory"}
+            out = [
+                {
+                    "name": path + "/" + f["path"] if path else f["path"],
+                    "mode": f["mode"],
+                    "type": types[f["type"]],
+                    "size": f.get("size", 0),
+                    "sha": f["sha"],
+                }
+                for f in r.json()["tree"]
+                if f["type"] in types
+            ]
+            if sha in [self.root, None]:
+                self.dircache[path] = out
+        else:
+            out = self.dircache[path]
+        if detail:
+            return out
+        else:
+            return sorted([f["name"] for f in out])
+
+    def invalidate_cache(self, path=None):
+        self.dircache.clear()
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        opts = infer_storage_options(path)
+        if "username" not in opts:
+            return super()._strip_protocol(path)
+        return opts["path"].lstrip("/")
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        opts = infer_storage_options(path)
+        if "username" not in opts:
+            return {}
+        out = {"org": opts["username"], "repo": opts["password"]}
+        if opts["host"]:
+            out["sha"] = opts["host"]
+        return out
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        sha=None,
+        **kwargs,
+    ):
+        if mode != "rb":
+            raise NotImplementedError
+        url = self.rurl.format(
+            org=self.org, repo=self.repo, path=path, sha=sha or self.root
+        )
+        r = requests.get(url, **self.kw)
+        if r.status_code == 404:
+            raise FileNotFoundError(path)
+        r.raise_for_status()
+        return MemoryFile(None, None, r.content)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/http.py b/lib/python3.11/site-packages/fsspec/implementations/http.py
new file mode 100644
index 0000000000000000000000000000000000000000..f851138936d75e840605d7532977805ad7e41991
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/http.py
@@ -0,0 +1,864 @@
+import asyncio
+import io
+import logging
+import re
+import weakref
+from copy import copy
+from urllib.parse import urlparse
+
+import aiohttp
+import requests
+import yarl
+
+from fsspec.asyn import AbstractAsyncStreamedFile, AsyncFileSystem, sync, sync_wrapper
+from fsspec.callbacks import _DEFAULT_CALLBACK
+from fsspec.exceptions import FSTimeoutError
+from fsspec.spec import AbstractBufferedFile
+from fsspec.utils import (
+    DEFAULT_BLOCK_SIZE,
+    glob_translate,
+    isfilelike,
+    nullcontext,
+    tokenize,
+)
+
+from ..caching import AllBytes
+
+# https://stackoverflow.com/a/15926317/3821154
+ex = re.compile(r"""<(a|A)\s+(?:[^>]*?\s+)?(href|HREF)=["'](?P<url>[^"']+)""")
+ex2 = re.compile(r"""(?P<url>http[s]?://[-a-zA-Z0-9@:%_+.~#?&/=]+)""")
+logger = logging.getLogger("fsspec.http")
+
+
+async def get_client(**kwargs):
+    return aiohttp.ClientSession(**kwargs)
+
+
+class HTTPFileSystem(AsyncFileSystem):
+    """
+    Simple File-System for fetching data via HTTP(S)
+
+    ``ls()`` is implemented by loading the parent page and doing a regex
+    match on the result. If simple_link=True, anything of the form
+    "http(s)://server.com/stuff?thing=other"; otherwise only links within
+    HTML href tags will be used.
+    """
+
+    sep = "/"
+
+    def __init__(
+        self,
+        simple_links=True,
+        block_size=None,
+        same_scheme=True,
+        size_policy=None,
+        cache_type="bytes",
+        cache_options=None,
+        asynchronous=False,
+        loop=None,
+        client_kwargs=None,
+        get_client=get_client,
+        encoded=False,
+        **storage_options,
+    ):
+        """
+        NB: if this is called async, you must await set_client
+
+        Parameters
+        ----------
+        block_size: int
+            Blocks to read bytes; if 0, will default to raw requests file-like
+            objects instead of HTTPFile instances
+        simple_links: bool
+            If True, will consider both HTML <a> tags and anything that looks
+            like a URL; if False, will consider only the former.
+        same_scheme: True
+            When doing ls/glob, if this is True, only consider paths that have
+            http/https matching the input URLs.
+        size_policy: this argument is deprecated
+        client_kwargs: dict
+            Passed to aiohttp.ClientSession, see
+            https://docs.aiohttp.org/en/stable/client_reference.html
+            For example, ``{'auth': aiohttp.BasicAuth('user', 'pass')}``
+        get_client: Callable[..., aiohttp.ClientSession]
+            A callable which takes keyword arguments and constructs
+            an aiohttp.ClientSession. It's state will be managed by
+            the HTTPFileSystem class.
+        storage_options: key-value
+            Any other parameters passed on to requests
+        cache_type, cache_options: defaults used in open
+        """
+        super().__init__(self, asynchronous=asynchronous, loop=loop, **storage_options)
+        self.block_size = block_size if block_size is not None else DEFAULT_BLOCK_SIZE
+        self.simple_links = simple_links
+        self.same_schema = same_scheme
+        self.cache_type = cache_type
+        self.cache_options = cache_options
+        self.client_kwargs = client_kwargs or {}
+        self.get_client = get_client
+        self.encoded = encoded
+        self.kwargs = storage_options
+        self._session = None
+
+        # Clean caching-related parameters from `storage_options`
+        # before propagating them as `request_options` through `self.kwargs`.
+        # TODO: Maybe rename `self.kwargs` to `self.request_options` to make
+        #       it clearer.
+        request_options = copy(storage_options)
+        self.use_listings_cache = request_options.pop("use_listings_cache", False)
+        request_options.pop("listings_expiry_time", None)
+        request_options.pop("max_paths", None)
+        request_options.pop("skip_instance_cache", None)
+        self.kwargs = request_options
+
+    @property
+    def fsid(self):
+        return "http"
+
+    def encode_url(self, url):
+        return yarl.URL(url, encoded=self.encoded)
+
+    @staticmethod
+    def close_session(loop, session):
+        if loop is not None and loop.is_running():
+            try:
+                sync(loop, session.close, timeout=0.1)
+                return
+            except (TimeoutError, FSTimeoutError):
+                pass
+        connector = getattr(session, "_connector", None)
+        if connector is not None:
+            # close after loop is dead
+            connector._close()
+
+    async def set_session(self):
+        if self._session is None:
+            self._session = await self.get_client(loop=self.loop, **self.client_kwargs)
+            if not self.asynchronous:
+                weakref.finalize(self, self.close_session, self.loop, self._session)
+        return self._session
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        """For HTTP, we always want to keep the full URL"""
+        return path
+
+    @classmethod
+    def _parent(cls, path):
+        # override, since _strip_protocol is different for URLs
+        par = super()._parent(path)
+        if len(par) > 7:  # "http://..."
+            return par
+        return ""
+
+    async def _ls_real(self, url, detail=True, **kwargs):
+        # ignoring URL-encoded arguments
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(url)
+        session = await self.set_session()
+        async with session.get(self.encode_url(url), **self.kwargs) as r:
+            self._raise_not_found_for_status(r, url)
+            text = await r.text()
+        if self.simple_links:
+            links = ex2.findall(text) + [u[2] for u in ex.findall(text)]
+        else:
+            links = [u[2] for u in ex.findall(text)]
+        out = set()
+        parts = urlparse(url)
+        for l in links:
+            if isinstance(l, tuple):
+                l = l[1]
+            if l.startswith("/") and len(l) > 1:
+                # absolute URL on this server
+                l = f"{parts.scheme}://{parts.netloc}{l}"
+            if l.startswith("http"):
+                if self.same_schema and l.startswith(url.rstrip("/") + "/"):
+                    out.add(l)
+                elif l.replace("https", "http").startswith(
+                    url.replace("https", "http").rstrip("/") + "/"
+                ):
+                    # allowed to cross http <-> https
+                    out.add(l)
+            else:
+                if l not in ["..", "../"]:
+                    # Ignore FTP-like "parent"
+                    out.add("/".join([url.rstrip("/"), l.lstrip("/")]))
+        if not out and url.endswith("/"):
+            out = await self._ls_real(url.rstrip("/"), detail=False)
+        if detail:
+            return [
+                {
+                    "name": u,
+                    "size": None,
+                    "type": "directory" if u.endswith("/") else "file",
+                }
+                for u in out
+            ]
+        else:
+            return sorted(out)
+
+    async def _ls(self, url, detail=True, **kwargs):
+        if self.use_listings_cache and url in self.dircache:
+            out = self.dircache[url]
+        else:
+            out = await self._ls_real(url, detail=detail, **kwargs)
+            self.dircache[url] = out
+        return out
+
+    ls = sync_wrapper(_ls)
+
+    def _raise_not_found_for_status(self, response, url):
+        """
+        Raises FileNotFoundError for 404s, otherwise uses raise_for_status.
+        """
+        if response.status == 404:
+            raise FileNotFoundError(url)
+        response.raise_for_status()
+
+    async def _cat_file(self, url, start=None, end=None, **kwargs):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(url)
+
+        if start is not None or end is not None:
+            if start == end:
+                return b""
+            headers = kw.pop("headers", {}).copy()
+
+            headers["Range"] = await self._process_limits(url, start, end)
+            kw["headers"] = headers
+        session = await self.set_session()
+        async with session.get(self.encode_url(url), **kw) as r:
+            out = await r.read()
+            self._raise_not_found_for_status(r, url)
+        return out
+
+    async def _get_file(
+        self, rpath, lpath, chunk_size=5 * 2**20, callback=_DEFAULT_CALLBACK, **kwargs
+    ):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(rpath)
+        session = await self.set_session()
+        async with session.get(self.encode_url(rpath), **kw) as r:
+            try:
+                size = int(r.headers["content-length"])
+            except (ValueError, KeyError):
+                size = None
+
+            callback.set_size(size)
+            self._raise_not_found_for_status(r, rpath)
+            if isfilelike(lpath):
+                outfile = lpath
+            else:
+                outfile = open(lpath, "wb")
+
+            try:
+                chunk = True
+                while chunk:
+                    chunk = await r.content.read(chunk_size)
+                    outfile.write(chunk)
+                    callback.relative_update(len(chunk))
+            finally:
+                if not isfilelike(lpath):
+                    outfile.close()
+
+    async def _put_file(
+        self,
+        lpath,
+        rpath,
+        chunk_size=5 * 2**20,
+        callback=_DEFAULT_CALLBACK,
+        method="post",
+        **kwargs,
+    ):
+        async def gen_chunks():
+            # Support passing arbitrary file-like objects
+            # and use them instead of streams.
+            if isinstance(lpath, io.IOBase):
+                context = nullcontext(lpath)
+                use_seek = False  # might not support seeking
+            else:
+                context = open(lpath, "rb")
+                use_seek = True
+
+            with context as f:
+                if use_seek:
+                    callback.set_size(f.seek(0, 2))
+                    f.seek(0)
+                else:
+                    callback.set_size(getattr(f, "size", None))
+
+                chunk = f.read(chunk_size)
+                while chunk:
+                    yield chunk
+                    callback.relative_update(len(chunk))
+                    chunk = f.read(chunk_size)
+
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        session = await self.set_session()
+
+        method = method.lower()
+        if method not in ("post", "put"):
+            raise ValueError(
+                f"method has to be either 'post' or 'put', not: {method!r}"
+            )
+
+        meth = getattr(session, method)
+        async with meth(self.encode_url(rpath), data=gen_chunks(), **kw) as resp:
+            self._raise_not_found_for_status(resp, rpath)
+
+    async def _exists(self, path, **kwargs):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        try:
+            logger.debug(path)
+            session = await self.set_session()
+            r = await session.get(self.encode_url(path), **kw)
+            async with r:
+                return r.status < 400
+        except (requests.HTTPError, aiohttp.ClientError):
+            return False
+
+    async def _isfile(self, path, **kwargs):
+        return await self._exists(path, **kwargs)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=None,  # XXX: This differs from the base class.
+        cache_type=None,
+        cache_options=None,
+        size=None,
+        **kwargs,
+    ):
+        """Make a file-like object
+
+        Parameters
+        ----------
+        path: str
+            Full URL with protocol
+        mode: string
+            must be "rb"
+        block_size: int or None
+            Bytes to download in one request; use instance value if None. If
+            zero, will return a streaming Requests file-like instance.
+        kwargs: key-value
+            Any other parameters, passed to requests calls
+        """
+        if mode != "rb":
+            raise NotImplementedError
+        block_size = block_size if block_size is not None else self.block_size
+        kw = self.kwargs.copy()
+        kw["asynchronous"] = self.asynchronous
+        kw.update(kwargs)
+        size = size or self.info(path, **kwargs)["size"]
+        session = sync(self.loop, self.set_session)
+        if block_size and size:
+            return HTTPFile(
+                self,
+                path,
+                session=session,
+                block_size=block_size,
+                mode=mode,
+                size=size,
+                cache_type=cache_type or self.cache_type,
+                cache_options=cache_options or self.cache_options,
+                loop=self.loop,
+                **kw,
+            )
+        else:
+            return HTTPStreamFile(
+                self,
+                path,
+                mode=mode,
+                loop=self.loop,
+                session=session,
+                **kw,
+            )
+
+    async def open_async(self, path, mode="rb", size=None, **kwargs):
+        session = await self.set_session()
+        if size is None:
+            try:
+                size = (await self._info(path, **kwargs))["size"]
+            except FileNotFoundError:
+                pass
+        return AsyncStreamFile(
+            self,
+            path,
+            loop=self.loop,
+            session=session,
+            size=size,
+            **kwargs,
+        )
+
+    def ukey(self, url):
+        """Unique identifier; assume HTTP files are static, unchanging"""
+        return tokenize(url, self.kwargs, self.protocol)
+
+    async def _info(self, url, **kwargs):
+        """Get info of URL
+
+        Tries to access location via HEAD, and then GET methods, but does
+        not fetch the data.
+
+        It is possible that the server does not supply any size information, in
+        which case size will be given as None (and certain operations on the
+        corresponding file will not work).
+        """
+        info = {}
+        session = await self.set_session()
+
+        for policy in ["head", "get"]:
+            try:
+                info.update(
+                    await _file_info(
+                        self.encode_url(url),
+                        size_policy=policy,
+                        session=session,
+                        **self.kwargs,
+                        **kwargs,
+                    )
+                )
+                if info.get("size") is not None:
+                    break
+            except Exception as exc:
+                if policy == "get":
+                    # If get failed, then raise a FileNotFoundError
+                    raise FileNotFoundError(url) from exc
+                logger.debug(str(exc))
+
+        return {"name": url, "size": None, **info, "type": "file"}
+
+    async def _glob(self, path, maxdepth=None, **kwargs):
+        """
+        Find files by glob-matching.
+
+        This implementation is idntical to the one in AbstractFileSystem,
+        but "?" is not considered as a character for globbing, because it is
+        so common in URLs, often identifying the "query" part.
+        """
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+        import re
+
+        ends_with_slash = path.endswith("/")  # _strip_protocol strips trailing slash
+        path = self._strip_protocol(path)
+        append_slash_to_dirname = ends_with_slash or path.endswith("/**")
+        idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+        idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+        min_idx = min(idx_star, idx_brace)
+
+        detail = kwargs.pop("detail", False)
+
+        if not has_magic(path):
+            if await self._exists(path, **kwargs):
+                if not detail:
+                    return [path]
+                else:
+                    return {path: await self._info(path, **kwargs)}
+            else:
+                if not detail:
+                    return []  # glob of non-existent returns empty
+                else:
+                    return {}
+        elif "/" in path[:min_idx]:
+            min_idx = path[:min_idx].rindex("/")
+            root = path[: min_idx + 1]
+            depth = path[min_idx + 1 :].count("/") + 1
+        else:
+            root = ""
+            depth = path[min_idx + 1 :].count("/") + 1
+
+        if "**" in path:
+            if maxdepth is not None:
+                idx_double_stars = path.find("**")
+                depth_double_stars = path[idx_double_stars:].count("/") + 1
+                depth = depth - depth_double_stars + maxdepth
+            else:
+                depth = None
+
+        allpaths = await self._find(
+            root, maxdepth=depth, withdirs=True, detail=True, **kwargs
+        )
+
+        pattern = glob_translate(path + ("/" if ends_with_slash else ""))
+        pattern = re.compile(pattern)
+
+        out = {
+            p: info
+            for p, info in sorted(allpaths.items())
+            if pattern.match(
+                (
+                    p + "/"
+                    if append_slash_to_dirname and info["type"] == "directory"
+                    else p
+                )
+            )
+        }
+
+        if detail:
+            return out
+        else:
+            return list(out)
+
+    async def _isdir(self, path):
+        # override, since all URLs are (also) files
+        try:
+            return bool(await self._ls(path))
+        except (FileNotFoundError, ValueError):
+            return False
+
+
+class HTTPFile(AbstractBufferedFile):
+    """
+    A file-like object pointing to a remove HTTP(S) resource
+
+    Supports only reading, with read-ahead of a predermined block-size.
+
+    In the case that the server does not supply the filesize, only reading of
+    the complete file in one go is supported.
+
+    Parameters
+    ----------
+    url: str
+        Full URL of the remote resource, including the protocol
+    session: requests.Session or None
+        All calls will be made within this session, to avoid restarting
+        connections where the server allows this
+    block_size: int or None
+        The amount of read-ahead to do, in bytes. Default is 5MB, or the value
+        configured for the FileSystem creating this file
+    size: None or int
+        If given, this is the size of the file in bytes, and we don't attempt
+        to call the server to find the value.
+    kwargs: all other key-values are passed to requests calls.
+    """
+
+    def __init__(
+        self,
+        fs,
+        url,
+        session=None,
+        block_size=None,
+        mode="rb",
+        cache_type="bytes",
+        cache_options=None,
+        size=None,
+        loop=None,
+        asynchronous=False,
+        **kwargs,
+    ):
+        if mode != "rb":
+            raise NotImplementedError("File mode not supported")
+        self.asynchronous = asynchronous
+        self.url = url
+        self.session = session
+        self.details = {"name": url, "size": size, "type": "file"}
+        super().__init__(
+            fs=fs,
+            path=url,
+            mode=mode,
+            block_size=block_size,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            **kwargs,
+        )
+        self.loop = loop
+
+    def read(self, length=-1):
+        """Read bytes from file
+
+        Parameters
+        ----------
+        length: int
+            Read up to this many bytes. If negative, read all content to end of
+            file. If the server has not supplied the filesize, attempting to
+            read only part of the data will raise a ValueError.
+        """
+        if (
+            (length < 0 and self.loc == 0)  # explicit read all
+            # but not when the size is known and fits into a block anyways
+            and not (self.size is not None and self.size <= self.blocksize)
+        ):
+            self._fetch_all()
+        if self.size is None:
+            if length < 0:
+                self._fetch_all()
+        else:
+            length = min(self.size - self.loc, length)
+        return super().read(length)
+
+    async def async_fetch_all(self):
+        """Read whole file in one shot, without caching
+
+        This is only called when position is still at zero,
+        and read() is called without a byte-count.
+        """
+        logger.debug(f"Fetch all for {self}")
+        if not isinstance(self.cache, AllBytes):
+            r = await self.session.get(self.fs.encode_url(self.url), **self.kwargs)
+            async with r:
+                r.raise_for_status()
+                out = await r.read()
+                self.cache = AllBytes(
+                    size=len(out), fetcher=None, blocksize=None, data=out
+                )
+                self.size = len(out)
+
+    _fetch_all = sync_wrapper(async_fetch_all)
+
+    def _parse_content_range(self, headers):
+        """Parse the Content-Range header"""
+        s = headers.get("Content-Range", "")
+        m = re.match(r"bytes (\d+-\d+|\*)/(\d+|\*)", s)
+        if not m:
+            return None, None, None
+
+        if m[1] == "*":
+            start = end = None
+        else:
+            start, end = [int(x) for x in m[1].split("-")]
+        total = None if m[2] == "*" else int(m[2])
+        return start, end, total
+
+    async def async_fetch_range(self, start, end):
+        """Download a block of data
+
+        The expectation is that the server returns only the requested bytes,
+        with HTTP code 206. If this is not the case, we first check the headers,
+        and then stream the output - if the data size is bigger than we
+        requested, an exception is raised.
+        """
+        logger.debug(f"Fetch range for {self}: {start}-{end}")
+        kwargs = self.kwargs.copy()
+        headers = kwargs.pop("headers", {}).copy()
+        headers["Range"] = f"bytes={start}-{end - 1}"
+        logger.debug(f"{self.url} : {headers['Range']}")
+        r = await self.session.get(
+            self.fs.encode_url(self.url), headers=headers, **kwargs
+        )
+        async with r:
+            if r.status == 416:
+                # range request outside file
+                return b""
+            r.raise_for_status()
+
+            # If the server has handled the range request, it should reply
+            # with status 206 (partial content). But we'll guess that a suitable
+            # Content-Range header or a Content-Length no more than the
+            # requested range also mean we have got the desired range.
+            response_is_range = (
+                r.status == 206
+                or self._parse_content_range(r.headers)[0] == start
+                or int(r.headers.get("Content-Length", end + 1)) <= end - start
+            )
+
+            if response_is_range:
+                # partial content, as expected
+                out = await r.read()
+            elif start > 0:
+                raise ValueError(
+                    "The HTTP server doesn't appear to support range requests. "
+                    "Only reading this file from the beginning is supported. "
+                    "Open with block_size=0 for a streaming file interface."
+                )
+            else:
+                # Response is not a range, but we want the start of the file,
+                # so we can read the required amount anyway.
+                cl = 0
+                out = []
+                while True:
+                    chunk = await r.content.read(2**20)
+                    # data size unknown, let's read until we have enough
+                    if chunk:
+                        out.append(chunk)
+                        cl += len(chunk)
+                        if cl > end - start:
+                            break
+                    else:
+                        break
+                out = b"".join(out)[: end - start]
+            return out
+
+    _fetch_range = sync_wrapper(async_fetch_range)
+
+    def __reduce__(self):
+        return (
+            reopen,
+            (
+                self.fs,
+                self.url,
+                self.mode,
+                self.blocksize,
+                self.cache.name if self.cache else "none",
+                self.size,
+            ),
+        )
+
+
+def reopen(fs, url, mode, blocksize, cache_type, size=None):
+    return fs.open(
+        url, mode=mode, block_size=blocksize, cache_type=cache_type, size=size
+    )
+
+
+magic_check = re.compile("([*[])")
+
+
+def has_magic(s):
+    match = magic_check.search(s)
+    return match is not None
+
+
+class HTTPStreamFile(AbstractBufferedFile):
+    def __init__(self, fs, url, mode="rb", loop=None, session=None, **kwargs):
+        self.asynchronous = kwargs.pop("asynchronous", False)
+        self.url = url
+        self.loop = loop
+        self.session = session
+        if mode != "rb":
+            raise ValueError
+        self.details = {"name": url, "size": None}
+        super().__init__(fs=fs, path=url, mode=mode, cache_type="none", **kwargs)
+
+        async def cor():
+            r = await self.session.get(self.fs.encode_url(url), **kwargs).__aenter__()
+            self.fs._raise_not_found_for_status(r, url)
+            return r
+
+        self.r = sync(self.loop, cor)
+
+    def seek(self, loc, whence=0):
+        if loc == 0 and whence == 1:
+            return
+        if loc == self.loc and whence == 0:
+            return
+        raise ValueError("Cannot seek streaming HTTP file")
+
+    async def _read(self, num=-1):
+        out = await self.r.content.read(num)
+        self.loc += len(out)
+        return out
+
+    read = sync_wrapper(_read)
+
+    async def _close(self):
+        self.r.close()
+
+    def close(self):
+        asyncio.run_coroutine_threadsafe(self._close(), self.loop)
+        super().close()
+
+    def __reduce__(self):
+        return reopen, (self.fs, self.url, self.mode, self.blocksize, self.cache.name)
+
+
+class AsyncStreamFile(AbstractAsyncStreamedFile):
+    def __init__(
+        self, fs, url, mode="rb", loop=None, session=None, size=None, **kwargs
+    ):
+        self.url = url
+        self.session = session
+        self.r = None
+        if mode != "rb":
+            raise ValueError
+        self.details = {"name": url, "size": None}
+        self.kwargs = kwargs
+        super().__init__(fs=fs, path=url, mode=mode, cache_type="none")
+        self.size = size
+
+    async def read(self, num=-1):
+        if self.r is None:
+            r = await self.session.get(
+                self.fs.encode_url(self.url), **self.kwargs
+            ).__aenter__()
+            self.fs._raise_not_found_for_status(r, self.url)
+            self.r = r
+        out = await self.r.content.read(num)
+        self.loc += len(out)
+        return out
+
+    async def close(self):
+        if self.r is not None:
+            self.r.close()
+            self.r = None
+        await super().close()
+
+
+async def get_range(session, url, start, end, file=None, **kwargs):
+    # explicit get a range when we know it must be safe
+    kwargs = kwargs.copy()
+    headers = kwargs.pop("headers", {}).copy()
+    headers["Range"] = f"bytes={start}-{end - 1}"
+    r = await session.get(url, headers=headers, **kwargs)
+    r.raise_for_status()
+    async with r:
+        out = await r.read()
+    if file:
+        with open(file, "r+b") as f:
+            f.seek(start)
+            f.write(out)
+    else:
+        return out
+
+
+async def _file_info(url, session, size_policy="head", **kwargs):
+    """Call HEAD on the server to get details about the file (size/checksum etc.)
+
+    Default operation is to explicitly allow redirects and use encoding
+    'identity' (no compression) to get the true size of the target.
+    """
+    logger.debug("Retrieve file size for %s", url)
+    kwargs = kwargs.copy()
+    ar = kwargs.pop("allow_redirects", True)
+    head = kwargs.get("headers", {}).copy()
+    head["Accept-Encoding"] = "identity"
+    kwargs["headers"] = head
+
+    info = {}
+    if size_policy == "head":
+        r = await session.head(url, allow_redirects=ar, **kwargs)
+    elif size_policy == "get":
+        r = await session.get(url, allow_redirects=ar, **kwargs)
+    else:
+        raise TypeError(f'size_policy must be "head" or "get", got {size_policy}')
+    async with r:
+        r.raise_for_status()
+
+        # TODO:
+        #  recognise lack of 'Accept-Ranges',
+        #                 or 'Accept-Ranges': 'none' (not 'bytes')
+        #  to mean streaming only, no random access => return None
+        if "Content-Length" in r.headers:
+            # Some servers may choose to ignore Accept-Encoding and return
+            # compressed content, in which case the returned size is unreliable.
+            if "Content-Encoding" not in r.headers or r.headers["Content-Encoding"] in [
+                "identity",
+                "",
+            ]:
+                info["size"] = int(r.headers["Content-Length"])
+        elif "Content-Range" in r.headers:
+            info["size"] = int(r.headers["Content-Range"].split("/")[1])
+
+        for checksum_field in ["ETag", "Content-MD5", "Digest"]:
+            if r.headers.get(checksum_field):
+                info[checksum_field] = r.headers[checksum_field]
+
+    return info
+
+
+async def _file_size(url, session=None, *args, **kwargs):
+    if session is None:
+        session = await get_client()
+    info = await _file_info(url, session=session, *args, **kwargs)
+    return info.get("size")
+
+
+file_size = sync_wrapper(_file_size)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/jupyter.py b/lib/python3.11/site-packages/fsspec/implementations/jupyter.py
new file mode 100644
index 0000000000000000000000000000000000000000..2839f4c1feea56dddd54bdc00f0b884c8461d29e
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/jupyter.py
@@ -0,0 +1,124 @@
+import base64
+import io
+import re
+
+import requests
+
+import fsspec
+
+
+class JupyterFileSystem(fsspec.AbstractFileSystem):
+    """View of the files as seen by a Jupyter server (notebook or lab)"""
+
+    protocol = ("jupyter", "jlab")
+
+    def __init__(self, url, tok=None, **kwargs):
+        """
+
+        Parameters
+        ----------
+        url : str
+            Base URL of the server, like "http://127.0.0.1:8888". May include
+            token in the string, which is given by the process when starting up
+        tok : str
+            If the token is obtained separately, can be given here
+        kwargs
+        """
+        if "?" in url:
+            if tok is None:
+                try:
+                    tok = re.findall("token=([a-z0-9]+)", url)[0]
+                except IndexError as e:
+                    raise ValueError("Could not determine token") from e
+            url = url.split("?", 1)[0]
+        self.url = url.rstrip("/") + "/api/contents"
+        self.session = requests.Session()
+        if tok:
+            self.session.headers["Authorization"] = f"token {tok}"
+
+        super().__init__(**kwargs)
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        r = self.session.get(f"{self.url}/{path}")
+        if r.status_code == 404:
+            return FileNotFoundError(path)
+        r.raise_for_status()
+        out = r.json()
+
+        if out["type"] == "directory":
+            out = out["content"]
+        else:
+            out = [out]
+        for o in out:
+            o["name"] = o.pop("path")
+            o.pop("content")
+            if o["type"] == "notebook":
+                o["type"] = "file"
+        if detail:
+            return out
+        return [o["name"] for o in out]
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        path = self._strip_protocol(path)
+        r = self.session.get(f"{self.url}/{path}")
+        if r.status_code == 404:
+            return FileNotFoundError(path)
+        r.raise_for_status()
+        out = r.json()
+        if out["format"] == "text":
+            # data should be binary
+            b = out["content"].encode()
+        else:
+            b = base64.b64decode(out["content"])
+        return b[start:end]
+
+    def pipe_file(self, path, value, **_):
+        path = self._strip_protocol(path)
+        json = {
+            "name": path.rsplit("/", 1)[-1],
+            "path": path,
+            "size": len(value),
+            "content": base64.b64encode(value).decode(),
+            "format": "base64",
+            "type": "file",
+        }
+        self.session.put(f"{self.url}/{path}", json=json)
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if create_parents and "/" in path:
+            self.mkdir(path.rsplit("/", 1)[0], True)
+        json = {
+            "name": path.rsplit("/", 1)[-1],
+            "path": path,
+            "size": None,
+            "content": None,
+            "type": "directory",
+        }
+        self.session.put(f"{self.url}/{path}", json=json)
+
+    def _rm(self, path):
+        path = self._strip_protocol(path)
+        self.session.delete(f"{self.url}/{path}")
+
+    def _open(self, path, mode="rb", **kwargs):
+        path = self._strip_protocol(path)
+        if mode == "rb":
+            data = self.cat_file(path)
+            return io.BytesIO(data)
+        else:
+            return SimpleFileWriter(self, path, mode="wb")
+
+
+class SimpleFileWriter(fsspec.spec.AbstractBufferedFile):
+    def _upload_chunk(self, final=False):
+        """Never uploads a chunk until file is done
+
+        Not suitable for large files
+        """
+        if final is False:
+            return False
+        self.buffer.seek(0)
+        data = self.buffer.read()
+        self.fs.pipe_file(self.path, data)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/libarchive.py b/lib/python3.11/site-packages/fsspec/implementations/libarchive.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb6f145352e1989e0477e259be02d8d7f4d729e2
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/libarchive.py
@@ -0,0 +1,213 @@
+from contextlib import contextmanager
+from ctypes import (
+    CFUNCTYPE,
+    POINTER,
+    c_int,
+    c_longlong,
+    c_void_p,
+    cast,
+    create_string_buffer,
+)
+
+import libarchive
+import libarchive.ffi as ffi
+
+from fsspec import open_files
+from fsspec.archive import AbstractArchiveFileSystem
+from fsspec.implementations.memory import MemoryFile
+from fsspec.utils import DEFAULT_BLOCK_SIZE
+
+# Libarchive requires seekable files or memory only for certain archive
+# types. However, since we read the directory first to cache the contents
+# and also allow random access to any file, the file-like object needs
+# to be seekable no matter what.
+
+# Seek call-backs (not provided in the libarchive python wrapper)
+SEEK_CALLBACK = CFUNCTYPE(c_longlong, c_int, c_void_p, c_longlong, c_int)
+read_set_seek_callback = ffi.ffi(
+    "read_set_seek_callback", [ffi.c_archive_p, SEEK_CALLBACK], c_int, ffi.check_int
+)
+new_api = hasattr(ffi, "NO_OPEN_CB")
+
+
+@contextmanager
+def custom_reader(file, format_name="all", filter_name="all", block_size=ffi.page_size):
+    """Read an archive from a seekable file-like object.
+
+    The `file` object must support the standard `readinto` and 'seek' methods.
+    """
+    buf = create_string_buffer(block_size)
+    buf_p = cast(buf, c_void_p)
+
+    def read_func(archive_p, context, ptrptr):
+        # readinto the buffer, returns number of bytes read
+        length = file.readinto(buf)
+        # write the address of the buffer into the pointer
+        ptrptr = cast(ptrptr, POINTER(c_void_p))
+        ptrptr[0] = buf_p
+        # tell libarchive how much data was written into the buffer
+        return length
+
+    def seek_func(archive_p, context, offset, whence):
+        file.seek(offset, whence)
+        # tell libarchvie the current position
+        return file.tell()
+
+    read_cb = ffi.READ_CALLBACK(read_func)
+    seek_cb = SEEK_CALLBACK(seek_func)
+
+    if new_api:
+        open_cb = ffi.NO_OPEN_CB
+        close_cb = ffi.NO_CLOSE_CB
+    else:
+        open_cb = libarchive.read.OPEN_CALLBACK(ffi.VOID_CB)
+        close_cb = libarchive.read.CLOSE_CALLBACK(ffi.VOID_CB)
+
+    with libarchive.read.new_archive_read(format_name, filter_name) as archive_p:
+        read_set_seek_callback(archive_p, seek_cb)
+        ffi.read_open(archive_p, None, open_cb, read_cb, close_cb)
+        yield libarchive.read.ArchiveRead(archive_p)
+
+
+class LibArchiveFileSystem(AbstractArchiveFileSystem):
+    """Compressed archives as a file-system (read-only)
+
+    Supports the following formats:
+    tar, pax , cpio, ISO9660, zip, mtree, shar, ar, raw, xar, lha/lzh, rar
+    Microsoft CAB, 7-Zip, WARC
+
+    See the libarchive documentation for further restrictions.
+    https://www.libarchive.org/
+
+    Keeps file object open while instance lives. It only works in seekable
+    file-like objects. In case the filesystem does not support this kind of
+    file object, it is recommended to cache locally.
+
+    This class is pickleable, but not necessarily thread-safe (depends on the
+    platform). See libarchive documentation for details.
+    """
+
+    root_marker = ""
+    protocol = "libarchive"
+    cachable = False
+
+    def __init__(
+        self,
+        fo="",
+        mode="r",
+        target_protocol=None,
+        target_options=None,
+        block_size=DEFAULT_BLOCK_SIZE,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        fo: str or file-like
+            Contains ZIP, and must exist. If a str, will fetch file using
+            :meth:`~fsspec.open_files`, which must return one file exactly.
+        mode: str
+            Currently, only 'r' accepted
+        target_protocol: str (optional)
+            If ``fo`` is a string, this value can be used to override the
+            FS protocol inferred from a URL
+        target_options: dict (optional)
+            Kwargs passed when instantiating the target FS, if ``fo`` is
+            a string.
+        """
+        super().__init__(self, **kwargs)
+        if mode != "r":
+            raise ValueError("Only read from archive files accepted")
+        if isinstance(fo, str):
+            files = open_files(fo, protocol=target_protocol, **(target_options or {}))
+            if len(files) != 1:
+                raise ValueError(
+                    f'Path "{fo}" did not resolve to exactly one file: "{files}"'
+                )
+            fo = files[0]
+        self.of = fo
+        self.fo = fo.__enter__()  # the whole instance is a context
+        self.block_size = block_size
+        self.dir_cache = None
+
+    @contextmanager
+    def _open_archive(self):
+        self.fo.seek(0)
+        with custom_reader(self.fo, block_size=self.block_size) as arc:
+            yield arc
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        # file paths are always relative to the archive root
+        return super()._strip_protocol(path).lstrip("/")
+
+    def _get_dirs(self):
+        fields = {
+            "name": "pathname",
+            "size": "size",
+            "created": "ctime",
+            "mode": "mode",
+            "uid": "uid",
+            "gid": "gid",
+            "mtime": "mtime",
+        }
+
+        if self.dir_cache is not None:
+            return
+
+        self.dir_cache = {}
+        list_names = []
+        with self._open_archive() as arc:
+            for entry in arc:
+                if not entry.isdir and not entry.isfile:
+                    # Skip symbolic links, fifo entries, etc.
+                    continue
+                self.dir_cache.update(
+                    {
+                        dirname: {"name": dirname, "size": 0, "type": "directory"}
+                        for dirname in self._all_dirnames(set(entry.name))
+                    }
+                )
+                f = {key: getattr(entry, fields[key]) for key in fields}
+                f["type"] = "directory" if entry.isdir else "file"
+                list_names.append(entry.name)
+
+                self.dir_cache[f["name"]] = f
+        # libarchive does not seem to return an entry for the directories (at least
+        # not in all formats), so get the directories names from the files names
+        self.dir_cache.update(
+            {
+                dirname: {"name": dirname, "size": 0, "type": "directory"}
+                for dirname in self._all_dirnames(list_names)
+            }
+        )
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        if mode != "rb":
+            raise NotImplementedError
+
+        data = bytes()
+        with self._open_archive() as arc:
+            for entry in arc:
+                if entry.pathname != path:
+                    continue
+
+                if entry.size == 0:
+                    # empty file, so there are no blocks
+                    break
+
+                for block in entry.get_blocks(entry.size):
+                    data = block
+                    break
+                else:
+                    raise ValueError
+        return MemoryFile(fs=self, path=path, data=data)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/local.py b/lib/python3.11/site-packages/fsspec/implementations/local.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7861e2eac952d5c9b096e07a258f484cd5a533d
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/local.py
@@ -0,0 +1,414 @@
+import datetime
+import io
+import logging
+import os
+import os.path as osp
+import posixpath
+import re
+import shutil
+import stat
+import tempfile
+
+from fsspec import AbstractFileSystem
+from fsspec.compression import compr
+from fsspec.core import get_compression
+from fsspec.utils import isfilelike, stringify_path
+
+logger = logging.getLogger("fsspec.local")
+
+
+class LocalFileSystem(AbstractFileSystem):
+    """Interface to files on local storage
+
+    Parameters
+    ----------
+    auto_mkdir: bool
+        Whether, when opening a file, the directory containing it should
+        be created (if it doesn't already exist). This is assumed by pyarrow
+        code.
+    """
+
+    root_marker = "/"
+    protocol = "file", "local"
+    local_file = True
+
+    def __init__(self, auto_mkdir=False, **kwargs):
+        super().__init__(**kwargs)
+        self.auto_mkdir = auto_mkdir
+
+    @property
+    def fsid(self):
+        return "local"
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if self.exists(path):
+            raise FileExistsError(path)
+        if create_parents:
+            self.makedirs(path, exist_ok=True)
+        else:
+            os.mkdir(path, **kwargs)
+
+    def makedirs(self, path, exist_ok=False):
+        path = self._strip_protocol(path)
+        os.makedirs(path, exist_ok=exist_ok)
+
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        os.rmdir(path)
+
+    def ls(self, path, detail=False, **kwargs):
+        path = self._strip_protocol(path)
+        if detail:
+            with os.scandir(path) as it:
+                return [self.info(f) for f in it]
+        else:
+            return [posixpath.join(path, f) for f in os.listdir(path)]
+
+    def info(self, path, **kwargs):
+        if isinstance(path, os.DirEntry):
+            # scandir DirEntry
+            out = path.stat(follow_symlinks=False)
+            link = path.is_symlink()
+            if path.is_dir(follow_symlinks=False):
+                t = "directory"
+            elif path.is_file(follow_symlinks=False):
+                t = "file"
+            else:
+                t = "other"
+            path = self._strip_protocol(path.path)
+        else:
+            # str or path-like
+            path = self._strip_protocol(path)
+            out = os.stat(path, follow_symlinks=False)
+            link = stat.S_ISLNK(out.st_mode)
+            if link:
+                out = os.stat(path, follow_symlinks=True)
+            if stat.S_ISDIR(out.st_mode):
+                t = "directory"
+            elif stat.S_ISREG(out.st_mode):
+                t = "file"
+            else:
+                t = "other"
+        result = {
+            "name": path,
+            "size": out.st_size,
+            "type": t,
+            "created": out.st_ctime,
+            "islink": link,
+        }
+        for field in ["mode", "uid", "gid", "mtime", "ino", "nlink"]:
+            result[field] = getattr(out, f"st_{field}")
+        if result["islink"]:
+            result["destination"] = os.readlink(path)
+            try:
+                out2 = os.stat(path, follow_symlinks=True)
+                result["size"] = out2.st_size
+            except OSError:
+                result["size"] = 0
+        return result
+
+    def lexists(self, path, **kwargs):
+        return osp.lexists(path)
+
+    def cp_file(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1).rstrip("/")
+        path2 = self._strip_protocol(path2).rstrip("/")
+        if self.auto_mkdir:
+            self.makedirs(self._parent(path2), exist_ok=True)
+        if self.isfile(path1):
+            shutil.copyfile(path1, path2)
+        elif self.isdir(path1):
+            self.mkdirs(path2, exist_ok=True)
+        else:
+            raise FileNotFoundError(path1)
+
+    def get_file(self, path1, path2, callback=None, **kwargs):
+        if isfilelike(path2):
+            with open(path1, "rb") as f:
+                shutil.copyfileobj(f, path2)
+        else:
+            return self.cp_file(path1, path2, **kwargs)
+
+    def put_file(self, path1, path2, callback=None, **kwargs):
+        return self.cp_file(path1, path2, **kwargs)
+
+    def mv_file(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1).rstrip("/")
+        path2 = self._strip_protocol(path2).rstrip("/")
+        shutil.move(path1, path2)
+
+    def link(self, src, dst, **kwargs):
+        src = self._strip_protocol(src)
+        dst = self._strip_protocol(dst)
+        os.link(src, dst, **kwargs)
+
+    def symlink(self, src, dst, **kwargs):
+        src = self._strip_protocol(src)
+        dst = self._strip_protocol(dst)
+        os.symlink(src, dst, **kwargs)
+
+    def islink(self, path) -> bool:
+        return os.path.islink(self._strip_protocol(path))
+
+    def rm_file(self, path):
+        os.remove(self._strip_protocol(path))
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        if not isinstance(path, list):
+            path = [path]
+
+        for p in path:
+            p = self._strip_protocol(p).rstrip("/")
+            if self.isdir(p):
+                if not recursive:
+                    raise ValueError("Cannot delete directory, set recursive=True")
+                if osp.abspath(p) == os.getcwd():
+                    raise ValueError("Cannot delete current working directory")
+                shutil.rmtree(p)
+            else:
+                os.remove(p)
+
+    def unstrip_protocol(self, name):
+        name = self._strip_protocol(name)  # normalise for local/win/...
+        return f"file://{name}"
+
+    def _open(self, path, mode="rb", block_size=None, **kwargs):
+        path = self._strip_protocol(path)
+        if self.auto_mkdir and "w" in mode:
+            self.makedirs(self._parent(path), exist_ok=True)
+        return LocalFileOpener(path, mode, fs=self, **kwargs)
+
+    def touch(self, path, truncate=True, **kwargs):
+        path = self._strip_protocol(path)
+        if self.auto_mkdir:
+            self.makedirs(self._parent(path), exist_ok=True)
+        if self.exists(path):
+            os.utime(path, None)
+        else:
+            open(path, "a").close()
+        if truncate:
+            os.truncate(path, 0)
+
+    def created(self, path):
+        info = self.info(path=path)
+        return datetime.datetime.fromtimestamp(
+            info["created"], tz=datetime.timezone.utc
+        )
+
+    def modified(self, path):
+        info = self.info(path=path)
+        return datetime.datetime.fromtimestamp(info["mtime"], tz=datetime.timezone.utc)
+
+    @classmethod
+    def _parent(cls, path):
+        path = cls._strip_protocol(path).rstrip("/")
+        if "/" in path:
+            return path.rsplit("/", 1)[0]
+        else:
+            return cls.root_marker
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        path = stringify_path(path)
+        if path.startswith("file://"):
+            path = path[7:]
+        elif path.startswith("file:"):
+            path = path[5:]
+        elif path.startswith("local://"):
+            path = path[8:]
+        elif path.startswith("local:"):
+            path = path[6:]
+        return make_path_posix(path).rstrip("/") or cls.root_marker
+
+    def _isfilestore(self):
+        # Inheriting from DaskFileSystem makes this False (S3, etc. were)
+        # the original motivation. But we are a posix-like file system.
+        # See https://github.com/dask/dask/issues/5526
+        return True
+
+    def chmod(self, path, mode):
+        path = stringify_path(path)
+        return os.chmod(path, mode)
+
+
+def make_path_posix(path, sep=os.sep):
+    """Make path generic"""
+    if isinstance(path, (list, set, tuple)):
+        return type(path)(make_path_posix(p) for p in path)
+    if "~" in path:
+        path = osp.expanduser(path)
+    if sep == "/":
+        # most common fast case for posix
+        if path.startswith("/"):
+            return path
+        if path.startswith("./"):
+            path = path[2:]
+        return f"{os.getcwd()}/{path}"
+    if (
+        (sep not in path and "/" not in path)
+        or (sep == "/" and not path.startswith("/"))
+        or (sep == "\\" and ":" not in path and not path.startswith("\\\\"))
+    ):
+        # relative path like "path" or "rel\\path" (win) or rel/path"
+        if os.sep == "\\":
+            # abspath made some more '\\' separators
+            return make_path_posix(osp.abspath(path))
+        else:
+            return f"{os.getcwd()}/{path}"
+    if path.startswith("file://"):
+        path = path[7:]
+    if re.match("/[A-Za-z]:", path):
+        # for windows file URI like "file:///C:/folder/file"
+        # or "file:///C:\\dir\\file"
+        path = path[1:].replace("\\", "/").replace("//", "/")
+    if path.startswith("\\\\"):
+        # special case for windows UNC/DFS-style paths, do nothing,
+        # just flip the slashes around (case below does not work!)
+        return path.replace("\\", "/")
+    if re.match("[A-Za-z]:", path):
+        # windows full path like "C:\\local\\path"
+        return path.lstrip("\\").replace("\\", "/").replace("//", "/")
+    if path.startswith("\\"):
+        # windows network path like "\\server\\path"
+        return "/" + path.lstrip("\\").replace("\\", "/").replace("//", "/")
+    return path
+
+
+def trailing_sep(path):
+    """Return True if the path ends with a path separator.
+
+    A forward slash is always considered a path separator, even on Operating
+    Systems that normally use a backslash.
+    """
+    # TODO: if all incoming paths were posix-compliant then separator would
+    # always be a forward slash, simplifying this function.
+    # See https://github.com/fsspec/filesystem_spec/pull/1250
+    return path.endswith(os.sep) or (os.altsep is not None and path.endswith(os.altsep))
+
+
+class LocalFileOpener(io.IOBase):
+    def __init__(
+        self, path, mode, autocommit=True, fs=None, compression=None, **kwargs
+    ):
+        logger.debug("open file: %s", path)
+        self.path = path
+        self.mode = mode
+        self.fs = fs
+        self.f = None
+        self.autocommit = autocommit
+        self.compression = get_compression(path, compression)
+        self.blocksize = io.DEFAULT_BUFFER_SIZE
+        self._open()
+
+    def _open(self):
+        if self.f is None or self.f.closed:
+            if self.autocommit or "w" not in self.mode:
+                self.f = open(self.path, mode=self.mode)
+                if self.compression:
+                    compress = compr[self.compression]
+                    self.f = compress(self.f, mode=self.mode)
+            else:
+                # TODO: check if path is writable?
+                i, name = tempfile.mkstemp()
+                os.close(i)  # we want normal open and normal buffered file
+                self.temp = name
+                self.f = open(name, mode=self.mode)
+            if "w" not in self.mode:
+                self.size = self.f.seek(0, 2)
+                self.f.seek(0)
+                self.f.size = self.size
+
+    def _fetch_range(self, start, end):
+        # probably only used by cached FS
+        if "r" not in self.mode:
+            raise ValueError
+        self._open()
+        self.f.seek(start)
+        return self.f.read(end - start)
+
+    def __setstate__(self, state):
+        self.f = None
+        loc = state.pop("loc", None)
+        self.__dict__.update(state)
+        if "r" in state["mode"]:
+            self.f = None
+            self._open()
+            self.f.seek(loc)
+
+    def __getstate__(self):
+        d = self.__dict__.copy()
+        d.pop("f")
+        if "r" in self.mode:
+            d["loc"] = self.f.tell()
+        else:
+            if not self.f.closed:
+                raise ValueError("Cannot serialise open write-mode local file")
+        return d
+
+    def commit(self):
+        if self.autocommit:
+            raise RuntimeError("Can only commit if not already set to autocommit")
+        shutil.move(self.temp, self.path)
+
+    def discard(self):
+        if self.autocommit:
+            raise RuntimeError("Cannot discard if set to autocommit")
+        os.remove(self.temp)
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return "r" not in self.mode
+
+    def read(self, *args, **kwargs):
+        return self.f.read(*args, **kwargs)
+
+    def write(self, *args, **kwargs):
+        return self.f.write(*args, **kwargs)
+
+    def tell(self, *args, **kwargs):
+        return self.f.tell(*args, **kwargs)
+
+    def seek(self, *args, **kwargs):
+        return self.f.seek(*args, **kwargs)
+
+    def seekable(self, *args, **kwargs):
+        return self.f.seekable(*args, **kwargs)
+
+    def readline(self, *args, **kwargs):
+        return self.f.readline(*args, **kwargs)
+
+    def readlines(self, *args, **kwargs):
+        return self.f.readlines(*args, **kwargs)
+
+    def close(self):
+        return self.f.close()
+
+    def truncate(self, size=None) -> int:
+        return self.f.truncate(size)
+
+    @property
+    def closed(self):
+        return self.f.closed
+
+    def fileno(self):
+        return self.raw.fileno()
+
+    def flush(self) -> None:
+        self.f.flush()
+
+    def __iter__(self):
+        return self.f.__iter__()
+
+    def __getattr__(self, item):
+        return getattr(self.f, item)
+
+    def __enter__(self):
+        self._incontext = True
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._incontext = False
+        self.f.__exit__(exc_type, exc_value, traceback)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/memory.py b/lib/python3.11/site-packages/fsspec/implementations/memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..4022ff13abf7c5fa152977c527c53f18adafc7d4
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/memory.py
@@ -0,0 +1,292 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from errno import ENOTEMPTY
+from io import BytesIO
+from typing import Any, ClassVar
+
+from fsspec import AbstractFileSystem
+
+logger = logging.Logger("fsspec.memoryfs")
+
+
+class MemoryFileSystem(AbstractFileSystem):
+    """A filesystem based on a dict of BytesIO objects
+
+    This is a global filesystem so instances of this class all point to the same
+    in memory filesystem.
+    """
+
+    store: ClassVar[dict[str, Any]] = {}  # global, do not overwrite!
+    pseudo_dirs = [""]  # global, do not overwrite!
+    protocol = "memory"
+    root_marker = "/"
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        if path.startswith("memory://"):
+            path = path[len("memory://") :]
+        if "::" in path or "://" in path:
+            return path.rstrip("/")
+        path = path.lstrip("/").rstrip("/")
+        return "/" + path if path else ""
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        if path in self.store:
+            # there is a key with this exact name
+            if not detail:
+                return [path]
+            return [
+                {
+                    "name": path,
+                    "size": self.store[path].size,
+                    "type": "file",
+                    "created": self.store[path].created.timestamp(),
+                }
+            ]
+        paths = set()
+        starter = path + "/"
+        out = []
+        for p2 in tuple(self.store):
+            if p2.startswith(starter):
+                if "/" not in p2[len(starter) :]:
+                    # exact child
+                    out.append(
+                        {
+                            "name": p2,
+                            "size": self.store[p2].size,
+                            "type": "file",
+                            "created": self.store[p2].created.timestamp(),
+                        }
+                    )
+                elif len(p2) > len(starter):
+                    # implied child directory
+                    ppath = starter + p2[len(starter) :].split("/", 1)[0]
+                    if ppath not in paths:
+                        out = out or []
+                        out.append(
+                            {
+                                "name": ppath,
+                                "size": 0,
+                                "type": "directory",
+                            }
+                        )
+                        paths.add(ppath)
+        for p2 in self.pseudo_dirs:
+            if p2.startswith(starter):
+                if "/" not in p2[len(starter) :]:
+                    # exact child pdir
+                    if p2 not in paths:
+                        out.append({"name": p2, "size": 0, "type": "directory"})
+                        paths.add(p2)
+                else:
+                    # directory implied by deeper pdir
+                    ppath = starter + p2[len(starter) :].split("/", 1)[0]
+                    if ppath not in paths:
+                        out.append({"name": ppath, "size": 0, "type": "directory"})
+                        paths.add(ppath)
+        if not out:
+            if path in self.pseudo_dirs:
+                # empty dir
+                return []
+            raise FileNotFoundError(path)
+        if detail:
+            return out
+        return sorted([f["name"] for f in out])
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if path in self.store or path in self.pseudo_dirs:
+            raise FileExistsError(path)
+        if self._parent(path).strip("/") and self.isfile(self._parent(path)):
+            raise NotADirectoryError(self._parent(path))
+        if create_parents and self._parent(path).strip("/"):
+            try:
+                self.mkdir(self._parent(path), create_parents, **kwargs)
+            except FileExistsError:
+                pass
+        if path and path not in self.pseudo_dirs:
+            self.pseudo_dirs.append(path)
+
+    def makedirs(self, path, exist_ok=False):
+        try:
+            self.mkdir(path, create_parents=True)
+        except FileExistsError:
+            if not exist_ok:
+                raise
+
+    def pipe_file(self, path, value, **kwargs):
+        """Set the bytes of given file
+
+        Avoids copies of the data if possible
+        """
+        self.open(path, "wb", data=value)
+
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        if path == "":
+            # silently avoid deleting FS root
+            return
+        if path in self.pseudo_dirs:
+            if not self.ls(path):
+                self.pseudo_dirs.remove(path)
+            else:
+                raise OSError(ENOTEMPTY, "Directory not empty", path)
+        else:
+            raise FileNotFoundError(path)
+
+    def info(self, path, **kwargs):
+        path = self._strip_protocol(path)
+        if path in self.pseudo_dirs or any(
+            p.startswith(path + "/") for p in list(self.store) + self.pseudo_dirs
+        ):
+            return {
+                "name": path,
+                "size": 0,
+                "type": "directory",
+            }
+        elif path in self.store:
+            filelike = self.store[path]
+            return {
+                "name": path,
+                "size": filelike.size,
+                "type": "file",
+                "created": getattr(filelike, "created", None),
+            }
+        else:
+            raise FileNotFoundError(path)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        if path in self.pseudo_dirs:
+            raise IsADirectoryError(path)
+        parent = path
+        while len(parent) > 1:
+            parent = self._parent(parent)
+            if self.isfile(parent):
+                raise FileExistsError(parent)
+        if mode in ["rb", "ab", "r+b"]:
+            if path in self.store:
+                f = self.store[path]
+                if mode == "ab":
+                    # position at the end of file
+                    f.seek(0, 2)
+                else:
+                    # position at the beginning of file
+                    f.seek(0)
+                return f
+            else:
+                raise FileNotFoundError(path)
+        elif mode == "wb":
+            m = MemoryFile(self, path, kwargs.get("data"))
+            if not self._intrans:
+                m.commit()
+            return m
+        else:
+            name = self.__class__.__name__
+            raise ValueError(f"unsupported file mode for {name}: {mode!r}")
+
+    def cp_file(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1)
+        path2 = self._strip_protocol(path2)
+        if self.isfile(path1):
+            self.store[path2] = MemoryFile(
+                self, path2, self.store[path1].getvalue()
+            )  # implicit copy
+        elif self.isdir(path1):
+            if path2 not in self.pseudo_dirs:
+                self.pseudo_dirs.append(path2)
+        else:
+            raise FileNotFoundError(path1)
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        path = self._strip_protocol(path)
+        try:
+            return bytes(self.store[path].getbuffer()[start:end])
+        except KeyError:
+            raise FileNotFoundError(path)
+
+    def _rm(self, path):
+        path = self._strip_protocol(path)
+        try:
+            del self.store[path]
+        except KeyError as e:
+            raise FileNotFoundError(path) from e
+
+    def modified(self, path):
+        path = self._strip_protocol(path)
+        try:
+            return self.store[path].modified
+        except KeyError:
+            raise FileNotFoundError(path)
+
+    def created(self, path):
+        path = self._strip_protocol(path)
+        try:
+            return self.store[path].created
+        except KeyError:
+            raise FileNotFoundError(path)
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        if isinstance(path, str):
+            path = self._strip_protocol(path)
+        else:
+            path = [self._strip_protocol(p) for p in path]
+        paths = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        for p in reversed(paths):
+            # If the expanded path doesn't exist, it is only because the expanded
+            # path was a directory that does not exist in self.pseudo_dirs. This
+            # is possible if you directly create files without making the
+            # directories first.
+            if not self.exists(p):
+                continue
+            if self.isfile(p):
+                self.rm_file(p)
+            else:
+                self.rmdir(p)
+
+
+class MemoryFile(BytesIO):
+    """A BytesIO which can't close and works as a context manager
+
+    Can initialise with data. Each path should only be active once at any moment.
+
+    No need to provide fs, path if auto-committing (default)
+    """
+
+    def __init__(self, fs=None, path=None, data=None):
+        logger.debug("open file %s", path)
+        self.fs = fs
+        self.path = path
+        self.created = datetime.now(tz=timezone.utc)
+        self.modified = datetime.now(tz=timezone.utc)
+        if data:
+            super().__init__(data)
+            self.seek(0)
+
+    @property
+    def size(self):
+        return self.getbuffer().nbytes
+
+    def __enter__(self):
+        return self
+
+    def close(self):
+        pass
+
+    def discard(self):
+        pass
+
+    def commit(self):
+        self.fs.store[self.path] = self
+        self.modified = datetime.now(tz=timezone.utc)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/reference.py b/lib/python3.11/site-packages/fsspec/implementations/reference.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b6752ee12536bfa17075badf21f5c92ac038c75
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/reference.py
@@ -0,0 +1,1122 @@
+import base64
+import collections
+import io
+import itertools
+import logging
+import math
+import os
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+import fsspec.core
+
+try:
+    import ujson as json
+except ImportError:
+    if not TYPE_CHECKING:
+        import json
+
+from ..asyn import AsyncFileSystem
+from ..callbacks import _DEFAULT_CALLBACK
+from ..core import filesystem, open, split_protocol
+from ..utils import isfilelike, merge_offset_ranges, other_paths
+
+logger = logging.getLogger("fsspec.reference")
+
+
+class ReferenceNotReachable(RuntimeError):
+    def __init__(self, reference, target, *args):
+        super().__init__(*args)
+        self.reference = reference
+        self.target = target
+
+    def __str__(self):
+        return f'Reference "{self.reference}" failed to fetch target {self.target}'
+
+
+def _first(d):
+    return list(d.values())[0]
+
+
+def _prot_in_references(path, references):
+    ref = references.get(path)
+    if isinstance(ref, (list, tuple)):
+        return split_protocol(ref[0])[0] if ref[0] else ref[0]
+
+
+def _protocol_groups(paths, references):
+    if isinstance(paths, str):
+        return {_prot_in_references(paths, references): [paths]}
+    out = {}
+    for path in paths:
+        protocol = _prot_in_references(path, references)
+        out.setdefault(protocol, []).append(path)
+    return out
+
+
+class RefsValuesView(collections.abc.ValuesView):
+    def __iter__(self):
+        for val in self._mapping.zmetadata.values():
+            yield json.dumps(val).encode()
+        yield from self._mapping._items.values()
+        for field in self._mapping.listdir():
+            chunk_sizes = self._mapping._get_chunk_sizes(field)
+            if len(chunk_sizes) == 0:
+                yield self._mapping[field + "/0"]
+                continue
+            yield from self._mapping._generate_all_records(field)
+
+
+class RefsItemsView(collections.abc.ItemsView):
+    def __iter__(self):
+        return zip(self._mapping.keys(), self._mapping.values())
+
+
+def ravel_multi_index(idx, sizes):
+    val = 0
+    mult = 1
+    for i, s in zip(idx[::-1], sizes[::-1]):
+        val += i * mult
+        mult *= s
+    return val
+
+
+class LazyReferenceMapper(collections.abc.MutableMapping):
+    """This interface can be used to read/write references from Parquet stores.
+    It is not intended for other types of references.
+    It can be used with Kerchunk's MultiZarrToZarr method to combine
+    references into a parquet store.
+    Examples of this use-case can be found here:
+    https://fsspec.github.io/kerchunk/advanced.html?highlight=parquet#parquet-storage"""
+
+    # import is class level to prevent numpy dep requirement for fsspec
+    @property
+    def np(self):
+        import numpy as np
+
+        return np
+
+    @property
+    def pd(self):
+        import pandas as pd
+
+        return pd
+
+    def __init__(
+        self, root, fs=None, out_root=None, cache_size=128, categorical_threshold=10
+    ):
+        """
+        Parameters
+        ----------
+        root : str
+            Root of parquet store
+        fs : fsspec.AbstractFileSystem
+            fsspec filesystem object, default is local filesystem.
+        cache_size : int, default=128
+            Maximum size of LRU cache, where cache_size*record_size denotes
+            the total number of references that can be loaded in memory at once.
+        categorical_threshold : int
+            Encode urls as pandas.Categorical to reduce memory footprint if the ratio
+            of the number of unique urls to total number of refs for each variable
+            is greater than or equal to this number. (default 10)
+
+
+        """
+        self.root = root
+        self.chunk_sizes = {}
+        self._items = {}
+        self.dirs = None
+        self.fs = fsspec.filesystem("file") if fs is None else fs
+        self._items[".zmetadata"] = self.fs.cat_file(
+            "/".join([self.root, ".zmetadata"])
+        )
+        met = json.loads(self._items[".zmetadata"])
+        self.record_size = met["record_size"]
+        self.zmetadata = met["metadata"]
+        self.url = self.root + "/{field}/refs.{record}.parq"
+        self.out_root = out_root or self.root
+        self.cat_thresh = categorical_threshold
+
+        # Define function to open and decompress refs
+        @lru_cache(maxsize=cache_size)
+        def open_refs(field, record):
+            """cached parquet file loader"""
+            path = self.url.format(field=field, record=record)
+            data = io.BytesIO(self.fs.cat_file(path))
+            df = self.pd.read_parquet(data, engine="fastparquet")
+            refs = {c: df[c].values for c in df.columns}
+            return refs
+
+        self.open_refs = open_refs
+
+    @staticmethod
+    def create(root, storage_options=None, fs=None, record_size=10000, **kwargs):
+        """Make empty parquet reference set
+
+        Parameters
+        ----------
+        root: str
+            Directory to contain the output; will be created
+        storage_options: dict | None
+            For making the filesystem to use for writing is fs is None
+        fs: FileSystem | None
+            Filesystem for writing
+        record_size: int
+            Number of references per parquet file
+        kwargs: passed to __init__
+
+        Returns
+        -------
+        LazyReferenceMapper instance
+        """
+        met = {"metadata": {}, "record_size": record_size}
+        if fs is None:
+            fs, root = fsspec.core.url_to_fs(root, **(storage_options or {}))
+        fs.makedirs(root, exist_ok=True)
+        fs.pipe("/".join([root, ".zmetadata"]), json.dumps(met).encode())
+        return LazyReferenceMapper(root, fs, **kwargs)
+
+    def listdir(self, basename=True):
+        """List top-level directories"""
+        if self.dirs is None:
+            dirs = [p.split("/", 1)[0] for p in self.zmetadata]
+            self.dirs = {p for p in dirs if p and not p.startswith(".")}
+        listing = self.dirs
+        if basename:
+            listing = [os.path.basename(path) for path in listing]
+        return listing
+
+    def ls(self, path="", detail=True):
+        """Shortcut file listings"""
+        if not path:
+            dirnames = self.listdir()
+            others = set(
+                [".zmetadata"]
+                + [name for name in self.zmetadata if "/" not in name]
+                + [name for name in self._items if "/" not in name]
+            )
+            if detail is False:
+                others.update(dirnames)
+                return sorted(others)
+            dirinfo = [
+                {"name": name, "type": "directory", "size": 0} for name in dirnames
+            ]
+            fileinfo = [
+                {
+                    "name": name,
+                    "type": "file",
+                    "size": len(
+                        json.dumps(self.zmetadata[name])
+                        if name in self.zmetadata
+                        else self._items[name]
+                    ),
+                }
+                for name in others
+            ]
+            return sorted(dirinfo + fileinfo, key=lambda s: s["name"])
+        parts = path.split("/", 1)
+        if len(parts) > 1:
+            raise FileNotFoundError("Cannot list within directories right now")
+        field = parts[0]
+        others = set(
+            [name for name in self.zmetadata if name.startswith(f"{path}/")]
+            + [name for name in self._items if name.startswith(f"{path}/")]
+        )
+        fileinfo = [
+            {
+                "name": name,
+                "type": "file",
+                "size": len(
+                    json.dumps(self.zmetadata[name])
+                    if name in self.zmetadata
+                    else self._items[name]
+                ),
+            }
+            for name in others
+        ]
+        keys = self._keys_in_field(field)
+
+        if detail is False:
+            return list(others) + list(keys)
+        recs = self._generate_all_records(field)
+        recinfo = [
+            {"name": name, "type": "file", "size": rec[-1]}
+            for name, rec in zip(keys, recs)
+            if rec[0]  # filters out path==None, deleted/missing
+        ]
+        return fileinfo + recinfo
+
+    def _load_one_key(self, key):
+        """Get the reference for one key
+
+        Returns bytes, one-element list or three-element list.
+        """
+        if key in self._items:
+            return self._items[key]
+        elif key in self.zmetadata:
+            return json.dumps(self.zmetadata[key]).encode()
+        elif "/" not in key or self._is_meta(key):
+            raise KeyError(key)
+        field, sub_key = key.split("/")
+        record, _, _ = self._key_to_record(key)
+        maybe = self._items.get((field, key), {}).get(sub_key, False)
+        if maybe is None:
+            # explicitly deleted
+            raise KeyError
+        elif maybe:
+            return maybe
+
+        # Chunk keys can be loaded from row group and cached in LRU cache
+        try:
+            record, ri, chunk_size = self._key_to_record(key)
+            if chunk_size == 0:
+                return b""
+            refs = self.open_refs(field, record)
+        except (ValueError, TypeError, FileNotFoundError):
+            raise KeyError(key)
+        columns = ["path", "offset", "size", "raw"]
+        selection = [refs[c][ri] if c in refs else None for c in columns]
+        raw = selection[-1]
+        if raw is not None:
+            return raw
+        if selection[0] is None:
+            raise KeyError("This reference has been deleted")
+        if selection[1:3] == [0, 0]:
+            # URL only
+            return selection[:1]
+        # URL, offset, size
+        return selection[:3]
+
+    @lru_cache(4096)
+    def _key_to_record(self, key):
+        """Details needed to construct a reference for one key"""
+        field, chunk = key.split("/")
+        chunk_sizes = self._get_chunk_sizes(field)
+        if len(chunk_sizes) == 0:
+            return 0, 0, 0
+        chunk_idx = [int(c) for c in chunk.split(".")]
+        chunk_number = ravel_multi_index(chunk_idx, chunk_sizes)
+        record = chunk_number // self.record_size
+        ri = chunk_number % self.record_size
+        return record, ri, len(chunk_sizes)
+
+    def _get_chunk_sizes(self, field):
+        """The number of chunks along each axis for a given field"""
+        if field not in self.chunk_sizes:
+            zarray = self.zmetadata[f"{field}/.zarray"]
+            size_ratio = [
+                math.ceil(s / c) for s, c in zip(zarray["shape"], zarray["chunks"])
+            ]
+            self.chunk_sizes[field] = size_ratio
+        return self.chunk_sizes[field]
+
+    def _generate_record(self, field, record):
+        """The references for a given parquet file of a given field"""
+        refs = self.open_refs(field, record)
+        it = iter(zip(*refs.values()))
+        if len(refs) == 3:
+            # All urls
+            return (list(t) for t in it)
+        elif len(refs) == 1:
+            # All raws
+            return refs["raw"]
+        else:
+            # Mix of urls and raws
+            return (list(t[:3]) if not t[3] else t[3] for t in it)
+
+    def _generate_all_records(self, field):
+        """Load all the references within a field by iterating over the parquet files"""
+        nrec = 1
+        for ch in self._get_chunk_sizes(field):
+            nrec *= ch
+        nrec = math.ceil(nrec / self.record_size)
+        for record in range(nrec):
+            yield from self._generate_record(field, record)
+
+    def values(self):
+        return RefsValuesView(self)
+
+    def items(self):
+        return RefsItemsView(self)
+
+    def __hash__(self):
+        return id(self)
+
+    @lru_cache(20)
+    def __getitem__(self, key):
+        return self._load_one_key(key)
+
+    def __setitem__(self, key, value):
+        if "/" in key and not self._is_meta(key):
+            field, chunk = key.split("/")
+            record, i, _ = self._key_to_record(key)
+            subdict = self._items.setdefault((field, record), {})
+            subdict[i] = value
+            if len(subdict) == self.record_size:
+                self.write(field, record)
+        else:
+            # metadata or top-level
+            self._items[key] = value
+            self.zmetadata[key] = json.loads(
+                value.decode() if isinstance(value, bytes) else value
+            )
+
+    @staticmethod
+    def _is_meta(key):
+        return key.startswith(".z") or "/.z" in key
+
+    def __delitem__(self, key):
+        if key in self._items:
+            del self._items[key]
+        elif key in self.zmetadata:
+            del self.zmetadata[key]
+        else:
+            if "/" in key and not self._is_meta(key):
+                field, chunk = key.split("/")
+                record, _, _ = self._key_to_record(key)
+                subdict = self._items.setdefault((field, record), {})
+                subdict[chunk] = None
+                if len(subdict) == self.record_size:
+                    self.write(field, record)
+            else:
+                # metadata or top-level
+                self._items[key] = None
+
+    def write(self, field, record, base_url=None, storage_options=None):
+        # extra requirements if writing
+        import kerchunk.df
+        import numpy as np
+        import pandas as pd
+
+        # TODO: if the dict is incomplete, also load records and merge in
+        partition = self._items[(field, record)]
+        fn = f"{base_url or self.out_root}/{field}/refs.{record}.parq"
+
+        ####
+        paths = np.full(self.record_size, np.nan, dtype="O")
+        offsets = np.zeros(self.record_size, dtype="int64")
+        sizes = np.zeros(self.record_size, dtype="int64")
+        raws = np.full(self.record_size, np.nan, dtype="O")
+        nraw = 0
+        npath = 0
+        for j, data in partition.items():
+            if isinstance(data, list):
+                npath += 1
+                paths[j] = data[0]
+                if len(data) > 1:
+                    offsets[j] = data[1]
+                    sizes[j] = data[2]
+            else:
+                nraw += 1
+                raws[j] = kerchunk.df._proc_raw(data)
+        # TODO: only save needed columns
+        df = pd.DataFrame(
+            {
+                "path": paths,
+                "offset": offsets,
+                "size": sizes,
+                "raw": raws,
+            },
+            copy=False,
+        )
+        if df.path.count() / (df.path.nunique() or 1) > self.cat_thresh:
+            df["path"] = df["path"].astype("category")
+        object_encoding = {"raw": "bytes", "path": "utf8"}
+        has_nulls = ["path", "raw"]
+
+        self.fs.mkdirs(f"{base_url or self.out_root}/{field}", exist_ok=True)
+        df.to_parquet(
+            fn,
+            engine="fastparquet",
+            storage_options=storage_options
+            or getattr(self.fs, "storage_options", None),
+            compression="zstd",
+            index=False,
+            stats=False,
+            object_encoding=object_encoding,
+            has_nulls=has_nulls,
+            # **kwargs,
+        )
+        partition.clear()
+        self._items.pop((field, record))
+
+    def flush(self, base_url=None, storage_options=None):
+        """Output any modified or deleted keys
+
+        Parameters
+        ----------
+        base_url: str
+            Location of the output
+        """
+        # write what we have so far and clear sub chunks
+        for thing in list(self._items):
+            if isinstance(thing, tuple):
+                field, record = thing
+                self.write(
+                    field,
+                    record,
+                    base_url=base_url,
+                    storage_options=storage_options,
+                )
+
+        # gather .zmetadata from self._items and write that too
+        for k in list(self._items):
+            if k != ".zmetadata" and ".z" in k:
+                self.zmetadata[k] = json.loads(self._items.pop(k))
+        met = {"metadata": self.zmetadata, "record_size": self.record_size}
+        self._items[".zmetadata"] = json.dumps(met).encode()
+        self.fs.pipe(
+            "/".join([base_url or self.out_root, ".zmetadata"]),
+            self._items[".zmetadata"],
+        )
+
+        # TODO: only clear those that we wrote to?
+        self.open_refs.cache_clear()
+
+    def __len__(self):
+        # Caveat: This counts expected references, not actual
+        count = 0
+        for field in self.listdir():
+            if field.startswith("."):
+                count += 1
+            else:
+                chunk_sizes = self._get_chunk_sizes(field)
+                nchunks = self.np.product(chunk_sizes)
+                count += nchunks
+        count += len(self.zmetadata)  # all metadata keys
+        count += len(self._items)  # the metadata file itself
+        return count
+
+    def __iter__(self):
+        # Caveat: Note that this generates all expected keys, but does not
+        # account for reference keys that are missing.
+        metas = set(self.zmetadata)
+        metas.update(self._items)
+        for bit in metas:
+            if isinstance(bit, str):
+                yield bit
+        for field in self.listdir():
+            yield from self._keys_in_field(field)
+
+    def __contains__(self, item):
+        try:
+            self._load_one_key(item)
+            return True
+        except KeyError:
+            return False
+
+    def _keys_in_field(self, field):
+        """List key names in given field
+
+        Produces strings like "field/x.y" appropriate from the chunking of the array
+        """
+        chunk_sizes = self._get_chunk_sizes(field)
+        if len(chunk_sizes) == 0:
+            yield field + "/0"
+            return
+        inds = itertools.product(*(range(i) for i in chunk_sizes))
+        for ind in inds:
+            yield field + "/" + ".".join([str(c) for c in ind])
+
+
+class ReferenceFileSystem(AsyncFileSystem):
+    """View byte ranges of some other file as a file system
+    Initial version: single file system target, which must support
+    async, and must allow start and end args in _cat_file. Later versions
+    may allow multiple arbitrary URLs for the targets.
+    This FileSystem is read-only. It is designed to be used with async
+    targets (for now). This FileSystem only allows whole-file access, no
+    ``open``. We do not get original file details from the target FS.
+    Configuration is by passing a dict of references at init, or a URL to
+    a JSON file containing the same; this dict
+    can also contain concrete data for some set of paths.
+    Reference dict format:
+    {path0: bytes_data, path1: (target_url, offset, size)}
+    https://github.com/fsspec/kerchunk/blob/main/README.md
+    """
+
+    protocol = "reference"
+
+    def __init__(
+        self,
+        fo,
+        target=None,
+        ref_storage_args=None,
+        target_protocol=None,
+        target_options=None,
+        remote_protocol=None,
+        remote_options=None,
+        fs=None,
+        template_overrides=None,
+        simple_templates=True,
+        max_gap=64_000,
+        max_block=256_000_000,
+        cache_size=128,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        fo : dict or str
+            The set of references to use for this instance, with a structure as above.
+            If str referencing a JSON file, will use fsspec.open, in conjunction
+            with target_options and target_protocol to open and parse JSON at this
+            location. If a directory, then assume references are a set of parquet
+            files to be loaded lazily.
+        target : str
+            For any references having target_url as None, this is the default file
+            target to use
+        ref_storage_args : dict
+            If references is a str, use these kwargs for loading the JSON file.
+            Deprecated: use target_options instead.
+        target_protocol : str
+            Used for loading the reference file, if it is a path. If None, protocol
+            will be derived from the given path
+        target_options : dict
+            Extra FS options for loading the reference file ``fo``, if given as a path
+        remote_protocol : str
+            The protocol of the filesystem on which the references will be evaluated
+            (unless fs is provided). If not given, will be derived from the first
+            URL that has a protocol in the templates or in the references, in that
+            order.
+        remote_options : dict
+            kwargs to go with remote_protocol
+        fs : AbstractFileSystem | dict(str, (AbstractFileSystem | dict))
+            Directly provide a file system(s):
+                - a single filesystem instance
+                - a dict of protocol:filesystem, where each value is either a filesystem
+                  instance, or a dict of kwargs that can be used to create in
+                  instance for the given protocol
+
+            If this is given, remote_options and remote_protocol are ignored.
+        template_overrides : dict
+            Swap out any templates in the references file with these - useful for
+            testing.
+        simple_templates: bool
+            Whether templates can be processed with simple replace (True) or if
+            jinja  is needed (False, much slower). All reference sets produced by
+            ``kerchunk`` are simple in this sense, but the spec allows for complex.
+        max_gap, max_block: int
+            For merging multiple concurrent requests to the same remote file.
+            Neighboring byte ranges will only be merged when their
+            inter-range gap is <= ``max_gap``. Default is 64KB. Set to 0
+            to only merge when it requires no extra bytes. Pass a negative
+            number to disable merging, appropriate for local target files.
+            Neighboring byte ranges will only be merged when the size of
+            the aggregated range is <= ``max_block``. Default is 256MB.
+        cache_size : int
+            Maximum size of LRU cache, where cache_size*record_size denotes
+            the total number of references that can be loaded in memory at once.
+            Only used for lazily loaded references.
+        kwargs : passed to parent class
+        """
+        super().__init__(**kwargs)
+        self.target = target
+        self.template_overrides = template_overrides
+        self.simple_templates = simple_templates
+        self.templates = {}
+        self.fss = {}
+        self._dircache = {}
+        self.max_gap = max_gap
+        self.max_block = max_block
+        if isinstance(fo, str):
+            dic = dict(
+                **(ref_storage_args or target_options or {}), protocol=target_protocol
+            )
+            ref_fs, fo2 = fsspec.core.url_to_fs(fo, **dic)
+            if ref_fs.isfile(fo2):
+                # text JSON
+                with fsspec.open(fo, "rb", **dic) as f:
+                    logger.info("Read reference from URL %s", fo)
+                    text = json.load(f)
+                self._process_references(text, template_overrides)
+            else:
+                # Lazy parquet refs
+                logger.info("Open lazy reference dict from URL %s", fo)
+                self.references = LazyReferenceMapper(
+                    fo2,
+                    fs=ref_fs,
+                    cache_size=cache_size,
+                )
+        else:
+            # dictionaries
+            self._process_references(fo, template_overrides)
+        if isinstance(fs, dict):
+            self.fss = {
+                k: (
+                    fsspec.filesystem(k.split(":", 1)[0], **opts)
+                    if isinstance(opts, dict)
+                    else opts
+                )
+                for k, opts in fs.items()
+            }
+            if None not in self.fss:
+                self.fss[None] = filesystem("file")
+            return
+        if fs is not None:
+            # single remote FS
+            remote_protocol = (
+                fs.protocol[0] if isinstance(fs.protocol, tuple) else fs.protocol
+            )
+            self.fss[remote_protocol] = fs
+
+        if remote_protocol is None:
+            # get single protocol from any templates
+            for ref in self.templates.values():
+                if callable(ref):
+                    ref = ref()
+                protocol, _ = fsspec.core.split_protocol(ref)
+                if protocol and protocol not in self.fss:
+                    fs = filesystem(protocol, **(remote_options or {}))
+                    self.fss[protocol] = fs
+        if remote_protocol is None:
+            # get single protocol from references
+            # TODO: warning here, since this can be very expensive?
+            for ref in self.references.values():
+                if callable(ref):
+                    ref = ref()
+                if isinstance(ref, list) and ref[0]:
+                    protocol, _ = fsspec.core.split_protocol(ref[0])
+                    if protocol not in self.fss:
+                        fs = filesystem(protocol, **(remote_options or {}))
+                        self.fss[protocol] = fs
+                        # only use first remote URL
+                        break
+
+        if remote_protocol and remote_protocol not in self.fss:
+            fs = filesystem(remote_protocol, **(remote_options or {}))
+            self.fss[remote_protocol] = fs
+
+        self.fss[None] = fs or filesystem("file")  # default one
+
+    def _cat_common(self, path, start=None, end=None):
+        path = self._strip_protocol(path)
+        logger.debug(f"cat: {path}")
+        try:
+            part = self.references[path]
+        except KeyError:
+            raise FileNotFoundError(path)
+        if isinstance(part, str):
+            part = part.encode()
+        if isinstance(part, bytes):
+            logger.debug(f"Reference: {path}, type bytes")
+            if part.startswith(b"base64:"):
+                part = base64.b64decode(part[7:])
+            return part, None, None
+
+        if len(part) == 1:
+            logger.debug(f"Reference: {path}, whole file => {part}")
+            url = part[0]
+            start1, end1 = start, end
+        else:
+            url, start0, size = part
+            logger.debug(f"Reference: {path} => {url}, offset {start0}, size {size}")
+            end0 = start0 + size
+
+            if start is not None:
+                if start >= 0:
+                    start1 = start0 + start
+                else:
+                    start1 = end0 + start
+            else:
+                start1 = start0
+            if end is not None:
+                if end >= 0:
+                    end1 = start0 + end
+                else:
+                    end1 = end0 + end
+            else:
+                end1 = end0
+        if url is None:
+            url = self.target
+        return url, start1, end1
+
+    async def _cat_file(self, path, start=None, end=None, **kwargs):
+        part_or_url, start0, end0 = self._cat_common(path, start=start, end=end)
+        if isinstance(part_or_url, bytes):
+            return part_or_url[start:end]
+        protocol, _ = split_protocol(part_or_url)
+        try:
+            await self.fss[protocol]._cat_file(part_or_url, start=start, end=end)
+        except Exception as e:
+            raise ReferenceNotReachable(path, part_or_url) from e
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        part_or_url, start0, end0 = self._cat_common(path, start=start, end=end)
+        if isinstance(part_or_url, bytes):
+            return part_or_url[start:end]
+        protocol, _ = split_protocol(part_or_url)
+        try:
+            return self.fss[protocol].cat_file(part_or_url, start=start0, end=end0)
+        except Exception as e:
+            raise ReferenceNotReachable(path, part_or_url) from e
+
+    def pipe_file(self, path, value, **_):
+        """Temporarily add binary data or reference as a file"""
+        self.references[path] = value
+
+    async def _get_file(self, rpath, lpath, **kwargs):
+        if self.isdir(rpath):
+            return os.makedirs(lpath, exist_ok=True)
+        data = await self._cat_file(rpath)
+        with open(lpath, "wb") as f:
+            f.write(data)
+
+    def get_file(self, rpath, lpath, callback=_DEFAULT_CALLBACK, **kwargs):
+        if self.isdir(rpath):
+            return os.makedirs(lpath, exist_ok=True)
+        data = self.cat_file(rpath, **kwargs)
+        callback.set_size(len(data))
+        if isfilelike(lpath):
+            lpath.write(data)
+        else:
+            with open(lpath, "wb") as f:
+                f.write(data)
+        callback.absolute_update(len(data))
+
+    def get(self, rpath, lpath, recursive=False, **kwargs):
+        if recursive:
+            # trigger directory build
+            self.ls("")
+        rpath = self.expand_path(rpath, recursive=recursive)
+        fs = fsspec.filesystem("file", auto_mkdir=True)
+        targets = other_paths(rpath, lpath)
+        if recursive:
+            data = self.cat([r for r in rpath if not self.isdir(r)])
+        else:
+            data = self.cat(rpath)
+        for remote, local in zip(rpath, targets):
+            if remote in data:
+                fs.pipe_file(local, data[remote])
+
+    def cat(self, path, recursive=False, on_error="raise", **kwargs):
+        if isinstance(path, str) and recursive:
+            raise NotImplementedError
+        if isinstance(path, list) and (recursive or any("*" in p for p in path)):
+            raise NotImplementedError
+        # TODO: if references is lazy, pre-fetch all paths in batch before access
+        proto_dict = _protocol_groups(path, self.references)
+        out = {}
+        for proto, paths in proto_dict.items():
+            fs = self.fss[proto]
+            urls, starts, ends, valid_paths = [], [], [], []
+            for p in paths:
+                # find references or label not-found. Early exit if any not
+                # found and on_error is "raise"
+                try:
+                    u, s, e = self._cat_common(p)
+                except FileNotFoundError as err:
+                    if on_error == "raise":
+                        raise
+                    if on_error != "omit":
+                        out[p] = err
+                else:
+                    urls.append(u)
+                    starts.append(s)
+                    ends.append(e)
+                    valid_paths.append(p)
+
+            # process references into form for merging
+            urls2 = []
+            starts2 = []
+            ends2 = []
+            paths2 = []
+            whole_files = set()
+            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+                if isinstance(u, bytes):
+                    # data
+                    out[p] = u
+                elif s is None:
+                    # whole file - limits are None, None, but no further
+                    # entries take for this file
+                    whole_files.add(u)
+                    urls2.append(u)
+                    starts2.append(s)
+                    ends2.append(e)
+                    paths2.append(p)
+            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+                # second run to account for files that are to be loaded whole
+                if s is not None and u not in whole_files:
+                    urls2.append(u)
+                    starts2.append(s)
+                    ends2.append(e)
+                    paths2.append(p)
+
+            # merge and fetch consolidated ranges
+            new_paths, new_starts, new_ends = merge_offset_ranges(
+                list(urls2),
+                list(starts2),
+                list(ends2),
+                sort=True,
+                max_gap=self.max_gap,
+                max_block=self.max_block,
+            )
+            bytes_out = fs.cat_ranges(new_paths, new_starts, new_ends)
+
+            # unbundle from merged bytes - simple approach
+            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+                if p in out:
+                    continue  # was bytes, already handled
+                for np, ns, ne, b in zip(new_paths, new_starts, new_ends, bytes_out):
+                    if np == u and (ns is None or ne is None):
+                        if isinstance(b, Exception):
+                            out[p] = b
+                        else:
+                            out[p] = b[s:e]
+                    elif np == u and s >= ns and e <= ne:
+                        if isinstance(b, Exception):
+                            out[p] = b
+                        else:
+                            out[p] = b[s - ns : (e - ne) or None]
+
+        for k, v in out.copy().items():
+            # these were valid references, but fetch failed, so transform exc
+            if isinstance(v, Exception) and k in self.references:
+                ex = out[k]
+                new_ex = ReferenceNotReachable(k, self.references[k])
+                new_ex.__cause__ = ex
+                if on_error == "raise":
+                    raise new_ex
+                elif on_error != "omit":
+                    out[k] = new_ex
+
+        if len(out) == 1 and isinstance(path, str) and "*" not in path:
+            return _first(out)
+        return out
+
+    def _process_references(self, references, template_overrides=None):
+        vers = references.get("version", None)
+        if vers is None:
+            self._process_references0(references)
+        elif vers == 1:
+            self._process_references1(references, template_overrides=template_overrides)
+        else:
+            raise ValueError(f"Unknown reference spec version: {vers}")
+        # TODO: we make dircache by iterating over all entries, but for Spec >= 1,
+        #  can replace with programmatic. Is it even needed for mapper interface?
+
+    def _process_references0(self, references):
+        """Make reference dict for Spec Version 0"""
+        self.references = references
+
+    def _process_references1(self, references, template_overrides=None):
+        if not self.simple_templates or self.templates:
+            import jinja2
+        self.references = {}
+        self._process_templates(references.get("templates", {}))
+
+        @lru_cache(1000)
+        def _render_jinja(u):
+            return jinja2.Template(u).render(**self.templates)
+
+        for k, v in references.get("refs", {}).items():
+            if isinstance(v, str):
+                if v.startswith("base64:"):
+                    self.references[k] = base64.b64decode(v[7:])
+                self.references[k] = v
+            elif self.templates:
+                u = v[0]
+                if "{{" in u:
+                    if self.simple_templates:
+                        u = (
+                            u.replace("{{", "{")
+                            .replace("}}", "}")
+                            .format(**self.templates)
+                        )
+                    else:
+                        u = _render_jinja(u)
+                self.references[k] = [u] if len(v) == 1 else [u, v[1], v[2]]
+            else:
+                self.references[k] = v
+        self.references.update(self._process_gen(references.get("gen", [])))
+
+    def _process_templates(self, tmp):
+        self.templates = {}
+        if self.template_overrides is not None:
+            tmp.update(self.template_overrides)
+        for k, v in tmp.items():
+            if "{{" in v:
+                import jinja2
+
+                self.templates[k] = lambda temp=v, **kwargs: jinja2.Template(
+                    temp
+                ).render(**kwargs)
+            else:
+                self.templates[k] = v
+
+    def _process_gen(self, gens):
+        out = {}
+        for gen in gens:
+            dimension = {
+                k: v
+                if isinstance(v, list)
+                else range(v.get("start", 0), v["stop"], v.get("step", 1))
+                for k, v in gen["dimensions"].items()
+            }
+            products = (
+                dict(zip(dimension.keys(), values))
+                for values in itertools.product(*dimension.values())
+            )
+            for pr in products:
+                import jinja2
+
+                key = jinja2.Template(gen["key"]).render(**pr, **self.templates)
+                url = jinja2.Template(gen["url"]).render(**pr, **self.templates)
+                if ("offset" in gen) and ("length" in gen):
+                    offset = int(
+                        jinja2.Template(gen["offset"]).render(**pr, **self.templates)
+                    )
+                    length = int(
+                        jinja2.Template(gen["length"]).render(**pr, **self.templates)
+                    )
+                    out[key] = [url, offset, length]
+                elif ("offset" in gen) ^ ("length" in gen):
+                    raise ValueError(
+                        "Both 'offset' and 'length' are required for a "
+                        "reference generator entry if either is provided."
+                    )
+                else:
+                    out[key] = [url]
+        return out
+
+    def _dircache_from_items(self):
+        self.dircache = {"": []}
+        it = self.references.items()
+        for path, part in it:
+            if isinstance(part, (bytes, str)):
+                size = len(part)
+            elif len(part) == 1:
+                size = None
+            else:
+                _, _, size = part
+            par = path.rsplit("/", 1)[0] if "/" in path else ""
+            par0 = par
+            subdirs = [par0]
+            while par0 and par0 not in self.dircache:
+                # collect parent directories
+                par0 = self._parent(par0)
+                subdirs.append(par0)
+
+            subdirs = subdirs[::-1]
+            for parent, child in zip(subdirs, subdirs[1:]):
+                # register newly discovered directories
+                assert child not in self.dircache
+                assert parent in self.dircache
+                self.dircache[parent].append(
+                    {"name": child, "type": "directory", "size": 0}
+                )
+                self.dircache[child] = []
+
+            self.dircache[par].append({"name": path, "type": "file", "size": size})
+
+    def _open(self, path, mode="rb", block_size=None, cache_options=None, **kwargs):
+        data = self.cat_file(path)  # load whole chunk into memory
+        return io.BytesIO(data)
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        if isinstance(self.references, LazyReferenceMapper):
+            try:
+                return self.references.ls(path, detail)
+            except KeyError:
+                pass
+            raise FileNotFoundError(f"'{path}' is not a known key")
+        if not self.dircache:
+            self._dircache_from_items()
+        out = self._ls_from_cache(path)
+        if out is None:
+            raise FileNotFoundError(path)
+        if detail:
+            return out
+        return [o["name"] for o in out]
+
+    def exists(self, path, **kwargs):  # overwrite auto-sync version
+        return self.isdir(path) or self.isfile(path)
+
+    def isdir(self, path):  # overwrite auto-sync version
+        if self.dircache:
+            return path in self.dircache
+        elif isinstance(self.references, LazyReferenceMapper):
+            return path in self.references.listdir("")
+        else:
+            # this may be faster than building dircache for single calls, but
+            # by looping will be slow for many calls; could cache it?
+            return any(_.startswith(f"{path}/") for _ in self.references)
+
+    def isfile(self, path):  # overwrite auto-sync version
+        return path in self.references
+
+    async def _ls(self, path, detail=True, **kwargs):  # calls fast sync code
+        return self.ls(path, detail, **kwargs)
+
+    def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        if withdirs:
+            return super().find(
+                path, maxdepth=maxdepth, withdirs=withdirs, detail=detail, **kwargs
+            )
+        if path:
+            path = self._strip_protocol(path)
+            r = sorted(k for k in self.references if k.startswith(path))
+        else:
+            r = sorted(self.references)
+        if detail:
+            if not self.dircache:
+                self._dircache_from_items()
+            return {k: self._ls_from_cache(k)[0] for k in r}
+        else:
+            return r
+
+    def info(self, path, **kwargs):
+        out = self.references.get(path)
+        if out is not None:
+            if isinstance(out, (str, bytes)):
+                # decode base64 here
+                return {"name": path, "type": "file", "size": len(out)}
+            elif len(out) > 1:
+                return {"name": path, "type": "file", "size": out[2]}
+            else:
+                out0 = [{"name": path, "type": "file", "size": None}]
+        else:
+            out = self.ls(path, True)
+            out0 = [o for o in out if o["name"] == path]
+            if not out0:
+                return {"name": path, "type": "directory", "size": 0}
+        if out0[0]["size"] is None:
+            # if this is a whole remote file, update size using remote FS
+            prot, _ = split_protocol(self.references[path][0])
+            out0[0]["size"] = self.fss[prot].size(self.references[path][0])
+        return out0[0]
+
+    async def _info(self, path, **kwargs):  # calls fast sync code
+        return self.info(path)
+
+    async def _rm_file(self, path, **kwargs):
+        self.references.pop(
+            path, None
+        )  # ignores FileNotFound, just as well for directories
+        self.dircache.clear()  # this is a bit heavy handed
+
+    async def _pipe_file(self, path, data):
+        # can be str or bytes
+        self.references[path] = data
+        self.dircache.clear()  # this is a bit heavy handed
+
+    async def _put_file(self, lpath, rpath):
+        # puts binary
+        with open(lpath, "rb") as f:
+            self.references[rpath] = f.read()
+        self.dircache.clear()  # this is a bit heavy handed
+
+    def save_json(self, url, **storage_options):
+        """Write modified references into new location"""
+        out = {}
+        for k, v in self.references.items():
+            if isinstance(v, bytes):
+                try:
+                    out[k] = v.decode("ascii")
+                except UnicodeDecodeError:
+                    out[k] = (b"base64:" + base64.b64encode(v)).decode()
+            else:
+                out[k] = v
+        with fsspec.open(url, "wb", **storage_options) as f:
+            f.write(json.dumps({"version": 1, "refs": out}).encode())
diff --git a/lib/python3.11/site-packages/fsspec/implementations/sftp.py b/lib/python3.11/site-packages/fsspec/implementations/sftp.py
new file mode 100644
index 0000000000000000000000000000000000000000..052b8261fefce6a247fd3cb5a01d6a1cc9103589
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/sftp.py
@@ -0,0 +1,180 @@
+import datetime
+import logging
+import os
+import types
+import uuid
+from stat import S_ISDIR, S_ISLNK
+
+import paramiko
+
+from .. import AbstractFileSystem
+from ..utils import infer_storage_options
+
+logger = logging.getLogger("fsspec.sftp")
+
+
+class SFTPFileSystem(AbstractFileSystem):
+    """Files over SFTP/SSH
+
+    Peer-to-peer filesystem over SSH using paramiko.
+
+    Note: if using this with the ``open`` or ``open_files``, with full URLs,
+    there is no way to tell if a path is relative, so all paths are assumed
+    to be absolute.
+    """
+
+    protocol = "sftp", "ssh"
+
+    def __init__(self, host, **ssh_kwargs):
+        """
+
+        Parameters
+        ----------
+        host: str
+            Hostname or IP as a string
+        temppath: str
+            Location on the server to put files, when within a transaction
+        ssh_kwargs: dict
+            Parameters passed on to connection. See details in
+            https://docs.paramiko.org/en/3.3/api/client.html#paramiko.client.SSHClient.connect
+            May include port, username, password...
+        """
+        if self._cached:
+            return
+        super().__init__(**ssh_kwargs)
+        self.temppath = ssh_kwargs.pop("temppath", "/tmp")  # remote temp directory
+        self.host = host
+        self.ssh_kwargs = ssh_kwargs
+        self._connect()
+
+    def _connect(self):
+        logger.debug("Connecting to SFTP server %s", self.host)
+        self.client = paramiko.SSHClient()
+        self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        self.client.connect(self.host, **self.ssh_kwargs)
+        self.ftp = self.client.open_sftp()
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return infer_storage_options(path)["path"]
+
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        out = infer_storage_options(urlpath)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        return out
+
+    def mkdir(self, path, create_parents=False, mode=511):
+        logger.debug("Creating folder %s", path)
+        if self.exists(path):
+            raise FileExistsError(f"File exists: {path}")
+
+        if create_parents:
+            self.makedirs(path)
+        else:
+            self.ftp.mkdir(path, mode)
+
+    def makedirs(self, path, exist_ok=False, mode=511):
+        if self.exists(path) and not exist_ok:
+            raise FileExistsError(f"File exists: {path}")
+
+        parts = path.split("/")
+        new_path = "/" if path[:1] == "/" else ""
+
+        for part in parts:
+            if part:
+                new_path = f"{new_path}/{part}" if new_path else part
+                if not self.exists(new_path):
+                    self.ftp.mkdir(new_path, mode)
+
+    def rmdir(self, path):
+        logger.debug("Removing folder %s", path)
+        self.ftp.rmdir(path)
+
+    def info(self, path):
+        stat = self._decode_stat(self.ftp.stat(path))
+        stat["name"] = path
+        return stat
+
+    @staticmethod
+    def _decode_stat(stat, parent_path=None):
+        if S_ISDIR(stat.st_mode):
+            t = "directory"
+        elif S_ISLNK(stat.st_mode):
+            t = "link"
+        else:
+            t = "file"
+        out = {
+            "name": "",
+            "size": stat.st_size,
+            "type": t,
+            "uid": stat.st_uid,
+            "gid": stat.st_gid,
+            "time": datetime.datetime.fromtimestamp(
+                stat.st_atime, tz=datetime.timezone.utc
+            ),
+            "mtime": datetime.datetime.fromtimestamp(
+                stat.st_mtime, tz=datetime.timezone.utc
+            ),
+        }
+        if parent_path:
+            out["name"] = "/".join([parent_path.rstrip("/"), stat.filename])
+        return out
+
+    def ls(self, path, detail=False):
+        logger.debug("Listing folder %s", path)
+        stats = [self._decode_stat(stat, path) for stat in self.ftp.listdir_iter(path)]
+        if detail:
+            return stats
+        else:
+            paths = [stat["name"] for stat in stats]
+            return sorted(paths)
+
+    def put(self, lpath, rpath, callback=None, **kwargs):
+        logger.debug("Put file %s into %s", lpath, rpath)
+        self.ftp.put(lpath, rpath)
+
+    def get_file(self, rpath, lpath, **kwargs):
+        if self.isdir(rpath):
+            os.makedirs(lpath, exist_ok=True)
+        else:
+            self.ftp.get(self._strip_protocol(rpath), lpath)
+
+    def _open(self, path, mode="rb", block_size=None, **kwargs):
+        """
+        block_size: int or None
+            If 0, no buffering, if 1, line buffering, if >1, buffer that many
+            bytes, if None use default from paramiko.
+        """
+        logger.debug("Opening file %s", path)
+        if kwargs.get("autocommit", True) is False:
+            # writes to temporary file, move on commit
+            path2 = "/".join([self.temppath, str(uuid.uuid4())])
+            f = self.ftp.open(path2, mode, bufsize=block_size if block_size else -1)
+            f.temppath = path2
+            f.targetpath = path
+            f.fs = self
+            f.commit = types.MethodType(commit_a_file, f)
+            f.discard = types.MethodType(discard_a_file, f)
+        else:
+            f = self.ftp.open(path, mode, bufsize=block_size if block_size else -1)
+        return f
+
+    def _rm(self, path):
+        if self.isdir(path):
+            self.ftp.rmdir(path)
+        else:
+            self.ftp.remove(path)
+
+    def mv(self, old, new):
+        logger.debug("Renaming %s into %s", old, new)
+        self.ftp.posix_rename(old, new)
+
+
+def commit_a_file(self):
+    self.fs.mv(self.temppath, self.targetpath)
+
+
+def discard_a_file(self):
+    self.fs._rm(self.temppath)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/smb.py b/lib/python3.11/site-packages/fsspec/implementations/smb.py
new file mode 100644
index 0000000000000000000000000000000000000000..02f9ede372a6e383387609df5593814e2e5f8296
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/smb.py
@@ -0,0 +1,324 @@
+"""
+This module contains SMBFileSystem class responsible for handling access to
+Windows Samba network shares by using package smbprotocol
+"""
+
+import datetime
+import uuid
+from stat import S_ISDIR, S_ISLNK
+
+import smbclient
+
+from .. import AbstractFileSystem
+from ..utils import infer_storage_options
+
+# ! pylint: disable=bad-continuation
+
+
+class SMBFileSystem(AbstractFileSystem):
+    """Allow reading and writing to Windows and Samba network shares.
+
+    When using `fsspec.open()` for getting a file-like object the URI
+    should be specified as this format:
+    ``smb://workgroup;user:password@server:port/share/folder/file.csv``.
+
+    Example::
+
+        >>> import fsspec
+        >>> with fsspec.open(
+        ...     'smb://myuser:mypassword@myserver.com/' 'share/folder/file.csv'
+        ... ) as smbfile:
+        ...     df = pd.read_csv(smbfile, sep='|', header=None)
+
+    Note that you need to pass in a valid hostname or IP address for the host
+    component of the URL. Do not use the Windows/NetBIOS machine name for the
+    host component.
+
+    The first component of the path in the URL points to the name of the shared
+    folder. Subsequent path components will point to the directory/folder/file.
+
+    The URL components ``workgroup`` , ``user``, ``password`` and ``port`` may be
+    optional.
+
+    .. note::
+
+        For working this source require `smbprotocol`_ to be installed, e.g.::
+
+            $ pip install smbprotocol
+            # or
+            # pip install smbprotocol[kerberos]
+
+    .. _smbprotocol: https://github.com/jborean93/smbprotocol#requirements
+
+    Note: if using this with the ``open`` or ``open_files``, with full URLs,
+    there is no way to tell if a path is relative, so all paths are assumed
+    to be absolute.
+    """
+
+    protocol = "smb"
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        host,
+        port=None,
+        username=None,
+        password=None,
+        timeout=60,
+        encrypt=None,
+        share_access=None,
+        **kwargs,
+    ):
+        """
+        You can use _get_kwargs_from_urls to get some kwargs from
+        a reasonable SMB url.
+
+        Authentication will be anonymous or integrated if username/password are not
+        given.
+
+        Parameters
+        ----------
+        host: str
+            The remote server name/ip to connect to
+        port: int or None
+            Port to connect with. Usually 445, sometimes 139.
+        username: str or None
+            Username to connect with. Required if Kerberos auth is not being used.
+        password: str or None
+            User's password on the server, if using username
+        timeout: int
+            Connection timeout in seconds
+        encrypt: bool
+            Whether to force encryption or not, once this has been set to True
+            the session cannot be changed back to False.
+        share_access: str or None
+            Specifies the default access applied to file open operations
+            performed with this file system object.
+            This affects whether other processes can concurrently open a handle
+            to the same file.
+
+            - None (the default): exclusively locks the file until closed.
+            - 'r': Allow other handles to be opened with read access.
+            - 'w': Allow other handles to be opened with write access.
+            - 'd': Allow other handles to be opened with delete access.
+        """
+        super().__init__(**kwargs)
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.timeout = timeout
+        self.encrypt = encrypt
+        self.temppath = kwargs.pop("temppath", "")
+        self.share_access = share_access
+        self._connect()
+
+    @property
+    def _port(self):
+        return 445 if self.port is None else self.port
+
+    def _connect(self):
+        smbclient.register_session(
+            self.host,
+            username=self.username,
+            password=self.password,
+            port=self._port,
+            encrypt=self.encrypt,
+            connection_timeout=self.timeout,
+        )
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return infer_storage_options(path)["path"]
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        # smb://workgroup;user:password@host:port/share/folder/file.csv
+        out = infer_storage_options(path)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        return out
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        wpath = _as_unc_path(self.host, path)
+        if create_parents:
+            smbclient.makedirs(wpath, exist_ok=False, port=self._port, **kwargs)
+        else:
+            smbclient.mkdir(wpath, port=self._port, **kwargs)
+
+    def makedirs(self, path, exist_ok=False):
+        if _share_has_path(path):
+            wpath = _as_unc_path(self.host, path)
+            smbclient.makedirs(wpath, exist_ok=exist_ok, port=self._port)
+
+    def rmdir(self, path):
+        if _share_has_path(path):
+            wpath = _as_unc_path(self.host, path)
+            smbclient.rmdir(wpath, port=self._port)
+
+    def info(self, path, **kwargs):
+        wpath = _as_unc_path(self.host, path)
+        stats = smbclient.stat(wpath, port=self._port, **kwargs)
+        if S_ISDIR(stats.st_mode):
+            stype = "directory"
+        elif S_ISLNK(stats.st_mode):
+            stype = "link"
+        else:
+            stype = "file"
+        res = {
+            "name": path + "/" if stype == "directory" else path,
+            "size": stats.st_size,
+            "type": stype,
+            "uid": stats.st_uid,
+            "gid": stats.st_gid,
+            "time": stats.st_atime,
+            "mtime": stats.st_mtime,
+        }
+        return res
+
+    def created(self, path):
+        """Return the created timestamp of a file as a datetime.datetime"""
+        wpath = _as_unc_path(self.host, path)
+        stats = smbclient.stat(wpath, port=self._port)
+        return datetime.datetime.fromtimestamp(stats.st_ctime, tz=datetime.timezone.utc)
+
+    def modified(self, path):
+        """Return the modified timestamp of a file as a datetime.datetime"""
+        wpath = _as_unc_path(self.host, path)
+        stats = smbclient.stat(wpath, port=self._port)
+        return datetime.datetime.fromtimestamp(stats.st_mtime, tz=datetime.timezone.utc)
+
+    def ls(self, path, detail=True, **kwargs):
+        unc = _as_unc_path(self.host, path)
+        listed = smbclient.listdir(unc, port=self._port, **kwargs)
+        dirs = ["/".join([path.rstrip("/"), p]) for p in listed]
+        if detail:
+            dirs = [self.info(d) for d in dirs]
+        return dirs
+
+    # pylint: disable=too-many-arguments
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=-1,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        """
+        block_size: int or None
+            If 0, no buffering, 1, line buffering, >1, buffer that many bytes
+
+        Notes
+        -----
+        By specifying 'share_access' in 'kwargs' it is possible to override the
+        default shared access setting applied in the constructor of this object.
+        """
+        bls = block_size if block_size is not None and block_size >= 0 else -1
+        wpath = _as_unc_path(self.host, path)
+        share_access = kwargs.pop("share_access", self.share_access)
+        if "w" in mode and autocommit is False:
+            temp = _as_temp_path(self.host, path, self.temppath)
+            return SMBFileOpener(
+                wpath, temp, mode, port=self._port, block_size=bls, **kwargs
+            )
+        return smbclient.open_file(
+            wpath,
+            mode,
+            buffering=bls,
+            share_access=share_access,
+            port=self._port,
+            **kwargs,
+        )
+
+    def copy(self, path1, path2, **kwargs):
+        """Copy within two locations in the same filesystem"""
+        wpath1 = _as_unc_path(self.host, path1)
+        wpath2 = _as_unc_path(self.host, path2)
+        smbclient.copyfile(wpath1, wpath2, port=self._port, **kwargs)
+
+    def _rm(self, path):
+        if _share_has_path(path):
+            wpath = _as_unc_path(self.host, path)
+            stats = smbclient.stat(wpath, port=self._port)
+            if S_ISDIR(stats.st_mode):
+                smbclient.rmdir(wpath, port=self._port)
+            else:
+                smbclient.remove(wpath, port=self._port)
+
+    def mv(self, path1, path2, recursive=None, maxdepth=None, **kwargs):
+        wpath1 = _as_unc_path(self.host, path1)
+        wpath2 = _as_unc_path(self.host, path2)
+        smbclient.rename(wpath1, wpath2, port=self._port, **kwargs)
+
+
+def _as_unc_path(host, path):
+    rpath = path.replace("/", "\\")
+    unc = f"\\\\{host}{rpath}"
+    return unc
+
+
+def _as_temp_path(host, path, temppath):
+    share = path.split("/")[1]
+    temp_file = f"/{share}{temppath}/{uuid.uuid4()}"
+    unc = _as_unc_path(host, temp_file)
+    return unc
+
+
+def _share_has_path(path):
+    parts = path.count("/")
+    if path.endswith("/"):
+        return parts > 2
+    return parts > 1
+
+
+class SMBFileOpener:
+    """writes to remote temporary file, move on commit"""
+
+    def __init__(self, path, temp, mode, port=445, block_size=-1, **kwargs):
+        self.path = path
+        self.temp = temp
+        self.mode = mode
+        self.block_size = block_size
+        self.kwargs = kwargs
+        self.smbfile = None
+        self._incontext = False
+        self.port = port
+        self._open()
+
+    def _open(self):
+        if self.smbfile is None or self.smbfile.closed:
+            self.smbfile = smbclient.open_file(
+                self.temp,
+                self.mode,
+                port=self.port,
+                buffering=self.block_size,
+                **self.kwargs,
+            )
+
+    def commit(self):
+        """Move temp file to definitive on success."""
+        # TODO: use transaction support in SMB protocol
+        smbclient.replace(self.temp, self.path, port=self.port)
+
+    def discard(self):
+        """Remove the temp file on failure."""
+        smbclient.remove(self.temp, port=self.port)
+
+    def __fspath__(self):
+        return self.path
+
+    def __iter__(self):
+        return self.smbfile.__iter__()
+
+    def __getattr__(self, item):
+        return getattr(self.smbfile, item)
+
+    def __enter__(self):
+        self._incontext = True
+        return self.smbfile.__enter__()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._incontext = False
+        self.smbfile.__exit__(exc_type, exc_value, traceback)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/tar.py b/lib/python3.11/site-packages/fsspec/implementations/tar.py
new file mode 100644
index 0000000000000000000000000000000000000000..412e5ba4d2cdea7db090dc96412e697909a38d78
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/tar.py
@@ -0,0 +1,124 @@
+import logging
+import tarfile
+
+import fsspec
+from fsspec.archive import AbstractArchiveFileSystem
+from fsspec.compression import compr
+from fsspec.utils import infer_compression
+
+typemap = {b"0": "file", b"5": "directory"}
+
+logger = logging.getLogger("tar")
+
+
+class TarFileSystem(AbstractArchiveFileSystem):
+    """Compressed Tar archives as a file-system (read-only)
+
+    Supports the following formats:
+    tar.gz, tar.bz2, tar.xz
+    """
+
+    root_marker = ""
+    protocol = "tar"
+    cachable = False
+
+    def __init__(
+        self,
+        fo="",
+        index_store=None,
+        target_options=None,
+        target_protocol=None,
+        compression=None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        target_options = target_options or {}
+
+        if isinstance(fo, str):
+            self.of = fsspec.open(fo, protocol=target_protocol, **target_options)
+            fo = self.of.open()  # keep the reference
+
+        # Try to infer compression.
+        if compression is None:
+            name = None
+
+            # Try different ways to get hold of the filename. `fo` might either
+            # be a `fsspec.LocalFileOpener`, an `io.BufferedReader` or an
+            # `fsspec.AbstractFileSystem` instance.
+            try:
+                # Amended io.BufferedReader or similar.
+                # This uses a "protocol extension" where original filenames are
+                # propagated to archive-like filesystems in order to let them
+                # infer the right compression appropriately.
+                if hasattr(fo, "original"):
+                    name = fo.original
+
+                # fsspec.LocalFileOpener
+                elif hasattr(fo, "path"):
+                    name = fo.path
+
+                # io.BufferedReader
+                elif hasattr(fo, "name"):
+                    name = fo.name
+
+                # fsspec.AbstractFileSystem
+                elif hasattr(fo, "info"):
+                    name = fo.info()["name"]
+
+            except Exception as ex:
+                logger.warning(
+                    f"Unable to determine file name, not inferring compression: {ex}"
+                )
+
+            if name is not None:
+                compression = infer_compression(name)
+                logger.info(f"Inferred compression {compression} from file name {name}")
+
+        if compression is not None:
+            # TODO: tarfile already implements compression with modes like "'r:gz'",
+            #  but then would seek to offset in the file work?
+            fo = compr[compression](fo)
+
+        self._fo_ref = fo
+        self.fo = fo  # the whole instance is a context
+        self.tar = tarfile.TarFile(fileobj=self.fo)
+        self.dir_cache = None
+
+        self.index_store = index_store
+        self.index = None
+        self._index()
+
+    def _index(self):
+        # TODO: load and set saved index, if exists
+        out = {}
+        for ti in self.tar:
+            info = ti.get_info()
+            info["type"] = typemap.get(info["type"], "file")
+            name = ti.get_info()["name"].rstrip("/")
+            out[name] = (info, ti.offset_data)
+
+        self.index = out
+        # TODO: save index to self.index_store here, if set
+
+    def _get_dirs(self):
+        if self.dir_cache is not None:
+            return
+
+        # This enables ls to get directories as children as well as files
+        self.dir_cache = {
+            dirname: {"name": dirname, "size": 0, "type": "directory"}
+            for dirname in self._all_dirnames(self.tar.getnames())
+        }
+        for member in self.tar.getmembers():
+            info = member.get_info()
+            info["name"] = info["name"].rstrip("/")
+            info["type"] = typemap.get(info["type"], "file")
+            self.dir_cache[info["name"]] = info
+
+    def _open(self, path, mode="rb", **kwargs):
+        if mode != "rb":
+            raise ValueError("Read-only filesystem implementation")
+        details, offset = self.index[path]
+        if details["type"] != "file":
+            raise ValueError("Can only handle regular files")
+        return self.tar.extractfile(path)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/webhdfs.py b/lib/python3.11/site-packages/fsspec/implementations/webhdfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7426b261a34084af0941d6fea44baf99c6b80c5
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/webhdfs.py
@@ -0,0 +1,467 @@
+# https://hadoop.apache.org/docs/r1.0.4/webhdfs.html
+
+import logging
+import os
+import secrets
+import shutil
+import tempfile
+import uuid
+from contextlib import suppress
+from urllib.parse import quote
+
+import requests
+
+from ..spec import AbstractBufferedFile, AbstractFileSystem
+from ..utils import infer_storage_options, tokenize
+
+logger = logging.getLogger("webhdfs")
+
+
+class WebHDFS(AbstractFileSystem):
+    """
+    Interface to HDFS over HTTP using the WebHDFS API. Supports also HttpFS gateways.
+
+    Four auth mechanisms are supported:
+
+    insecure: no auth is done, and the user is assumed to be whoever they
+        say they are (parameter ``user``), or a predefined value such as
+        "dr.who" if not given
+    spnego: when kerberos authentication is enabled, auth is negotiated by
+        requests_kerberos https://github.com/requests/requests-kerberos .
+        This establishes a session based on existing kinit login and/or
+        specified principal/password; parameters are passed with ``kerb_kwargs``
+    token: uses an existing Hadoop delegation token from another secured
+        service. Indeed, this client can also generate such tokens when
+        not insecure. Note that tokens expire, but can be renewed (by a
+        previously specified user) and may allow for proxying.
+    basic-auth: used when both parameter ``user`` and parameter ``password``
+        are provided.
+
+    """
+
+    tempdir = str(tempfile.gettempdir())
+    protocol = "webhdfs", "webHDFS"
+
+    def __init__(
+        self,
+        host,
+        port=50070,
+        kerberos=False,
+        token=None,
+        user=None,
+        password=None,
+        proxy_to=None,
+        kerb_kwargs=None,
+        data_proxy=None,
+        use_https=False,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        host: str
+            Name-node address
+        port: int
+            Port for webHDFS
+        kerberos: bool
+            Whether to authenticate with kerberos for this connection
+        token: str or None
+            If given, use this token on every call to authenticate. A user
+            and user-proxy may be encoded in the token and should not be also
+            given
+        user: str or None
+            If given, assert the user name to connect with
+        password: str or None
+            If given, assert the password to use for basic auth. If password
+            is provided, user must be provided also
+        proxy_to: str or None
+            If given, the user has the authority to proxy, and this value is
+            the user in who's name actions are taken
+        kerb_kwargs: dict
+            Any extra arguments for HTTPKerberosAuth, see
+            `<https://github.com/requests/requests-kerberos/blob/master/requests_kerberos/kerberos_.py>`_
+        data_proxy: dict, callable or None
+            If given, map data-node addresses. This can be necessary if the
+            HDFS cluster is behind a proxy, running on Docker or otherwise has
+            a mismatch between the host-names given by the name-node and the
+            address by which to refer to them from the client. If a dict,
+            maps host names ``host->data_proxy[host]``; if a callable, full
+            URLs are passed, and function must conform to
+            ``url->data_proxy(url)``.
+        use_https: bool
+            Whether to connect to the Name-node using HTTPS instead of HTTP
+        kwargs
+        """
+        if self._cached:
+            return
+        super().__init__(**kwargs)
+        self.url = f"{'https' if use_https else 'http'}://{host}:{port}/webhdfs/v1"
+        self.kerb = kerberos
+        self.kerb_kwargs = kerb_kwargs or {}
+        self.pars = {}
+        self.proxy = data_proxy or {}
+        if token is not None:
+            if user is not None or proxy_to is not None:
+                raise ValueError(
+                    "If passing a delegation token, must not set "
+                    "user or proxy_to, as these are encoded in the"
+                    " token"
+                )
+            self.pars["delegation"] = token
+        self.user = user
+        self.password = password
+
+        if password is not None:
+            if user is None:
+                raise ValueError(
+                    "If passing a password, the user must also be"
+                    "set in order to set up the basic-auth"
+                )
+        else:
+            if user is not None:
+                self.pars["user.name"] = user
+
+        if proxy_to is not None:
+            self.pars["doas"] = proxy_to
+        if kerberos and user is not None:
+            raise ValueError(
+                "If using Kerberos auth, do not specify the "
+                "user, this is handled by kinit."
+            )
+        self._connect()
+
+        self._fsid = f"webhdfs_{tokenize(host, port)}"
+
+    @property
+    def fsid(self):
+        return self._fsid
+
+    def _connect(self):
+        self.session = requests.Session()
+        if self.kerb:
+            from requests_kerberos import HTTPKerberosAuth
+
+            self.session.auth = HTTPKerberosAuth(**self.kerb_kwargs)
+
+        if self.user is not None and self.password is not None:
+            from requests.auth import HTTPBasicAuth
+
+            self.session.auth = HTTPBasicAuth(self.user, self.password)
+
+    def _call(self, op, method="get", path=None, data=None, redirect=True, **kwargs):
+        url = self._apply_proxy(self.url + quote(path or "", safe="/="))
+        args = kwargs.copy()
+        args.update(self.pars)
+        args["op"] = op.upper()
+        logger.debug("sending %s with %s", url, method)
+        out = self.session.request(
+            method=method.upper(),
+            url=url,
+            params=args,
+            data=data,
+            allow_redirects=redirect,
+        )
+        if out.status_code in [400, 401, 403, 404, 500]:
+            try:
+                err = out.json()
+                msg = err["RemoteException"]["message"]
+                exp = err["RemoteException"]["exception"]
+            except (ValueError, KeyError):
+                pass
+            else:
+                if exp in ["IllegalArgumentException", "UnsupportedOperationException"]:
+                    raise ValueError(msg)
+                elif exp in ["SecurityException", "AccessControlException"]:
+                    raise PermissionError(msg)
+                elif exp in ["FileNotFoundException"]:
+                    raise FileNotFoundError(msg)
+                else:
+                    raise RuntimeError(msg)
+        out.raise_for_status()
+        return out
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        replication=None,
+        permissions=None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        path: str
+            File location
+        mode: str
+            'rb', 'wb', etc.
+        block_size: int
+            Client buffer size for read-ahead or write buffer
+        autocommit: bool
+            If False, writes to temporary file that only gets put in final
+            location upon commit
+        replication: int
+            Number of copies of file on the cluster, write mode only
+        permissions: str or int
+            posix permissions, write mode only
+        kwargs
+
+        Returns
+        -------
+        WebHDFile instance
+        """
+        block_size = block_size or self.blocksize
+        return WebHDFile(
+            self,
+            path,
+            mode=mode,
+            block_size=block_size,
+            tempdir=self.tempdir,
+            autocommit=autocommit,
+            replication=replication,
+            permissions=permissions,
+        )
+
+    @staticmethod
+    def _process_info(info):
+        info["type"] = info["type"].lower()
+        info["size"] = info["length"]
+        return info
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return infer_storage_options(path)["path"]
+
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        out = infer_storage_options(urlpath)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        if "username" in out:
+            out["user"] = out.pop("username")
+        return out
+
+    def info(self, path):
+        out = self._call("GETFILESTATUS", path=path)
+        info = out.json()["FileStatus"]
+        info["name"] = path
+        return self._process_info(info)
+
+    def ls(self, path, detail=False):
+        out = self._call("LISTSTATUS", path=path)
+        infos = out.json()["FileStatuses"]["FileStatus"]
+        for info in infos:
+            self._process_info(info)
+            info["name"] = path.rstrip("/") + "/" + info["pathSuffix"]
+        if detail:
+            return sorted(infos, key=lambda i: i["name"])
+        else:
+            return sorted(info["name"] for info in infos)
+
+    def content_summary(self, path):
+        """Total numbers of files, directories and bytes under path"""
+        out = self._call("GETCONTENTSUMMARY", path=path)
+        return out.json()["ContentSummary"]
+
+    def ukey(self, path):
+        """Checksum info of file, giving method and result"""
+        out = self._call("GETFILECHECKSUM", path=path, redirect=False)
+        if "Location" in out.headers:
+            location = self._apply_proxy(out.headers["Location"])
+            out2 = self.session.get(location)
+            out2.raise_for_status()
+            return out2.json()["FileChecksum"]
+        else:
+            out.raise_for_status()
+            return out.json()["FileChecksum"]
+
+    def home_directory(self):
+        """Get user's home directory"""
+        out = self._call("GETHOMEDIRECTORY")
+        return out.json()["Path"]
+
+    def get_delegation_token(self, renewer=None):
+        """Retrieve token which can give the same authority to other uses
+
+        Parameters
+        ----------
+        renewer: str or None
+            User who may use this token; if None, will be current user
+        """
+        if renewer:
+            out = self._call("GETDELEGATIONTOKEN", renewer=renewer)
+        else:
+            out = self._call("GETDELEGATIONTOKEN")
+        t = out.json()["Token"]
+        if t is None:
+            raise ValueError("No token available for this user/security context")
+        return t["urlString"]
+
+    def renew_delegation_token(self, token):
+        """Make token live longer. Returns new expiry time"""
+        out = self._call("RENEWDELEGATIONTOKEN", method="put", token=token)
+        return out.json()["long"]
+
+    def cancel_delegation_token(self, token):
+        """Stop the token from being useful"""
+        self._call("CANCELDELEGATIONTOKEN", method="put", token=token)
+
+    def chmod(self, path, mod):
+        """Set the permission at path
+
+        Parameters
+        ----------
+        path: str
+            location to set (file or directory)
+        mod: str or int
+            posix epresentation or permission, give as oct string, e.g, '777'
+            or 0o777
+        """
+        self._call("SETPERMISSION", method="put", path=path, permission=mod)
+
+    def chown(self, path, owner=None, group=None):
+        """Change owning user and/or group"""
+        kwargs = {}
+        if owner is not None:
+            kwargs["owner"] = owner
+        if group is not None:
+            kwargs["group"] = group
+        self._call("SETOWNER", method="put", path=path, **kwargs)
+
+    def set_replication(self, path, replication):
+        """
+        Set file replication factor
+
+        Parameters
+        ----------
+        path: str
+            File location (not for directories)
+        replication: int
+            Number of copies of file on the cluster. Should be smaller than
+            number of data nodes; normally 3 on most systems.
+        """
+        self._call("SETREPLICATION", path=path, method="put", replication=replication)
+
+    def mkdir(self, path, **kwargs):
+        self._call("MKDIRS", method="put", path=path)
+
+    def makedirs(self, path, exist_ok=False):
+        if exist_ok is False and self.exists(path):
+            raise FileExistsError(path)
+        self.mkdir(path)
+
+    def mv(self, path1, path2, **kwargs):
+        self._call("RENAME", method="put", path=path1, destination=path2)
+
+    def rm(self, path, recursive=False, **kwargs):
+        self._call(
+            "DELETE",
+            method="delete",
+            path=path,
+            recursive="true" if recursive else "false",
+        )
+
+    def rm_file(self, path, **kwargs):
+        self.rm(path)
+
+    def cp_file(self, lpath, rpath, **kwargs):
+        with self.open(lpath) as lstream:
+            tmp_fname = "/".join([self._parent(rpath), f".tmp.{secrets.token_hex(16)}"])
+            # Perform an atomic copy (stream to a temporary file and
+            # move it to the actual destination).
+            try:
+                with self.open(tmp_fname, "wb") as rstream:
+                    shutil.copyfileobj(lstream, rstream)
+                self.mv(tmp_fname, rpath)
+            except BaseException:  # noqa
+                with suppress(FileNotFoundError):
+                    self.rm(tmp_fname)
+                raise
+
+    def _apply_proxy(self, location):
+        if self.proxy and callable(self.proxy):
+            location = self.proxy(location)
+        elif self.proxy:
+            # as a dict
+            for k, v in self.proxy.items():
+                location = location.replace(k, v, 1)
+        return location
+
+
+class WebHDFile(AbstractBufferedFile):
+    """A file living in HDFS over webHDFS"""
+
+    def __init__(self, fs, path, **kwargs):
+        super().__init__(fs, path, **kwargs)
+        kwargs = kwargs.copy()
+        if kwargs.get("permissions", None) is None:
+            kwargs.pop("permissions", None)
+        if kwargs.get("replication", None) is None:
+            kwargs.pop("replication", None)
+        self.permissions = kwargs.pop("permissions", 511)
+        tempdir = kwargs.pop("tempdir")
+        if kwargs.pop("autocommit", False) is False:
+            self.target = self.path
+            self.path = os.path.join(tempdir, str(uuid.uuid4()))
+
+    def _upload_chunk(self, final=False):
+        """Write one part of a multi-block file upload
+
+        Parameters
+        ==========
+        final: bool
+            This is the last block, so should complete file, if
+            self.autocommit is True.
+        """
+        out = self.fs.session.post(
+            self.location,
+            data=self.buffer.getvalue(),
+            headers={"content-type": "application/octet-stream"},
+        )
+        out.raise_for_status()
+        return True
+
+    def _initiate_upload(self):
+        """Create remote file/upload"""
+        kwargs = self.kwargs.copy()
+        if "a" in self.mode:
+            op, method = "APPEND", "POST"
+        else:
+            op, method = "CREATE", "PUT"
+            kwargs["overwrite"] = "true"
+        out = self.fs._call(op, method, self.path, redirect=False, **kwargs)
+        location = self.fs._apply_proxy(out.headers["Location"])
+        if "w" in self.mode:
+            # create empty file to append to
+            out2 = self.fs.session.put(
+                location, headers={"content-type": "application/octet-stream"}
+            )
+            out2.raise_for_status()
+            # after creating empty file, change location to append to
+            out2 = self.fs._call("APPEND", "POST", self.path, redirect=False, **kwargs)
+            self.location = self.fs._apply_proxy(out2.headers["Location"])
+
+    def _fetch_range(self, start, end):
+        start = max(start, 0)
+        end = min(self.size, end)
+        if start >= end or start >= self.size:
+            return b""
+        out = self.fs._call(
+            "OPEN", path=self.path, offset=start, length=end - start, redirect=False
+        )
+        out.raise_for_status()
+        if "Location" in out.headers:
+            location = out.headers["Location"]
+            out2 = self.fs.session.get(self.fs._apply_proxy(location))
+            return out2.content
+        else:
+            return out.content
+
+    def commit(self):
+        self.fs.mv(self.path, self.target)
+
+    def discard(self):
+        self.fs.rm(self.path)
diff --git a/lib/python3.11/site-packages/fsspec/implementations/zip.py b/lib/python3.11/site-packages/fsspec/implementations/zip.py
new file mode 100644
index 0000000000000000000000000000000000000000..473975df3c73fb50106bd9b9b36ed8a30c4bc322
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/implementations/zip.py
@@ -0,0 +1,133 @@
+import zipfile
+
+import fsspec
+from fsspec.archive import AbstractArchiveFileSystem
+
+
+class ZipFileSystem(AbstractArchiveFileSystem):
+    """Read/Write contents of ZIP archive as a file-system
+
+    Keeps file object open while instance lives.
+
+    This class is pickleable, but not necessarily thread-safe
+    """
+
+    root_marker = ""
+    protocol = "zip"
+    cachable = False
+
+    def __init__(
+        self,
+        fo="",
+        mode="r",
+        target_protocol=None,
+        target_options=None,
+        compression=zipfile.ZIP_STORED,
+        allowZip64=True,
+        compresslevel=None,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        fo: str or file-like
+            Contains ZIP, and must exist. If a str, will fetch file using
+            :meth:`~fsspec.open_files`, which must return one file exactly.
+        mode: str
+            Accept: "r", "w", "a"
+        target_protocol: str (optional)
+            If ``fo`` is a string, this value can be used to override the
+            FS protocol inferred from a URL
+        target_options: dict (optional)
+            Kwargs passed when instantiating the target FS, if ``fo`` is
+            a string.
+        compression, allowZip64, compresslevel: passed to ZipFile
+            Only relevant when creating a ZIP
+        """
+        super().__init__(self, **kwargs)
+        if mode not in set("rwa"):
+            raise ValueError(f"mode '{mode}' no understood")
+        self.mode = mode
+        if isinstance(fo, str):
+            if mode == "a":
+                m = "r+b"
+            else:
+                m = mode + "b"
+            fo = fsspec.open(
+                fo, mode=m, protocol=target_protocol, **(target_options or {})
+            )
+        self.of = fo
+        self.fo = fo.__enter__()  # the whole instance is a context
+        self.zip = zipfile.ZipFile(
+            self.fo,
+            mode=mode,
+            compression=compression,
+            allowZip64=allowZip64,
+            compresslevel=compresslevel,
+        )
+        self.dir_cache = None
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        # zip file paths are always relative to the archive root
+        return super()._strip_protocol(path).lstrip("/")
+
+    def __del__(self):
+        if hasattr(self, "zip"):
+            self.close()
+            del self.zip
+
+    def close(self):
+        """Commits any write changes to the file. Done on ``del`` too."""
+        self.zip.close()
+
+    def _get_dirs(self):
+        if self.dir_cache is None or self.mode in set("wa"):
+            # when writing, dir_cache is always in the ZipFile's attributes,
+            # not read from the file.
+            files = self.zip.infolist()
+            self.dir_cache = {
+                dirname.rstrip("/"): {
+                    "name": dirname.rstrip("/"),
+                    "size": 0,
+                    "type": "directory",
+                }
+                for dirname in self._all_dirnames(self.zip.namelist())
+            }
+            for z in files:
+                f = {s: getattr(z, s, None) for s in zipfile.ZipInfo.__slots__}
+                f.update(
+                    {
+                        "name": z.filename.rstrip("/"),
+                        "size": z.file_size,
+                        "type": ("directory" if z.is_dir() else "file"),
+                    }
+                )
+                self.dir_cache[f["name"]] = f
+
+    def pipe_file(self, path, value, **kwargs):
+        # override upstream, because we know the exact file size in this case
+        self.zip.writestr(path, value, **kwargs)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        if "r" in mode and self.mode in set("wa"):
+            if self.exists(path):
+                raise OSError("ZipFS can only be open for reading or writing, not both")
+            raise FileNotFoundError(path)
+        if "r" in self.mode and "w" in mode:
+            raise OSError("ZipFS can only be open for reading or writing, not both")
+        out = self.zip.open(path, mode.strip("b"))
+        if "r" in mode:
+            info = self.info(path)
+            out.size = info["size"]
+            out.name = info["name"]
+        return out
diff --git a/lib/python3.11/site-packages/fsspec/mapping.py b/lib/python3.11/site-packages/fsspec/mapping.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9822ae1750fe3657aaec608b7434ccc832f86cb
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/mapping.py
@@ -0,0 +1,247 @@
+import array
+import posixpath
+import warnings
+from collections.abc import MutableMapping
+from functools import cached_property
+
+from .core import url_to_fs
+
+
+class FSMap(MutableMapping):
+    """Wrap a FileSystem instance as a mutable wrapping.
+
+    The keys of the mapping become files under the given root, and the
+    values (which must be bytes) the contents of those files.
+
+    Parameters
+    ----------
+    root: string
+        prefix for all the files
+    fs: FileSystem instance
+    check: bool (=True)
+        performs a touch at the location, to check for write access.
+
+    Examples
+    --------
+    >>> fs = FileSystem(**parameters)  # doctest: +SKIP
+    >>> d = FSMap('my-data/path/', fs)  # doctest: +SKIP
+    or, more likely
+    >>> d = fs.get_mapper('my-data/path/')
+
+    >>> d['loc1'] = b'Hello World'  # doctest: +SKIP
+    >>> list(d.keys())  # doctest: +SKIP
+    ['loc1']
+    >>> d['loc1']  # doctest: +SKIP
+    b'Hello World'
+    """
+
+    def __init__(self, root, fs, check=False, create=False, missing_exceptions=None):
+        self.fs = fs
+        self.root = fs._strip_protocol(root).rstrip("/")
+        self._root_key_to_str = fs._strip_protocol(posixpath.join(root, "x"))[:-1]
+        if missing_exceptions is None:
+            missing_exceptions = (
+                FileNotFoundError,
+                IsADirectoryError,
+                NotADirectoryError,
+            )
+        self.missing_exceptions = missing_exceptions
+        self.check = check
+        self.create = create
+        if create:
+            if not self.fs.exists(root):
+                self.fs.mkdir(root)
+        if check:
+            if not self.fs.exists(root):
+                raise ValueError(
+                    f"Path {root} does not exist. Create "
+                    f" with the ``create=True`` keyword"
+                )
+            self.fs.touch(root + "/a")
+            self.fs.rm(root + "/a")
+
+    @cached_property
+    def dirfs(self):
+        """dirfs instance that can be used with the same keys as the mapper"""
+        from .implementations.dirfs import DirFileSystem
+
+        return DirFileSystem(path=self._root_key_to_str, fs=self.fs)
+
+    def clear(self):
+        """Remove all keys below root - empties out mapping"""
+        try:
+            self.fs.rm(self.root, True)
+            self.fs.mkdir(self.root)
+        except:  # noqa: E722
+            pass
+
+    def getitems(self, keys, on_error="raise"):
+        """Fetch multiple items from the store
+
+        If the backend is async-able, this might proceed concurrently
+
+        Parameters
+        ----------
+        keys: list(str)
+            They keys to be fetched
+        on_error : "raise", "omit", "return"
+            If raise, an underlying exception will be raised (converted to KeyError
+            if the type is in self.missing_exceptions); if omit, keys with exception
+            will simply not be included in the output; if "return", all keys are
+            included in the output, but the value will be bytes or an exception
+            instance.
+
+        Returns
+        -------
+        dict(key, bytes|exception)
+        """
+        keys2 = [self._key_to_str(k) for k in keys]
+        oe = on_error if on_error == "raise" else "return"
+        try:
+            out = self.fs.cat(keys2, on_error=oe)
+            if isinstance(out, bytes):
+                out = {keys2[0]: out}
+        except self.missing_exceptions as e:
+            raise KeyError from e
+        out = {
+            k: (KeyError() if isinstance(v, self.missing_exceptions) else v)
+            for k, v in out.items()
+        }
+        return {
+            key: out[k2]
+            for key, k2 in zip(keys, keys2)
+            if on_error == "return" or not isinstance(out[k2], BaseException)
+        }
+
+    def setitems(self, values_dict):
+        """Set the values of multiple items in the store
+
+        Parameters
+        ----------
+        values_dict: dict(str, bytes)
+        """
+        values = {self._key_to_str(k): maybe_convert(v) for k, v in values_dict.items()}
+        self.fs.pipe(values)
+
+    def delitems(self, keys):
+        """Remove multiple keys from the store"""
+        self.fs.rm([self._key_to_str(k) for k in keys])
+
+    def _key_to_str(self, key):
+        """Generate full path for the key"""
+        if not isinstance(key, str):
+            # raise TypeError("key must be of type `str`, got `{type(key).__name__}`"
+            warnings.warn(
+                "from fsspec 2023.5 onward FSMap non-str keys will raise TypeError",
+                DeprecationWarning,
+            )
+            if isinstance(key, list):
+                key = tuple(key)
+            key = str(key)
+        return f"{self._root_key_to_str}{key}"
+
+    def _str_to_key(self, s):
+        """Strip path of to leave key name"""
+        return s[len(self.root) :].lstrip("/")
+
+    def __getitem__(self, key, default=None):
+        """Retrieve data"""
+        k = self._key_to_str(key)
+        try:
+            result = self.fs.cat(k)
+        except self.missing_exceptions:
+            if default is not None:
+                return default
+            raise KeyError(key)
+        return result
+
+    def pop(self, key, default=None):
+        """Pop data"""
+        result = self.__getitem__(key, default)
+        try:
+            del self[key]
+        except KeyError:
+            pass
+        return result
+
+    def __setitem__(self, key, value):
+        """Store value in key"""
+        key = self._key_to_str(key)
+        self.fs.mkdirs(self.fs._parent(key), exist_ok=True)
+        self.fs.pipe_file(key, maybe_convert(value))
+
+    def __iter__(self):
+        return (self._str_to_key(x) for x in self.fs.find(self.root))
+
+    def __len__(self):
+        return len(self.fs.find(self.root))
+
+    def __delitem__(self, key):
+        """Remove key"""
+        try:
+            self.fs.rm(self._key_to_str(key))
+        except:  # noqa: E722
+            raise KeyError
+
+    def __contains__(self, key):
+        """Does key exist in mapping?"""
+        path = self._key_to_str(key)
+        return self.fs.exists(path) and self.fs.isfile(path)
+
+    def __reduce__(self):
+        return FSMap, (self.root, self.fs, False, False, self.missing_exceptions)
+
+
+def maybe_convert(value):
+    if isinstance(value, array.array) or hasattr(value, "__array__"):
+        # bytes-like things
+        if hasattr(value, "dtype") and value.dtype.kind in "Mm":
+            # The buffer interface doesn't support datetime64/timdelta64 numpy
+            # arrays
+            value = value.view("int64")
+        value = bytes(memoryview(value))
+    return value
+
+
+def get_mapper(
+    url="",
+    check=False,
+    create=False,
+    missing_exceptions=None,
+    alternate_root=None,
+    **kwargs,
+):
+    """Create key-value interface for given URL and options
+
+    The URL will be of the form "protocol://location" and point to the root
+    of the mapper required. All keys will be file-names below this location,
+    and their values the contents of each key.
+
+    Also accepts compound URLs like zip::s3://bucket/file.zip , see ``fsspec.open``.
+
+    Parameters
+    ----------
+    url: str
+        Root URL of mapping
+    check: bool
+        Whether to attempt to read from the location before instantiation, to
+        check that the mapping does exist
+    create: bool
+        Whether to make the directory corresponding to the root before
+        instantiating
+    missing_exceptions: None or tuple
+        If given, these exception types will be regarded as missing keys and
+        return KeyError when trying to read data. By default, you get
+        (FileNotFoundError, IsADirectoryError, NotADirectoryError)
+    alternate_root: None or str
+        In cases of complex URLs, the parser may fail to pick the correct part
+        for the mapper root, so this arg can override
+
+    Returns
+    -------
+    ``FSMap`` instance, the dict-like key-value store.
+    """
+    # Removing protocol here - could defer to each open() on the backend
+    fs, urlpath = url_to_fs(url, **kwargs)
+    root = alternate_root if alternate_root is not None else urlpath
+    return FSMap(root, fs, check, create, missing_exceptions=missing_exceptions)
diff --git a/lib/python3.11/site-packages/fsspec/parquet.py b/lib/python3.11/site-packages/fsspec/parquet.py
new file mode 100644
index 0000000000000000000000000000000000000000..af55f8cf48e80ed81ba9abc3bff51915a5daf84c
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/parquet.py
@@ -0,0 +1,551 @@
+import io
+import json
+import warnings
+
+from .core import url_to_fs
+from .utils import merge_offset_ranges
+
+# Parquet-Specific Utilities for fsspec
+#
+# Most of the functions defined in this module are NOT
+# intended for public consumption. The only exception
+# to this is `open_parquet_file`, which should be used
+# place of `fs.open()` to open parquet-formatted files
+# on remote file systems.
+
+
+def open_parquet_file(
+    path,
+    mode="rb",
+    fs=None,
+    metadata=None,
+    columns=None,
+    row_groups=None,
+    storage_options=None,
+    strict=False,
+    engine="auto",
+    max_gap=64_000,
+    max_block=256_000_000,
+    footer_sample_size=1_000_000,
+    **kwargs,
+):
+    """
+    Return a file-like object for a single Parquet file.
+
+    The specified parquet `engine` will be used to parse the
+    footer metadata, and determine the required byte ranges
+    from the file. The target path will then be opened with
+    the "parts" (`KnownPartsOfAFile`) caching strategy.
+
+    Note that this method is intended for usage with remote
+    file systems, and is unlikely to improve parquet-read
+    performance on local file systems.
+
+    Parameters
+    ----------
+    path: str
+        Target file path.
+    mode: str, optional
+        Mode option to be passed through to `fs.open`. Default is "rb".
+    metadata: Any, optional
+        Parquet metadata object. Object type must be supported
+        by the backend parquet engine. For now, only the "fastparquet"
+        engine supports an explicit `ParquetFile` metadata object.
+        If a metadata object is supplied, the remote footer metadata
+        will not need to be transferred into local memory.
+    fs: AbstractFileSystem, optional
+        Filesystem object to use for opening the file. If nothing is
+        specified, an `AbstractFileSystem` object will be inferred.
+    engine : str, default "auto"
+        Parquet engine to use for metadata parsing. Allowed options
+        include "fastparquet", "pyarrow", and "auto". The specified
+        engine must be installed in the current environment. If
+        "auto" is specified, and both engines are installed,
+        "fastparquet" will take precedence over "pyarrow".
+    columns: list, optional
+        List of all column names that may be read from the file.
+    row_groups : list, optional
+        List of all row-groups that may be read from the file. This
+        may be a list of row-group indices (integers), or it may be
+        a list of `RowGroup` metadata objects (if the "fastparquet"
+        engine is used).
+    storage_options : dict, optional
+        Used to generate an `AbstractFileSystem` object if `fs` was
+        not specified.
+    strict : bool, optional
+        Whether the resulting `KnownPartsOfAFile` cache should
+        fetch reads that go beyond a known byte-range boundary.
+        If `False` (the default), any read that ends outside a
+        known part will be zero padded. Note that using
+        `strict=True` may be useful for debugging.
+    max_gap : int, optional
+        Neighboring byte ranges will only be merged when their
+        inter-range gap is <= `max_gap`. Default is 64KB.
+    max_block : int, optional
+        Neighboring byte ranges will only be merged when the size of
+        the aggregated range is <= `max_block`. Default is 256MB.
+    footer_sample_size : int, optional
+        Number of bytes to read from the end of the path to look
+        for the footer metadata. If the sampled bytes do not contain
+        the footer, a second read request will be required, and
+        performance will suffer. Default is 1MB.
+    **kwargs :
+        Optional key-word arguments to pass to `fs.open`
+    """
+
+    # Make sure we have an `AbstractFileSystem` object
+    # to work with
+    if fs is None:
+        fs = url_to_fs(path, **(storage_options or {}))[0]
+
+    # For now, `columns == []` not supported. Just use
+    # default `open` command with `path` input
+    if columns is not None and len(columns) == 0:
+        return fs.open(path, mode=mode)
+
+    # Set the engine
+    engine = _set_engine(engine)
+
+    # Fetch the known byte ranges needed to read
+    # `columns` and/or `row_groups`
+    data = _get_parquet_byte_ranges(
+        [path],
+        fs,
+        metadata=metadata,
+        columns=columns,
+        row_groups=row_groups,
+        engine=engine,
+        max_gap=max_gap,
+        max_block=max_block,
+        footer_sample_size=footer_sample_size,
+    )
+
+    # Extract file name from `data`
+    fn = next(iter(data)) if data else path
+
+    # Call self.open with "parts" caching
+    options = kwargs.pop("cache_options", {}).copy()
+    return fs.open(
+        fn,
+        mode=mode,
+        cache_type="parts",
+        cache_options={
+            **options,
+            **{
+                "data": data.get(fn, {}),
+                "strict": strict,
+            },
+        },
+        **kwargs,
+    )
+
+
+def _get_parquet_byte_ranges(
+    paths,
+    fs,
+    metadata=None,
+    columns=None,
+    row_groups=None,
+    max_gap=64_000,
+    max_block=256_000_000,
+    footer_sample_size=1_000_000,
+    engine="auto",
+):
+    """Get a dictionary of the known byte ranges needed
+    to read a specific column/row-group selection from a
+    Parquet dataset. Each value in the output dictionary
+    is intended for use as the `data` argument for the
+    `KnownPartsOfAFile` caching strategy of a single path.
+    """
+
+    # Set engine if necessary
+    if isinstance(engine, str):
+        engine = _set_engine(engine)
+
+    # Pass to specialized function if metadata is defined
+    if metadata is not None:
+
+        # Use the provided parquet metadata object
+        # to avoid transferring/parsing footer metadata
+        return _get_parquet_byte_ranges_from_metadata(
+            metadata,
+            fs,
+            engine,
+            columns=columns,
+            row_groups=row_groups,
+            max_gap=max_gap,
+            max_block=max_block,
+        )
+
+    # Get file sizes asynchronously
+    file_sizes = fs.sizes(paths)
+
+    # Populate global paths, starts, & ends
+    result = {}
+    data_paths = []
+    data_starts = []
+    data_ends = []
+    add_header_magic = True
+    if columns is None and row_groups is None:
+        # We are NOT selecting specific columns or row-groups.
+        #
+        # We can avoid sampling the footers, and just transfer
+        # all file data with cat_ranges
+        for i, path in enumerate(paths):
+            result[path] = {}
+            for b in range(0, file_sizes[i], max_block):
+                data_paths.append(path)
+                data_starts.append(b)
+                data_ends.append(min(b + max_block, file_sizes[i]))
+        add_header_magic = False  # "Magic" should already be included
+    else:
+        # We ARE selecting specific columns or row-groups.
+        #
+        # Gather file footers.
+        # We just take the last `footer_sample_size` bytes of each
+        # file (or the entire file if it is smaller than that)
+        footer_starts = []
+        footer_ends = []
+        for i, path in enumerate(paths):
+            footer_ends.append(file_sizes[i])
+            sample_size = max(0, file_sizes[i] - footer_sample_size)
+            footer_starts.append(sample_size)
+        footer_samples = fs.cat_ranges(paths, footer_starts, footer_ends)
+
+        # Check our footer samples and re-sample if necessary.
+        missing_footer_starts = footer_starts.copy()
+        large_footer = 0
+        for i, path in enumerate(paths):
+            footer_size = int.from_bytes(footer_samples[i][-8:-4], "little")
+            real_footer_start = file_sizes[i] - (footer_size + 8)
+            if real_footer_start < footer_starts[i]:
+                missing_footer_starts[i] = real_footer_start
+                large_footer = max(large_footer, (footer_size + 8))
+        if large_footer:
+            warnings.warn(
+                f"Not enough data was used to sample the parquet footer. "
+                f"Try setting footer_sample_size >= {large_footer}."
+            )
+            for i, block in enumerate(
+                fs.cat_ranges(
+                    paths,
+                    missing_footer_starts,
+                    footer_starts,
+                )
+            ):
+                footer_samples[i] = block + footer_samples[i]
+                footer_starts[i] = missing_footer_starts[i]
+
+        # Calculate required byte ranges for each path
+        for i, path in enumerate(paths):
+
+            # Deal with small-file case.
+            # Just include all remaining bytes of the file
+            # in a single range.
+            if file_sizes[i] < max_block:
+                if footer_starts[i] > 0:
+                    # Only need to transfer the data if the
+                    # footer sample isn't already the whole file
+                    data_paths.append(path)
+                    data_starts.append(0)
+                    data_ends.append(footer_starts[i])
+                continue
+
+            # Use "engine" to collect data byte ranges
+            path_data_starts, path_data_ends = engine._parquet_byte_ranges(
+                columns,
+                row_groups=row_groups,
+                footer=footer_samples[i],
+                footer_start=footer_starts[i],
+            )
+
+            data_paths += [path] * len(path_data_starts)
+            data_starts += path_data_starts
+            data_ends += path_data_ends
+
+        # Merge adjacent offset ranges
+        data_paths, data_starts, data_ends = merge_offset_ranges(
+            data_paths,
+            data_starts,
+            data_ends,
+            max_gap=max_gap,
+            max_block=max_block,
+            sort=False,  # Should already be sorted
+        )
+
+        # Start by populating `result` with footer samples
+        for i, path in enumerate(paths):
+            result[path] = {(footer_starts[i], footer_ends[i]): footer_samples[i]}
+
+    # Transfer the data byte-ranges into local memory
+    _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
+
+    # Add b"PAR1" to header if necessary
+    if add_header_magic:
+        _add_header_magic(result)
+
+    return result
+
+
+def _get_parquet_byte_ranges_from_metadata(
+    metadata,
+    fs,
+    engine,
+    columns=None,
+    row_groups=None,
+    max_gap=64_000,
+    max_block=256_000_000,
+):
+    """Simplified version of `_get_parquet_byte_ranges` for
+    the case that an engine-specific `metadata` object is
+    provided, and the remote footer metadata does not need to
+    be transferred before calculating the required byte ranges.
+    """
+
+    # Use "engine" to collect data byte ranges
+    data_paths, data_starts, data_ends = engine._parquet_byte_ranges(
+        columns,
+        row_groups=row_groups,
+        metadata=metadata,
+    )
+
+    # Merge adjacent offset ranges
+    data_paths, data_starts, data_ends = merge_offset_ranges(
+        data_paths,
+        data_starts,
+        data_ends,
+        max_gap=max_gap,
+        max_block=max_block,
+        sort=False,  # Should be sorted
+    )
+
+    # Transfer the data byte-ranges into local memory
+    result = {fn: {} for fn in list(set(data_paths))}
+    _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
+
+    # Add b"PAR1" to header
+    _add_header_magic(result)
+
+    return result
+
+
+def _transfer_ranges(fs, blocks, paths, starts, ends):
+    # Use cat_ranges to gather the data byte_ranges
+    ranges = (paths, starts, ends)
+    for path, start, stop, data in zip(*ranges, fs.cat_ranges(*ranges)):
+        blocks[path][(start, stop)] = data
+
+
+def _add_header_magic(data):
+    # Add b"PAR1" to file headers
+    for i, path in enumerate(list(data.keys())):
+        add_magic = True
+        for k in data[path].keys():
+            if k[0] == 0 and k[1] >= 4:
+                add_magic = False
+                break
+        if add_magic:
+            data[path][(0, 4)] = b"PAR1"
+
+
+def _set_engine(engine_str):
+
+    # Define a list of parquet engines to try
+    if engine_str == "auto":
+        try_engines = ("fastparquet", "pyarrow")
+    elif not isinstance(engine_str, str):
+        raise ValueError(
+            "Failed to set parquet engine! "
+            "Please pass 'fastparquet', 'pyarrow', or 'auto'"
+        )
+    elif engine_str not in ("fastparquet", "pyarrow"):
+        raise ValueError(f"{engine_str} engine not supported by `fsspec.parquet`")
+    else:
+        try_engines = [engine_str]
+
+    # Try importing the engines in `try_engines`,
+    # and choose the first one that succeeds
+    for engine in try_engines:
+        try:
+            if engine == "fastparquet":
+                return FastparquetEngine()
+            elif engine == "pyarrow":
+                return PyarrowEngine()
+        except ImportError:
+            pass
+
+    # Raise an error if a supported parquet engine
+    # was not found
+    raise ImportError(
+        f"The following parquet engines are not installed "
+        f"in your python environment: {try_engines}."
+        f"Please install 'fastparquert' or 'pyarrow' to "
+        f"utilize the `fsspec.parquet` module."
+    )
+
+
+class FastparquetEngine:
+
+    # The purpose of the FastparquetEngine class is
+    # to check if fastparquet can be imported (on initialization)
+    # and to define a `_parquet_byte_ranges` method. In the
+    # future, this class may also be used to define other
+    # methods/logic that are specific to fastparquet.
+
+    def __init__(self):
+        import fastparquet as fp
+
+        self.fp = fp
+
+    def _row_group_filename(self, row_group, pf):
+        return pf.row_group_filename(row_group)
+
+    def _parquet_byte_ranges(
+        self,
+        columns,
+        row_groups=None,
+        metadata=None,
+        footer=None,
+        footer_start=None,
+    ):
+
+        # Initialize offset ranges and define ParqetFile metadata
+        pf = metadata
+        data_paths, data_starts, data_ends = [], [], []
+        if pf is None:
+            pf = self.fp.ParquetFile(io.BytesIO(footer))
+
+        # Convert columns to a set and add any index columns
+        # specified in the pandas metadata (just in case)
+        column_set = None if columns is None else set(columns)
+        if column_set is not None and hasattr(pf, "pandas_metadata"):
+            md_index = [
+                ind
+                for ind in pf.pandas_metadata.get("index_columns", [])
+                # Ignore RangeIndex information
+                if not isinstance(ind, dict)
+            ]
+            column_set |= set(md_index)
+
+        # Check if row_groups is a list of integers
+        # or a list of row-group metadata
+        if row_groups and not isinstance(row_groups[0], int):
+            # Input row_groups contains row-group metadata
+            row_group_indices = None
+        else:
+            # Input row_groups contains row-group indices
+            row_group_indices = row_groups
+            row_groups = pf.row_groups
+
+        # Loop through column chunks to add required byte ranges
+        for r, row_group in enumerate(row_groups):
+            # Skip this row-group if we are targeting
+            # specific row-groups
+            if row_group_indices is None or r in row_group_indices:
+
+                # Find the target parquet-file path for `row_group`
+                fn = self._row_group_filename(row_group, pf)
+
+                for column in row_group.columns:
+                    name = column.meta_data.path_in_schema[0]
+                    # Skip this column if we are targeting a
+                    # specific columns
+                    if column_set is None or name in column_set:
+                        file_offset0 = column.meta_data.dictionary_page_offset
+                        if file_offset0 is None:
+                            file_offset0 = column.meta_data.data_page_offset
+                        num_bytes = column.meta_data.total_compressed_size
+                        if footer_start is None or file_offset0 < footer_start:
+                            data_paths.append(fn)
+                            data_starts.append(file_offset0)
+                            data_ends.append(
+                                min(
+                                    file_offset0 + num_bytes,
+                                    footer_start or (file_offset0 + num_bytes),
+                                )
+                            )
+
+        if metadata:
+            # The metadata in this call may map to multiple
+            # file paths. Need to include `data_paths`
+            return data_paths, data_starts, data_ends
+        return data_starts, data_ends
+
+
+class PyarrowEngine:
+
+    # The purpose of the PyarrowEngine class is
+    # to check if pyarrow can be imported (on initialization)
+    # and to define a `_parquet_byte_ranges` method. In the
+    # future, this class may also be used to define other
+    # methods/logic that are specific to pyarrow.
+
+    def __init__(self):
+        import pyarrow.parquet as pq
+
+        self.pq = pq
+
+    def _row_group_filename(self, row_group, metadata):
+        raise NotImplementedError
+
+    def _parquet_byte_ranges(
+        self,
+        columns,
+        row_groups=None,
+        metadata=None,
+        footer=None,
+        footer_start=None,
+    ):
+
+        if metadata is not None:
+            raise ValueError("metadata input not supported for PyarrowEngine")
+
+        data_starts, data_ends = [], []
+        md = self.pq.ParquetFile(io.BytesIO(footer)).metadata
+
+        # Convert columns to a set and add any index columns
+        # specified in the pandas metadata (just in case)
+        column_set = None if columns is None else set(columns)
+        if column_set is not None:
+            schema = md.schema.to_arrow_schema()
+            has_pandas_metadata = (
+                schema.metadata is not None and b"pandas" in schema.metadata
+            )
+            if has_pandas_metadata:
+                md_index = [
+                    ind
+                    for ind in json.loads(
+                        schema.metadata[b"pandas"].decode("utf8")
+                    ).get("index_columns", [])
+                    # Ignore RangeIndex information
+                    if not isinstance(ind, dict)
+                ]
+                column_set |= set(md_index)
+
+        # Loop through column chunks to add required byte ranges
+        for r in range(md.num_row_groups):
+            # Skip this row-group if we are targeting
+            # specific row-groups
+            if row_groups is None or r in row_groups:
+                row_group = md.row_group(r)
+                for c in range(row_group.num_columns):
+                    column = row_group.column(c)
+                    name = column.path_in_schema
+                    # Skip this column if we are targeting a
+                    # specific columns
+                    split_name = name.split(".")[0]
+                    if (
+                        column_set is None
+                        or name in column_set
+                        or split_name in column_set
+                    ):
+                        file_offset0 = column.dictionary_page_offset
+                        if file_offset0 is None:
+                            file_offset0 = column.data_page_offset
+                        num_bytes = column.total_compressed_size
+                        if file_offset0 < footer_start:
+                            data_starts.append(file_offset0)
+                            data_ends.append(
+                                min(file_offset0 + num_bytes, footer_start)
+                            )
+        return data_starts, data_ends
diff --git a/lib/python3.11/site-packages/fsspec/registry.py b/lib/python3.11/site-packages/fsspec/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..db9d3d577e9f9490fdbdc70802b2c9f19ac6c964
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/registry.py
@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+import importlib
+import types
+import warnings
+
+__all__ = ["registry", "get_filesystem_class", "default"]
+
+# internal, mutable
+_registry: dict[str, type] = {}
+
+# external, immutable
+registry = types.MappingProxyType(_registry)
+default = "file"
+
+
+def register_implementation(name, cls, clobber=False, errtxt=None):
+    """Add implementation class to the registry
+
+    Parameters
+    ----------
+    name: str
+        Protocol name to associate with the class
+    cls: class or str
+        if a class: fsspec-compliant implementation class (normally inherits from
+        ``fsspec.AbstractFileSystem``, gets added straight to the registry. If a
+        str, the full path to an implementation class like package.module.class,
+        which gets added to known_implementations,
+        so the import is deferred until the filesystem is actually used.
+    clobber: bool (optional)
+        Whether to overwrite a protocol with the same name; if False, will raise
+        instead.
+    errtxt: str (optional)
+        If given, then a failure to import the given class will result in this
+        text being given.
+    """
+    if isinstance(cls, str):
+        if name in known_implementations and clobber is False:
+            if cls != known_implementations[name]["class"]:
+                raise ValueError(
+                    f"Name ({name}) already in the known_implementations and clobber "
+                    f"is False"
+                )
+        else:
+            known_implementations[name] = {
+                "class": cls,
+                "err": errtxt or f"{cls} import failed for protocol {name}",
+            }
+
+    else:
+        if name in registry and clobber is False:
+            if _registry[name] is not cls:
+                raise ValueError(
+                    f"Name ({name}) already in the registry and clobber is False"
+                )
+        else:
+            _registry[name] = cls
+
+
+# protocols mapped to the class which implements them. This dict can be
+# updated with register_implementation
+known_implementations = {
+    "data": {"class": "fsspec.implementations.data.DataFileSystem"},
+    "file": {"class": "fsspec.implementations.local.LocalFileSystem"},
+    "local": {"class": "fsspec.implementations.local.LocalFileSystem"},
+    "memory": {"class": "fsspec.implementations.memory.MemoryFileSystem"},
+    "dropbox": {
+        "class": "dropboxdrivefs.DropboxDriveFileSystem",
+        "err": (
+            'DropboxFileSystem requires "dropboxdrivefs",'
+            '"requests" and "dropbox" to be installed'
+        ),
+    },
+    "http": {
+        "class": "fsspec.implementations.http.HTTPFileSystem",
+        "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+    },
+    "https": {
+        "class": "fsspec.implementations.http.HTTPFileSystem",
+        "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+    },
+    "zip": {"class": "fsspec.implementations.zip.ZipFileSystem"},
+    "tar": {"class": "fsspec.implementations.tar.TarFileSystem"},
+    "gcs": {
+        "class": "gcsfs.GCSFileSystem",
+        "err": "Please install gcsfs to access Google Storage",
+    },
+    "gs": {
+        "class": "gcsfs.GCSFileSystem",
+        "err": "Please install gcsfs to access Google Storage",
+    },
+    "gdrive": {
+        "class": "gdrivefs.GoogleDriveFileSystem",
+        "err": "Please install gdrivefs for access to Google Drive",
+    },
+    "sftp": {
+        "class": "fsspec.implementations.sftp.SFTPFileSystem",
+        "err": 'SFTPFileSystem requires "paramiko" to be installed',
+    },
+    "ssh": {
+        "class": "fsspec.implementations.sftp.SFTPFileSystem",
+        "err": 'SFTPFileSystem requires "paramiko" to be installed',
+    },
+    "ftp": {"class": "fsspec.implementations.ftp.FTPFileSystem"},
+    "hdfs": {
+        "class": "fsspec.implementations.arrow.HadoopFileSystem",
+        "err": "pyarrow and local java libraries required for HDFS",
+    },
+    "arrow_hdfs": {
+        "class": "fsspec.implementations.arrow.HadoopFileSystem",
+        "err": "pyarrow and local java libraries required for HDFS",
+    },
+    "webhdfs": {
+        "class": "fsspec.implementations.webhdfs.WebHDFS",
+        "err": 'webHDFS access requires "requests" to be installed',
+    },
+    "s3": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+    "s3a": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+    "wandb": {"class": "wandbfs.WandbFS", "err": "Install wandbfs to access wandb"},
+    "oci": {
+        "class": "ocifs.OCIFileSystem",
+        "err": "Install ocifs to access OCI Object Storage",
+    },
+    "ocilake": {
+        "class": "ocifs.OCIFileSystem",
+        "err": "Install ocifs to access OCI Data Lake",
+    },
+    "asynclocal": {
+        "class": "morefs.asyn_local.AsyncLocalFileSystem",
+        "err": "Install 'morefs[asynclocalfs]' to use AsyncLocalFileSystem",
+    },
+    "adl": {
+        "class": "adlfs.AzureDatalakeFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen1",
+    },
+    "abfs": {
+        "class": "adlfs.AzureBlobFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+    },
+    "az": {
+        "class": "adlfs.AzureBlobFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+    },
+    "cached": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+    "blockcache": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+    "filecache": {"class": "fsspec.implementations.cached.WholeFileCacheFileSystem"},
+    "simplecache": {"class": "fsspec.implementations.cached.SimpleCacheFileSystem"},
+    "dask": {
+        "class": "fsspec.implementations.dask.DaskWorkerFileSystem",
+        "err": "Install dask distributed to access worker file system",
+    },
+    "dbfs": {
+        "class": "fsspec.implementations.dbfs.DatabricksFileSystem",
+        "err": "Install the requests package to use the DatabricksFileSystem",
+    },
+    "github": {
+        "class": "fsspec.implementations.github.GithubFileSystem",
+        "err": "Install the requests package to use the github FS",
+    },
+    "git": {
+        "class": "fsspec.implementations.git.GitFileSystem",
+        "err": "Install pygit2 to browse local git repos",
+    },
+    "smb": {
+        "class": "fsspec.implementations.smb.SMBFileSystem",
+        "err": 'SMB requires "smbprotocol" or "smbprotocol[kerberos]" installed',
+    },
+    "jupyter": {
+        "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+        "err": "Jupyter FS requires requests to be installed",
+    },
+    "jlab": {
+        "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+        "err": "Jupyter FS requires requests to be installed",
+    },
+    "libarchive": {
+        "class": "fsspec.implementations.libarchive.LibArchiveFileSystem",
+        "err": "LibArchive requires to be installed",
+    },
+    "reference": {"class": "fsspec.implementations.reference.ReferenceFileSystem"},
+    "generic": {"class": "fsspec.generic.GenericFileSystem"},
+    "oss": {
+        "class": "ossfs.OSSFileSystem",
+        "err": "Install ossfs to access Alibaba Object Storage System",
+    },
+    "webdav": {
+        "class": "webdav4.fsspec.WebdavFileSystem",
+        "err": "Install webdav4 to access WebDAV",
+    },
+    "dvc": {
+        "class": "dvc.api.DVCFileSystem",
+        "err": "Install dvc to access DVCFileSystem",
+    },
+    "hf": {
+        "class": "huggingface_hub.HfFileSystem",
+        "err": "Install huggingface_hub to access HfFileSystem",
+    },
+    "root": {
+        "class": "fsspec_xrootd.XRootDFileSystem",
+        "err": "Install fsspec-xrootd to access xrootd storage system."
+        + " Note: 'root' is the protocol name for xrootd storage systems,"
+        + " not referring to root directories",
+    },
+    "dir": {"class": "fsspec.implementations.dirfs.DirFileSystem"},
+    "box": {
+        "class": "boxfs.BoxFileSystem",
+        "err": "Please install boxfs to access BoxFileSystem",
+    },
+    "lakefs": {
+        "class": "lakefs_spec.LakeFSFileSystem",
+        "err": "Please install lakefs-spec to access LakeFSFileSystem",
+    },
+}
+
+
+def get_filesystem_class(protocol):
+    """Fetch named protocol implementation from the registry
+
+    The dict ``known_implementations`` maps protocol names to the locations
+    of classes implementing the corresponding file-system. When used for the
+    first time, appropriate imports will happen and the class will be placed in
+    the registry. All subsequent calls will fetch directly from the registry.
+
+    Some protocol implementations require additional dependencies, and so the
+    import may fail. In this case, the string in the "err" field of the
+    ``known_implementations`` will be given as the error message.
+    """
+    if not protocol:
+        protocol = default
+
+    if protocol not in registry:
+        if protocol not in known_implementations:
+            raise ValueError(f"Protocol not known: {protocol}")
+        bit = known_implementations[protocol]
+        try:
+            register_implementation(protocol, _import_class(bit["class"]))
+        except ImportError as e:
+            raise ImportError(bit["err"]) from e
+    cls = registry[protocol]
+    if getattr(cls, "protocol", None) in ("abstract", None):
+        cls.protocol = protocol
+
+    return cls
+
+
+s3_msg = """Your installed version of s3fs is very old and known to cause
+severe performance issues, see also https://github.com/dask/dask/issues/10276
+
+To fix, you should specify a lower version bound on s3fs, or
+update the current installation.
+"""
+
+
+def _import_class(cls, minv=None):
+    """Take a string FQP and return the imported class or identifier
+
+    clas is of the form "package.module.klass" or "package.module:subobject.klass"
+    """
+    if ":" in cls:
+        mod, name = cls.rsplit(":", 1)
+        s3 = mod == "s3fs"
+        mod = importlib.import_module(mod)
+        if s3 and mod.__version__.split(".") < ["0", "5"]:
+            warnings.warn(s3_msg)
+        for part in name.split("."):
+            mod = getattr(mod, part)
+        return mod
+    else:
+        mod, name = cls.rsplit(".", 1)
+        s3 = mod == "s3fs"
+        mod = importlib.import_module(mod)
+        if s3 and mod.__version__.split(".") < ["0", "5"]:
+            warnings.warn(s3_msg)
+        return getattr(mod, name)
+
+
+def filesystem(protocol, **storage_options):
+    """Instantiate filesystems for given protocol and arguments
+
+    ``storage_options`` are specific to the protocol being chosen, and are
+    passed directly to the class.
+    """
+    if protocol == "arrow_hdfs":
+        warnings.warn(
+            "The 'arrow_hdfs' protocol has been deprecated and will be "
+            "removed in the future. Specify it as 'hdfs'.",
+            DeprecationWarning,
+        )
+
+    cls = get_filesystem_class(protocol)
+    return cls(**storage_options)
+
+
+def available_protocols():
+    """Return a list of the implemented protocols.
+
+    Note that any given protocol may require extra packages to be importable.
+    """
+    return list(known_implementations)
diff --git a/lib/python3.11/site-packages/fsspec/spec.py b/lib/python3.11/site-packages/fsspec/spec.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bd46686dcfec8c4efb564051d966764c7a2a4fb
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/spec.py
@@ -0,0 +1,1963 @@
+from __future__ import annotations
+
+import io
+import logging
+import os
+import threading
+import warnings
+import weakref
+from errno import ESPIPE
+from glob import has_magic
+from hashlib import sha256
+from typing import ClassVar
+
+from .callbacks import _DEFAULT_CALLBACK
+from .config import apply_config, conf
+from .dircache import DirCache
+from .transaction import Transaction
+from .utils import (
+    _unstrip_protocol,
+    glob_translate,
+    isfilelike,
+    other_paths,
+    read_block,
+    stringify_path,
+    tokenize,
+)
+
+logger = logging.getLogger("fsspec")
+
+
+def make_instance(cls, args, kwargs):
+    return cls(*args, **kwargs)
+
+
+class _Cached(type):
+    """
+    Metaclass for caching file system instances.
+
+    Notes
+    -----
+    Instances are cached according to
+
+    * The values of the class attributes listed in `_extra_tokenize_attributes`
+    * The arguments passed to ``__init__``.
+
+    This creates an additional reference to the filesystem, which prevents the
+    filesystem from being garbage collected when all *user* references go away.
+    A call to the :meth:`AbstractFileSystem.clear_instance_cache` must *also*
+    be made for a filesystem instance to be garbage collected.
+    """
+
+    def __init__(cls, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Note: we intentionally create a reference here, to avoid garbage
+        # collecting instances when all other references are gone. To really
+        # delete a FileSystem, the cache must be cleared.
+        if conf.get("weakref_instance_cache"):  # pragma: no cover
+            # debug option for analysing fork/spawn conditions
+            cls._cache = weakref.WeakValueDictionary()
+        else:
+            cls._cache = {}
+        cls._pid = os.getpid()
+
+    def __call__(cls, *args, **kwargs):
+        kwargs = apply_config(cls, kwargs)
+        extra_tokens = tuple(
+            getattr(cls, attr, None) for attr in cls._extra_tokenize_attributes
+        )
+        token = tokenize(
+            cls, cls._pid, threading.get_ident(), *args, *extra_tokens, **kwargs
+        )
+        skip = kwargs.pop("skip_instance_cache", False)
+        if os.getpid() != cls._pid:
+            cls._cache.clear()
+            cls._pid = os.getpid()
+        if not skip and cls.cachable and token in cls._cache:
+            cls._latest = token
+            return cls._cache[token]
+        else:
+            obj = super().__call__(*args, **kwargs)
+            # Setting _fs_token here causes some static linters to complain.
+            obj._fs_token_ = token
+            obj.storage_args = args
+            obj.storage_options = kwargs
+            if obj.async_impl and obj.mirror_sync_methods:
+                from .asyn import mirror_sync_methods
+
+                mirror_sync_methods(obj)
+
+            if cls.cachable and not skip:
+                cls._latest = token
+                cls._cache[token] = obj
+            return obj
+
+
+class AbstractFileSystem(metaclass=_Cached):
+    """
+    An abstract super-class for pythonic file-systems
+
+    Implementations are expected to be compatible with or, better, subclass
+    from here.
+    """
+
+    cachable = True  # this class can be cached, instances reused
+    _cached = False
+    blocksize = 2**22
+    sep = "/"
+    protocol: ClassVar[str | tuple[str, ...]] = "abstract"
+    _latest = None
+    async_impl = False
+    mirror_sync_methods = False
+    root_marker = ""  # For some FSs, may require leading '/' or other character
+    transaction_type = Transaction
+
+    #: Extra *class attributes* that should be considered when hashing.
+    _extra_tokenize_attributes = ()
+
+    def __init__(self, *args, **storage_options):
+        """Create and configure file-system instance
+
+        Instances may be cachable, so if similar enough arguments are seen
+        a new instance is not required. The token attribute exists to allow
+        implementations to cache instances if they wish.
+
+        A reasonable default should be provided if there are no arguments.
+
+        Subclasses should call this method.
+
+        Parameters
+        ----------
+        use_listings_cache, listings_expiry_time, max_paths:
+            passed to ``DirCache``, if the implementation supports
+            directory listing caching. Pass use_listings_cache=False
+            to disable such caching.
+        skip_instance_cache: bool
+            If this is a cachable implementation, pass True here to force
+            creating a new instance even if a matching instance exists, and prevent
+            storing this instance.
+        asynchronous: bool
+        loop: asyncio-compatible IOLoop or None
+        """
+        if self._cached:
+            # reusing instance, don't change
+            return
+        self._cached = True
+        self._intrans = False
+        self._transaction = None
+        self._invalidated_caches_in_transaction = []
+        self.dircache = DirCache(**storage_options)
+
+        if storage_options.pop("add_docs", None):
+            warnings.warn("add_docs is no longer supported.", FutureWarning)
+
+        if storage_options.pop("add_aliases", None):
+            warnings.warn("add_aliases has been removed.", FutureWarning)
+        # This is set in _Cached
+        self._fs_token_ = None
+
+    @property
+    def fsid(self):
+        """Persistent filesystem id that can be used to compare filesystems
+        across sessions.
+        """
+        raise NotImplementedError
+
+    @property
+    def _fs_token(self):
+        return self._fs_token_
+
+    def __dask_tokenize__(self):
+        return self._fs_token
+
+    def __hash__(self):
+        return int(self._fs_token, 16)
+
+    def __eq__(self, other):
+        return isinstance(other, type(self)) and self._fs_token == other._fs_token
+
+    def __reduce__(self):
+        return make_instance, (type(self), self.storage_args, self.storage_options)
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        """Turn path from fully-qualified to file-system-specific
+
+        May require FS-specific handling, e.g., for relative paths or links.
+        """
+        if isinstance(path, list):
+            return [cls._strip_protocol(p) for p in path]
+        path = stringify_path(path)
+        protos = (cls.protocol,) if isinstance(cls.protocol, str) else cls.protocol
+        for protocol in protos:
+            if path.startswith(protocol + "://"):
+                path = path[len(protocol) + 3 :]
+            elif path.startswith(protocol + "::"):
+                path = path[len(protocol) + 2 :]
+        path = path.rstrip("/")
+        # use of root_marker to make minimum required path, e.g., "/"
+        return path or cls.root_marker
+
+    def unstrip_protocol(self, name: str) -> str:
+        """Format FS-specific path to generic, including protocol"""
+        protos = (self.protocol,) if isinstance(self.protocol, str) else self.protocol
+        for protocol in protos:
+            if name.startswith(f"{protocol}://"):
+                return name
+        return f"{protos[0]}://{name}"
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        """If kwargs can be encoded in the paths, extract them here
+
+        This should happen before instantiation of the class; incoming paths
+        then should be amended to strip the options in methods.
+
+        Examples may look like an sftp path "sftp://user@host:/my/path", where
+        the user and host should become kwargs and later get stripped.
+        """
+        # by default, nothing happens
+        return {}
+
+    @classmethod
+    def current(cls):
+        """Return the most recently instantiated FileSystem
+
+        If no instance has been created, then create one with defaults
+        """
+        if cls._latest in cls._cache:
+            return cls._cache[cls._latest]
+        return cls()
+
+    @property
+    def transaction(self):
+        """A context within which files are committed together upon exit
+
+        Requires the file class to implement `.commit()` and `.discard()`
+        for the normal and exception cases.
+        """
+        if self._transaction is None:
+            self._transaction = self.transaction_type(self)
+        return self._transaction
+
+    def start_transaction(self):
+        """Begin write transaction for deferring files, non-context version"""
+        self._intrans = True
+        self._transaction = self.transaction_type(self)
+        return self.transaction
+
+    def end_transaction(self):
+        """Finish write transaction, non-context version"""
+        self.transaction.complete()
+        self._transaction = None
+        # The invalid cache must be cleared after the transaction is completed.
+        for path in self._invalidated_caches_in_transaction:
+            self.invalidate_cache(path)
+        self._invalidated_caches_in_transaction.clear()
+
+    def invalidate_cache(self, path=None):
+        """
+        Discard any cached directory information
+
+        Parameters
+        ----------
+        path: string or None
+            If None, clear all listings cached else listings at or under given
+            path.
+        """
+        # Not necessary to implement invalidation mechanism, may have no cache.
+        # But if have, you should call this method of parent class from your
+        # subclass to ensure expiring caches after transacations correctly.
+        # See the implementation of FTPFileSystem in ftp.py
+        if self._intrans:
+            self._invalidated_caches_in_transaction.append(path)
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        """
+        Create directory entry at path
+
+        For systems that don't have true directories, may create an for
+        this instance only and not touch the real filesystem
+
+        Parameters
+        ----------
+        path: str
+            location
+        create_parents: bool
+            if True, this is equivalent to ``makedirs``
+        kwargs:
+            may be permissions, etc.
+        """
+        pass  # not necessary to implement, may not have directories
+
+    def makedirs(self, path, exist_ok=False):
+        """Recursively make directories
+
+        Creates directory at path and any intervening required directories.
+        Raises exception if, for instance, the path already exists but is a
+        file.
+
+        Parameters
+        ----------
+        path: str
+            leaf directory name
+        exist_ok: bool (False)
+            If False, will error if the target already exists
+        """
+        pass  # not necessary to implement, may not have directories
+
+    def rmdir(self, path):
+        """Remove a directory, if empty"""
+        pass  # not necessary to implement, may not have directories
+
+    def ls(self, path, detail=True, **kwargs):
+        """List objects at path.
+
+        This should include subdirectories and files at that location. The
+        difference between a file and a directory must be clear when details
+        are requested.
+
+        The specific keys, or perhaps a FileInfo class, or similar, is TBD,
+        but must be consistent across implementations.
+        Must include:
+
+        - full path to the entry (without protocol)
+        - size of the entry, in bytes. If the value cannot be determined, will
+          be ``None``.
+        - type of entry, "file", "directory" or other
+
+        Additional information
+        may be present, appropriate to the file-system, e.g., generation,
+        checksum, etc.
+
+        May use refresh=True|False to allow use of self._ls_from_cache to
+        check for a saved listing and avoid calling the backend. This would be
+        common where listing may be expensive.
+
+        Parameters
+        ----------
+        path: str
+        detail: bool
+            if True, gives a list of dictionaries, where each is the same as
+            the result of ``info(path)``. If False, gives a list of paths
+            (str).
+        kwargs: may have additional backend-specific options, such as version
+            information
+
+        Returns
+        -------
+        List of strings if detail is False, or list of directory information
+        dicts if detail is True.
+        """
+        raise NotImplementedError
+
+    def _ls_from_cache(self, path):
+        """Check cache for listing
+
+        Returns listing, if found (may be empty list for a directly that exists
+        but contains nothing), None if not in cache.
+        """
+        parent = self._parent(path)
+        if path.rstrip("/") in self.dircache:
+            return self.dircache[path.rstrip("/")]
+        try:
+            files = [
+                f
+                for f in self.dircache[parent]
+                if f["name"] == path
+                or (f["name"] == path.rstrip("/") and f["type"] == "directory")
+            ]
+            if len(files) == 0:
+                # parent dir was listed but did not contain this file
+                raise FileNotFoundError(path)
+            return files
+        except KeyError:
+            pass
+
+    def walk(self, path, maxdepth=None, topdown=True, on_error="omit", **kwargs):
+        """Return all files belows path
+
+        List all files, recursing into subdirectories; output is iterator-style,
+        like ``os.walk()``. For a simple list of files, ``find()`` is available.
+
+        When topdown is True, the caller can modify the dirnames list in-place (perhaps
+        using del or slice assignment), and walk() will
+        only recurse into the subdirectories whose names remain in dirnames;
+        this can be used to prune the search, impose a specific order of visiting,
+        or even to inform walk() about directories the caller creates or renames before
+        it resumes walk() again.
+        Modifying dirnames when topdown is False has no effect. (see os.walk)
+
+        Note that the "files" outputted will include anything that is not
+        a directory, such as links.
+
+        Parameters
+        ----------
+        path: str
+            Root to recurse into
+        maxdepth: int
+            Maximum recursion depth. None means limitless, but not recommended
+            on link-based file-systems.
+        topdown: bool (True)
+            Whether to walk the directory tree from the top downwards or from
+            the bottom upwards.
+        on_error: "omit", "raise", a collable
+            if omit (default), path with exception will simply be empty;
+            If raise, an underlying exception will be raised;
+            if callable, it will be called with a single OSError instance as argument
+        kwargs: passed to ``ls``
+        """
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        path = self._strip_protocol(path)
+        full_dirs = {}
+        dirs = {}
+        files = {}
+
+        detail = kwargs.pop("detail", False)
+        try:
+            listing = self.ls(path, detail=True, **kwargs)
+        except (FileNotFoundError, OSError) as e:
+            if on_error == "raise":
+                raise
+            elif callable(on_error):
+                on_error(e)
+            if detail:
+                return path, {}, {}
+            return path, [], []
+
+        for info in listing:
+            # each info name must be at least [path]/part , but here
+            # we check also for names like [path]/part/
+            pathname = info["name"].rstrip("/")
+            name = pathname.rsplit("/", 1)[-1]
+            if info["type"] == "directory" and pathname != path:
+                # do not include "self" path
+                full_dirs[name] = pathname
+                dirs[name] = info
+            elif pathname == path:
+                # file-like with same name as give path
+                files[""] = info
+            else:
+                files[name] = info
+
+        if not detail:
+            dirs = list(dirs)
+            files = list(files)
+
+        if topdown:
+            # Yield before recursion if walking top down
+            yield path, dirs, files
+
+        if maxdepth is not None:
+            maxdepth -= 1
+            if maxdepth < 1:
+                if not topdown:
+                    yield path, dirs, files
+                return
+
+        for d in dirs:
+            yield from self.walk(
+                full_dirs[d],
+                maxdepth=maxdepth,
+                detail=detail,
+                topdown=topdown,
+                **kwargs,
+            )
+
+        if not topdown:
+            # Yield after recursion if walking bottom up
+            yield path, dirs, files
+
+    def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        """List all files below path.
+
+        Like posix ``find`` command without conditions
+
+        Parameters
+        ----------
+        path : str
+        maxdepth: int or None
+            If not None, the maximum number of levels to descend
+        withdirs: bool
+            Whether to include directory paths in the output. This is True
+            when used by glob, but users usually only want files.
+        kwargs are passed to ``ls``.
+        """
+        # TODO: allow equivalent of -name parameter
+        path = self._strip_protocol(path)
+        out = {}
+
+        # Add the root directory if withdirs is requested
+        # This is needed for posix glob compliance
+        if withdirs and path != "" and self.isdir(path):
+            out[path] = self.info(path)
+
+        for _, dirs, files in self.walk(path, maxdepth, detail=True, **kwargs):
+            if withdirs:
+                files.update(dirs)
+            out.update({info["name"]: info for name, info in files.items()})
+        if not out and self.isfile(path):
+            # walk works on directories, but find should also return [path]
+            # when path happens to be a file
+            out[path] = {}
+        names = sorted(out)
+        if not detail:
+            return names
+        else:
+            return {name: out[name] for name in names}
+
+    def du(self, path, total=True, maxdepth=None, withdirs=False, **kwargs):
+        """Space used by files and optionally directories within a path
+
+        Directory size does not include the size of its contents.
+
+        Parameters
+        ----------
+        path: str
+        total: bool
+            Whether to sum all the file sizes
+        maxdepth: int or None
+            Maximum number of directory levels to descend, None for unlimited.
+        withdirs: bool
+            Whether to include directory paths in the output.
+        kwargs: passed to ``find``
+
+        Returns
+        -------
+        Dict of {path: size} if total=False, or int otherwise, where numbers
+        refer to bytes used.
+        """
+        sizes = {}
+        if withdirs and self.isdir(path):
+            # Include top-level directory in output
+            info = self.info(path)
+            sizes[info["name"]] = info["size"]
+        for f in self.find(path, maxdepth=maxdepth, withdirs=withdirs, **kwargs):
+            info = self.info(f)
+            sizes[info["name"]] = info["size"]
+        if total:
+            return sum(sizes.values())
+        else:
+            return sizes
+
+    def glob(self, path, maxdepth=None, **kwargs):
+        """
+        Find files by glob-matching.
+
+        If the path ends with '/', only folders are returned.
+
+        We support ``"**"``,
+        ``"?"`` and ``"[..]"``. We do not support ^ for pattern negation.
+
+        The `maxdepth` option is applied on the first `**` found in the path.
+
+        kwargs are passed to ``ls``.
+        """
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        import re
+
+        seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,)
+        ends_with_sep = path.endswith(seps)  # _strip_protocol strips trailing slash
+        path = self._strip_protocol(path)
+        append_slash_to_dirname = ends_with_sep or path.endswith(
+            tuple(sep + "**" for sep in seps)
+        )
+        idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+        idx_qmark = path.find("?") if path.find("?") >= 0 else len(path)
+        idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+        min_idx = min(idx_star, idx_qmark, idx_brace)
+
+        detail = kwargs.pop("detail", False)
+
+        if not has_magic(path):
+            if self.exists(path, **kwargs):
+                if not detail:
+                    return [path]
+                else:
+                    return {path: self.info(path, **kwargs)}
+            else:
+                if not detail:
+                    return []  # glob of non-existent returns empty
+                else:
+                    return {}
+        elif "/" in path[:min_idx]:
+            min_idx = path[:min_idx].rindex("/")
+            root = path[: min_idx + 1]
+            depth = path[min_idx + 1 :].count("/") + 1
+        else:
+            root = ""
+            depth = path[min_idx + 1 :].count("/") + 1
+
+        if "**" in path:
+            if maxdepth is not None:
+                idx_double_stars = path.find("**")
+                depth_double_stars = path[idx_double_stars:].count("/") + 1
+                depth = depth - depth_double_stars + maxdepth
+            else:
+                depth = None
+
+        allpaths = self.find(root, maxdepth=depth, withdirs=True, detail=True, **kwargs)
+
+        pattern = glob_translate(path + ("/" if ends_with_sep else ""))
+        pattern = re.compile(pattern)
+
+        out = {
+            p: info
+            for p, info in sorted(allpaths.items())
+            if pattern.match(
+                (
+                    p + "/"
+                    if append_slash_to_dirname and info["type"] == "directory"
+                    else p
+                )
+            )
+        }
+
+        if detail:
+            return out
+        else:
+            return list(out)
+
+    def exists(self, path, **kwargs):
+        """Is there a file at the given path"""
+        try:
+            self.info(path, **kwargs)
+            return True
+        except:  # noqa: E722
+            # any exception allowed bar FileNotFoundError?
+            return False
+
+    def lexists(self, path, **kwargs):
+        """If there is a file at the given path (including
+        broken links)"""
+        return self.exists(path)
+
+    def info(self, path, **kwargs):
+        """Give details of entry at path
+
+        Returns a single dictionary, with exactly the same information as ``ls``
+        would with ``detail=True``.
+
+        The default implementation should calls ls and could be overridden by a
+        shortcut. kwargs are passed on to ```ls()``.
+
+        Some file systems might not be able to measure the file's size, in
+        which case, the returned dict will include ``'size': None``.
+
+        Returns
+        -------
+        dict with keys: name (full path in the FS), size (in bytes), type (file,
+        directory, or something else) and other FS-specific keys.
+        """
+        path = self._strip_protocol(path)
+        out = self.ls(self._parent(path), detail=True, **kwargs)
+        out = [o for o in out if o["name"].rstrip("/") == path]
+        if out:
+            return out[0]
+        out = self.ls(path, detail=True, **kwargs)
+        path = path.rstrip("/")
+        out1 = [o for o in out if o["name"].rstrip("/") == path]
+        if len(out1) == 1:
+            if "size" not in out1[0]:
+                out1[0]["size"] = None
+            return out1[0]
+        elif len(out1) > 1 or out:
+            return {"name": path, "size": 0, "type": "directory"}
+        else:
+            raise FileNotFoundError(path)
+
+    def checksum(self, path):
+        """Unique value for current version of file
+
+        If the checksum is the same from one moment to another, the contents
+        are guaranteed to be the same. If the checksum changes, the contents
+        *might* have changed.
+
+        This should normally be overridden; default will probably capture
+        creation/modification timestamp (which would be good) or maybe
+        access timestamp (which would be bad)
+        """
+        return int(tokenize(self.info(path)), 16)
+
+    def size(self, path):
+        """Size in bytes of file"""
+        return self.info(path).get("size", None)
+
+    def sizes(self, paths):
+        """Size in bytes of each file in a list of paths"""
+        return [self.size(p) for p in paths]
+
+    def isdir(self, path):
+        """Is this entry directory-like?"""
+        try:
+            return self.info(path)["type"] == "directory"
+        except OSError:
+            return False
+
+    def isfile(self, path):
+        """Is this entry file-like?"""
+        try:
+            return self.info(path)["type"] == "file"
+        except:  # noqa: E722
+            return False
+
+    def read_text(self, path, encoding=None, errors=None, newline=None, **kwargs):
+        """Get the contents of the file as a string.
+
+        Parameters
+        ----------
+        path: str
+            URL of file on this filesystems
+        encoding, errors, newline: same as `open`.
+        """
+        with self.open(
+            path,
+            mode="r",
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            **kwargs,
+        ) as f:
+            return f.read()
+
+    def write_text(
+        self, path, value, encoding=None, errors=None, newline=None, **kwargs
+    ):
+        """Write the text to the given file.
+
+        An existing file will be overwritten.
+
+        Parameters
+        ----------
+        path: str
+            URL of file on this filesystems
+        value: str
+            Text to write.
+        encoding, errors, newline: same as `open`.
+        """
+        with self.open(
+            path,
+            mode="w",
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            **kwargs,
+        ) as f:
+            return f.write(value)
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        """Get the content of a file
+
+        Parameters
+        ----------
+        path: URL of file on this filesystems
+        start, end: int
+            Bytes limits of the read. If negative, backwards from end,
+            like usual python slices. Either can be None for start or
+            end of file, respectively
+        kwargs: passed to ``open()``.
+        """
+        # explicitly set buffering off?
+        with self.open(path, "rb", **kwargs) as f:
+            if start is not None:
+                if start >= 0:
+                    f.seek(start)
+                else:
+                    f.seek(max(0, f.size + start))
+            if end is not None:
+                if end < 0:
+                    end = f.size + end
+                return f.read(end - f.tell())
+            return f.read()
+
+    def pipe_file(self, path, value, **kwargs):
+        """Set the bytes of given file"""
+        with self.open(path, "wb", **kwargs) as f:
+            f.write(value)
+
+    def pipe(self, path, value=None, **kwargs):
+        """Put value into path
+
+        (counterpart to ``cat``)
+
+        Parameters
+        ----------
+        path: string or dict(str, bytes)
+            If a string, a single remote location to put ``value`` bytes; if a dict,
+            a mapping of {path: bytesvalue}.
+        value: bytes, optional
+            If using a single path, these are the bytes to put there. Ignored if
+            ``path`` is a dict
+        """
+        if isinstance(path, str):
+            self.pipe_file(self._strip_protocol(path), value, **kwargs)
+        elif isinstance(path, dict):
+            for k, v in path.items():
+                self.pipe_file(self._strip_protocol(k), v, **kwargs)
+        else:
+            raise ValueError("path must be str or dict")
+
+    def cat_ranges(
+        self, paths, starts, ends, max_gap=None, on_error="return", **kwargs
+    ):
+        """Get the contents of byte ranges from one or more files
+
+        Parameters
+        ----------
+        paths: list
+            A list of of filepaths on this filesystems
+        starts, ends: int or list
+            Bytes limits of the read. If using a single int, the same value will be
+            used to read all the specified files.
+        """
+        if max_gap is not None:
+            raise NotImplementedError
+        if not isinstance(paths, list):
+            raise TypeError
+        if not isinstance(starts, list):
+            starts = [starts] * len(paths)
+        if not isinstance(ends, list):
+            ends = [ends] * len(paths)
+        if len(starts) != len(paths) or len(ends) != len(paths):
+            raise ValueError
+        out = []
+        for p, s, e in zip(paths, starts, ends):
+            try:
+                out.append(self.cat_file(p, s, e))
+            except Exception as e:
+                if on_error == "return":
+                    out.append(e)
+                else:
+                    raise
+        return out
+
+    def cat(self, path, recursive=False, on_error="raise", **kwargs):
+        """Fetch (potentially multiple) paths' contents
+
+        Parameters
+        ----------
+        recursive: bool
+            If True, assume the path(s) are directories, and get all the
+            contained files
+        on_error : "raise", "omit", "return"
+            If raise, an underlying exception will be raised (converted to KeyError
+            if the type is in self.missing_exceptions); if omit, keys with exception
+            will simply not be included in the output; if "return", all keys are
+            included in the output, but the value will be bytes or an exception
+            instance.
+        kwargs: passed to cat_file
+
+        Returns
+        -------
+        dict of {path: contents} if there are multiple paths
+        or the path has been otherwise expanded
+        """
+        paths = self.expand_path(path, recursive=recursive)
+        if (
+            len(paths) > 1
+            or isinstance(path, list)
+            or paths[0] != self._strip_protocol(path)
+        ):
+            out = {}
+            for path in paths:
+                try:
+                    out[path] = self.cat_file(path, **kwargs)
+                except Exception as e:
+                    if on_error == "raise":
+                        raise
+                    if on_error == "return":
+                        out[path] = e
+            return out
+        else:
+            return self.cat_file(paths[0], **kwargs)
+
+    def get_file(
+        self, rpath, lpath, callback=_DEFAULT_CALLBACK, outfile=None, **kwargs
+    ):
+        """Copy single remote file to local"""
+        from .implementations.local import LocalFileSystem
+
+        if isfilelike(lpath):
+            outfile = lpath
+        elif self.isdir(rpath):
+            os.makedirs(lpath, exist_ok=True)
+            return None
+
+        fs = LocalFileSystem(auto_mkdir=True)
+        fs.makedirs(fs._parent(lpath), exist_ok=True)
+
+        with self.open(rpath, "rb", **kwargs) as f1:
+            if outfile is None:
+                outfile = open(lpath, "wb")
+
+            try:
+                callback.set_size(getattr(f1, "size", None))
+                data = True
+                while data:
+                    data = f1.read(self.blocksize)
+                    segment_len = outfile.write(data)
+                    if segment_len is None:
+                        segment_len = len(data)
+                    callback.relative_update(segment_len)
+            finally:
+                if not isfilelike(lpath):
+                    outfile.close()
+
+    def get(
+        self,
+        rpath,
+        lpath,
+        recursive=False,
+        callback=_DEFAULT_CALLBACK,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) to local.
+
+        Copies a specific file or tree of files (if recursive=True). If lpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within. Can submit a list of paths, which may be glob-patterns
+        and will be expanded.
+
+        Calls get_file for each source.
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            from .implementations.local import (
+                LocalFileSystem,
+                make_path_posix,
+                trailing_sep,
+            )
+
+            source_is_str = isinstance(rpath, str)
+            rpaths = self.expand_path(rpath, recursive=recursive, maxdepth=maxdepth)
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                rpaths = [p for p in rpaths if not (trailing_sep(p) or self.isdir(p))]
+                if not rpaths:
+                    return
+
+            if isinstance(lpath, str):
+                lpath = make_path_posix(lpath)
+
+            source_is_file = len(rpaths) == 1
+            dest_is_dir = isinstance(lpath, str) and (
+                trailing_sep(lpath) or LocalFileSystem().isdir(lpath)
+            )
+
+            exists = source_is_str and (
+                (has_magic(rpath) and source_is_file)
+                or (not has_magic(rpath) and dest_is_dir and not trailing_sep(rpath))
+            )
+            lpaths = other_paths(
+                rpaths,
+                lpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        callback.set_size(len(lpaths))
+        for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
+            callback.branch(rpath, lpath, kwargs)
+            self.get_file(rpath, lpath, **kwargs)
+
+    def put_file(self, lpath, rpath, callback=_DEFAULT_CALLBACK, **kwargs):
+        """Copy single file to remote"""
+        if os.path.isdir(lpath):
+            self.makedirs(rpath, exist_ok=True)
+            return None
+
+        with open(lpath, "rb") as f1:
+            size = f1.seek(0, 2)
+            callback.set_size(size)
+            f1.seek(0)
+
+            self.mkdirs(self._parent(os.fspath(rpath)), exist_ok=True)
+            with self.open(rpath, "wb", **kwargs) as f2:
+                while f1.tell() < size:
+                    data = f1.read(self.blocksize)
+                    segment_len = f2.write(data)
+                    if segment_len is None:
+                        segment_len = len(data)
+                    callback.relative_update(segment_len)
+
+    def put(
+        self,
+        lpath,
+        rpath,
+        recursive=False,
+        callback=_DEFAULT_CALLBACK,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) from local.
+
+        Copies a specific file or tree of files (if recursive=True). If rpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within.
+
+        Calls put_file for each source.
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            from .implementations.local import (
+                LocalFileSystem,
+                make_path_posix,
+                trailing_sep,
+            )
+
+            source_is_str = isinstance(lpath, str)
+            if source_is_str:
+                lpath = make_path_posix(lpath)
+            fs = LocalFileSystem()
+            lpaths = fs.expand_path(lpath, recursive=recursive, maxdepth=maxdepth)
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                lpaths = [p for p in lpaths if not (trailing_sep(p) or fs.isdir(p))]
+                if not lpaths:
+                    return
+
+            source_is_file = len(lpaths) == 1
+            dest_is_dir = isinstance(rpath, str) and (
+                trailing_sep(rpath) or self.isdir(rpath)
+            )
+
+            rpath = (
+                self._strip_protocol(rpath)
+                if isinstance(rpath, str)
+                else [self._strip_protocol(p) for p in rpath]
+            )
+            exists = source_is_str and (
+                (has_magic(lpath) and source_is_file)
+                or (not has_magic(lpath) and dest_is_dir and not trailing_sep(lpath))
+            )
+            rpaths = other_paths(
+                lpaths,
+                rpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        callback.set_size(len(rpaths))
+        for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
+            callback.branch(lpath, rpath, kwargs)
+            self.put_file(lpath, rpath, **kwargs)
+
+    def head(self, path, size=1024):
+        """Get the first ``size`` bytes from file"""
+        with self.open(path, "rb") as f:
+            return f.read(size)
+
+    def tail(self, path, size=1024):
+        """Get the last ``size`` bytes from file"""
+        with self.open(path, "rb") as f:
+            f.seek(max(-size, -f.size), 2)
+            return f.read()
+
+    def cp_file(self, path1, path2, **kwargs):
+        raise NotImplementedError
+
+    def copy(
+        self, path1, path2, recursive=False, maxdepth=None, on_error=None, **kwargs
+    ):
+        """Copy within two locations in the filesystem
+
+        on_error : "raise", "ignore"
+            If raise, any not-found exceptions will be raised; if ignore any
+            not-found exceptions will cause the path to be skipped; defaults to
+            raise unless recursive is true, where the default is ignore
+        """
+        if on_error is None and recursive:
+            on_error = "ignore"
+        elif on_error is None:
+            on_error = "raise"
+
+        if isinstance(path1, list) and isinstance(path2, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            paths1 = path1
+            paths2 = path2
+        else:
+            from .implementations.local import trailing_sep
+
+            source_is_str = isinstance(path1, str)
+            paths1 = self.expand_path(path1, recursive=recursive, maxdepth=maxdepth)
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                paths1 = [p for p in paths1 if not (trailing_sep(p) or self.isdir(p))]
+                if not paths1:
+                    return
+
+            source_is_file = len(paths1) == 1
+            dest_is_dir = isinstance(path2, str) and (
+                trailing_sep(path2) or self.isdir(path2)
+            )
+
+            exists = source_is_str and (
+                (has_magic(path1) and source_is_file)
+                or (not has_magic(path1) and dest_is_dir and not trailing_sep(path1))
+            )
+            paths2 = other_paths(
+                paths1,
+                path2,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        for p1, p2 in zip(paths1, paths2):
+            try:
+                self.cp_file(p1, p2, **kwargs)
+            except FileNotFoundError:
+                if on_error == "raise":
+                    raise
+
+    def expand_path(self, path, recursive=False, maxdepth=None, **kwargs):
+        """Turn one or more globs or directories into a list of all matching paths
+        to files or directories.
+
+        kwargs are passed to ``glob`` or ``find``, which may in turn call ``ls``
+        """
+
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        if isinstance(path, str):
+            out = self.expand_path([path], recursive, maxdepth)
+        else:
+            out = set()
+            path = [self._strip_protocol(p) for p in path]
+            for p in path:
+                if has_magic(p):
+                    bit = set(self.glob(p, maxdepth=maxdepth, **kwargs))
+                    out |= bit
+                    if recursive:
+                        # glob call above expanded one depth so if maxdepth is defined
+                        # then decrement it in expand_path call below. If it is zero
+                        # after decrementing then avoid expand_path call.
+                        if maxdepth is not None and maxdepth <= 1:
+                            continue
+                        out |= set(
+                            self.expand_path(
+                                list(bit),
+                                recursive=recursive,
+                                maxdepth=maxdepth - 1 if maxdepth is not None else None,
+                                **kwargs,
+                            )
+                        )
+                    continue
+                elif recursive:
+                    rec = set(
+                        self.find(
+                            p, maxdepth=maxdepth, withdirs=True, detail=False, **kwargs
+                        )
+                    )
+                    out |= rec
+                if p not in out and (recursive is False or self.exists(p)):
+                    # should only check once, for the root
+                    out.add(p)
+        if not out:
+            raise FileNotFoundError(path)
+        return sorted(out)
+
+    def mv(self, path1, path2, recursive=False, maxdepth=None, **kwargs):
+        """Move file(s) from one location to another"""
+        if path1 == path2:
+            logger.debug("%s mv: The paths are the same, so no files were moved.", self)
+        else:
+            self.copy(path1, path2, recursive=recursive, maxdepth=maxdepth)
+            self.rm(path1, recursive=recursive)
+
+    def rm_file(self, path):
+        """Delete a file"""
+        self._rm(path)
+
+    def _rm(self, path):
+        """Delete one file"""
+        # this is the old name for the method, prefer rm_file
+        raise NotImplementedError
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        """Delete files.
+
+        Parameters
+        ----------
+        path: str or list of str
+            File(s) to delete.
+        recursive: bool
+            If file(s) are directories, recursively delete contents and then
+            also remove the directory
+        maxdepth: int or None
+            Depth to pass to walk for finding files to delete, if recursive.
+            If None, there will be no limit and infinite recursion may be
+            possible.
+        """
+        path = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        for p in reversed(path):
+            self.rm_file(p)
+
+    @classmethod
+    def _parent(cls, path):
+        path = cls._strip_protocol(path)
+        if "/" in path:
+            parent = path.rsplit("/", 1)[0].lstrip(cls.root_marker)
+            return cls.root_marker + parent
+        else:
+            return cls.root_marker
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        """Return raw bytes-mode file-like from the file-system"""
+        return AbstractBufferedFile(
+            self,
+            path,
+            mode,
+            block_size,
+            autocommit,
+            cache_options=cache_options,
+            **kwargs,
+        )
+
+    def open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        cache_options=None,
+        compression=None,
+        **kwargs,
+    ):
+        """
+        Return a file-like object from the filesystem
+
+        The resultant instance must function correctly in a context ``with``
+        block.
+
+        Parameters
+        ----------
+        path: str
+            Target file
+        mode: str like 'rb', 'w'
+            See builtin ``open()``
+        block_size: int
+            Some indication of buffering - this is a value in bytes
+        cache_options : dict, optional
+            Extra arguments to pass through to the cache.
+        compression: string or None
+            If given, open file using compression codec. Can either be a compression
+            name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+            compression from the filename suffix.
+        encoding, errors, newline: passed on to TextIOWrapper for text mode
+        """
+        import io
+
+        path = self._strip_protocol(path)
+        if "b" not in mode:
+            mode = mode.replace("t", "") + "b"
+
+            text_kwargs = {
+                k: kwargs.pop(k)
+                for k in ["encoding", "errors", "newline"]
+                if k in kwargs
+            }
+            return io.TextIOWrapper(
+                self.open(
+                    path,
+                    mode,
+                    block_size=block_size,
+                    cache_options=cache_options,
+                    compression=compression,
+                    **kwargs,
+                ),
+                **text_kwargs,
+            )
+        else:
+            ac = kwargs.pop("autocommit", not self._intrans)
+            f = self._open(
+                path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=ac,
+                cache_options=cache_options,
+                **kwargs,
+            )
+            if compression is not None:
+                from fsspec.compression import compr
+                from fsspec.core import get_compression
+
+                compression = get_compression(path, compression)
+                compress = compr[compression]
+                f = compress(f, mode=mode[0])
+
+            if not ac and "r" not in mode:
+                self.transaction.files.append(f)
+            return f
+
+    def touch(self, path, truncate=True, **kwargs):
+        """Create empty file, or update timestamp
+
+        Parameters
+        ----------
+        path: str
+            file location
+        truncate: bool
+            If True, always set file size to 0; if False, update timestamp and
+            leave file unchanged, if backend allows this
+        """
+        if truncate or not self.exists(path):
+            with self.open(path, "wb", **kwargs):
+                pass
+        else:
+            raise NotImplementedError  # update timestamp, if possible
+
+    def ukey(self, path):
+        """Hash of file properties, to tell if it has changed"""
+        return sha256(str(self.info(path)).encode()).hexdigest()
+
+    def read_block(self, fn, offset, length, delimiter=None):
+        """Read a block of bytes from
+
+        Starting at ``offset`` of the file, read ``length`` bytes.  If
+        ``delimiter`` is set then we ensure that the read starts and stops at
+        delimiter boundaries that follow the locations ``offset`` and ``offset
+        + length``.  If ``offset`` is zero then we start at zero.  The
+        bytestring returned WILL include the end delimiter string.
+
+        If offset+length is beyond the eof, reads to eof.
+
+        Parameters
+        ----------
+        fn: string
+            Path to filename
+        offset: int
+            Byte offset to start read
+        length: int
+            Number of bytes to read. If None, read to end.
+        delimiter: bytes (optional)
+            Ensure reading starts and stops at delimiter bytestring
+
+        Examples
+        --------
+        >>> fs.read_block('data/file.csv', 0, 13)  # doctest: +SKIP
+        b'Alice, 100\\nBo'
+        >>> fs.read_block('data/file.csv', 0, 13, delimiter=b'\\n')  # doctest: +SKIP
+        b'Alice, 100\\nBob, 200\\n'
+
+        Use ``length=None`` to read to the end of the file.
+        >>> fs.read_block('data/file.csv', 0, None, delimiter=b'\\n')  # doctest: +SKIP
+        b'Alice, 100\\nBob, 200\\nCharlie, 300'
+
+        See Also
+        --------
+        :func:`fsspec.utils.read_block`
+        """
+        with self.open(fn, "rb") as f:
+            size = f.size
+            if length is None:
+                length = size
+            if size is not None and offset + length > size:
+                length = size - offset
+            return read_block(f, offset, length, delimiter)
+
+    def to_json(self):
+        """
+        JSON representation of this filesystem instance
+
+        Returns
+        -------
+        str: JSON structure with keys cls (the python location of this class),
+            protocol (text name of this class's protocol, first one in case of
+            multiple), args (positional args, usually empty), and all other
+            kwargs as their own keys.
+        """
+        import json
+
+        cls = type(self)
+        cls = ".".join((cls.__module__, cls.__name__))
+        proto = (
+            self.protocol[0]
+            if isinstance(self.protocol, (tuple, list))
+            else self.protocol
+        )
+        return json.dumps(
+            dict(
+                **{"cls": cls, "protocol": proto, "args": self.storage_args},
+                **self.storage_options,
+            )
+        )
+
+    @staticmethod
+    def from_json(blob):
+        """
+        Recreate a filesystem instance from JSON representation
+
+        See ``.to_json()`` for the expected structure of the input
+
+        Parameters
+        ----------
+        blob: str
+
+        Returns
+        -------
+        file system instance, not necessarily of this particular class.
+        """
+        import json
+
+        from .registry import _import_class, get_filesystem_class
+
+        dic = json.loads(blob)
+        protocol = dic.pop("protocol")
+        try:
+            cls = _import_class(dic.pop("cls"))
+        except (ImportError, ValueError, RuntimeError, KeyError):
+            cls = get_filesystem_class(protocol)
+        return cls(*dic.pop("args", ()), **dic)
+
+    def _get_pyarrow_filesystem(self):
+        """
+        Make a version of the FS instance which will be acceptable to pyarrow
+        """
+        # all instances already also derive from pyarrow
+        return self
+
+    def get_mapper(self, root="", check=False, create=False, missing_exceptions=None):
+        """Create key/value store based on this file-system
+
+        Makes a MutableMapping interface to the FS at the given root path.
+        See ``fsspec.mapping.FSMap`` for further details.
+        """
+        from .mapping import FSMap
+
+        return FSMap(
+            root,
+            self,
+            check=check,
+            create=create,
+            missing_exceptions=missing_exceptions,
+        )
+
+    @classmethod
+    def clear_instance_cache(cls):
+        """
+        Clear the cache of filesystem instances.
+
+        Notes
+        -----
+        Unless overridden by setting the ``cachable`` class attribute to False,
+        the filesystem class stores a reference to newly created instances. This
+        prevents Python's normal rules around garbage collection from working,
+        since the instances refcount will not drop to zero until
+        ``clear_instance_cache`` is called.
+        """
+        cls._cache.clear()
+
+    def created(self, path):
+        """Return the created timestamp of a file as a datetime.datetime"""
+        raise NotImplementedError
+
+    def modified(self, path):
+        """Return the modified timestamp of a file as a datetime.datetime"""
+        raise NotImplementedError
+
+    # ------------------------------------------------------------------------
+    # Aliases
+
+    def read_bytes(self, path, start=None, end=None, **kwargs):
+        """Alias of `AbstractFileSystem.cat_file`."""
+        return self.cat_file(path, start=start, end=end, **kwargs)
+
+    def write_bytes(self, path, value, **kwargs):
+        """Alias of `AbstractFileSystem.pipe_file`."""
+        self.pipe_file(path, value, **kwargs)
+
+    def makedir(self, path, create_parents=True, **kwargs):
+        """Alias of `AbstractFileSystem.mkdir`."""
+        return self.mkdir(path, create_parents=create_parents, **kwargs)
+
+    def mkdirs(self, path, exist_ok=False):
+        """Alias of `AbstractFileSystem.makedirs`."""
+        return self.makedirs(path, exist_ok=exist_ok)
+
+    def listdir(self, path, detail=True, **kwargs):
+        """Alias of `AbstractFileSystem.ls`."""
+        return self.ls(path, detail=detail, **kwargs)
+
+    def cp(self, path1, path2, **kwargs):
+        """Alias of `AbstractFileSystem.copy`."""
+        return self.copy(path1, path2, **kwargs)
+
+    def move(self, path1, path2, **kwargs):
+        """Alias of `AbstractFileSystem.mv`."""
+        return self.mv(path1, path2, **kwargs)
+
+    def stat(self, path, **kwargs):
+        """Alias of `AbstractFileSystem.info`."""
+        return self.info(path, **kwargs)
+
+    def disk_usage(self, path, total=True, maxdepth=None, **kwargs):
+        """Alias of `AbstractFileSystem.du`."""
+        return self.du(path, total=total, maxdepth=maxdepth, **kwargs)
+
+    def rename(self, path1, path2, **kwargs):
+        """Alias of `AbstractFileSystem.mv`."""
+        return self.mv(path1, path2, **kwargs)
+
+    def delete(self, path, recursive=False, maxdepth=None):
+        """Alias of `AbstractFileSystem.rm`."""
+        return self.rm(path, recursive=recursive, maxdepth=maxdepth)
+
+    def upload(self, lpath, rpath, recursive=False, **kwargs):
+        """Alias of `AbstractFileSystem.put`."""
+        return self.put(lpath, rpath, recursive=recursive, **kwargs)
+
+    def download(self, rpath, lpath, recursive=False, **kwargs):
+        """Alias of `AbstractFileSystem.get`."""
+        return self.get(rpath, lpath, recursive=recursive, **kwargs)
+
+    def sign(self, path, expiration=100, **kwargs):
+        """Create a signed URL representing the given path
+
+        Some implementations allow temporary URLs to be generated, as a
+        way of delegating credentials.
+
+        Parameters
+        ----------
+        path : str
+             The path on the filesystem
+        expiration : int
+            Number of seconds to enable the URL for (if supported)
+
+        Returns
+        -------
+        URL : str
+            The signed URL
+
+        Raises
+        ------
+        NotImplementedError : if method is not implemented for a filesystem
+        """
+        raise NotImplementedError("Sign is not implemented for this filesystem")
+
+    def _isfilestore(self):
+        # Originally inherited from pyarrow DaskFileSystem. Keeping this
+        # here for backwards compatibility as long as pyarrow uses its
+        # legacy fsspec-compatible filesystems and thus accepts fsspec
+        # filesystems as well
+        return False
+
+
+class AbstractBufferedFile(io.IOBase):
+    """Convenient class to derive from to provide buffering
+
+    In the case that the backend does not provide a pythonic file-like object
+    already, this class contains much of the logic to build one. The only
+    methods that need to be overridden are ``_upload_chunk``,
+    ``_initiate_upload`` and ``_fetch_range``.
+    """
+
+    DEFAULT_BLOCK_SIZE = 5 * 2**20
+    _details = None
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        block_size="default",
+        autocommit=True,
+        cache_type="readahead",
+        cache_options=None,
+        size=None,
+        **kwargs,
+    ):
+        """
+        Template for files with buffered reading and writing
+
+        Parameters
+        ----------
+        fs: instance of FileSystem
+        path: str
+            location in file-system
+        mode: str
+            Normal file modes. Currently only 'wb', 'ab' or 'rb'. Some file
+            systems may be read-only, and some may not support append.
+        block_size: int
+            Buffer size for reading or writing, 'default' for class default
+        autocommit: bool
+            Whether to write to final destination; may only impact what
+            happens when file is being closed.
+        cache_type: {"readahead", "none", "mmap", "bytes"}, default "readahead"
+            Caching policy in read mode. See the definitions in ``core``.
+        cache_options : dict
+            Additional options passed to the constructor for the cache specified
+            by `cache_type`.
+        size: int
+            If given and in read mode, suppressed having to look up the file size
+        kwargs:
+            Gets stored as self.kwargs
+        """
+        from .core import caches
+
+        self.path = path
+        self.fs = fs
+        self.mode = mode
+        self.blocksize = (
+            self.DEFAULT_BLOCK_SIZE if block_size in ["default", None] else block_size
+        )
+        self.loc = 0
+        self.autocommit = autocommit
+        self.end = None
+        self.start = None
+        self.closed = False
+
+        if cache_options is None:
+            cache_options = {}
+
+        if "trim" in kwargs:
+            warnings.warn(
+                "Passing 'trim' to control the cache behavior has been deprecated. "
+                "Specify it within the 'cache_options' argument instead.",
+                FutureWarning,
+            )
+            cache_options["trim"] = kwargs.pop("trim")
+
+        self.kwargs = kwargs
+
+        if mode not in {"ab", "rb", "wb"}:
+            raise NotImplementedError("File mode not supported")
+        if mode == "rb":
+            if size is not None:
+                self.size = size
+            else:
+                self.size = self.details["size"]
+            self.cache = caches[cache_type](
+                self.blocksize, self._fetch_range, self.size, **cache_options
+            )
+        else:
+            self.buffer = io.BytesIO()
+            self.offset = None
+            self.forced = False
+            self.location = None
+
+    @property
+    def details(self):
+        if self._details is None:
+            self._details = self.fs.info(self.path)
+        return self._details
+
+    @details.setter
+    def details(self, value):
+        self._details = value
+        self.size = value["size"]
+
+    @property
+    def full_name(self):
+        return _unstrip_protocol(self.path, self.fs)
+
+    @property
+    def closed(self):
+        # get around this attr being read-only in IOBase
+        # use getattr here, since this can be called during del
+        return getattr(self, "_closed", True)
+
+    @closed.setter
+    def closed(self, c):
+        self._closed = c
+
+    def __hash__(self):
+        if "w" in self.mode:
+            return id(self)
+        else:
+            return int(tokenize(self.details), 16)
+
+    def __eq__(self, other):
+        """Files are equal if they have the same checksum, only in read mode"""
+        return self.mode == "rb" and other.mode == "rb" and hash(self) == hash(other)
+
+    def commit(self):
+        """Move from temp to final destination"""
+
+    def discard(self):
+        """Throw away temporary file"""
+
+    def info(self):
+        """File information about this path"""
+        if "r" in self.mode:
+            return self.details
+        else:
+            raise ValueError("Info not available while writing")
+
+    def tell(self):
+        """Current file location"""
+        return self.loc
+
+    def seek(self, loc, whence=0):
+        """Set current file location
+
+        Parameters
+        ----------
+        loc: int
+            byte location
+        whence: {0, 1, 2}
+            from start of file, current location or end of file, resp.
+        """
+        loc = int(loc)
+        if not self.mode == "rb":
+            raise OSError(ESPIPE, "Seek only available in read mode")
+        if whence == 0:
+            nloc = loc
+        elif whence == 1:
+            nloc = self.loc + loc
+        elif whence == 2:
+            nloc = self.size + loc
+        else:
+            raise ValueError(f"invalid whence ({whence}, should be 0, 1 or 2)")
+        if nloc < 0:
+            raise ValueError("Seek before start of file")
+        self.loc = nloc
+        return self.loc
+
+    def write(self, data):
+        """
+        Write data to buffer.
+
+        Buffer only sent on flush() or if buffer is greater than
+        or equal to blocksize.
+
+        Parameters
+        ----------
+        data: bytes
+            Set of bytes to be written.
+        """
+        if self.mode not in {"wb", "ab"}:
+            raise ValueError("File not in write mode")
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        if self.forced:
+            raise ValueError("This file has been force-flushed, can only close")
+        out = self.buffer.write(data)
+        self.loc += out
+        if self.buffer.tell() >= self.blocksize:
+            self.flush()
+        return out
+
+    def flush(self, force=False):
+        """
+        Write buffered data to backend store.
+
+        Writes the current buffer, if it is larger than the block-size, or if
+        the file is being closed.
+
+        Parameters
+        ----------
+        force: bool
+            When closing, write the last block even if it is smaller than
+            blocks are allowed to be. Disallows further writing to this file.
+        """
+
+        if self.closed:
+            raise ValueError("Flush on closed file")
+        if force and self.forced:
+            raise ValueError("Force flush cannot be called more than once")
+        if force:
+            self.forced = True
+
+        if self.mode not in {"wb", "ab"}:
+            # no-op to flush on read-mode
+            return
+
+        if not force and self.buffer.tell() < self.blocksize:
+            # Defer write on small block
+            return
+
+        if self.offset is None:
+            # Initialize a multipart upload
+            self.offset = 0
+            try:
+                self._initiate_upload()
+            except:  # noqa: E722
+                self.closed = True
+                raise
+
+        if self._upload_chunk(final=force) is not False:
+            self.offset += self.buffer.seek(0, 2)
+            self.buffer = io.BytesIO()
+
+    def _upload_chunk(self, final=False):
+        """Write one part of a multi-block file upload
+
+        Parameters
+        ==========
+        final: bool
+            This is the last block, so should complete file, if
+            self.autocommit is True.
+        """
+        # may not yet have been initialized, may need to call _initialize_upload
+
+    def _initiate_upload(self):
+        """Create remote file/upload"""
+        pass
+
+    def _fetch_range(self, start, end):
+        """Get the specified set of bytes from remote"""
+        raise NotImplementedError
+
+    def read(self, length=-1):
+        """
+        Return data from cache, or fetch pieces as necessary
+
+        Parameters
+        ----------
+        length: int (-1)
+            Number of bytes to read; if <0, all remaining bytes.
+        """
+        length = -1 if length is None else int(length)
+        if self.mode != "rb":
+            raise ValueError("File not in read mode")
+        if length < 0:
+            length = self.size - self.loc
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        logger.debug("%s read: %i - %i", self, self.loc, self.loc + length)
+        if length == 0:
+            # don't even bother calling fetch
+            return b""
+        out = self.cache._fetch(self.loc, self.loc + length)
+        self.loc += len(out)
+        return out
+
+    def readinto(self, b):
+        """mirrors builtin file's readinto method
+
+        https://docs.python.org/3/library/io.html#io.RawIOBase.readinto
+        """
+        out = memoryview(b).cast("B")
+        data = self.read(out.nbytes)
+        out[: len(data)] = data
+        return len(data)
+
+    def readuntil(self, char=b"\n", blocks=None):
+        """Return data between current position and first occurrence of char
+
+        char is included in the output, except if the end of the tile is
+        encountered first.
+
+        Parameters
+        ----------
+        char: bytes
+            Thing to find
+        blocks: None or int
+            How much to read in each go. Defaults to file blocksize - which may
+            mean a new read on every call.
+        """
+        out = []
+        while True:
+            start = self.tell()
+            part = self.read(blocks or self.blocksize)
+            if len(part) == 0:
+                break
+            found = part.find(char)
+            if found > -1:
+                out.append(part[: found + len(char)])
+                self.seek(start + found + len(char))
+                break
+            out.append(part)
+        return b"".join(out)
+
+    def readline(self):
+        """Read until first occurrence of newline character
+
+        Note that, because of character encoding, this is not necessarily a
+        true line ending.
+        """
+        return self.readuntil(b"\n")
+
+    def __next__(self):
+        out = self.readline()
+        if out:
+            return out
+        raise StopIteration
+
+    def __iter__(self):
+        return self
+
+    def readlines(self):
+        """Return all data, split by the newline character"""
+        data = self.read()
+        lines = data.split(b"\n")
+        out = [l + b"\n" for l in lines[:-1]]
+        if data.endswith(b"\n"):
+            return out
+        else:
+            return out + [lines[-1]]
+        # return list(self)  ???
+
+    def readinto1(self, b):
+        return self.readinto(b)
+
+    def close(self):
+        """Close file
+
+        Finalizes writes, discards cache
+        """
+        if getattr(self, "_unclosable", False):
+            return
+        if self.closed:
+            return
+        if self.mode == "rb":
+            self.cache = None
+        else:
+            if not self.forced:
+                self.flush(force=True)
+
+            if self.fs is not None:
+                self.fs.invalidate_cache(self.path)
+                self.fs.invalidate_cache(self.fs._parent(self.path))
+
+        self.closed = True
+
+    def readable(self):
+        """Whether opened for reading"""
+        return self.mode == "rb" and not self.closed
+
+    def seekable(self):
+        """Whether is seekable (only in read mode)"""
+        return self.readable()
+
+    def writable(self):
+        """Whether opened for writing"""
+        return self.mode in {"wb", "ab"} and not self.closed
+
+    def __del__(self):
+        if not self.closed:
+            self.close()
+
+    def __str__(self):
+        return f"<File-like object {type(self.fs).__name__}, {self.path}>"
+
+    __repr__ = __str__
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/__init__.py b/lib/python3.11/site-packages/fsspec/tests/abstract/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..45d081921ad29104bedd336dbf04fa86e1e48b7a
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/tests/abstract/__init__.py
@@ -0,0 +1,287 @@
+import os
+from hashlib import md5
+
+import pytest
+
+from fsspec.implementations.local import LocalFileSystem
+from fsspec.tests.abstract.copy import AbstractCopyTests  # noqa
+from fsspec.tests.abstract.get import AbstractGetTests  # noqa
+from fsspec.tests.abstract.put import AbstractPutTests  # noqa
+
+
+class BaseAbstractFixtures:
+    """
+    Abstract base class containing fixtures that are used by but never need to
+    be overridden in derived filesystem-specific classes to run the abstract
+    tests on such filesystems.
+    """
+
+    @pytest.fixture
+    def fs_bulk_operations_scenario_0(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used for many cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._bulk_operations_scenario_0(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_glob_edge_cases_files(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used for glob edge cases cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._glob_edge_cases_files(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_dir_and_file_with_same_name_prefix(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used to check cp/get/put on directory
+        and file with the same name prefixes.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._dir_and_file_with_same_name_prefix(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_10_files_with_hashed_names(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used to check cp/get/put files order
+        when source and destination are lists.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._10_files_with_hashed_names(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_target(self, fs, fs_join, fs_path):
+        """
+        Return name of remote directory that does not yet exist to copy into.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        target = fs_join(fs_path, "target")
+        yield target
+        if fs.exists(target):
+            fs.rm(target, recursive=True)
+
+    @pytest.fixture
+    def local_bulk_operations_scenario_0(self, local_fs, local_join, local_path):
+        """
+        Scenario on local filesystem that is used for many cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._bulk_operations_scenario_0(local_fs, local_join, local_path)
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_glob_edge_cases_files(self, local_fs, local_join, local_path):
+        """
+        Scenario on local filesystem that is used for glob edge cases cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._glob_edge_cases_files(local_fs, local_join, local_path)
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_dir_and_file_with_same_name_prefix(
+        self, local_fs, local_join, local_path
+    ):
+        """
+        Scenario on local filesystem that is used to check cp/get/put on directory
+        and file with the same name prefixes.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._dir_and_file_with_same_name_prefix(
+            local_fs, local_join, local_path
+        )
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_10_files_with_hashed_names(self, local_fs, local_join, local_path):
+        """
+        Scenario on local filesystem that is used to check cp/get/put files order
+        when source and destination are lists.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._10_files_with_hashed_names(local_fs, local_join, local_path)
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_target(self, local_fs, local_join, local_path):
+        """
+        Return name of local directory that does not yet exist to copy into.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        target = local_join(local_path, "target")
+        yield target
+        if local_fs.exists(target):
+            local_fs.rm(target, recursive=True)
+
+    def _glob_edge_cases_files(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used for glob edge cases cp/get/put tests.
+        Creates the following directory and file structure:
+
+        📁 source
+        ├── 📄 file1
+        ├── 📄 file2
+        ├── 📁 subdir0
+        │   ├── 📄 subfile1
+        │   ├── 📄 subfile2
+        │   └── 📁 nesteddir
+        │       └── 📄 nestedfile
+        └── 📁 subdir1
+            ├── 📄 subfile1
+            ├── 📄 subfile2
+            └── 📁 nesteddir
+                └── 📄 nestedfile
+        """
+        source = some_join(some_path, "source")
+        some_fs.touch(some_join(source, "file1"))
+        some_fs.touch(some_join(source, "file2"))
+
+        for subdir_idx in range(2):
+            subdir = some_join(source, f"subdir{subdir_idx}")
+            nesteddir = some_join(subdir, "nesteddir")
+            some_fs.makedirs(nesteddir)
+            some_fs.touch(some_join(subdir, "subfile1"))
+            some_fs.touch(some_join(subdir, "subfile2"))
+            some_fs.touch(some_join(nesteddir, "nestedfile"))
+
+        return source
+
+    def _bulk_operations_scenario_0(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used for many cp/get/put tests. Creates the following
+        directory and file structure:
+
+        📁 source
+        ├── 📄 file1
+        ├── 📄 file2
+        └── 📁 subdir
+            ├── 📄 subfile1
+            ├── 📄 subfile2
+            └── 📁 nesteddir
+                └── 📄 nestedfile
+        """
+        source = some_join(some_path, "source")
+        subdir = some_join(source, "subdir")
+        nesteddir = some_join(subdir, "nesteddir")
+        some_fs.makedirs(nesteddir)
+        some_fs.touch(some_join(source, "file1"))
+        some_fs.touch(some_join(source, "file2"))
+        some_fs.touch(some_join(subdir, "subfile1"))
+        some_fs.touch(some_join(subdir, "subfile2"))
+        some_fs.touch(some_join(nesteddir, "nestedfile"))
+        return source
+
+    def _dir_and_file_with_same_name_prefix(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used to check cp/get/put on directory and file with
+        the same name prefixes. Creates the following directory and file structure:
+
+        📁 source
+        ├── 📄 subdir.txt
+        └── 📁 subdir
+            └── 📄 subfile.txt
+        """
+        source = some_join(some_path, "source")
+        subdir = some_join(source, "subdir")
+        file = some_join(source, "subdir.txt")
+        subfile = some_join(subdir, "subfile.txt")
+        some_fs.makedirs(subdir)
+        some_fs.touch(file)
+        some_fs.touch(subfile)
+        return source
+
+    def _10_files_with_hashed_names(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used to check cp/get/put files order when source and
+        destination are lists. Creates the following directory and file structure:
+
+        📁 source
+        └── 📄 {hashed([0-9])}.txt
+        """
+        source = some_join(some_path, "source")
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            path = some_join(source, f"{hashed_i}.txt")
+            some_fs.pipe(path=path, value=f"{i}".encode("utf-8"))
+        return source
+
+
+class AbstractFixtures(BaseAbstractFixtures):
+    """
+    Abstract base class containing fixtures that may be overridden in derived
+    filesystem-specific classes to run the abstract tests on such filesystems.
+
+    For any particular filesystem some of these fixtures must be overridden,
+    such as ``fs`` and ``fs_path``, and others may be overridden if the
+    default functions here are not appropriate, such as ``fs_join``.
+    """
+
+    @pytest.fixture
+    def fs(self):
+        raise NotImplementedError("This function must be overridden in derived classes")
+
+    @pytest.fixture
+    def fs_join(self):
+        """
+        Return a function that joins its arguments together into a path.
+
+        Most fsspec implementations join paths in a platform-dependent way,
+        but some will override this to always use a forward slash.
+        """
+        return os.path.join
+
+    @pytest.fixture
+    def fs_path(self):
+        raise NotImplementedError("This function must be overridden in derived classes")
+
+    @pytest.fixture(scope="class")
+    def local_fs(self):
+        # Maybe need an option for auto_mkdir=False?  This is only relevant
+        # for certain implementations.
+        return LocalFileSystem(auto_mkdir=True)
+
+    @pytest.fixture
+    def local_join(self):
+        """
+        Return a function that joins its arguments together into a path, on
+        the local filesystem.
+        """
+        return os.path.join
+
+    @pytest.fixture
+    def local_path(self, tmpdir):
+        return tmpdir
+
+    @pytest.fixture
+    def supports_empty_directories(self):
+        """
+        Return whether this implementation supports empty directories.
+        """
+        return True
+
+    @pytest.fixture
+    def fs_sanitize_path(self):
+        return lambda x: x
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff09bef91abf838c5abf84f200e96e1e9b41694e
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/common.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/common.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..215052f725bb65fc189331ec5db3051a2c2d7e09
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/common.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e04cba1e3fb8fa0f8719e62ac2eef6125fbe1be7
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/get.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/get.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d01b268128e965941686cc618c69eccecd31e8cf
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/get.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/put.cpython-311.pyc b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/put.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..70109dbc9c5e878e15e08217f99ab97a3574965d
Binary files /dev/null and b/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/put.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/common.py b/lib/python3.11/site-packages/fsspec/tests/abstract/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..22e7c4140404ab2a8928689721419cf05c2760b9
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/tests/abstract/common.py
@@ -0,0 +1,175 @@
+GLOB_EDGE_CASES_TESTS = {
+    "argnames": ("path", "recursive", "maxdepth", "expected"),
+    "argvalues": [
+        ("fil?1", False, None, ["file1"]),
+        ("fil?1", True, None, ["file1"]),
+        ("file[1-2]", False, None, ["file1", "file2"]),
+        ("file[1-2]", True, None, ["file1", "file2"]),
+        ("*", False, None, ["file1", "file2"]),
+        (
+            "*",
+            True,
+            None,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("*", True, 1, ["file1", "file2"]),
+        (
+            "*",
+            True,
+            2,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+        ("*1", False, None, ["file1"]),
+        (
+            "*1",
+            True,
+            None,
+            [
+                "file1",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("*1", True, 2, ["file1", "subdir1/subfile1", "subdir1/subfile2"]),
+        (
+            "**",
+            False,
+            None,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        (
+            "**",
+            True,
+            None,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("**", True, 1, ["file1", "file2"]),
+        (
+            "**",
+            True,
+            2,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        (
+            "**",
+            False,
+            2,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+        ("**/*1", False, None, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
+        (
+            "**/*1",
+            True,
+            None,
+            [
+                "file1",
+                "subdir0/subfile1",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("**/*1", True, 1, ["file1"]),
+        (
+            "**/*1",
+            True,
+            2,
+            ["file1", "subdir0/subfile1", "subdir1/subfile1", "subdir1/subfile2"],
+        ),
+        ("**/*1", False, 2, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
+        ("**/subdir0", False, None, []),
+        ("**/subdir0", True, None, ["subfile1", "subfile2", "nesteddir/nestedfile"]),
+        ("**/subdir0/nested*", False, 2, []),
+        ("**/subdir0/nested*", True, 2, ["nestedfile"]),
+        ("subdir[1-2]", False, None, []),
+        ("subdir[1-2]", True, None, ["subfile1", "subfile2", "nesteddir/nestedfile"]),
+        ("subdir[1-2]", True, 2, ["subfile1", "subfile2"]),
+        ("subdir[0-1]", False, None, []),
+        (
+            "subdir[0-1]",
+            True,
+            None,
+            [
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        (
+            "subdir[0-1]/*fil[e]*",
+            False,
+            None,
+            [
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+        (
+            "subdir[0-1]/*fil[e]*",
+            True,
+            None,
+            [
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+    ],
+}
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/copy.py b/lib/python3.11/site-packages/fsspec/tests/abstract/copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..01ff09c95e7d81b3aa3a58436f795b4d47b6889a
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/tests/abstract/copy.py
@@ -0,0 +1,543 @@
+from hashlib import md5
+from itertools import product
+
+import pytest
+
+from fsspec.tests.abstract.common import GLOB_EDGE_CASES_TESTS
+
+
+class AbstractCopyTests:
+    def test_copy_file_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1a
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        target_file2 = fs_join(target, "file2")
+        target_subfile1 = fs_join(target, "subfile1")
+
+        # Copy from source directory
+        fs.cp(fs_join(source, "file2"), target)
+        assert fs.isfile(target_file2)
+
+        # Copy from sub directory
+        fs.cp(fs_join(source, "subdir", "subfile1"), target)
+        assert fs.isfile(target_subfile1)
+
+        # Remove copied files
+        fs.rm([target_file2, target_subfile1])
+        assert not fs.exists(target_file2)
+        assert not fs.exists(target_subfile1)
+
+        # Repeat with trailing slash on target
+        fs.cp(fs_join(source, "file2"), target + "/")
+        assert fs.isdir(target)
+        assert fs.isfile(target_file2)
+
+        fs.cp(fs_join(source, "subdir", "subfile1"), target + "/")
+        assert fs.isfile(target_subfile1)
+
+    def test_copy_file_to_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 1b
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.cp(
+            fs_join(source, "subdir", "subfile1"), fs_join(target, "newdir/")
+        )  # Note trailing slash
+        assert fs.isdir(target)
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_copy_file_to_file_in_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1c
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        fs.cp(fs_join(source, "subdir", "subfile1"), fs_join(target, "newfile"))
+        assert fs.isfile(fs_join(target, "newfile"))
+
+    def test_copy_file_to_file_in_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 1d
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.cp(
+            fs_join(source, "subdir", "subfile1"), fs_join(target, "newdir", "newfile")
+        )
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "newfile"))
+
+    def test_copy_directory_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1e
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = target + "/" if target_slash else target
+
+            # Without recursive does nothing
+            fs.cp(s, t)
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+            # With recursive
+            fs.cp(s, t, recursive=True)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "subdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+            # Limit recursive by maxdepth
+            fs.cp(s, t, recursive=True, maxdepth=1)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+    def test_copy_directory_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1f
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive does nothing
+            fs.cp(s, t)
+            if supports_empty_directories:
+                assert fs.ls(target) == []
+            else:
+                with pytest.raises(FileNotFoundError):
+                    fs.ls(target)
+
+            # With recursive
+            fs.cp(s, t, recursive=True)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+            assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # Limit recursive by maxdepth
+            fs.cp(s, t, recursive=True, maxdepth=1)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+    def test_copy_glob_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1g
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            # Without recursive
+            fs.cp(fs_join(source, "subdir", "*"), t)
+            assert fs.isfile(fs_join(target, "subfile1"))
+            assert fs.isfile(fs_join(target, "subfile2"))
+            assert not fs.isdir(fs_join(target, "nesteddir"))
+            assert not fs.exists(fs_join(target, "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(
+                [
+                    fs_join(target, "subfile1"),
+                    fs_join(target, "subfile2"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.cp(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+                # Limit recursive by maxdepth
+                fs.cp(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+    def test_copy_glob_to_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 1h
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive
+            fs.cp(fs_join(source, "subdir", "*"), t)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+            assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.cp(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+                # Limit recursive by maxdepth
+                fs.cp(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+    @pytest.mark.parametrize(
+        GLOB_EDGE_CASES_TESTS["argnames"],
+        GLOB_EDGE_CASES_TESTS["argvalues"],
+    )
+    def test_copy_glob_edge_cases(
+        self,
+        path,
+        recursive,
+        maxdepth,
+        expected,
+        fs,
+        fs_join,
+        fs_glob_edge_cases_files,
+        fs_target,
+        fs_sanitize_path,
+    ):
+        # Copy scenario 1g
+        source = fs_glob_edge_cases_files
+
+        target = fs_target
+
+        for new_dir, target_slash in product([True, False], [True, False]):
+            fs.mkdir(target)
+
+            t = fs_join(target, "newdir") if new_dir else target
+            t = t + "/" if target_slash else t
+
+            fs.copy(fs_join(source, path), t, recursive=recursive, maxdepth=maxdepth)
+
+            output = fs.find(target)
+            if new_dir:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, "newdir", p)) for p in expected
+                ]
+            else:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, p)) for p in expected
+                ]
+            assert sorted(output) == sorted(prefixed_expected)
+
+            try:
+                fs.rm(target, recursive=True)
+            except FileNotFoundError:
+                pass
+
+    def test_copy_list_of_files_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 2a
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            fs.cp(source_files, t)
+            assert fs.isfile(fs_join(target, "file1"))
+            assert fs.isfile(fs_join(target, "file2"))
+            assert fs.isfile(fs_join(target, "subfile1"))
+
+            fs.rm(
+                [
+                    fs_join(target, "file1"),
+                    fs_join(target, "file2"),
+                    fs_join(target, "subfile1"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+    def test_copy_list_of_files_to_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 2b
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        fs.cp(source_files, fs_join(target, "newdir") + "/")  # Note trailing slash
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "file1"))
+        assert fs.isfile(fs_join(target, "newdir", "file2"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_copy_two_files_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # This is a duplicate of test_copy_list_of_files_to_new_directory and
+        # can eventually be removed.
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        assert not fs.exists(target)
+        fs.cp([fs_join(source, "file1"), fs_join(source, "file2")], target)
+
+        assert fs.isdir(target)
+        assert fs.isfile(fs_join(target, "file1"))
+        assert fs.isfile(fs_join(target, "file2"))
+
+    def test_copy_directory_without_files_with_same_name_prefix(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        fs_dir_and_file_with_same_name_prefix,
+        supports_empty_directories,
+    ):
+        # Create the test dirs
+        source = fs_dir_and_file_with_same_name_prefix
+        target = fs_target
+
+        # Test without glob
+        fs.cp(fs_join(source, "subdir"), target, recursive=True)
+
+        assert fs.isfile(fs_join(target, "subfile.txt"))
+        assert not fs.isfile(fs_join(target, "subdir.txt"))
+
+        fs.rm([fs_join(target, "subfile.txt")])
+        if supports_empty_directories:
+            assert fs.ls(target) == []
+        else:
+            assert not fs.exists(target)
+
+        # Test with glob
+        fs.cp(fs_join(source, "subdir*"), target, recursive=True)
+
+        assert fs.isdir(fs_join(target, "subdir"))
+        assert fs.isfile(fs_join(target, "subdir", "subfile.txt"))
+        assert fs.isfile(fs_join(target, "subdir.txt"))
+
+    def test_copy_with_source_and_destination_as_list(
+        self, fs, fs_target, fs_join, fs_10_files_with_hashed_names
+    ):
+        # Create the test dir
+        source = fs_10_files_with_hashed_names
+        target = fs_target
+
+        # Create list of files for source and destination
+        source_files = []
+        destination_files = []
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            source_files.append(fs_join(source, f"{hashed_i}.txt"))
+            destination_files.append(fs_join(target, f"{hashed_i}.txt"))
+
+        # Copy and assert order was kept
+        fs.copy(path1=source_files, path2=destination_files)
+
+        for i in range(10):
+            file_content = fs.cat(destination_files[i]).decode("utf-8")
+            assert file_content == str(i)
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/get.py b/lib/python3.11/site-packages/fsspec/tests/abstract/get.py
new file mode 100644
index 0000000000000000000000000000000000000000..851ab81ee581e74cac41c64c83ef0af75826d6b0
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/tests/abstract/get.py
@@ -0,0 +1,587 @@
+from hashlib import md5
+from itertools import product
+
+import pytest
+
+from fsspec.implementations.local import make_path_posix
+from fsspec.tests.abstract.common import GLOB_EDGE_CASES_TESTS
+
+
+class AbstractGetTests:
+    def test_get_file_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1a
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+        assert local_fs.isdir(target)
+
+        target_file2 = local_join(target, "file2")
+        target_subfile1 = local_join(target, "subfile1")
+
+        # Copy from source directory
+        fs.get(fs_join(source, "file2"), target)
+        assert local_fs.isfile(target_file2)
+
+        # Copy from sub directory
+        fs.get(fs_join(source, "subdir", "subfile1"), target)
+        assert local_fs.isfile(target_subfile1)
+
+        # Remove copied files
+        local_fs.rm([target_file2, target_subfile1])
+        assert not local_fs.exists(target_file2)
+        assert not local_fs.exists(target_subfile1)
+
+        # Repeat with trailing slash on target
+        fs.get(fs_join(source, "file2"), target + "/")
+        assert local_fs.isdir(target)
+        assert local_fs.isfile(target_file2)
+
+        fs.get(fs_join(source, "subdir", "subfile1"), target + "/")
+        assert local_fs.isfile(target_subfile1)
+
+    def test_get_file_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1b
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        fs.get(
+            fs_join(source, "subdir", "subfile1"), local_join(target, "newdir/")
+        )  # Note trailing slash
+
+        assert local_fs.isdir(target)
+        assert local_fs.isdir(local_join(target, "newdir"))
+        assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+
+    def test_get_file_to_file_in_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1c
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        fs.get(fs_join(source, "subdir", "subfile1"), local_join(target, "newfile"))
+        assert local_fs.isfile(local_join(target, "newfile"))
+
+    def test_get_file_to_file_in_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1d
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        fs.get(
+            fs_join(source, "subdir", "subfile1"),
+            local_join(target, "newdir", "newfile"),
+        )
+        assert local_fs.isdir(local_join(target, "newdir"))
+        assert local_fs.isfile(local_join(target, "newdir", "newfile"))
+
+    def test_get_directory_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1e
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+        assert local_fs.isdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = target + "/" if target_slash else target
+
+            # Without recursive does nothing
+            fs.get(s, t)
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            fs.get(s, t, recursive=True)
+            if source_slash:
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert local_fs.isdir(local_join(target, "nesteddir"))
+                assert local_fs.isfile(local_join(target, "nesteddir", "nestedfile"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                        local_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert local_fs.isdir(local_join(target, "subdir"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile2"))
+                assert local_fs.isdir(local_join(target, "subdir", "nesteddir"))
+                assert local_fs.isfile(
+                    local_join(target, "subdir", "nesteddir", "nestedfile")
+                )
+
+                local_fs.rm(local_join(target, "subdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+            # Limit recursive by maxdepth
+            fs.get(s, t, recursive=True, maxdepth=1)
+            if source_slash:
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert not local_fs.exists(local_join(target, "nesteddir"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert local_fs.isdir(local_join(target, "subdir"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile2"))
+                assert not local_fs.exists(local_join(target, "subdir", "nesteddir"))
+
+                local_fs.rm(local_join(target, "subdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+    def test_get_directory_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1f
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = local_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive does nothing
+            fs.get(s, t)
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            fs.get(s, t, recursive=True)
+            assert local_fs.isdir(local_join(target, "newdir"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+            assert local_fs.isdir(local_join(target, "newdir", "nesteddir"))
+            assert local_fs.isfile(
+                local_join(target, "newdir", "nesteddir", "nestedfile")
+            )
+            assert not local_fs.exists(local_join(target, "subdir"))
+
+            local_fs.rm(local_join(target, "newdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+            # Limit recursive by maxdepth
+            fs.get(s, t, recursive=True, maxdepth=1)
+            assert local_fs.isdir(local_join(target, "newdir"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+            assert not local_fs.exists(local_join(target, "newdir", "nesteddir"))
+            assert not local_fs.exists(local_join(target, "subdir"))
+
+            local_fs.rm(local_join(target, "newdir"), recursive=True)
+            assert not local_fs.exists(local_join(target, "newdir"))
+
+    def test_get_glob_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1g
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            # Without recursive
+            fs.get(fs_join(source, "subdir", "*"), t)
+            assert local_fs.isfile(local_join(target, "subfile1"))
+            assert local_fs.isfile(local_join(target, "subfile2"))
+            assert not local_fs.isdir(local_join(target, "nesteddir"))
+            assert not local_fs.exists(local_join(target, "nesteddir", "nestedfile"))
+            assert not local_fs.exists(local_join(target, "subdir"))
+
+            local_fs.rm(
+                [
+                    local_join(target, "subfile1"),
+                    local_join(target, "subfile2"),
+                ],
+                recursive=True,
+            )
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.get(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert local_fs.isdir(local_join(target, "nesteddir"))
+                assert local_fs.isfile(local_join(target, "nesteddir", "nestedfile"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                        local_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+                assert local_fs.ls(target) == []
+
+                # Limit recursive by maxdepth
+                fs.get(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert not local_fs.exists(local_join(target, "nesteddir"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+                assert local_fs.ls(target) == []
+
+    def test_get_glob_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1h
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive
+            fs.get(fs_join(source, "subdir", "*"), t)
+            assert local_fs.isdir(local_join(target, "newdir"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+            assert not local_fs.exists(local_join(target, "newdir", "nesteddir"))
+            assert not local_fs.exists(
+                local_join(target, "newdir", "nesteddir", "nestedfile")
+            )
+            assert not local_fs.exists(local_join(target, "subdir"))
+            assert not local_fs.exists(local_join(target, "newdir", "subdir"))
+
+            local_fs.rm(local_join(target, "newdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.get(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert local_fs.isdir(local_join(target, "newdir"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+                assert local_fs.isdir(local_join(target, "newdir", "nesteddir"))
+                assert local_fs.isfile(
+                    local_join(target, "newdir", "nesteddir", "nestedfile")
+                )
+                assert not local_fs.exists(local_join(target, "subdir"))
+                assert not local_fs.exists(local_join(target, "newdir", "subdir"))
+
+                local_fs.rm(local_join(target, "newdir"), recursive=True)
+                assert not local_fs.exists(local_join(target, "newdir"))
+
+                # Limit recursive by maxdepth
+                fs.get(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert local_fs.isdir(local_join(target, "newdir"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+                assert not local_fs.exists(local_join(target, "newdir", "nesteddir"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+                assert not local_fs.exists(local_join(target, "newdir", "subdir"))
+
+                local_fs.rm(local_fs.ls(target, detail=False), recursive=True)
+                assert not local_fs.exists(local_join(target, "newdir"))
+
+    @pytest.mark.parametrize(
+        GLOB_EDGE_CASES_TESTS["argnames"],
+        GLOB_EDGE_CASES_TESTS["argvalues"],
+    )
+    def test_get_glob_edge_cases(
+        self,
+        path,
+        recursive,
+        maxdepth,
+        expected,
+        fs,
+        fs_join,
+        fs_glob_edge_cases_files,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1g
+        source = fs_glob_edge_cases_files
+
+        target = local_target
+
+        for new_dir, target_slash in product([True, False], [True, False]):
+            local_fs.mkdir(target)
+
+            t = local_join(target, "newdir") if new_dir else target
+            t = t + "/" if target_slash else t
+
+            fs.get(fs_join(source, path), t, recursive=recursive, maxdepth=maxdepth)
+
+            output = local_fs.find(target)
+            if new_dir:
+                prefixed_expected = [
+                    make_path_posix(local_join(target, "newdir", p)) for p in expected
+                ]
+            else:
+                prefixed_expected = [
+                    make_path_posix(local_join(target, p)) for p in expected
+                ]
+            assert sorted(output) == sorted(prefixed_expected)
+
+            try:
+                local_fs.rm(target, recursive=True)
+            except FileNotFoundError:
+                pass
+
+    def test_get_list_of_files_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 2a
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            fs.get(source_files, t)
+            assert local_fs.isfile(local_join(target, "file1"))
+            assert local_fs.isfile(local_join(target, "file2"))
+            assert local_fs.isfile(local_join(target, "subfile1"))
+
+            local_fs.rm(
+                [
+                    local_join(target, "file1"),
+                    local_join(target, "file2"),
+                    local_join(target, "subfile1"),
+                ],
+                recursive=True,
+            )
+            assert local_fs.ls(target) == []
+
+    def test_get_list_of_files_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 2b
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        fs.get(source_files, local_join(target, "newdir") + "/")  # Note trailing slash
+        assert local_fs.isdir(local_join(target, "newdir"))
+        assert local_fs.isfile(local_join(target, "newdir", "file1"))
+        assert local_fs.isfile(local_join(target, "newdir", "file2"))
+        assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+
+    def test_get_directory_recursive(
+        self, fs, fs_join, fs_path, local_fs, local_join, local_target
+    ):
+        # https://github.com/fsspec/filesystem_spec/issues/1062
+        # Recursive cp/get/put of source directory into non-existent target directory.
+        src = fs_join(fs_path, "src")
+        src_file = fs_join(src, "file")
+        fs.mkdir(src)
+        fs.touch(src_file)
+
+        target = local_target
+
+        # get without slash
+        assert not local_fs.exists(target)
+        for loop in range(2):
+            fs.get(src, target, recursive=True)
+            assert local_fs.isdir(target)
+
+            if loop == 0:
+                assert local_fs.isfile(local_join(target, "file"))
+                assert not local_fs.exists(local_join(target, "src"))
+            else:
+                assert local_fs.isfile(local_join(target, "file"))
+                assert local_fs.isdir(local_join(target, "src"))
+                assert local_fs.isfile(local_join(target, "src", "file"))
+
+        local_fs.rm(target, recursive=True)
+
+        # get with slash
+        assert not local_fs.exists(target)
+        for loop in range(2):
+            fs.get(src + "/", target, recursive=True)
+            assert local_fs.isdir(target)
+            assert local_fs.isfile(local_join(target, "file"))
+            assert not local_fs.exists(local_join(target, "src"))
+
+    def test_get_directory_without_files_with_same_name_prefix(
+        self,
+        fs,
+        fs_join,
+        local_fs,
+        local_join,
+        local_target,
+        fs_dir_and_file_with_same_name_prefix,
+    ):
+        # Create the test dirs
+        source = fs_dir_and_file_with_same_name_prefix
+        target = local_target
+
+        # Test without glob
+        fs.get(fs_join(source, "subdir"), target, recursive=True)
+
+        assert local_fs.isfile(local_join(target, "subfile.txt"))
+        assert not local_fs.isfile(local_join(target, "subdir.txt"))
+
+        local_fs.rm([local_join(target, "subfile.txt")])
+        assert local_fs.ls(target) == []
+
+        # Test with glob
+        fs.get(fs_join(source, "subdir*"), target, recursive=True)
+
+        assert local_fs.isdir(local_join(target, "subdir"))
+        assert local_fs.isfile(local_join(target, "subdir", "subfile.txt"))
+        assert local_fs.isfile(local_join(target, "subdir.txt"))
+
+    def test_get_with_source_and_destination_as_list(
+        self,
+        fs,
+        fs_join,
+        local_fs,
+        local_join,
+        local_target,
+        fs_10_files_with_hashed_names,
+    ):
+        # Create the test dir
+        source = fs_10_files_with_hashed_names
+        target = local_target
+
+        # Create list of files for source and destination
+        source_files = []
+        destination_files = []
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            source_files.append(fs_join(source, f"{hashed_i}.txt"))
+            destination_files.append(
+                make_path_posix(local_join(target, f"{hashed_i}.txt"))
+            )
+
+        # Copy and assert order was kept
+        fs.get(rpath=source_files, lpath=destination_files)
+
+        for i in range(10):
+            file_content = local_fs.cat(destination_files[i]).decode("utf-8")
+            assert file_content == str(i)
diff --git a/lib/python3.11/site-packages/fsspec/tests/abstract/put.py b/lib/python3.11/site-packages/fsspec/tests/abstract/put.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d5f2c7beb9e035e727766241509db367981bc81
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/tests/abstract/put.py
@@ -0,0 +1,577 @@
+from hashlib import md5
+from itertools import product
+
+import pytest
+
+from fsspec.tests.abstract.common import GLOB_EDGE_CASES_TESTS
+
+
+class AbstractPutTests:
+    def test_put_file_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1a
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        target_file2 = fs_join(target, "file2")
+        target_subfile1 = fs_join(target, "subfile1")
+
+        # Copy from source directory
+        fs.put(local_join(source, "file2"), target)
+        assert fs.isfile(target_file2)
+
+        # Copy from sub directory
+        fs.put(local_join(source, "subdir", "subfile1"), target)
+        assert fs.isfile(target_subfile1)
+
+        # Remove copied files
+        fs.rm([target_file2, target_subfile1])
+        assert not fs.exists(target_file2)
+        assert not fs.exists(target_subfile1)
+
+        # Repeat with trailing slash on target
+        fs.put(local_join(source, "file2"), target + "/")
+        assert fs.isdir(target)
+        assert fs.isfile(target_file2)
+
+        fs.put(local_join(source, "subdir", "subfile1"), target + "/")
+        assert fs.isfile(target_subfile1)
+
+    def test_put_file_to_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 1b
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.put(
+            local_join(source, "subdir", "subfile1"), fs_join(target, "newdir/")
+        )  # Note trailing slash
+        assert fs.isdir(target)
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_put_file_to_file_in_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        supports_empty_directories,
+        local_bulk_operations_scenario_0,
+    ):
+        # Copy scenario 1c
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        fs.put(local_join(source, "subdir", "subfile1"), fs_join(target, "newfile"))
+        assert fs.isfile(fs_join(target, "newfile"))
+
+    def test_put_file_to_file_in_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 1d
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.put(
+            local_join(source, "subdir", "subfile1"),
+            fs_join(target, "newdir", "newfile"),
+        )
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "newfile"))
+
+    def test_put_directory_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1e
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = target + "/" if target_slash else target
+
+            # Without recursive does nothing
+            fs.put(s, t)
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+            # With recursive
+            fs.put(s, t, recursive=True)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "subdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+            # Limit recursive by maxdepth
+            fs.put(s, t, recursive=True, maxdepth=1)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+    def test_put_directory_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1f
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive does nothing
+            fs.put(s, t)
+            if supports_empty_directories:
+                assert fs.ls(target) == []
+            else:
+                with pytest.raises(FileNotFoundError):
+                    fs.ls(target)
+
+            # With recursive
+            fs.put(s, t, recursive=True)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+            assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # Limit recursive by maxdepth
+            fs.put(s, t, recursive=True, maxdepth=1)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+    def test_put_glob_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        supports_empty_directories,
+        local_bulk_operations_scenario_0,
+    ):
+        # Copy scenario 1g
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            # Without recursive
+            fs.put(local_join(source, "subdir", "*"), t)
+            assert fs.isfile(fs_join(target, "subfile1"))
+            assert fs.isfile(fs_join(target, "subfile2"))
+            assert not fs.isdir(fs_join(target, "nesteddir"))
+            assert not fs.exists(fs_join(target, "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(
+                [
+                    fs_join(target, "subfile1"),
+                    fs_join(target, "subfile2"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.put(local_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+                # Limit recursive by maxdepth
+                fs.put(
+                    local_join(source, "subdir", glob),
+                    t,
+                    recursive=recursive,
+                    maxdepth=1,
+                )
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+    def test_put_glob_to_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 1h
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive
+            fs.put(local_join(source, "subdir", "*"), t)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+            assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.put(local_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+                # Limit recursive by maxdepth
+                fs.put(
+                    local_join(source, "subdir", glob),
+                    t,
+                    recursive=recursive,
+                    maxdepth=1,
+                )
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+    @pytest.mark.parametrize(
+        GLOB_EDGE_CASES_TESTS["argnames"],
+        GLOB_EDGE_CASES_TESTS["argvalues"],
+    )
+    def test_put_glob_edge_cases(
+        self,
+        path,
+        recursive,
+        maxdepth,
+        expected,
+        fs,
+        fs_join,
+        fs_target,
+        local_glob_edge_cases_files,
+        local_join,
+        fs_sanitize_path,
+    ):
+        # Copy scenario 1g
+        source = local_glob_edge_cases_files
+
+        target = fs_target
+
+        for new_dir, target_slash in product([True, False], [True, False]):
+            fs.mkdir(target)
+
+            t = fs_join(target, "newdir") if new_dir else target
+            t = t + "/" if target_slash else t
+
+            fs.put(local_join(source, path), t, recursive=recursive, maxdepth=maxdepth)
+
+            output = fs.find(target)
+            if new_dir:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, "newdir", p)) for p in expected
+                ]
+            else:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, p)) for p in expected
+                ]
+            assert sorted(output) == sorted(prefixed_expected)
+
+            try:
+                fs.rm(target, recursive=True)
+            except FileNotFoundError:
+                pass
+
+    def test_put_list_of_files_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 2a
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        source_files = [
+            local_join(source, "file1"),
+            local_join(source, "file2"),
+            local_join(source, "subdir", "subfile1"),
+        ]
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            fs.put(source_files, t)
+            assert fs.isfile(fs_join(target, "file1"))
+            assert fs.isfile(fs_join(target, "file2"))
+            assert fs.isfile(fs_join(target, "subfile1"))
+
+            fs.rm(
+                [
+                    fs_join(target, "file1"),
+                    fs_join(target, "file2"),
+                    fs_join(target, "subfile1"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+    def test_put_list_of_files_to_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 2b
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        source_files = [
+            local_join(source, "file1"),
+            local_join(source, "file2"),
+            local_join(source, "subdir", "subfile1"),
+        ]
+
+        fs.put(source_files, fs_join(target, "newdir") + "/")  # Note trailing slash
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "file1"))
+        assert fs.isfile(fs_join(target, "newdir", "file2"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_put_directory_recursive(
+        self, fs, fs_join, fs_target, local_fs, local_join, local_path
+    ):
+        # https://github.com/fsspec/filesystem_spec/issues/1062
+        # Recursive cp/get/put of source directory into non-existent target directory.
+        src = local_join(local_path, "src")
+        src_file = local_join(src, "file")
+        local_fs.mkdir(src)
+        local_fs.touch(src_file)
+
+        target = fs_target
+
+        # put without slash
+        assert not fs.exists(target)
+        for loop in range(2):
+            fs.put(src, target, recursive=True)
+            assert fs.isdir(target)
+
+            if loop == 0:
+                assert fs.isfile(fs_join(target, "file"))
+                assert not fs.exists(fs_join(target, "src"))
+            else:
+                assert fs.isfile(fs_join(target, "file"))
+                assert fs.isdir(fs_join(target, "src"))
+                assert fs.isfile(fs_join(target, "src", "file"))
+
+        fs.rm(target, recursive=True)
+
+        # put with slash
+        assert not fs.exists(target)
+        for loop in range(2):
+            fs.put(src + "/", target, recursive=True)
+            assert fs.isdir(target)
+            assert fs.isfile(fs_join(target, "file"))
+            assert not fs.exists(fs_join(target, "src"))
+
+    def test_put_directory_without_files_with_same_name_prefix(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        local_dir_and_file_with_same_name_prefix,
+        supports_empty_directories,
+    ):
+        # Create the test dirs
+        source = local_dir_and_file_with_same_name_prefix
+        target = fs_target
+
+        # Test without glob
+        fs.put(local_join(source, "subdir"), fs_target, recursive=True)
+
+        assert fs.isfile(fs_join(fs_target, "subfile.txt"))
+        assert not fs.isfile(fs_join(fs_target, "subdir.txt"))
+
+        fs.rm([fs_join(target, "subfile.txt")])
+        if supports_empty_directories:
+            assert fs.ls(target) == []
+        else:
+            assert not fs.exists(target)
+
+        # Test with glob
+        fs.put(local_join(source, "subdir*"), fs_target, recursive=True)
+
+        assert fs.isdir(fs_join(fs_target, "subdir"))
+        assert fs.isfile(fs_join(fs_target, "subdir", "subfile.txt"))
+        assert fs.isfile(fs_join(fs_target, "subdir.txt"))
+
+    def test_copy_with_source_and_destination_as_list(
+        self, fs, fs_target, fs_join, local_join, local_10_files_with_hashed_names
+    ):
+        # Create the test dir
+        source = local_10_files_with_hashed_names
+        target = fs_target
+
+        # Create list of files for source and destination
+        source_files = []
+        destination_files = []
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            source_files.append(local_join(source, f"{hashed_i}.txt"))
+            destination_files.append(fs_join(target, f"{hashed_i}.txt"))
+
+        # Copy and assert order was kept
+        fs.put(lpath=source_files, rpath=destination_files)
+
+        for i in range(10):
+            file_content = fs.cat(destination_files[i]).decode("utf-8")
+            assert file_content == str(i)
diff --git a/lib/python3.11/site-packages/fsspec/transaction.py b/lib/python3.11/site-packages/fsspec/transaction.py
new file mode 100644
index 0000000000000000000000000000000000000000..67584d61e8f5f86b22e19beb609ffe49ce7cc689
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/transaction.py
@@ -0,0 +1,85 @@
+from collections import deque
+
+
+class Transaction:
+    """Filesystem transaction write context
+
+    Gathers files for deferred commit or discard, so that several write
+    operations can be finalized semi-atomically. This works by having this
+    instance as the ``.transaction`` attribute of the given filesystem
+    """
+
+    def __init__(self, fs):
+        """
+        Parameters
+        ----------
+        fs: FileSystem instance
+        """
+        self.fs = fs
+        self.files = deque()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """End transaction and commit, if exit is not due to exception"""
+        # only commit if there was no exception
+        self.complete(commit=exc_type is None)
+        self.fs._intrans = False
+        self.fs._transaction = None
+
+    def start(self):
+        """Start a transaction on this FileSystem"""
+        self.files = deque()  # clean up after previous failed completions
+        self.fs._intrans = True
+
+    def complete(self, commit=True):
+        """Finish transaction: commit or discard all deferred files"""
+        while self.files:
+            f = self.files.popleft()
+            if commit:
+                f.commit()
+            else:
+                f.discard()
+        self.fs._intrans = False
+
+
+class FileActor:
+    def __init__(self):
+        self.files = []
+
+    def commit(self):
+        for f in self.files:
+            f.commit()
+        self.files.clear()
+
+    def discard(self):
+        for f in self.files:
+            f.discard()
+        self.files.clear()
+
+    def append(self, f):
+        self.files.append(f)
+
+
+class DaskTransaction(Transaction):
+    def __init__(self, fs):
+        """
+        Parameters
+        ----------
+        fs: FileSystem instance
+        """
+        import distributed
+
+        super().__init__(fs)
+        client = distributed.default_client()
+        self.files = client.submit(FileActor, actor=True).result()
+
+    def complete(self, commit=True):
+        """Finish transaction: commit or discard all deferred files"""
+        if commit:
+            self.files.commit().result()
+        else:
+            self.files.discard().result()
+        self.fs._intrans = False
diff --git a/lib/python3.11/site-packages/fsspec/utils.py b/lib/python3.11/site-packages/fsspec/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..543bd89d79751a1d88688677ac313f94896512e5
--- /dev/null
+++ b/lib/python3.11/site-packages/fsspec/utils.py
@@ -0,0 +1,742 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import math
+import os
+import pathlib
+import re
+import sys
+import tempfile
+from functools import partial
+from hashlib import md5
+from importlib.metadata import version
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    Sequence,
+    TypeVar,
+)
+from urllib.parse import urlsplit
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeGuard
+
+    from fsspec.spec import AbstractFileSystem
+
+
+DEFAULT_BLOCK_SIZE = 5 * 2**20
+
+T = TypeVar("T")
+
+
+def infer_storage_options(
+    urlpath: str, inherit_storage_options: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """Infer storage options from URL path and merge it with existing storage
+    options.
+
+    Parameters
+    ----------
+    urlpath: str or unicode
+        Either local absolute file path or URL (hdfs://namenode:8020/file.csv)
+    inherit_storage_options: dict (optional)
+        Its contents will get merged with the inferred information from the
+        given path
+
+    Returns
+    -------
+    Storage options dict.
+
+    Examples
+    --------
+    >>> infer_storage_options('/mnt/datasets/test.csv')  # doctest: +SKIP
+    {"protocol": "file", "path", "/mnt/datasets/test.csv"}
+    >>> infer_storage_options(
+    ...     'hdfs://username:pwd@node:123/mnt/datasets/test.csv?q=1',
+    ...     inherit_storage_options={'extra': 'value'},
+    ... )  # doctest: +SKIP
+    {"protocol": "hdfs", "username": "username", "password": "pwd",
+    "host": "node", "port": 123, "path": "/mnt/datasets/test.csv",
+    "url_query": "q=1", "extra": "value"}
+    """
+    # Handle Windows paths including disk name in this special case
+    if (
+        re.match(r"^[a-zA-Z]:[\\/]", urlpath)
+        or re.match(r"^[a-zA-Z0-9]+://", urlpath) is None
+    ):
+        return {"protocol": "file", "path": urlpath}
+
+    parsed_path = urlsplit(urlpath)
+    protocol = parsed_path.scheme or "file"
+    if parsed_path.fragment:
+        path = "#".join([parsed_path.path, parsed_path.fragment])
+    else:
+        path = parsed_path.path
+    if protocol == "file":
+        # Special case parsing file protocol URL on Windows according to:
+        # https://msdn.microsoft.com/en-us/library/jj710207.aspx
+        windows_path = re.match(r"^/([a-zA-Z])[:|]([\\/].*)$", path)
+        if windows_path:
+            path = "%s:%s" % windows_path.groups()
+
+    if protocol in ["http", "https"]:
+        # for HTTP, we don't want to parse, as requests will anyway
+        return {"protocol": protocol, "path": urlpath}
+
+    options: dict[str, Any] = {"protocol": protocol, "path": path}
+
+    if parsed_path.netloc:
+        # Parse `hostname` from netloc manually because `parsed_path.hostname`
+        # lowercases the hostname which is not always desirable (e.g. in S3):
+        # https://github.com/dask/dask/issues/1417
+        options["host"] = parsed_path.netloc.rsplit("@", 1)[-1].rsplit(":", 1)[0]
+
+        if protocol in ("s3", "s3a", "gcs", "gs"):
+            options["path"] = options["host"] + options["path"]
+        else:
+            options["host"] = options["host"]
+        if parsed_path.port:
+            options["port"] = parsed_path.port
+        if parsed_path.username:
+            options["username"] = parsed_path.username
+        if parsed_path.password:
+            options["password"] = parsed_path.password
+
+    if parsed_path.query:
+        options["url_query"] = parsed_path.query
+    if parsed_path.fragment:
+        options["url_fragment"] = parsed_path.fragment
+
+    if inherit_storage_options:
+        update_storage_options(options, inherit_storage_options)
+
+    return options
+
+
+def update_storage_options(
+    options: dict[str, Any], inherited: dict[str, Any] | None = None
+) -> None:
+    if not inherited:
+        inherited = {}
+    collisions = set(options) & set(inherited)
+    if collisions:
+        for collision in collisions:
+            if options.get(collision) != inherited.get(collision):
+                raise KeyError(
+                    f"Collision between inferred and specified storage "
+                    f"option:\n{collision}"
+                )
+    options.update(inherited)
+
+
+# Compression extensions registered via fsspec.compression.register_compression
+compressions: dict[str, str] = {}
+
+
+def infer_compression(filename: str) -> str | None:
+    """Infer compression, if available, from filename.
+
+    Infer a named compression type, if registered and available, from filename
+    extension. This includes builtin (gz, bz2, zip) compressions, as well as
+    optional compressions. See fsspec.compression.register_compression.
+    """
+    extension = os.path.splitext(filename)[-1].strip(".").lower()
+    if extension in compressions:
+        return compressions[extension]
+    return None
+
+
+def build_name_function(max_int: float) -> Callable[[int], str]:
+    """Returns a function that receives a single integer
+    and returns it as a string padded by enough zero characters
+    to align with maximum possible integer
+
+    >>> name_f = build_name_function(57)
+
+    >>> name_f(7)
+    '07'
+    >>> name_f(31)
+    '31'
+    >>> build_name_function(1000)(42)
+    '0042'
+    >>> build_name_function(999)(42)
+    '042'
+    >>> build_name_function(0)(0)
+    '0'
+    """
+    # handle corner cases max_int is 0 or exact power of 10
+    max_int += 1e-8
+
+    pad_length = int(math.ceil(math.log10(max_int)))
+
+    def name_function(i: int) -> str:
+        return str(i).zfill(pad_length)
+
+    return name_function
+
+
+def seek_delimiter(file: IO[bytes], delimiter: bytes, blocksize: int) -> bool:
+    r"""Seek current file to file start, file end, or byte after delimiter seq.
+
+    Seeks file to next chunk delimiter, where chunks are defined on file start,
+    a delimiting sequence, and file end. Use file.tell() to see location afterwards.
+    Note that file start is a valid split, so must be at offset > 0 to seek for
+    delimiter.
+
+    Parameters
+    ----------
+    file: a file
+    delimiter: bytes
+        a delimiter like ``b'\n'`` or message sentinel, matching file .read() type
+    blocksize: int
+        Number of bytes to read from the file at once.
+
+
+    Returns
+    -------
+    Returns True if a delimiter was found, False if at file start or end.
+
+    """
+
+    if file.tell() == 0:
+        # beginning-of-file, return without seek
+        return False
+
+    # Interface is for binary IO, with delimiter as bytes, but initialize last
+    # with result of file.read to preserve compatibility with text IO.
+    last: bytes | None = None
+    while True:
+        current = file.read(blocksize)
+        if not current:
+            # end-of-file without delimiter
+            return False
+        full = last + current if last else current
+        try:
+            if delimiter in full:
+                i = full.index(delimiter)
+                file.seek(file.tell() - (len(full) - i) + len(delimiter))
+                return True
+            elif len(current) < blocksize:
+                # end-of-file without delimiter
+                return False
+        except (OSError, ValueError):
+            pass
+        last = full[-len(delimiter) :]
+
+
+def read_block(
+    f: IO[bytes],
+    offset: int,
+    length: int | None,
+    delimiter: bytes | None = None,
+    split_before: bool = False,
+) -> bytes:
+    """Read a block of bytes from a file
+
+    Parameters
+    ----------
+    f: File
+        Open file
+    offset: int
+        Byte offset to start read
+    length: int
+        Number of bytes to read, read through end of file if None
+    delimiter: bytes (optional)
+        Ensure reading starts and stops at delimiter bytestring
+    split_before: bool (optional)
+        Start/stop read *before* delimiter bytestring.
+
+
+    If using the ``delimiter=`` keyword argument we ensure that the read
+    starts and stops at delimiter boundaries that follow the locations
+    ``offset`` and ``offset + length``.  If ``offset`` is zero then we
+    start at zero, regardless of delimiter.  The bytestring returned WILL
+    include the terminating delimiter string.
+
+    Examples
+    --------
+
+    >>> from io import BytesIO  # doctest: +SKIP
+    >>> f = BytesIO(b'Alice, 100\\nBob, 200\\nCharlie, 300')  # doctest: +SKIP
+    >>> read_block(f, 0, 13)  # doctest: +SKIP
+    b'Alice, 100\\nBo'
+
+    >>> read_block(f, 0, 13, delimiter=b'\\n')  # doctest: +SKIP
+    b'Alice, 100\\nBob, 200\\n'
+
+    >>> read_block(f, 10, 10, delimiter=b'\\n')  # doctest: +SKIP
+    b'Bob, 200\\nCharlie, 300'
+    """
+    if delimiter:
+        f.seek(offset)
+        found_start_delim = seek_delimiter(f, delimiter, 2**16)
+        if length is None:
+            return f.read()
+        start = f.tell()
+        length -= start - offset
+
+        f.seek(start + length)
+        found_end_delim = seek_delimiter(f, delimiter, 2**16)
+        end = f.tell()
+
+        # Adjust split location to before delimiter iff seek found the
+        # delimiter sequence, not start or end of file.
+        if found_start_delim and split_before:
+            start -= len(delimiter)
+
+        if found_end_delim and split_before:
+            end -= len(delimiter)
+
+        offset = start
+        length = end - start
+
+    f.seek(offset)
+
+    # TODO: allow length to be None and read to the end of the file?
+    assert length is not None
+    b = f.read(length)
+    return b
+
+
+def tokenize(*args: Any, **kwargs: Any) -> str:
+    """Deterministic token
+
+    (modified from dask.base)
+
+    >>> tokenize([1, 2, '3'])
+    '9d71491b50023b06fc76928e6eddb952'
+
+    >>> tokenize('Hello') == tokenize('Hello')
+    True
+    """
+    if kwargs:
+        args += (kwargs,)
+    try:
+        h = md5(str(args).encode())
+    except ValueError:
+        # FIPS systems: https://github.com/fsspec/filesystem_spec/issues/380
+        h = md5(str(args).encode(), usedforsecurity=False)
+    return h.hexdigest()
+
+
+def stringify_path(filepath: str | os.PathLike[str] | pathlib.Path) -> str:
+    """Attempt to convert a path-like object to a string.
+
+    Parameters
+    ----------
+    filepath: object to be converted
+
+    Returns
+    -------
+    filepath_str: maybe a string version of the object
+
+    Notes
+    -----
+    Objects supporting the fspath protocol are coerced according to its
+    __fspath__ method.
+
+    For backwards compatibility with older Python version, pathlib.Path
+    objects are specially coerced.
+
+    Any other object is passed through unchanged, which includes bytes,
+    strings, buffers, or anything else that's not even path-like.
+    """
+    if isinstance(filepath, str):
+        return filepath
+    elif hasattr(filepath, "__fspath__"):
+        return filepath.__fspath__()
+    elif isinstance(filepath, pathlib.Path):
+        return str(filepath)
+    elif hasattr(filepath, "path"):
+        return filepath.path
+    else:
+        return filepath  # type: ignore[return-value]
+
+
+def make_instance(
+    cls: Callable[..., T], args: Sequence[Any], kwargs: dict[str, Any]
+) -> T:
+    inst = cls(*args, **kwargs)
+    inst._determine_worker()  # type: ignore[attr-defined]
+    return inst
+
+
+def common_prefix(paths: Iterable[str]) -> str:
+    """For a list of paths, find the shortest prefix common to all"""
+    parts = [p.split("/") for p in paths]
+    lmax = min(len(p) for p in parts)
+    end = 0
+    for i in range(lmax):
+        end = all(p[i] == parts[0][i] for p in parts)
+        if not end:
+            break
+    i += end
+    return "/".join(parts[0][:i])
+
+
+def other_paths(
+    paths: list[str],
+    path2: str | list[str],
+    exists: bool = False,
+    flatten: bool = False,
+) -> list[str]:
+    """In bulk file operations, construct a new file tree from a list of files
+
+    Parameters
+    ----------
+    paths: list of str
+        The input file tree
+    path2: str or list of str
+        Root to construct the new list in. If this is already a list of str, we just
+        assert it has the right number of elements.
+    exists: bool (optional)
+        For a str destination, it is already exists (and is a dir), files should
+        end up inside.
+    flatten: bool (optional)
+        Whether to flatten the input directory tree structure so that the output files
+        are in the same directory.
+
+    Returns
+    -------
+    list of str
+    """
+
+    if isinstance(path2, str):
+        path2 = path2.rstrip("/")
+
+        if flatten:
+            path2 = ["/".join((path2, p.split("/")[-1])) for p in paths]
+        else:
+            cp = common_prefix(paths)
+            if exists:
+                cp = cp.rsplit("/", 1)[0]
+            if not cp and all(not s.startswith("/") for s in paths):
+                path2 = ["/".join([path2, p]) for p in paths]
+            else:
+                path2 = [p.replace(cp, path2, 1) for p in paths]
+    else:
+        assert len(paths) == len(path2)
+    return path2
+
+
+def is_exception(obj: Any) -> bool:
+    return isinstance(obj, BaseException)
+
+
+def isfilelike(f: Any) -> TypeGuard[IO[bytes]]:
+    for attr in ["read", "close", "tell"]:
+        if not hasattr(f, attr):
+            return False
+    return True
+
+
+def get_protocol(url: str) -> str:
+    url = stringify_path(url)
+    parts = re.split(r"(\:\:|\://)", url, 1)
+    if len(parts) > 1:
+        return parts[0]
+    return "file"
+
+
+def can_be_local(path: str) -> bool:
+    """Can the given URL be used with open_local?"""
+    from fsspec import get_filesystem_class
+
+    try:
+        return getattr(get_filesystem_class(get_protocol(path)), "local_file", False)
+    except (ValueError, ImportError):
+        # not in registry or import failed
+        return False
+
+
+def get_package_version_without_import(name: str) -> str | None:
+    """For given package name, try to find the version without importing it
+
+    Import and package.__version__ is still the backup here, so an import
+    *might* happen.
+
+    Returns either the version string, or None if the package
+    or the version was not readily  found.
+    """
+    if name in sys.modules:
+        mod = sys.modules[name]
+        if hasattr(mod, "__version__"):
+            return mod.__version__
+    try:
+        return version(name)
+    except:  # noqa: E722
+        pass
+    try:
+        import importlib
+
+        mod = importlib.import_module(name)
+        return mod.__version__
+    except (ImportError, AttributeError):
+        return None
+
+
+def setup_logging(
+    logger: logging.Logger | None = None,
+    logger_name: str | None = None,
+    level: str = "DEBUG",
+    clear: bool = True,
+) -> logging.Logger:
+    if logger is None and logger_name is None:
+        raise ValueError("Provide either logger object or logger name")
+    logger = logger or logging.getLogger(logger_name)
+    handle = logging.StreamHandler()
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(funcName)s -- %(message)s"
+    )
+    handle.setFormatter(formatter)
+    if clear:
+        logger.handlers.clear()
+    logger.addHandler(handle)
+    logger.setLevel(level)
+    return logger
+
+
+def _unstrip_protocol(name: str, fs: AbstractFileSystem) -> str:
+    return fs.unstrip_protocol(name)
+
+
+def mirror_from(
+    origin_name: str, methods: Iterable[str]
+) -> Callable[[type[T]], type[T]]:
+    """Mirror attributes and methods from the given
+    origin_name attribute of the instance to the
+    decorated class"""
+
+    def origin_getter(method: str, self: Any) -> Any:
+        origin = getattr(self, origin_name)
+        return getattr(origin, method)
+
+    def wrapper(cls: type[T]) -> type[T]:
+        for method in methods:
+            wrapped_method = partial(origin_getter, method)
+            setattr(cls, method, property(wrapped_method))
+        return cls
+
+    return wrapper
+
+
+@contextlib.contextmanager
+def nullcontext(obj: T) -> Iterator[T]:
+    yield obj
+
+
+def merge_offset_ranges(
+    paths: list[str],
+    starts: list[int] | int,
+    ends: list[int] | int,
+    max_gap: int = 0,
+    max_block: int | None = None,
+    sort: bool = True,
+) -> tuple[list[str], list[int], list[int]]:
+    """Merge adjacent byte-offset ranges when the inter-range
+    gap is <= `max_gap`, and when the merged byte range does not
+    exceed `max_block` (if specified). By default, this function
+    will re-order the input paths and byte ranges to ensure sorted
+    order. If the user can guarantee that the inputs are already
+    sorted, passing `sort=False` will skip the re-ordering.
+    """
+    # Check input
+    if not isinstance(paths, list):
+        raise TypeError
+    if not isinstance(starts, list):
+        starts = [starts] * len(paths)
+    if not isinstance(ends, list):
+        ends = [ends] * len(paths)
+    if len(starts) != len(paths) or len(ends) != len(paths):
+        raise ValueError
+
+    # Early Return
+    if len(starts) <= 1:
+        return paths, starts, ends
+
+    starts = [s or 0 for s in starts]
+    # Sort by paths and then ranges if `sort=True`
+    if sort:
+        paths, starts, ends = (
+            list(v)
+            for v in zip(
+                *sorted(
+                    zip(paths, starts, ends),
+                )
+            )
+        )
+
+    if paths:
+        # Loop through the coupled `paths`, `starts`, and
+        # `ends`, and merge adjacent blocks when appropriate
+        new_paths = paths[:1]
+        new_starts = starts[:1]
+        new_ends = ends[:1]
+        for i in range(1, len(paths)):
+            if paths[i] == paths[i - 1] and new_ends[-1] is None:
+                continue
+            elif (
+                paths[i] != paths[i - 1]
+                or ((starts[i] - new_ends[-1]) > max_gap)
+                or (max_block is not None and (ends[i] - new_starts[-1]) > max_block)
+            ):
+                # Cannot merge with previous block.
+                # Add new `paths`, `starts`, and `ends` elements
+                new_paths.append(paths[i])
+                new_starts.append(starts[i])
+                new_ends.append(ends[i])
+            else:
+                # Merge with previous block by updating the
+                # last element of `ends`
+                new_ends[-1] = ends[i]
+        return new_paths, new_starts, new_ends
+
+    # `paths` is empty. Just return input lists
+    return paths, starts, ends
+
+
+def file_size(filelike: IO[bytes]) -> int:
+    """Find length of any open read-mode file-like"""
+    pos = filelike.tell()
+    try:
+        return filelike.seek(0, 2)
+    finally:
+        filelike.seek(pos)
+
+
+@contextlib.contextmanager
+def atomic_write(path: str, mode: str = "wb"):
+    """
+    A context manager that opens a temporary file next to `path` and, on exit,
+    replaces `path` with the temporary file, thereby updating `path`
+    atomically.
+    """
+    fd, fn = tempfile.mkstemp(
+        dir=os.path.dirname(path), prefix=os.path.basename(path) + "-"
+    )
+    try:
+        with open(fd, mode) as fp:
+            yield fp
+    except BaseException:
+        with contextlib.suppress(FileNotFoundError):
+            os.unlink(fn)
+        raise
+    else:
+        os.replace(fn, path)
+
+
+def _translate(pat, STAR, QUESTION_MARK):
+    # Copied from: https://github.com/python/cpython/pull/106703.
+    res: list[str] = []
+    add = res.append
+    i, n = 0, len(pat)
+    while i < n:
+        c = pat[i]
+        i = i + 1
+        if c == "*":
+            # compress consecutive `*` into one
+            if (not res) or res[-1] is not STAR:
+                add(STAR)
+        elif c == "?":
+            add(QUESTION_MARK)
+        elif c == "[":
+            j = i
+            if j < n and pat[j] == "!":
+                j = j + 1
+            if j < n and pat[j] == "]":
+                j = j + 1
+            while j < n and pat[j] != "]":
+                j = j + 1
+            if j >= n:
+                add("\\[")
+            else:
+                stuff = pat[i:j]
+                if "-" not in stuff:
+                    stuff = stuff.replace("\\", r"\\")
+                else:
+                    chunks = []
+                    k = i + 2 if pat[i] == "!" else i + 1
+                    while True:
+                        k = pat.find("-", k, j)
+                        if k < 0:
+                            break
+                        chunks.append(pat[i:k])
+                        i = k + 1
+                        k = k + 3
+                    chunk = pat[i:j]
+                    if chunk:
+                        chunks.append(chunk)
+                    else:
+                        chunks[-1] += "-"
+                    # Remove empty ranges -- invalid in RE.
+                    for k in range(len(chunks) - 1, 0, -1):
+                        if chunks[k - 1][-1] > chunks[k][0]:
+                            chunks[k - 1] = chunks[k - 1][:-1] + chunks[k][1:]
+                            del chunks[k]
+                    # Escape backslashes and hyphens for set difference (--).
+                    # Hyphens that create ranges shouldn't be escaped.
+                    stuff = "-".join(
+                        s.replace("\\", r"\\").replace("-", r"\-") for s in chunks
+                    )
+                # Escape set operations (&&, ~~ and ||).
+                stuff = re.sub(r"([&~|])", r"\\\1", stuff)
+                i = j + 1
+                if not stuff:
+                    # Empty range: never match.
+                    add("(?!)")
+                elif stuff == "!":
+                    # Negated empty range: match any character.
+                    add(".")
+                else:
+                    if stuff[0] == "!":
+                        stuff = "^" + stuff[1:]
+                    elif stuff[0] in ("^", "["):
+                        stuff = "\\" + stuff
+                    add(f"[{stuff}]")
+        else:
+            add(re.escape(c))
+    assert i == n
+    return res
+
+
+def glob_translate(pat):
+    # Copied from: https://github.com/python/cpython/pull/106703.
+    # The keyword parameters' values are fixed to:
+    # recursive=True, include_hidden=True, seps=None
+    """Translate a pathname with shell wildcards to a regular expression."""
+    if os.path.altsep:
+        seps = os.path.sep + os.path.altsep
+    else:
+        seps = os.path.sep
+    escaped_seps = "".join(map(re.escape, seps))
+    any_sep = f"[{escaped_seps}]" if len(seps) > 1 else escaped_seps
+    not_sep = f"[^{escaped_seps}]"
+    one_last_segment = f"{not_sep}+"
+    one_segment = f"{one_last_segment}{any_sep}"
+    any_segments = f"(?:.+{any_sep})?"
+    any_last_segments = ".*"
+    results = []
+    parts = re.split(any_sep, pat)
+    last_part_idx = len(parts) - 1
+    for idx, part in enumerate(parts):
+        if part == "*":
+            results.append(one_segment if idx < last_part_idx else one_last_segment)
+            continue
+        if part == "**":
+            results.append(any_segments if idx < last_part_idx else any_last_segments)
+            continue
+        elif "**" in part:
+            raise ValueError(
+                "Invalid pattern: '**' can only be an entire path component"
+            )
+        if part:
+            results.extend(_translate(part, f"{not_sep}*", not_sep))
+        if idx < last_part_idx:
+            results.append(any_sep)
+    res = "".join(results)
+    return rf"(?s:{res})\Z"
diff --git a/lib/python3.11/site-packages/functorch/_C.cpython-311-darwin.so b/lib/python3.11/site-packages/functorch/_C.cpython-311-darwin.so
new file mode 100644
index 0000000000000000000000000000000000000000..0571c5111204deb351d916e6cb8b598d8a8d8d8d
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/_C.cpython-311-darwin.so differ
diff --git a/lib/python3.11/site-packages/functorch/__init__.py b/lib/python3.11/site-packages/functorch/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aff35e592d80e510b08ff18a4c3571202b653d6e
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/__init__.py
@@ -0,0 +1,38 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+import torch
+
+from torch._functorch.deprecated import (
+    combine_state_for_ensemble,
+    functionalize,
+    grad,
+    grad_and_value,
+    hessian,
+    jacfwd,
+    jacrev,
+    jvp,
+    make_functional,
+    make_functional_with_buffers,
+    vjp,
+    vmap,
+)
+
+# utilities. Maybe these should go in their own namespace in the future?
+from torch._functorch.make_functional import (
+    FunctionalModule,
+    FunctionalModuleWithBuffers,
+)
+
+# Top-level APIs. Please think carefully before adding something to the
+# top-level namespace:
+# - private helper functions should go into torch._functorch
+# - very experimental things should go into functorch.experimental
+# - compilation related things should go into functorch.compile
+
+# Was never documented
+from torch._functorch.python_key import make_fx
+
+__version__ = torch.__version__
diff --git a/lib/python3.11/site-packages/functorch/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80112ff9be9e6466268cea1b9f92d6d15601a7f9
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/_src/__init__.py b/lib/python3.11/site-packages/functorch/_src/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/functorch/_src/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/_src/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2673fbaaeec9f722d6f5db6fadf8889f6ccb84da
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/_src/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/_src/aot_autograd/__init__.py b/lib/python3.11/site-packages/functorch/_src/aot_autograd/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..94f258df84ba8730208768fc44222bee4b3ebc33
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/_src/aot_autograd/__init__.py
@@ -0,0 +1,8 @@
+# This file has moved to under torch/_functorch. It is not public API.
+# If you are not a PyTorch developer and you are relying on the following
+# imports, please file an issue.
+from torch._functorch.aot_autograd import (
+    aot_autograd_decompositions,
+    KNOWN_TYPES,
+    PytreeThunk,
+)
diff --git a/lib/python3.11/site-packages/functorch/_src/aot_autograd/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/_src/aot_autograd/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..59140d900a486fa8064ddcd87e657d2ac51b6f6a
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/_src/aot_autograd/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/_src/eager_transforms/__init__.py b/lib/python3.11/site-packages/functorch/_src/eager_transforms/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6052b5548f4af3dbc6d9d45b0ffe72a8d5013d41
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/_src/eager_transforms/__init__.py
@@ -0,0 +1,7 @@
+# This file has moved to under torch/_functorch. It is not public API.
+# If you are not a PyTorch developer and you are relying on the following
+# imports, please file an issue.
+from torch._functorch.eager_transforms import (
+    _assert_wrapped_functional,
+    _unwrap_functional_tensor,
+)
diff --git a/lib/python3.11/site-packages/functorch/_src/eager_transforms/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/_src/eager_transforms/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d10db79f915e4fb75bc483055d98bdbad29a345
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/_src/eager_transforms/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/_src/make_functional/__init__.py b/lib/python3.11/site-packages/functorch/_src/make_functional/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3de7787df0c3304207b42b51e9fb62da9d33c7d0
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/_src/make_functional/__init__.py
@@ -0,0 +1,4 @@
+# This file has moved to under torch/_functorch. It is not public API.
+# If you are not a PyTorch developer and you are relying on the following
+# imports, please file an issue.
+from torch._functorch.make_functional import _swap_state
diff --git a/lib/python3.11/site-packages/functorch/_src/make_functional/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/_src/make_functional/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0aef837ec3618b685372f027fcbfde0e51012b10
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/_src/make_functional/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/_src/vmap/__init__.py b/lib/python3.11/site-packages/functorch/_src/vmap/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc90517753e50f92362ba954248e31f69f7cfcd5
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/_src/vmap/__init__.py
@@ -0,0 +1,16 @@
+# This file has moved to under torch/_functorch. It is not public API.
+# If you are not a PyTorch developer and you are relying on the following
+# imports, please file an issue.
+from torch._functorch.vmap import (
+    _add_batch_dim,
+    _broadcast_to_and_flatten,
+    _create_batched_inputs,
+    _get_name,
+    _process_batched_inputs,
+    _remove_batch_dim,
+    _unwrap_batched,
+    _validate_and_get_batch_size,
+    Tensor,
+    tree_flatten,
+    tree_unflatten,
+)
diff --git a/lib/python3.11/site-packages/functorch/_src/vmap/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/_src/vmap/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..149f1e032efa23a2b65fbbd34b48f69b6ac2f973
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/_src/vmap/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/compile/__init__.py b/lib/python3.11/site-packages/functorch/compile/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..96b853cd2e27e947bf25b63325741637a801426f
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/compile/__init__.py
@@ -0,0 +1,31 @@
+from torch._functorch import config
+from torch._functorch.aot_autograd import (
+    aot_function,
+    aot_module,
+    aot_module_simplified,
+    compiled_function,
+    compiled_module,
+    get_aot_compilation_context,
+    get_aot_graph_name,
+    get_graph_being_compiled,
+    make_boxed_compiler,
+    make_boxed_func,
+)
+from torch._functorch.compilers import (
+    debug_compile,
+    default_decompositions,
+    draw_graph_compile,
+    memory_efficient_fusion,
+    nnc_jit,
+    nop,
+    print_compile,
+    ts_compile,
+)
+from torch._functorch.fx_minifier import minifier
+from torch._functorch.partitioners import (
+    default_partition,
+    draw_graph,
+    draw_joint_graph,
+    min_cut_rematerialization_partition,
+)
+from torch._functorch.python_key import pythonkey_decompose
diff --git a/lib/python3.11/site-packages/functorch/compile/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/compile/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60027fa853aa788e261bb2d7b2d49f68b05eadc5
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/compile/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__init__.py b/lib/python3.11/site-packages/functorch/dim/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8c6b0df0d58019bf1256d7307521fb090d0b376
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/__init__.py
@@ -0,0 +1,179 @@
+import dis
+import inspect
+from typing import Sequence, Union
+
+import torch
+
+import functorch._C
+from functorch._C import dim as _C
+from .tree_map import tree_flatten, tree_map
+from .wrap_type import wrap_type
+
+_C._patch_tensor_class()
+dims, DimList, dimlists = _C.dims, _C.DimList, _C.dimlists
+
+
+class DimensionMismatchError(Exception):
+    pass
+
+
+class DimensionBindError(Exception):
+    pass
+
+
+from . import op_properties
+
+# use dict to avoid writing C++ bindings for set
+pointwise = {t: True for t in op_properties.pointwise}
+
+use_c = True
+if not use_c:
+    from . import reference
+
+
+class _Tensor:
+    # fast path around slow wrapping/unwrapping logic for simply queries used
+    # by the implementation...
+
+    @property
+    def dims(self):
+        return tuple(d for d in self._levels if isinstance(d, Dim))
+
+    def dim(self):
+        return self.ndim
+
+    if use_c:
+        __torch_function__ = classmethod(_C.__torch_function__)
+        expand = _C._instancemethod(_C.expand)
+    else:
+        __torch_function__ = reference.__torch_function__
+        expand = reference.expand
+
+    index = _C._instancemethod(_C.index)
+
+    def __repr__(self):
+        tensor, levels, ndim = self._tensor, self._levels, self.ndim
+        return f"{tensor}\nwith dims={tuple(l + ndim if isinstance(l, int) else l for l in levels)} sizes={tuple(tensor.size())}"
+
+
+TensorLike = (_Tensor, torch.Tensor)
+
+
+class Dim(_C.Dim, _Tensor):
+    # note that _C.Dim comes before tensor because we want the Dim API for things like size to take precendence.
+    # Tensor defines format, but we want to print Dims with special formatting
+    __format__ = object.__format__
+
+
+class Tensor(_Tensor, _C.Tensor):
+    if not use_c:
+        from_batched = staticmethod(_C.Tensor_from_batched)
+    from_positional = staticmethod(_C.Tensor_from_positional)
+    sum = _C._instancemethod(_C.Tensor_sum)
+
+
+def cat(tensors, dim, new_dim):
+    n = dims()
+    return stack(tensors, n, dim).index([n, dim], new_dim)
+
+
+if use_c:
+    _wrap = _C._wrap
+
+    def _def(name, *args, **kwargs):
+        orig = getattr(torch.Tensor, name)
+        setattr(_Tensor, name, _C._instancemethod(_wrap(orig, *args, **kwargs)))
+
+    t__getitem__ = _C._instancemethod(_C.__getitem__)
+    stack = _C.stack
+    split = _C._instancemethod(_C.split)
+else:
+    _wrap, _def = reference._wrap, reference._def
+    t__getitem__ = reference.t__getitem__
+    stack = reference.stack
+    split = reference.split
+
+# note: there is no python reference
+t__setitem__ = _C._instancemethod(_C.__setitem__)
+# this is patched in the C API because otherwise torch.Tensor will
+# no longer be considered a sequence and things will break
+# torch.Tensor.__getitem__ = t__getitem__
+
+_Tensor.__getitem__ = t__getitem__
+# torch.Tensor.__setitem__ = t__setitem__
+_Tensor.__setitem__ = t__setitem__
+
+torch.Tensor.split = split
+_Tensor.split = split
+torch.Tensor.expand = _C._instancemethod(_C.expand)
+torch.Tensor.index = _C._instancemethod(_C.index)
+wrap_type(use_c, _Tensor, torch.Tensor, _Tensor.__torch_function__)
+del _Tensor.ndim
+
+if use_c:
+    _Tensor.order = _C._instancemethod(_C.order)
+else:
+    _Tensor.order = reference.positional
+
+_def("mean")
+_def("sum")
+_def("all")
+_def("amax")
+_def("amin")
+_def("aminmax")
+_def("any")
+_def("count_nonzero")
+_def("logsumexp")
+_def("nanmean")
+_def("nansum")
+_def("prod")
+_def("std", keepdim_offset=2)
+_def("var", keepdim_offset=2)
+_def("max", single_dim=True)
+_def("min", single_dim=True)
+_def("argmax", single_dim=True)
+_def("argmin", single_dim=True)
+_def("kthvalue", single_dim=True)
+_def("median", single_dim=True)
+_def("nanmedian", single_dim=True)
+_def("mode", single_dim=True)
+_def("sort", reduce=False)
+_def("argsort", reduce=False)
+_def("unbind", single_dim=True)
+_def("chunk", dim_offset=1, reduce=False)
+_def("cummax", single_dim=True, reduce=False)
+_def("cummin", single_dim=True, reduce=False)
+_def("cumprod", single_dim=True, reduce=False)
+_def("cumprod_", single_dim=True, reduce=False)
+_def("cumsum", single_dim=True, reduce=False)
+_def("cumsum_", single_dim=True, reduce=False)
+_def("logcumsumexp", single_dim=True, reduce=False)
+_def("renorm", dim_offset=1, single_dim=True, reduce=False)
+_def("softmax", single_dim=True, reduce=False)
+softmax = _wrap(torch.nn.functional.softmax, single_dim=True, reduce=False)
+
+# stuff to handle in the future, because they require special
+# binding logic for dims
+# cross
+# diag_embed
+# diagonal
+# diagonal_scatter
+# diff
+# nanquantile
+# quantile
+# roll
+# rot90
+# topk (new dimes on output)
+# should these all be subsumed by inplace indexing?
+# index_add_
+# index_add
+# index_copy
+# index_copy_
+# index_fill
+# index_fill_
+# index_select
+# scatter
+# scatter_
+# scatter_add
+# scatter_add_
+# scatter_reduce
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..59c520fa7c68b62fba7fca0c7887470058ae082f
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/batch_tensor.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/batch_tensor.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ae7d062ddf5523505492c8d0a2588f3ef6b2248
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/batch_tensor.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/delayed_mul_tensor.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/delayed_mul_tensor.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b69649399397e414d551a30a1bae8b800b41ff08
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/delayed_mul_tensor.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/dim.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/dim.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2269f5c4b5cbce929240bf651b9c1ca79db03cc
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/dim.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/magic_trace.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/magic_trace.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..313df78603e94013501db2b58e2c62007602ddf9
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/magic_trace.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/op_properties.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/op_properties.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6439c1caeafdd04ece2ab444ebccdf2d0d313b3
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/op_properties.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/reference.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/reference.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..904cc0b637cf20b4d69e8542064d8bc0d0006ab6
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/reference.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/tree_map.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/tree_map.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9672502114b7fa2dd9df2445441a403708060fe1
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/tree_map.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/__pycache__/wrap_type.cpython-311.pyc b/lib/python3.11/site-packages/functorch/dim/__pycache__/wrap_type.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a3189076bdf3e1982f7b19d3e5a62bb499d87651
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/dim/__pycache__/wrap_type.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/dim/batch_tensor.py b/lib/python3.11/site-packages/functorch/dim/batch_tensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fc17f2492d5344821071a726a0e3a0e9d5dea95
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/batch_tensor.py
@@ -0,0 +1,25 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+from contextlib import contextmanager
+
+from torch._C._functorch import _vmap_add_layers, _vmap_remove_layers
+
+_enabled = False
+
+
+@contextmanager
+def _enable_layers(dims):
+    global _enabled
+    assert not _enabled
+    input = sorted((d._level, d.size) for d in dims if not isinstance(d, int))
+    n = len(input)
+    try:
+        _vmap_add_layers(input)
+        _enabled = True
+        yield
+    finally:
+        _enabled = False
+        _vmap_remove_layers(n)
diff --git a/lib/python3.11/site-packages/functorch/dim/delayed_mul_tensor.py b/lib/python3.11/site-packages/functorch/dim/delayed_mul_tensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..3984a063885907141b56bdd2c6e8cc730c592cbb
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/delayed_mul_tensor.py
@@ -0,0 +1,77 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+import torch
+
+from . import _Tensor, Tensor
+from .reference import _dims, _enable_layers, llist, ltuple
+
+
+class DelayedMulTensor(_Tensor):
+    def __init__(self, lhs, rhs):
+        self._lhs, self._rhs = lhs, rhs
+        self._data = None
+        self._levels_data = None
+        self._has_device = lhs._has_device or rhs._has_device
+        self._batchtensor_data = None
+        self._tensor_data = None
+
+    @property
+    def _levels(self):
+        if self._levels_data is None:
+            levels = llist(self._lhs._levels)
+            for l in self._rhs._levels:
+                if l not in levels:
+                    levels.append(l)
+            self._levels_data = ltuple(levels)
+        return self._levels_data
+
+    @property
+    def _batchtensor(self):
+        if self._batchtensor_data is None:
+            with _enable_layers(self._levels):
+                print("bt multiply fallback")
+                self._batchtensor_data = self._lhs._batchtensor * self._rhs._batchtensor
+        return self._batchtensor_data
+
+    @property
+    def _tensor(self):
+        if self._tensor_data is None:
+            self._tensor_data = Tensor.from_batched(
+                self._batchtensor, self._has_device
+            )._tensor
+        return self._tensor_data
+
+    @property
+    def ndim(self):
+        return self._batchtensor.ndim
+
+    @property
+    def dims(self):
+        return ltuple(super().dims)
+
+    def sum(self, dim):
+        dims = _dims(dim, 0, False, False)
+        n = ord("a")
+        all_levels = self._levels
+
+        def to_char(d):
+            return chr(n + all_levels.index(d))
+
+        plhs, levelslhs = self._lhs._tensor, self._lhs._levels
+        prhs, levelsrhs = self._rhs._tensor, self._rhs._levels
+        new_dims = tuple(d for d in self.dims if d not in dims)
+        new_levels = [l for l in self._levels if l not in dims]
+        fmt = "".join(
+            [
+                *(to_char(d) for d in levelslhs),
+                ",",
+                *(to_char(d) for d in levelsrhs),
+                "->",
+                *(to_char(d) for d in new_levels),
+            ]
+        )
+        result_data = torch.einsum(fmt, (plhs, prhs))
+        return Tensor.from_positional(result_data, new_levels, True)
diff --git a/lib/python3.11/site-packages/functorch/dim/dim.py b/lib/python3.11/site-packages/functorch/dim/dim.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1a93ebe5c93af5c7b42a8b0b55e719c493ad0d8
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/dim.py
@@ -0,0 +1,110 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+_vmap_levels = []
+
+
+@dataclass
+class LevelInfo:
+    level: int
+    alive: bool = True
+
+
+class Dim:
+    def __init__(self, name: str, size: Union[None, int] = None):
+        self.name = name
+        self._size = None
+        self._vmap_level = None
+        if size is not None:
+            self.size = size
+
+    def __del__(self):
+        if self._vmap_level is not None:
+            _vmap_active_levels[self._vmap_stack].alive = False
+            while (
+                not _vmap_levels[-1].alive and current_level() == _vmap_levels[-1].level
+            ):
+                _vmap_decrement_nesting()
+                _vmap_levels.pop()
+
+    @property
+    def size(self):
+        assert self.is_bound
+        return self._size
+
+    @size.setter
+    def size(self, size: int):
+        if self._size is None:
+            self._size = size
+            self._vmap_level = _vmap_increment_nesting(size, "same")
+            self._vmap_stack = len(_vmap_levels)
+            _vmap_levels.append(LevelInfo(self._vmap_level))
+
+        elif self._size != size:
+            raise DimensionBindError(
+                f"Dim '{self}' previously bound to a dimension of size {self._size} cannot bind to a dimension of size {size}"
+            )
+
+    @property
+    def is_bound(self):
+        return self._size is not None
+
+    def __repr__(self):
+        return self.name
+
+
+def extract_name(inst):
+    assert inst.opname == "STORE_FAST" or inst.opname == "STORE_NAME"
+    return inst.argval
+
+
+_cache = {}
+
+
+def dims(lists=0):
+    frame = inspect.currentframe()
+    assert frame is not None
+    calling_frame = frame.f_back
+    assert calling_frame is not None
+    code, lasti = calling_frame.f_code, calling_frame.f_lasti
+    key = (code, lasti)
+    if key not in _cache:
+        first = lasti // 2 + 1
+        instructions = list(dis.get_instructions(calling_frame.f_code))
+        unpack = instructions[first]
+
+        if unpack.opname == "STORE_FAST" or unpack.opname == "STORE_NAME":
+            # just a single dim, not a list
+            name = unpack.argval
+            ctor = Dim if lists == 0 else DimList
+            _cache[key] = lambda: ctor(name=name)
+        else:
+            assert unpack.opname == "UNPACK_SEQUENCE"
+            ndims = unpack.argval
+            names = tuple(
+                extract_name(instructions[first + 1 + i]) for i in range(ndims)
+            )
+            first_list = len(names) - lists
+            _cache[key] = lambda: tuple(
+                Dim(n) if i < first_list else DimList(name=n)
+                for i, n in enumerate(names)
+            )
+    return _cache[key]()
+
+
+def _dim_set(positional, arg):
+    def convert(a):
+        if isinstance(a, Dim):
+            return a
+        else:
+            assert isinstance(a, int)
+            return positional[a]
+
+    if arg is None:
+        return positional
+    elif not isinstance(arg, (Dim, int)):
+        return tuple(convert(a) for a in arg)
+    else:
+        return (convert(arg),)
diff --git a/lib/python3.11/site-packages/functorch/dim/magic_trace.py b/lib/python3.11/site-packages/functorch/dim/magic_trace.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c962a898ca79cfe3d8af7432aacc3802d4f4ade
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/magic_trace.py
@@ -0,0 +1,42 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+import os
+import signal
+import subprocess
+from contextlib import contextmanager
+
+
+@contextmanager
+def magic_trace(output="trace.fxt", magic_trace_cache="/tmp/magic-trace"):
+    pid = os.getpid()
+    if not os.path.exists(magic_trace_cache):
+        print(f"Downloading magic_trace to: {magic_trace_cache}")
+        subprocess.run(
+            [
+                "wget",
+                "-O",
+                magic_trace_cache,
+                "-q",
+                "https://github.com/janestreet/magic-trace/releases/download/v1.0.2/magic-trace",
+            ]
+        )
+        subprocess.run(["chmod", "+x", magic_trace_cache])
+    args = [magic_trace_cache, "attach", "-pid", str(pid), "-o", output]
+    p = subprocess.Popen(args, stderr=subprocess.PIPE, encoding="utf-8")
+    while True:
+        x = p.stderr.readline()
+        print(x)
+        if "Attached" in x:
+            break
+    try:
+        yield
+    finally:
+        p.send_signal(signal.SIGINT)
+        r = p.wait()
+        print(p.stderr.read())
+        p.stderr.close()
+        if r != 0:
+            raise ValueError(f"magic_trace exited abnormally: {r}")
diff --git a/lib/python3.11/site-packages/functorch/dim/op_properties.py b/lib/python3.11/site-packages/functorch/dim/op_properties.py
new file mode 100644
index 0000000000000000000000000000000000000000..3760f2cb0ea79c2e4ee802abeb8bc954663553e6
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/op_properties.py
@@ -0,0 +1,311 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+import torch
+
+# pointwise operators can go through a faster pathway
+
+tensor_magic_methods = ["add", ""]
+pointwise_magic_methods_with_reverse = (
+    "add",
+    "sub",
+    "mul",
+    "floordiv",
+    "div",
+    "truediv",
+    "mod",
+    "pow",
+    "lshift",
+    "rshift",
+    "and",
+    "or",
+    "xor",
+)
+pointwise_magic_methods = (
+    *(x for m in pointwise_magic_methods_with_reverse for x in (m, "r" + m)),
+    "eq",
+    "gt",
+    "le",
+    "lt",
+    "ge",
+    "gt",
+    "ne",
+    "neg",
+    "pos",
+    "abs",
+    "invert",
+    "iadd",
+    "isub",
+    "imul",
+    "ifloordiv",
+    "idiv",
+    "itruediv",
+    "imod",
+    "ipow",
+    "ilshift",
+    "irshift",
+    "iand",
+    "ior",
+    "ixor",
+    "int",
+    "long",
+    "float",
+    "complex",
+)
+
+pointwise_methods = (*(f"__{m}__" for m in pointwise_magic_methods),)
+
+pointwise = (
+    *(getattr(torch.Tensor, m) for m in pointwise_methods),
+    torch.nn.functional.dropout,
+    torch.where,
+    torch.Tensor.abs,
+    torch.abs,
+    torch.Tensor.acos,
+    torch.acos,
+    torch.Tensor.acosh,
+    torch.acosh,
+    torch.Tensor.add,
+    torch.add,
+    torch.Tensor.addcdiv,
+    torch.addcdiv,
+    torch.Tensor.addcmul,
+    torch.addcmul,
+    torch.Tensor.addr,
+    torch.addr,
+    torch.Tensor.angle,
+    torch.angle,
+    torch.Tensor.asin,
+    torch.asin,
+    torch.Tensor.asinh,
+    torch.asinh,
+    torch.Tensor.atan,
+    torch.atan,
+    torch.Tensor.atan2,
+    torch.atan2,
+    torch.Tensor.atanh,
+    torch.atanh,
+    torch.Tensor.bitwise_and,
+    torch.bitwise_and,
+    torch.Tensor.bitwise_left_shift,
+    torch.bitwise_left_shift,
+    torch.Tensor.bitwise_not,
+    torch.bitwise_not,
+    torch.Tensor.bitwise_or,
+    torch.bitwise_or,
+    torch.Tensor.bitwise_right_shift,
+    torch.bitwise_right_shift,
+    torch.Tensor.bitwise_xor,
+    torch.bitwise_xor,
+    torch.Tensor.ceil,
+    torch.ceil,
+    torch.celu,
+    torch.nn.functional.celu,
+    torch.Tensor.clamp,
+    torch.clamp,
+    torch.Tensor.clamp_max,
+    torch.clamp_max,
+    torch.Tensor.clamp_min,
+    torch.clamp_min,
+    torch.Tensor.copysign,
+    torch.copysign,
+    torch.Tensor.cos,
+    torch.cos,
+    torch.Tensor.cosh,
+    torch.cosh,
+    torch.Tensor.deg2rad,
+    torch.deg2rad,
+    torch.Tensor.digamma,
+    torch.digamma,
+    torch.Tensor.div,
+    torch.div,
+    torch.dropout,
+    torch.nn.functional.dropout,
+    torch.nn.functional.elu,
+    torch.Tensor.eq,
+    torch.eq,
+    torch.Tensor.erf,
+    torch.erf,
+    torch.Tensor.erfc,
+    torch.erfc,
+    torch.Tensor.erfinv,
+    torch.erfinv,
+    torch.Tensor.exp,
+    torch.exp,
+    torch.Tensor.exp2,
+    torch.exp2,
+    torch.Tensor.expm1,
+    torch.expm1,
+    torch.feature_dropout,
+    torch.Tensor.float_power,
+    torch.float_power,
+    torch.Tensor.floor,
+    torch.floor,
+    torch.Tensor.floor_divide,
+    torch.floor_divide,
+    torch.Tensor.fmod,
+    torch.fmod,
+    torch.Tensor.frac,
+    torch.frac,
+    torch.Tensor.frexp,
+    torch.frexp,
+    torch.Tensor.gcd,
+    torch.gcd,
+    torch.Tensor.ge,
+    torch.ge,
+    torch.nn.functional.gelu,
+    torch.nn.functional.glu,
+    torch.Tensor.gt,
+    torch.gt,
+    torch.Tensor.hardshrink,
+    torch.hardshrink,
+    torch.nn.functional.hardshrink,
+    torch.nn.functional.hardsigmoid,
+    torch.nn.functional.hardswish,
+    torch.nn.functional.hardtanh,
+    torch.Tensor.heaviside,
+    torch.heaviside,
+    torch.Tensor.hypot,
+    torch.hypot,
+    torch.Tensor.i0,
+    torch.i0,
+    torch.Tensor.igamma,
+    torch.igamma,
+    torch.Tensor.igammac,
+    torch.igammac,
+    torch.Tensor.isclose,
+    torch.isclose,
+    torch.Tensor.isfinite,
+    torch.isfinite,
+    torch.Tensor.isinf,
+    torch.isinf,
+    torch.Tensor.isnan,
+    torch.isnan,
+    torch.Tensor.isneginf,
+    torch.isneginf,
+    torch.Tensor.isposinf,
+    torch.isposinf,
+    torch.Tensor.isreal,
+    torch.isreal,
+    torch.Tensor.kron,
+    torch.kron,
+    torch.Tensor.lcm,
+    torch.lcm,
+    torch.Tensor.ldexp,
+    torch.ldexp,
+    torch.Tensor.le,
+    torch.le,
+    torch.nn.functional.leaky_relu,
+    torch.Tensor.lerp,
+    torch.lerp,
+    torch.Tensor.lgamma,
+    torch.lgamma,
+    torch.Tensor.log,
+    torch.log,
+    torch.Tensor.log10,
+    torch.log10,
+    torch.Tensor.log1p,
+    torch.log1p,
+    torch.Tensor.log2,
+    torch.log2,
+    torch.nn.functional.logsigmoid,
+    torch.Tensor.logical_and,
+    torch.logical_and,
+    torch.Tensor.logical_not,
+    torch.logical_not,
+    torch.Tensor.logical_or,
+    torch.logical_or,
+    torch.Tensor.logical_xor,
+    torch.logical_xor,
+    torch.Tensor.logit,
+    torch.logit,
+    torch.Tensor.lt,
+    torch.lt,
+    torch.Tensor.maximum,
+    torch.maximum,
+    torch.Tensor.minimum,
+    torch.minimum,
+    torch.nn.functional.mish,
+    torch.Tensor.mvlgamma,
+    torch.mvlgamma,
+    torch.Tensor.nan_to_num,
+    torch.nan_to_num,
+    torch.Tensor.ne,
+    torch.ne,
+    torch.Tensor.neg,
+    torch.neg,
+    torch.Tensor.nextafter,
+    torch.nextafter,
+    torch.Tensor.outer,
+    torch.outer,
+    torch.polar,
+    torch.Tensor.polygamma,
+    torch.polygamma,
+    torch.Tensor.positive,
+    torch.positive,
+    torch.Tensor.pow,
+    torch.pow,
+    torch.Tensor.prelu,
+    torch.prelu,
+    torch.nn.functional.prelu,
+    torch.Tensor.rad2deg,
+    torch.rad2deg,
+    torch.Tensor.reciprocal,
+    torch.reciprocal,
+    torch.Tensor.relu,
+    torch.relu,
+    torch.nn.functional.relu,
+    torch.nn.functional.relu6,
+    torch.Tensor.remainder,
+    torch.remainder,
+    torch.Tensor.round,
+    torch.round,
+    torch.rrelu,
+    torch.nn.functional.rrelu,
+    torch.Tensor.rsqrt,
+    torch.rsqrt,
+    torch.rsub,
+    torch.selu,
+    torch.nn.functional.selu,
+    torch.Tensor.sgn,
+    torch.sgn,
+    torch.Tensor.sigmoid,
+    torch.sigmoid,
+    torch.nn.functional.sigmoid,
+    torch.Tensor.sign,
+    torch.sign,
+    torch.Tensor.signbit,
+    torch.signbit,
+    torch.nn.functional.silu,
+    torch.Tensor.sin,
+    torch.sin,
+    torch.Tensor.sinc,
+    torch.sinc,
+    torch.Tensor.sinh,
+    torch.sinh,
+    torch.nn.functional.softplus,
+    torch.nn.functional.softshrink,
+    torch.Tensor.sqrt,
+    torch.sqrt,
+    torch.Tensor.square,
+    torch.square,
+    torch.Tensor.sub,
+    torch.sub,
+    torch.Tensor.tan,
+    torch.tan,
+    torch.Tensor.tanh,
+    torch.tanh,
+    torch.nn.functional.tanh,
+    torch.threshold,
+    torch.nn.functional.threshold,
+    torch.trapz,
+    torch.Tensor.true_divide,
+    torch.true_divide,
+    torch.Tensor.trunc,
+    torch.trunc,
+    torch.Tensor.xlogy,
+    torch.xlogy,
+    torch.rand_like,
+)
diff --git a/lib/python3.11/site-packages/functorch/dim/reference.py b/lib/python3.11/site-packages/functorch/dim/reference.py
new file mode 100644
index 0000000000000000000000000000000000000000..29d65b13ab3aac89f24fa0ed97ef12928eb4f74c
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/reference.py
@@ -0,0 +1,645 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# reference python implementations for C ops
+import torch
+
+from functorch._C import dim as _C
+from . import op_properties
+from .batch_tensor import _enable_layers
+from .tree_map import tree_flatten, tree_map
+
+DimList = _C.DimList
+import operator
+from functools import reduce
+
+
+# use dict to avoid writing C++ bindings for set
+pointwise = set(op_properties.pointwise)
+
+
+def prod(x):
+    return reduce(operator.mul, x, 1)
+
+
+def _wrap_dim(d, N, keepdim):
+    from . import Dim
+
+    if isinstance(d, Dim):
+        assert not keepdim, "cannot preserve first-class dimensions with keepdim=True"
+        return d
+    elif d >= 0:
+        return d - N
+    else:
+        return d
+
+
+def _dims(d, N, keepdim, single_dim):
+    from . import Dim
+
+    if isinstance(d, (Dim, int)):
+        return ltuple((_wrap_dim(d, N, keepdim),))
+    assert not single_dim, f"expected a single dimension or int but found: {d}"
+    return ltuple(_wrap_dim(x, N, keepdim) for x in d)
+
+
+def _bind_dims_to_size(lhs_size, rhs, lhs_debug):
+    from . import DimensionMismatchError
+
+    not_bound = tuple((i, r) for i, r in enumerate(rhs) if not r.is_bound)
+    if len(not_bound) == 1:
+        idx, d = not_bound[0]
+        rhs_so_far = prod(r.size for r in rhs if r.is_bound)
+        if lhs_size % rhs_so_far != 0:
+            rhs_s = tuple("?" if not r.is_bound else str(r.size) for r in rhs)
+            raise DimensionMismatchError(
+                f"inferred dimension does not evenly fit into larger dimension: {lhs_size} vs {rhs_s}"
+            )
+        new_size = lhs_size // rhs_so_far
+        d.size = new_size
+    elif len(not_bound) > 1:
+        rhs_s = tuple("?" if not r.is_bound else str(r.size) for r in rhs)
+        raise DimensionMismatchError(
+            f"cannot infer the size of two dimensions at once: {rhs} with sizes {rhs_s}"
+        )
+    else:
+        rhs_size = prod(r.size for r in rhs)
+        if lhs_size != rhs_size:
+            raise DimensionMismatchError(
+                f"Dimension sizes to do not match ({lhs_size} != {rhs_size}) when matching {lhs_debug} to {rhs}"
+            )
+
+
+def _tensor_levels(inp):
+    from . import _Tensor
+
+    if isinstance(inp, _Tensor):
+        return inp._tensor, llist(inp._levels), inp._has_device
+    else:
+        return inp, llist(range(-inp.ndim, 0)), True
+
+
+def _match_levels(v, from_levels, to_levels):
+    view = []
+    permute = []
+    requires_view = False
+    size = v.size()
+    for t in to_levels:
+        try:
+            idx = from_levels.index(t)
+            permute.append(idx)
+            view.append(size[idx])
+        except ValueError:
+            view.append(1)
+            requires_view = True
+    if permute != list(range(len(permute))):
+        v = v.permute(*permute)
+    if requires_view:
+        v = v.view(*view)
+    return v
+
+
+# make a single dimension positional but do not permute it,
+# used to do multi-tensor operators where the dim being acted on
+# should not physically move if possible
+def _positional_no_permute(self, dim, expand_dim=False):
+    from . import Tensor
+
+    ptensor, levels = self._tensor, llist(self._levels)
+    try:
+        idx = levels.index(dim)
+    except ValueError:
+        if not expand_dim:
+            raise
+        idx = 0
+        ptensor = ptensor.expand(dim.size, *ptensor.size())
+        levels.insert(0, 0)
+    idx_batched = 0
+    for i in range(idx):
+        if isinstance(levels[i], int):
+            levels[i] -= 1
+            idx_batched += 1
+    levels[idx] = -idx_batched - 1
+    return Tensor.from_positional(ptensor, levels, self._has_device), idx_batched
+
+
+def seq(a, b):
+    from . import Dim
+
+    if isinstance(a, Dim) != isinstance(b, Dim):
+        return False
+    if isinstance(a, Dim):
+        return a is b
+    else:
+        return a == b
+
+
+class isin:
+    def __contains__(self, item):
+        for x in self:
+            if seq(item, x):
+                return True
+        return False
+
+    def index(self, item):
+        for i, x in enumerate(self):
+            if seq(item, x):
+                return i
+        raise ValueError
+
+
+class llist(isin, list):
+    pass
+
+
+class ltuple(isin, tuple):
+    pass
+
+
+empty_dict = {}
+
+
+@classmethod
+def __torch_function__(self, orig, cls, args, kwargs=empty_dict):
+    from . import _Tensor, Tensor, TensorLike
+    from .delayed_mul_tensor import DelayedMulTensor
+
+    if orig is torch.Tensor.__mul__:
+        lhs, rhs = args
+        if (
+            isinstance(lhs, _Tensor)
+            and isinstance(rhs, _Tensor)
+            and lhs.ndim == 0
+            and rhs.ndim == 0
+        ):
+            return DelayedMulTensor(lhs, rhs)
+    all_dims = llist()
+    flat_args, unflatten = tree_flatten((args, kwargs))
+    device_holding_tensor = None
+    for f in flat_args:
+        if isinstance(f, _Tensor):
+            if f._has_device:
+                device_holding_tensor = f._batchtensor
+            for d in f.dims:
+                if d not in all_dims:
+                    all_dims.append(d)
+
+    def unwrap(t):
+        if isinstance(t, _Tensor):
+            r = t._batchtensor
+            if device_holding_tensor is not None and not t._has_device:
+                r = r.to(device=device_holding_tensor.device)
+            return r
+        return t
+
+    if orig in pointwise:
+        result_levels = llist()
+        arg_levels = llist()
+        to_expand = []
+        for i, f in enumerate(flat_args):
+            if isinstance(f, TensorLike):
+                ptensor, levels, _ = _tensor_levels(f)
+                if (
+                    isinstance(f, _Tensor)
+                    and not f._has_device
+                    and device_holding_tensor is not None
+                ):
+                    ptensor = ptensor.to(device=device_holding_tensor.device)
+                flat_args[i] = ptensor
+                for l in levels:
+                    if l not in result_levels:
+                        result_levels.append(l)
+                to_expand.append((i, levels))
+
+        for i, levels in to_expand:
+            flat_args[i] = _match_levels(flat_args[i], levels, result_levels)
+        args, kwargs = unflatten(flat_args)
+        result = orig(*args, **kwargs)
+
+        def wrap(t):
+            if isinstance(t, TensorLike):
+                return Tensor.from_positional(
+                    t, result_levels, device_holding_tensor is not None
+                )
+            return t
+
+        return tree_map(wrap, result)
+    else:
+
+        def wrap(t):
+            if isinstance(t, TensorLike):
+                return Tensor.from_batched(t, device_holding_tensor is not None)
+            return t
+
+        with _enable_layers(all_dims):
+            print(f"batch_tensor for {orig}")
+            args, kwargs = unflatten(unwrap(f) for f in flat_args)
+            result = orig(*args, **kwargs)
+            # print("END", orig)
+            return tree_map(wrap, result)
+
+
+def positional(self, *dims):
+    from . import Dim, Tensor
+
+    ptensor, levels = self._tensor, llist(self._levels)
+    flat_dims = llist()
+    view = []
+    needs_view = False
+    ndim = self.ndim
+    for d in dims:
+        if isinstance(d, DimList):
+            flat_dims.extend(d)
+            view.extend(e.size for e in d)
+        elif isinstance(d, Dim):
+            flat_dims.append(d)
+            view.append(d.size)
+        elif isinstance(d, int):
+            d = _wrap_dim(d, ndim, False)
+            flat_dims.append(d)
+            view.append(ptensor.size(d))
+        else:
+            flat_dims.extend(d)
+            view.append(prod(e.size for e in d))
+            needs_view = True
+
+    permute = list(range(len(levels)))
+    nflat = len(flat_dims)
+    for i, d in enumerate(flat_dims):
+        try:
+            idx = levels.index(d)
+        except ValueError as e:
+            raise DimensionBindError(
+                f"tensor of dimensions {self.dims} does not contain dim {d}"
+            ) from e
+        p = permute[idx]
+        del levels[idx]
+        del permute[idx]
+        levels.insert(i, 0)
+        permute.insert(i, p)
+    ptensor = ptensor.permute(*permute)
+    seen = 0
+    for i in range(len(levels) - 1, -1, -1):
+        if isinstance(levels[i], int):
+            seen += 1
+            levels[i] = -seen
+    result = Tensor.from_positional(ptensor, levels, self._has_device)
+    if needs_view:
+        result = result.reshape(*view, *result.size()[len(flat_dims) :])
+    return result
+
+
+def _contains_dim(input):
+    from . import Dim
+
+    for i in input:
+        if isinstance(i, Dim):
+            return True
+
+
+def expand(self, *sizes):
+    if not _contains_dim(sizes):
+        return self.__torch_function__(torch.Tensor.expand, None, (self, *sizes))
+    dims = sizes
+    sizes = [d.size for d in dims] + [-1] * self.ndim
+    self = self.expand(*sizes)
+    return self[dims]
+
+
+_not_present = object()
+
+
+def _getarg(name, offset, args, kwargs, default):
+    if len(args) > offset:
+        return args[offset]
+    return kwargs.get(name, default)
+
+
+def _patcharg(name, offset, args, kwargs, value):
+    if len(args) > offset:
+        args[offset] = value
+    else:
+        kwargs[name] = value
+
+
+def _wrap(
+    orig, dim_offset=0, keepdim_offset=1, dim_name="dim", single_dim=False, reduce=True
+):
+    from . import Dim, Tensor, TensorLike
+
+    def fn(self, *args, **kwargs):
+        dim = _getarg(dim_name, dim_offset, args, kwargs, _not_present)
+        if dim is _not_present or (single_dim and not isinstance(dim, Dim)):
+            with _enable_layers(self.dims):
+                print(f"dim fallback batch_tensor for {orig}")
+                return Tensor.from_batched(
+                    orig(self._batchtensor, *args, **kwargs), self._has_device
+                )
+        keepdim = (
+            _getarg("keepdim", keepdim_offset, args, kwargs, False) if reduce else False
+        )
+        t, levels = self._tensor, llist(self._levels)
+        dims = _dims(dim, self._batchtensor.ndim, keepdim, single_dim)
+        dim_indices = tuple(levels.index(d) for d in dims)
+        if reduce and not keepdim:
+            new_levels = [l for i, l in enumerate(levels) if i not in dim_indices]
+        else:
+            new_levels = levels
+
+        if len(dim_indices) == 1:
+            dim_indices = dim_indices[
+                0
+            ]  # so that dims that really only take a single argument work...
+        args = list(args)
+        _patcharg(dim_name, dim_offset, args, kwargs, dim_indices)
+
+        def wrap(t):
+            if isinstance(t, TensorLike):
+                return Tensor.from_positional(t, new_levels, self._has_device)
+            return t
+
+        with _enable_layers(new_levels):
+            print(f"dim used batch_tensor for {orig}")
+            r = orig(t, *args, **kwargs)
+            return tree_map(wrap, r)
+
+    return fn
+
+
+def _def(name, *args, **kwargs):
+    from . import _Tensor
+
+    orig = getattr(torch.Tensor, name)
+    setattr(_Tensor, name, _wrap(orig, *args, **kwargs))
+
+
+no_slice = slice(None)
+
+_orig_getitem = torch.Tensor.__getitem__
+
+
+class dim_tracker:
+    def __init__(self):
+        self.dims = llist()
+        self.count = []
+
+    def record(self, d):
+        if d not in self.dims:
+            self.dims.append(d)
+            self.count.append(1)
+
+    def __getitem__(self, d):
+        return self.count[self.dims.index(d)]
+
+
+def t__getitem__(self, input):
+    from . import _Tensor, Dim, DimensionBindError, DimList, Tensor, TensorLike
+
+    # * bail to original example if we have a single non-Dim tensor, or a non-tensor
+    # * locate ... or an unbound tensor list, and determine its size, bind dim list
+    #   (remember that None does not count to the total dim count)
+    # * bind simple dims and dim-packs to their sizes, count the number of uses of each dim,
+    #   produce the re-view if needed
+    # * for each single-use dim index, replace with no_slice and mark that it will be added
+    #   (keep track of whether we have to call super)
+    # * call super if needed
+    # * if we have dims to bind, bind them (it will help if we eliminated ... and None before)
+
+    # this handles bool indexing handling, as well as some other simple cases.
+
+    is_simple = (
+        not isinstance(input, Dim)
+        and not isinstance(input, (tuple, list))
+        and
+        # WAR for functorch bug where zero time tensors in getitem are not handled correctly.
+        not (isinstance(input, TensorLike) and input.ndim == 0)
+    )
+
+    if is_simple:
+        if isinstance(self, _Tensor):
+            return _Tensor.__torch_function__(_orig_getitem, None, (self, input))
+        else:
+            return _orig_getitem(self, input)
+
+    # can further optimize this case
+    if not isinstance(input, tuple):
+        input = [input]
+    else:
+        input = list(input)
+
+    dims_indexed = 0
+    expanding_object = None
+    dimlists = []
+    for i, s in enumerate(input):
+        if s is ... or isinstance(s, DimList) and not s.is_bound:
+            if expanding_object is not None:
+                msg = (
+                    "at most one ... or unbound dimension list can exist in indexing list but"
+                    f" found 2 at offsets {i} and {expanding_object}"
+                )
+                raise DimensionBindError(msg)
+            expanding_object = i
+
+        if isinstance(s, DimList):
+            dims_indexed += len(s) if s.is_bound else 0
+            dimlists.append(i)
+        elif s is not None and s is not ...:
+            dims_indexed += 1
+
+    ndim = self.ndim
+    if dims_indexed > ndim:
+        raise IndexError(
+            f"at least {dims_indexed} indices were supplied but the tensor only has {ndim} dimensions."
+        )
+    if expanding_object is not None:
+        expanding_ndims = ndim - dims_indexed
+        obj = input[expanding_object]
+        if obj is ...:
+            input[expanding_object : expanding_object + 1] = [
+                no_slice
+            ] * expanding_ndims
+        else:
+            obj.bind_len(expanding_ndims)
+    # flatten the dimslists into the indexing
+    for i in reversed(dimlists):
+        input[i : i + 1] = input[i]
+    dims_indexed = 0
+    requires_view = False
+    size = self.size()
+    view_sizes = []
+    dims_seen = dim_tracker()
+
+    def add_dims(t):
+        if not isinstance(t, _Tensor):
+            return
+        for d in t.dims:
+            dims_seen.record(d)
+
+    add_dims(self)
+    dim_packs = []
+    for i, idx in enumerate(input):
+        if idx is None:
+            input[i] = no_slice
+            view_sizes.append(1)
+            requires_view = True
+        else:
+            sz = size[dims_indexed]
+            if isinstance(idx, Dim):
+                idx.size = sz
+                dims_seen.record(idx)
+                view_sizes.append(sz)
+            elif isinstance(idx, (tuple, list)) and idx and isinstance(idx[0], Dim):
+                for d in idx:
+                    dims_seen.record(idx)
+                _bind_dims_to_size(sz, idx, f"offset {i}")
+                view_sizes.extend(d.size for d in idx)
+                requires_view = True
+                dim_packs.append(i)
+            else:
+                add_dims(idx)
+                view_sizes.append(sz)
+            dims_indexed += 1
+    if requires_view:
+        self = self.view(*view_sizes)
+    for i in reversed(dim_packs):
+        input[i : i + 1] = input[i]
+
+    # currenty:
+    # input is flat, containing either Dim, or Tensor, or something valid for standard indexing
+    # self may have first-class dims as well.
+
+    # to index:
+    # drop the first class dims from self, they just become direct indices of their positions
+
+    # figure out the dimensions of the indexing tensors: union of all the dims in the tensors in the index.
+    # these dimensions will appear and need to be bound at the first place tensor occures
+
+    if isinstance(self, _Tensor):
+        ptensor_self, levels = self._tensor, list(self._levels)
+        # indices to ptensor rather than self which has first-class dimensions
+        input_it = iter(input)
+        flat_inputs = [next(input_it) if isinstance(l, int) else l for l in levels]
+        has_device = self._has_device
+        to_pad = 0
+    else:
+        ptensor_self, flat_inputs = self, input
+        to_pad = ptensor_self.ndim - len(flat_inputs)
+        has_device = True
+
+    result_levels = []
+    index_levels = []
+    tensor_insert_point = None
+    to_expand = {}
+    requires_getindex = False
+    for i, inp in enumerate(flat_inputs):
+        if isinstance(inp, Dim) and dims_seen[inp] == 1:
+            flat_inputs[i] = no_slice
+            result_levels.append(inp)
+        elif isinstance(inp, TensorLike):
+            requires_getindex = True
+            if tensor_insert_point is None:
+                tensor_insert_point = len(result_levels)
+            ptensor, levels, _ = _tensor_levels(inp)
+            to_expand[i] = levels
+            flat_inputs[i] = ptensor
+            for l in levels:
+                if l not in index_levels:
+                    index_levels.append(l)
+        else:
+            requires_getindex = True
+            result_levels.append(0)
+
+    if tensor_insert_point is not None:
+        result_levels[tensor_insert_point:tensor_insert_point] = index_levels
+
+    for i, levels in to_expand.items():
+        flat_inputs[i] = _match_levels(flat_inputs[i], levels, index_levels)
+
+    if requires_getindex:
+        result = _orig_getitem(ptensor_self, flat_inputs)
+    else:
+        result = ptensor_self
+
+    next_positional = -1
+    if to_pad > 0:
+        result_levels.extend([0] * to_pad)
+    for i, r in enumerate(reversed(result_levels)):
+        if isinstance(r, int):
+            result_levels[-1 - i] = next_positional
+            next_positional -= 1
+
+    return Tensor.from_positional(result, result_levels, has_device)
+
+
+# XXX - dim is optional and can be the outer-most dimension...
+def stack(tensors, new_dim, dim=0, out=None):
+    if isinstance(dim, int):
+        return torch.stack(tensors, dim, out).index(dim, new_dim)
+    index = None
+    if out is not None:
+        out, index = _positional_no_permute(out, dim, expand_dim=True)
+    ptensors = []
+    for t in tensors:
+        pt, pi = _positional_no_permute(t, dim, expand_dim=True)
+        if index is not None and pi != index:
+            pt = pt.move_dim(pi, index)
+        else:
+            index = pi
+        ptensors.append(pt)
+    pr = torch.stack(ptensors, index, out=out)
+    return pr.index((index, index + 1), (new_dim, dim))
+
+
+_orig_split = torch.Tensor.split
+
+
+def split(self, split_size_or_sections, dim=0):
+    from . import _Tensor, Dim
+
+    if isinstance(split_size_or_sections, int) or any(
+        isinstance(t, int) for t in split_size_or_sections
+    ):
+        if isinstance(dim, Dim):
+            raise ValueError(
+                "when dim is specified as a Dim object, split sizes must also be dimensions."
+            )
+        return _orig_split(self, split_size_or_sections, dim=dim)
+
+    if isinstance(dim, Dim):
+        assert isinstance(self, _Tensor), f"Tensor does not have dimension {dim}"
+        self, dim = _positional_no_permute(self, dim)
+
+    size = self.size(dim)
+    total_bound_size = 0
+    unbound = []
+    sizes = []
+    for i, d in enumerate(split_size_or_sections):
+        if d.is_bound:
+            sizes.append(d.size)
+            total_bound_size += d.size
+        else:
+            sizes.append(0)
+            unbound.append(i)
+
+    if unbound:
+        assert (
+            total_bound_size <= size
+        ), f"result dimensions are larger than original: {total_bound_size} vs {size} ({split_size_or_sections})"
+        remaining_size = size - total_bound_size
+        chunk_size = -(-remaining_size // len(unbound))
+        for u in unbound:
+            sz = min(chunk_size, remaining_size)
+            split_size_or_sections[u].size = sz
+            sizes[u] = sz
+            remaining_size -= sz
+    else:
+        assert (
+            total_bound_size == size
+        ), f"result dimensions do not match original: {total_bound_size} vs {size} ({split_size_or_sections})"
+    return tuple(
+        t.index(dim, d)
+        for d, t in zip(split_size_or_sections, _orig_split(self, sizes, dim=dim))
+    )
diff --git a/lib/python3.11/site-packages/functorch/dim/tree_map.py b/lib/python3.11/site-packages/functorch/dim/tree_map.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f02f02656f288f81b81bee61736567b2326500d
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/tree_map.py
@@ -0,0 +1,14 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from functorch._C import dim
+
+tree_flatten = dim.tree_flatten
+
+
+def tree_map(fn, tree):
+    vs, unflatten = tree_flatten(tree)
+    return unflatten(fn(v) for v in vs)
diff --git a/lib/python3.11/site-packages/functorch/dim/wrap_type.py b/lib/python3.11/site-packages/functorch/dim/wrap_type.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2146c4a21a144dc3942e304d1406ace47df0e57
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/dim/wrap_type.py
@@ -0,0 +1,71 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from types import (
+    BuiltinMethodType,
+    FunctionType,
+    GetSetDescriptorType,
+    MethodDescriptorType,
+    WrapperDescriptorType,
+)
+
+from functorch._C import dim as _C
+
+_wrap_method = _C._wrap_method
+
+FUNC_TYPES = (
+    FunctionType,
+    MethodDescriptorType,
+    BuiltinMethodType,
+    WrapperDescriptorType,
+)
+PROPERTY_TYPES = (GetSetDescriptorType, property)
+
+
+def _py_wrap_method(orig, __torch_function__):
+    def impl(*args, **kwargs):
+        return __torch_function__(orig, None, args, kwargs)
+
+    return impl
+
+
+def wrap_type(use_c, to_patch, pattern, __torch_function__):
+    if use_c:
+        wrap_method = _wrap_method
+    else:
+        wrap_method = _py_wrap_method
+
+    all = {}
+    for t in reversed(pattern.mro()[:-1]):  # skip object
+        all.update(t.__dict__)
+
+    def wrap_attr(orig):
+        return property(wrap_method(orig.__get__, __torch_function__))
+
+    for name, obj in all.items():
+        if name in (
+            "__dict__",
+            "__new__",
+            "__init__",
+            "__repr__",
+            "__weakref__",
+            "__doc__",
+            "__module__",
+            "__dir__",
+        ):
+            continue
+
+        # skip things that have been overloaded
+        # things that come from object like `__eq__` still need to be patched, however.
+        if hasattr(to_patch, name) and getattr(to_patch, name) is not getattr(
+            object, name, None
+        ):
+            continue
+
+        if isinstance(obj, FUNC_TYPES):
+            setattr(to_patch, name, wrap_method(obj, __torch_function__))
+        elif isinstance(obj, PROPERTY_TYPES):
+            setattr(to_patch, name, wrap_attr(obj))
diff --git a/lib/python3.11/site-packages/functorch/einops/__init__.py b/lib/python3.11/site-packages/functorch/einops/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b32751d6e2493ab6a81f5a7f91a572553201f466
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/einops/__init__.py
@@ -0,0 +1,3 @@
+from .rearrange import rearrange
+
+__all__ = ["rearrange"]
diff --git a/lib/python3.11/site-packages/functorch/einops/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/einops/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..97566145bbf88c41a6229175d7f9ba019657c865
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/einops/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/einops/__pycache__/_parsing.cpython-311.pyc b/lib/python3.11/site-packages/functorch/einops/__pycache__/_parsing.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..451b234766045e68a3a11ec27fbcc9a59b0b9080
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/einops/__pycache__/_parsing.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/einops/__pycache__/rearrange.cpython-311.pyc b/lib/python3.11/site-packages/functorch/einops/__pycache__/rearrange.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2a3313b51261acb4b7864c2ca8eb47949c462f8
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/einops/__pycache__/rearrange.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/einops/_parsing.py b/lib/python3.11/site-packages/functorch/einops/_parsing.py
new file mode 100644
index 0000000000000000000000000000000000000000..63adcb6e5a64c777a4e1a711da5ac9f3b7fe1dfd
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/einops/_parsing.py
@@ -0,0 +1,302 @@
+"""Adapted from https://github.com/arogozhnikov/einops/blob/36c7bb16e57d6e57f8f3050f9e07abdf3f00469f/einops/parsing.py.
+
+MIT License
+
+Copyright (c) 2018 Alex Rogozhnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+from __future__ import annotations
+
+import keyword
+import warnings
+from typing import Collection, List, Mapping, Optional, Set, Tuple, Union
+
+_ellipsis: str = "…"  # NB, this is a single unicode symbol. String is used as it is not a list, but can be iterated
+
+
+class AnonymousAxis:
+    """Used by `ParsedExpression` to represent an axis with a size (> 1), but no associated identifier.
+
+    Note: Different instances of this class are not equal to each other, even if they have the same value.
+    """
+
+    def __init__(self, value: str) -> None:
+        self.value = int(value)
+        if self.value < 1:
+            raise ValueError(
+                f"Anonymous axis should have positive length, not {self.value}"
+            )
+
+    def __repr__(self) -> str:
+        return f"{self.value}-axis"
+
+
+class ParsedExpression:
+    """Structure containing information about one side of an `einops`-style pattern (e.g. 'b c (h w)')."""
+
+    def __init__(
+        self,
+        expression: str,
+        *,
+        allow_underscore: bool = False,
+        allow_duplicates: bool = False,
+    ) -> None:
+        """Parse the expression and store relevant metadata.
+
+        Args:
+            expression (str): the `einops`-pattern to parse
+            allow_underscore (bool): whether to allow axis identifier names to begin with an underscore
+            allow_duplicates (bool): whether to allow an identifier to appear more than once in the expression
+        """
+        self.has_ellipsis: bool = False
+        self.has_ellipsis_parenthesized: Optional[bool] = None
+        self.identifiers: Set[Union[str, AnonymousAxis]] = set()
+        # that's axes like 2, 3, 4 or 5. Axes with size 1 are exceptional and replaced with empty composition
+        self.has_non_unitary_anonymous_axes: bool = False
+        # composition keeps structure of composite axes, see how different corner cases are handled in tests
+        self.composition: List[Union[List[Union[str, AnonymousAxis]], str]] = []
+        if "." in expression:
+            if "..." not in expression:
+                raise ValueError(
+                    "Expression may contain dots only inside ellipsis (...)"
+                )
+            if str.count(expression, "...") != 1 or str.count(expression, ".") != 3:
+                raise ValueError(
+                    "Expression may contain dots only inside ellipsis (...); only one ellipsis for tensor "
+                )
+            expression = expression.replace("...", _ellipsis)
+            self.has_ellipsis = True
+
+        bracket_group: Optional[List[Union[str, AnonymousAxis]]] = None
+
+        def add_axis_name(x: str) -> None:
+            if x in self.identifiers:
+                if not (allow_underscore and x == "_") and not allow_duplicates:
+                    raise ValueError(
+                        f"Indexing expression contains duplicate dimension '{x}'"
+                    )
+            if x == _ellipsis:
+                self.identifiers.add(_ellipsis)
+                if bracket_group is None:
+                    self.composition.append(_ellipsis)
+                    self.has_ellipsis_parenthesized = False
+                else:
+                    bracket_group.append(_ellipsis)
+                    self.has_ellipsis_parenthesized = True
+            else:
+                is_number = str.isdecimal(x)
+                if is_number and int(x) == 1:
+                    # handling the case of anonymous axis of length 1
+                    if bracket_group is None:
+                        self.composition.append([])
+                    else:
+                        pass  # no need to think about 1s inside parenthesis
+                    return
+                is_axis_name, reason = self.check_axis_name_return_reason(
+                    x, allow_underscore=allow_underscore
+                )
+                if not (is_number or is_axis_name):
+                    raise ValueError(f"Invalid axis identifier: {x}\n{reason}")
+                axis_name: Union[str, AnonymousAxis] = (
+                    AnonymousAxis(x) if is_number else x
+                )
+                self.identifiers.add(axis_name)
+                if is_number:
+                    self.has_non_unitary_anonymous_axes = True
+                if bracket_group is None:
+                    self.composition.append([axis_name])
+                else:
+                    bracket_group.append(axis_name)
+
+        current_identifier = None
+        for char in expression:
+            if char in "() ":
+                if current_identifier is not None:
+                    add_axis_name(current_identifier)
+                current_identifier = None
+                if char == "(":
+                    if bracket_group is not None:
+                        raise ValueError(
+                            "Axis composition is one-level (brackets inside brackets not allowed)"
+                        )
+                    bracket_group = []
+                elif char == ")":
+                    if bracket_group is None:
+                        raise ValueError("Brackets are not balanced")
+                    self.composition.append(bracket_group)
+                    bracket_group = None
+            elif str.isalnum(char) or char in ["_", _ellipsis]:
+                if current_identifier is None:
+                    current_identifier = char
+                else:
+                    current_identifier += char
+            else:
+                raise ValueError(f"Unknown character '{char}'")
+
+        if bracket_group is not None:
+            raise ValueError(f"Imbalanced parentheses in expression: '{expression}'")
+        if current_identifier is not None:
+            add_axis_name(current_identifier)
+
+    @staticmethod
+    def check_axis_name_return_reason(
+        name: str, allow_underscore: bool = False
+    ) -> Tuple[bool, str]:
+        """Check if the given axis name is valid, and a message explaining why if not.
+
+        Valid axes names are python identifiers except keywords, and should not start or end with an underscore.
+
+        Args:
+            name (str): the axis name to check
+            allow_underscore (bool): whether axis names are allowed to start with an underscore
+
+        Returns:
+            Tuple[bool, str]: whether the axis name is valid, a message explaining why if not
+        """
+        if not str.isidentifier(name):
+            return False, "not a valid python identifier"
+        elif name[0] == "_" or name[-1] == "_":
+            if name == "_" and allow_underscore:
+                return True, ""
+            return False, "axis name should should not start or end with underscore"
+        else:
+            if keyword.iskeyword(name):
+                warnings.warn(
+                    f"It is discouraged to use axes names that are keywords: {name}",
+                    RuntimeWarning,
+                )
+            if name in ["axis"]:
+                warnings.warn(
+                    "It is discouraged to use 'axis' as an axis name and will raise an error in future",
+                    FutureWarning,
+                )
+            return True, ""
+
+    @staticmethod
+    def check_axis_name(name: str) -> bool:
+        """Check if the name is a valid axis name.
+
+        Args:
+            name (str): the axis name to check
+
+        Returns:
+            bool: whether the axis name is valid
+        """
+        is_valid, _ = ParsedExpression.check_axis_name_return_reason(name)
+        return is_valid
+
+
+def parse_pattern(
+    pattern: str, axes_lengths: Mapping[str, int]
+) -> Tuple[ParsedExpression, ParsedExpression]:
+    """Parse an `einops`-style pattern into a left-hand side and right-hand side `ParsedExpression` object.
+
+    Args:
+        pattern (str): the `einops`-style rearrangement pattern
+        axes_lengths (Mapping[str, int]): any additional length specifications for dimensions
+
+    Returns:
+       Tuple[ParsedExpression, ParsedExpression]: a tuple containing the left-hand side and right-hand side expressions
+    """
+    # adapted from einops.einops._prepare_transformation_recipe
+    # https://github.com/arogozhnikov/einops/blob/230ac1526c1f42c9e1f7373912c7f8047496df11/einops/einops.py
+    try:
+        left_str, right_str = pattern.split("->")
+    except ValueError:
+        raise ValueError("Pattern must contain a single '->' separator") from None
+
+    if _ellipsis in axes_lengths:
+        raise ValueError(f"'{_ellipsis}' is not an allowed axis identifier")
+
+    left = ParsedExpression(left_str)
+    right = ParsedExpression(right_str)
+
+    if not left.has_ellipsis and right.has_ellipsis:
+        raise ValueError(
+            f"Ellipsis found in right side, but not left side of a pattern {pattern}"
+        )
+    if left.has_ellipsis and left.has_ellipsis_parenthesized:
+        raise ValueError(
+            f"Ellipsis is parenthesis in the left side is not allowed: {pattern}"
+        )
+
+    return left, right
+
+
+def validate_rearrange_expressions(
+    left: ParsedExpression, right: ParsedExpression, axes_lengths: Mapping[str, int]
+) -> None:
+    """Perform expression validations that are specific to the `rearrange` operation.
+
+    Args:
+        left (ParsedExpression): left-hand side expression
+        right (ParsedExpression): right-hand side expression
+        axes_lengths (Mapping[str, int]): any additional length specifications for dimensions
+    """
+    for length in axes_lengths.values():
+        if (length_type := type(length)) is not int:
+            raise TypeError(
+                f"rearrange axis lengths must be integers, got: {length_type}"
+            )
+
+    if left.has_non_unitary_anonymous_axes or right.has_non_unitary_anonymous_axes:
+        raise ValueError("rearrange only supports unnamed axes of size 1")
+
+    difference = set.symmetric_difference(left.identifiers, right.identifiers)
+    if len(difference) > 0:
+        raise ValueError(
+            f"Identifiers only on one side of rearrange expression (should be on both): {difference}"
+        )
+
+    unmatched_axes = axes_lengths.keys() - left.identifiers
+    if len(unmatched_axes) > 0:
+        raise ValueError(
+            f"Identifiers not found in rearrange expression: {unmatched_axes}"
+        )
+
+
+def comma_separate(collection: Collection[Union[str, Collection[str]]]) -> str:
+    """Convert a collection of strings representing first class dims into a comma-separated string.
+
+    Args:
+        collection (Collection[Union[str, Collection[str]]]): the collection of strings to convert
+
+    Returns:
+        str: the comma-separated string
+
+    Examples:
+        >>> comma_separate(('d0',))
+        'd0'
+
+        >>> comma_separate(('d0', 'd1', 'd2', 'd3'))
+        'd0, d1, d2, d3'
+
+        >>> comma_separate([('d1', 'd4')])
+        '(d1, d4)'
+
+        >>> comma_separate([('d0',), (), ('d1',), ('d2',), ('d3', 'd4')])
+        '(d0,), (), (d1,), (d2,), (d3, d4)'
+    """
+    return ", ".join(
+        item
+        if isinstance(item, str)
+        else f"({comma_separate(item)}{',' if len(item) == 1 else ''})"
+        for item in collection
+    )
diff --git a/lib/python3.11/site-packages/functorch/einops/rearrange.py b/lib/python3.11/site-packages/functorch/einops/rearrange.py
new file mode 100644
index 0000000000000000000000000000000000000000..0449bb7ed2c72ef68f966f253c99e8570dfbd7ef
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/einops/rearrange.py
@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import functools
+from typing import Callable, Dict, List, Sequence, Tuple, Union
+
+import torch
+
+from functorch._C import dim as _C
+from ._parsing import (
+    _ellipsis,
+    AnonymousAxis,
+    comma_separate,
+    parse_pattern,
+    validate_rearrange_expressions,
+)
+
+__all__ = ["rearrange"]
+
+dims = _C.dims
+
+
+@functools.lru_cache(256)
+def _create_rearrange_callable(
+    tensor_ndim: int, pattern: str, **axes_lengths: int
+) -> Callable[[torch.Tensor], torch.Tensor]:
+    r"""Translate an `einops`-style pattern into a callable that performs the rearrange using first-class dimensions.
+
+    Since the an equivalent result is computed for tensors with the same number of dimensions, with the same pattern and
+    specified axes lengths, this function can be memoized.
+
+    Args:
+        tensor_ndim (int): the number of dimensions in the tensor to rearrange
+        pattern (str): the `einops`-style rearrangement pattern
+        axes_lengths (int): any additional length specifications for dimensions
+
+    Returns:
+        Callable[[torch.Tensor], torch.Tensor]: a callable that performs the rearrangement
+    """
+    left, right = parse_pattern(pattern, axes_lengths)
+    validate_rearrange_expressions(left, right, axes_lengths)
+
+    n_anon_dims = sum(not dim for dim in left.composition)
+    if left.has_ellipsis:
+        n_ellipsis_dims = tensor_ndim - (len(left.composition) - 1)
+        n_named_dims = len(left.identifiers) - 1
+
+        if (pattern_ndim := n_anon_dims + n_named_dims) > tensor_ndim:
+            raise ValueError(
+                f"Number of dimensions in pattern ({pattern_ndim}) must be less than or equal to the number of "
+                f"dimensions in the tensor ({tensor_ndim})"
+            )
+    else:
+        n_ellipsis_dims = 0
+        n_named_dims = len(left.identifiers)
+
+        if (pattern_ndim := len(left.composition)) != tensor_ndim:
+            raise ValueError(
+                f"Number of dimensions in pattern ({pattern_ndim}) must be equal to the number of dimensions in "
+                f"the tensor ({tensor_ndim})"
+            )
+    n_dims = n_named_dims + n_ellipsis_dims + n_anon_dims
+
+    if n_dims == 0:
+        # an identity rearrangement on a 0-dimension tensor
+        return lambda tensor: tensor
+
+    first_class_dims: Tuple[str, ...] = tuple(f"d{i}" for i in range(n_dims))
+    identifier_dim_map: Dict[Union[str, AnonymousAxis], Tuple[str, ...]] = {}
+    anon_axes: List[AnonymousAxis] = []
+
+    # map the left-hand side identifiers to strings representing first class dims
+    dims_i = 0
+    for dimension in left.composition:
+        if isinstance(dimension, list):
+            for identifier in dimension:
+                # non-unitary anon axes are not allowed in rearrange & unitary anon axes are represented as empty lists
+                assert isinstance(identifier, str)
+                identifier_dim_map[identifier] = (first_class_dims[dims_i],)
+                dims_i += 1
+            if not dimension:
+                # unitary anonymous axis
+                anon_axis = AnonymousAxis("1")
+                identifier_dim_map[anon_axis] = (first_class_dims[dims_i],)
+                anon_axes.append(anon_axis)
+                dimension.append(anon_axis)
+                dims_i += 1
+        elif dimension == _ellipsis:
+            identifier = _ellipsis
+            identifier_dim_map[identifier] = tuple(
+                first_class_dims[dims_i + j] for j in range(n_ellipsis_dims)
+            )
+            dims_i += n_ellipsis_dims
+        else:
+            raise ValueError(f"Unexpected dimension: {dimension}")
+
+    def composition_to_dims(
+        composition: Sequence[Union[List[Union[str, AnonymousAxis]], str]]
+    ) -> List[Union[str, Tuple[str, ...]]]:
+        """Convert a `ParsedExpression.composition` into a `Tensor.__getitem__` index of strings representing first
+        class dims."""
+        dim_composition: List[Union[str, Tuple[str, ...]]] = []
+        for dimension in composition:
+            if isinstance(dimension, list):
+                dim_composition.append(
+                    tuple(
+                        dim
+                        for identifier in dimension
+                        for dim in identifier_dim_map[identifier]
+                    )
+                )
+            elif dimension == _ellipsis:
+                dim_composition.extend(identifier_dim_map[_ellipsis])
+            else:
+                raise ValueError(f"Unexpected dimension: {dimension}")
+        return dim_composition
+
+    left_dims = composition_to_dims(left.composition)
+    right_dims = composition_to_dims(right.composition)
+    anon_dims = tuple(identifier_dim_map[axis][0] for axis in anon_axes)
+    specified_lengths = tuple(
+        (identifier_dim_map[axis][0], length) for axis, length in axes_lengths.items()
+    )
+
+    custom_rearrange_callable_name = "do_rearrange"
+    custom_rearrange_callable_code = (
+        (
+            f"def {custom_rearrange_callable_name}(tensor):\n"
+            f"    {comma_separate(first_class_dims)} = dims({n_dims})\n"
+        )
+        + (
+            "".join(
+                f"    {dim}.size = {length}\n" for (dim, length) in specified_lengths
+            )
+            if specified_lengths
+            else ""
+        )
+        + f"    tensor = tensor[{comma_separate(left_dims)}].order({comma_separate(right_dims)})\n"
+        + (
+            f"    return tensor.sum({comma_separate([anon_dims])}, keepdim=False)\n"
+            if anon_dims
+            else "    return tensor\n"
+        )
+    )
+
+    exec(custom_rearrange_callable_code)
+    return locals()[custom_rearrange_callable_name]
+
+
+def rearrange(
+    tensor: Union[torch.Tensor, List[torch.Tensor], Tuple[torch.Tensor, ...]],
+    pattern: str,
+    **axes_lengths: int,
+) -> torch.Tensor:
+    r"""A native implementation of `einops.rearrange`, a reader-friendly smart element reordering for multidimensional
+    tensors. This operation includes functionality of transpose (axes permutation), reshape (view), squeeze, unsqueeze,
+    stack, concatenate and other operations.
+
+    See: https://einops.rocks/api/rearrange/
+
+    Args:
+        tensor (Tensor or sequence of Tensor): the tensor(s) to rearrange
+        pattern (str): the rearrangement pattern
+        axes_lengths (int): any additional length specifications for dimensions
+
+    Returns:
+        Tensor: the rearranged tensor
+
+    Examples:
+        >>> # suppose we have a set of 32 images in "h w c" format (height-width-channel)
+        >>> images = torch.randn((32, 30, 40, 3))
+
+        >>> # stack along first (batch) axis, output is a single array
+        >>> rearrange(images, 'b h w c -> b h w c').shape
+        torch.Size([32, 30, 40, 3])
+
+        >>> # concatenate images along height (vertical axis), 960 = 32 * 30
+        >>> rearrange(images, 'b h w c -> (b h) w c').shape
+        torch.Size([960, 40, 3])
+
+        >>> # concatenated images along horizontal axis, 1280 = 32 * 40
+        >>> rearrange(images, 'b h w c -> h (b w) c').shape
+        torch.Size([30, 1280, 3])
+
+        >>> # reordered axes to "b c h w" format for deep learning
+        >>> rearrange(images, 'b h w c -> b c h w').shape
+        torch.Size([32, 3, 30, 40])
+
+        >>> # flattened each image into a vector, 3600 = 30 * 40 * 3
+        >>> rearrange(images, 'b h w c -> b (c h w)').shape
+        torch.Size([32, 3600])
+
+        >>> # split each image into 4 smaller (top-left, top-right, bottom-left, bottom-right), 128 = 32 * 2 * 2
+        >>> rearrange(images, 'b (h1 h) (w1 w) c -> (b h1 w1) h w c', h1=2, w1=2).shape
+        torch.Size([128, 15, 20, 3])
+
+        >>> # space-to-depth operation
+        >>> rearrange(images, 'b (h h1) (w w1) c -> b h w (c h1 w1)', h1=2, w1=2).shape
+        torch.Size([32, 15, 20, 12])
+    """
+    if not isinstance(tensor, torch.Tensor):
+        tensor = torch.stack(tensor)
+
+    rearrange_callable = _create_rearrange_callable(
+        tensor.ndim, pattern, **axes_lengths
+    )
+
+    return rearrange_callable(tensor)
diff --git a/lib/python3.11/site-packages/functorch/experimental/__init__.py b/lib/python3.11/site-packages/functorch/experimental/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..23fc8381cc2358880f935064edd7eeff9766fec6
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/experimental/__init__.py
@@ -0,0 +1,6 @@
+# PyTorch forward-mode is not mature yet
+from torch._functorch.apis import chunk_vmap
+from torch._functorch.batch_norm_replacement import replace_all_batch_norm_modules_
+from torch._functorch.eager_transforms import hessian, jacfwd, jvp
+
+from functorch import functionalize
diff --git a/lib/python3.11/site-packages/functorch/experimental/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/functorch/experimental/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3dc25d3d460631c6afc42f516688bb4e481f4e6e
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/experimental/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/experimental/__pycache__/_map.cpython-311.pyc b/lib/python3.11/site-packages/functorch/experimental/__pycache__/_map.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80d58e0a55bd1708cbab1c7c7423be8562ce726f
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/experimental/__pycache__/_map.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/experimental/__pycache__/control_flow.cpython-311.pyc b/lib/python3.11/site-packages/functorch/experimental/__pycache__/control_flow.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8369048db64d8fd80823f83f6a9d9c1bdf447d01
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/experimental/__pycache__/control_flow.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/experimental/__pycache__/ops.cpython-311.pyc b/lib/python3.11/site-packages/functorch/experimental/__pycache__/ops.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c6e7ec19b5c1649497a2fa44feeaae4e3800ada
Binary files /dev/null and b/lib/python3.11/site-packages/functorch/experimental/__pycache__/ops.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/functorch/experimental/_map.py b/lib/python3.11/site-packages/functorch/experimental/_map.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fb130f243ed765cff79496f8faac4feb8c10744
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/experimental/_map.py
@@ -0,0 +1,393 @@
+import torch
+import torch.utils._pytree as pytree
+from torch._C import _ExcludeDispatchKeyGuard, DispatchKey, DispatchKeySet
+from torch._dispatch.python import suspend_functionalization
+from torch._functorch.aot_autograd import AOTConfig, create_joint
+from torch._functorch.eager_transforms import (
+    _unwrap_all_tensors_from_functional,
+    _wrap_all_tensors_to_functional,
+    functionalize,
+)
+
+from torch._higher_order_ops.cond import (
+    _has_potential_branch_input_alias,
+    _has_potential_branch_input_mutation,
+    UnsupportedAliasMutationException,
+)
+from torch._ops import HigherOrderOperator
+from torch._subclasses.fake_tensor import FakeTensorMode
+from torch.fx.experimental.proxy_tensor import (
+    disable_proxy_modes_tracing,
+    make_fx,
+    ProxyTorchDispatchMode,
+    track_tensor_tree,
+)
+from torch.multiprocessing.reductions import StorageWeakRef
+from torch.utils._python_dispatch import (
+    _get_current_dispatch_mode,
+    _pop_mode_temporarily,
+)
+
+
+# TODO: We add this to prevent dymamo from tracing into map_wrapper,
+# remove the wrapper call when it's ready.
+class MapWrapper(HigherOrderOperator):
+    def __call__(self, xs, *args):
+        return map_wrapper(xs, *args)
+
+
+map = MapWrapper("map", _deprecated_global_ns=True)
+map_impl = HigherOrderOperator("map_impl", _deprecated_global_ns=True)
+
+dummy_aot_config = AOTConfig(
+    fw_compiler=None,
+    bw_compiler=None,
+    partition_fn=None,
+    decompositions={},
+    num_params_buffers=0,
+    aot_id=0,
+    keep_inference_input_mutations=False,
+)
+
+
+def create_fw_bw_graph(f, num_mapped_args, *args):
+    mapped_xs = args[:num_mapped_args]
+    pos_args = args[num_mapped_args:]
+
+    # Note: We create "clean" environments for make_fx by suspending all dispatch keys
+    # between Autograd and Python key. Currently, we only suspend functionalization but more can be
+    # added when required. Will encounter two problems if we don't suspend functionalization:
+    #
+    # 1. make_fx fails to capture operations on input: the inputs are wrapped as _to_functional_tensor_wrapper,
+    # but they will be unwrapped before entering ProxyTorchDispatchMode as part of the dispatching.
+    # However, it's the outside wrapper that tracer creates proxies for. This casuses tracer fail to
+    # fetch the proxy for the inputs and fail to capture any operations on them.
+    #
+    # 2. make_fx fails to capture output: the outputs after ProxyTorchDispatchMode are further
+    # wrapped as FunctionalTensorWrapper in Functionalize key after return. However, the tracer
+    # only associates the inner tensor with proxy in ProxyTorchDispatchMode. Therefore,
+    # when creating the output node, it fails to associate the wrapped tensor with its proxy.
+    # Instead, it will create _tensor_constant as output.
+
+    with suspend_functionalization():
+        with disable_proxy_modes_tracing():
+
+            def from_fun(t):
+                if isinstance(t, torch.Tensor):
+                    if t.dtype != torch.bool:
+                        return torch.empty_strided(
+                            t.size(),
+                            t.stride(),
+                            dtype=t.dtype,
+                            requires_grad=t.requires_grad,
+                        )
+                    else:
+                        return t.clone()
+                return t
+
+            example_xs = [from_fun(xs) for xs in _unstack_pytree(mapped_xs)[0]]
+            example_pos_args = [
+                from_fun(arg) if isinstance(arg, torch.Tensor) else arg
+                for arg in pos_args
+            ]
+            example_flat_out = pytree.tree_map(
+                from_fun, f(*example_xs, *example_pos_args)
+            )
+            if any(
+                not isinstance(out, torch.Tensor)
+                for out in example_flat_out
+                if out is not None
+            ):
+                raise RuntimeError(
+                    "Expect outputs of map only contains tensors or None. "
+                    f"Got types {[type(out) for out in example_flat_out]}."
+                )
+            example_grad = [from_fun(out) for out in example_flat_out]
+
+            fw_graph = make_fx(f)(*example_xs, *example_pos_args)
+
+        def joint_f(*example_args):
+            joint_mapped_args = example_args[:joint_num_mapped]
+            args = example_args[joint_num_mapped:]
+
+            mapped_input = joint_mapped_args[:num_mapped_args]
+            mapped_grads = joint_mapped_args[num_mapped_args:]
+
+            def fw_with_masks(*args):
+                fw_out = f(*args)
+                return fw_out, [
+                    True
+                    if isinstance(ret, torch.Tensor) and ret.requires_grad
+                    else False
+                    for ret in fw_out
+                ]
+
+            joint = create_joint(fw_with_masks, aot_config=dummy_aot_config)
+            _, grads = joint(
+                list(mapped_input) + list(args),
+                [
+                    grad
+                    for grad in mapped_grads
+                    if grad is not None and grad.requires_grad
+                ],
+            )
+
+            # In order to keep map functional for backward graph,
+            # we clone outputs that are aliasing inputs
+            input_storage = {
+                StorageWeakRef(arg._typed_storage())
+                for arg in example_args
+                if isinstance(arg, torch.Tensor)
+            }
+
+            def maybe_clone(t):
+                if (
+                    isinstance(t, torch.Tensor)
+                    and StorageWeakRef(t._typed_storage()) in input_storage
+                ):
+                    return t.clone()
+                return t
+
+            return pytree.tree_map(maybe_clone, grads)
+
+        joint_num_mapped = len(example_grad) + len(example_xs)
+        joint_graph = make_fx(joint_f)(*example_xs, *example_grad, *example_pos_args)
+        return fw_graph, joint_graph
+
+
+def map_wrapper(f, xs, *args):
+    flat_xs, xs_spec = pytree.tree_flatten(xs)
+    if not all(isinstance(t, torch.Tensor) for t in flat_xs):
+        raise RuntimeError(f"Mapped xs can only consist of tensors. Got xs {flat_xs}.")
+
+    num_mapped_args = len(flat_xs)
+    shapes = [xs.shape for xs in flat_xs]
+    leading_dim_size = shapes[0][0]
+    if leading_dim_size == 0:
+        raise RuntimeError("Leading dimensions of mapped xs cannot be 0.")
+
+    if any(cur_shape[0] != leading_dim_size for cur_shape in shapes):
+        raise RuntimeError(
+            f"Leading dimensions of mapped xs must be consistent. Got shapes {shapes}."
+        )
+
+    out_spec = None
+
+    def flat_fn(*flat_args):
+        xs = pytree.tree_unflatten(flat_args[:num_mapped_args], xs_spec)
+        unflattened_out = f(xs, *flat_args[num_mapped_args:])
+        flat_out, tmp_out_spec = pytree.tree_flatten(unflattened_out)
+
+        nonlocal out_spec
+        out_spec = tmp_out_spec
+        return flat_out
+
+    return pytree.tree_unflatten(
+        map_impl(flat_fn, num_mapped_args, *flat_xs, *args), out_spec
+    )
+
+
+class MapAutogradOp(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, fw_graph, joint_graph, num_mapped_args, *flat_args):
+        ctx.save_for_backward(*flat_args)
+        ctx._joint_graph = joint_graph
+        ctx._num_mapped_args = num_mapped_args
+        with torch._C._AutoDispatchBelowAutograd():
+            return (*map_impl(fw_graph, num_mapped_args, *flat_args),)
+
+    @staticmethod
+    def backward(ctx, *flat_grads):
+        fw_args = ctx.saved_tensors
+        fw_mapped_args = fw_args[: ctx._num_mapped_args]
+        pos_args = fw_args[ctx._num_mapped_args :]
+
+        grads = map_impl(
+            ctx._joint_graph,
+            ctx._num_mapped_args + len(flat_grads),
+            *fw_mapped_args,
+            *flat_grads,
+            *pos_args,
+        )
+        return None, None, None, *grads
+
+
+def trace_map(proxy_mode, func_overload, f, num_mapped, *args):
+    xs = list(args[:num_mapped])
+    pos_args = list(args[num_mapped:])
+    leading_dim_size = xs[0].shape[0]
+
+    example_input = _unstack_pytree(xs)[0]
+    body_graph = f
+    if not isinstance(body_graph, torch.fx.GraphModule):
+        body_graph = make_fx(body_graph)(*example_input, *pos_args)
+
+    with disable_proxy_modes_tracing():
+        example_outs = body_graph(*example_input, *pos_args)
+
+        def expand_tensor(t):
+            if isinstance(t, torch.Tensor):
+                return t.expand(leading_dim_size, *t.shape)
+            return t
+
+        expanded_outs = pytree.tree_map(expand_tensor, example_outs)
+
+    next_name = None
+    i = 0
+    while not next_name:
+        candidate = f"body_graph_{i}"
+        if hasattr(proxy_mode.tracer.root, candidate):
+            i += 1
+        else:
+            next_name = candidate
+
+    proxy_mode.tracer.root.register_module(next_name, body_graph)
+    node_args = (body_graph, num_mapped, *args)
+    proxy_args = pytree.tree_map(proxy_mode.tracer.unwrap_proxy, node_args)
+    out_proxy = proxy_mode.tracer.create_proxy(
+        "call_function", func_overload, proxy_args, {}, name="map_impl"
+    )
+    return track_tensor_tree(
+        expanded_outs, out_proxy, constant=None, tracer=proxy_mode.tracer
+    )
+
+
+def _unstack_pytree(xs):
+    flat_xs, inspec = pytree.tree_flatten(xs)
+    if not all(isinstance(xs, torch.Tensor) for xs in flat_xs):
+        raise RuntimeError(f"Leaves of xs must be Tensor {flat_xs}")
+
+    if not all(xs.shape[0] == flat_xs[0].shape[0] for xs in flat_xs):
+        raise RuntimeError(
+            f"Leaves of xs must have same leading dimension size {[xs.shape for xs in flat_xs]}"
+        )
+
+    a = zip(*flat_xs)
+    pytrees = []
+    for tuple in a:
+        pytrees.append(pytree.tree_unflatten(tuple, inspec))
+    return pytrees
+
+
+def _stack_pytree(pytrees):
+    flat_out = []
+    out_spec = None
+    for pt in pytrees:
+        flat_pt, out_spec = pytree.tree_flatten(pt)
+        flat_out.append(flat_pt)
+    b = zip(*flat_out)
+    stacked_out = []
+    for leaves in b:
+        if all(isinstance(leaf, torch.Tensor) for leaf in leaves):
+            stacked_out.append(torch.stack(leaves))
+        elif all(leaf is None for leaf in leaves):
+            # Backward graph can return None output when forward inputs doesn't require grad.
+            # When we eagerly execute backward graph, we need to call _stack_pytree on its output,
+            # therefore we need to deal with None output.
+            stacked_out.append(None)
+        else:
+            raise RuntimeError(f"Cannot stack {leaves}.")
+    return pytree.tree_unflatten(stacked_out, out_spec)
+
+
+@map_impl.py_impl(DispatchKey.CompositeExplicitAutograd)
+def map_dense(f, num_mapped_args, *args):
+    xs = args[:num_mapped_args]
+    pos_args = args[num_mapped_args:]
+    pytrees = []
+    for inp in _unstack_pytree(xs):
+        pytrees.append(f(*inp, *pos_args))
+    return _stack_pytree(pytrees)
+
+
+@map_impl.py_impl(DispatchKey.Autograd)
+def map_autograd(f, num_mapped_args, *args):
+    fw_graph, bw_graph = create_fw_bw_graph(f, num_mapped_args, *args)
+    flat_out = MapAutogradOp.apply(fw_graph, bw_graph, num_mapped_args, *args)
+    return flat_out
+
+
+@map_impl.py_impl(ProxyTorchDispatchMode)
+def map_proxy_torch_dispatch_mode(f, num_mapped, *args):
+    mode = _get_current_dispatch_mode()
+    assert mode is not None, "Mode should always be enabled for python fallback key"
+    with _pop_mode_temporarily() as mode:
+        if mode.enable_tracing:
+            return trace_map(mode, map_impl, f, num_mapped, *args)
+        else:
+            return map_impl(f, num_mapped, *args)
+
+
+@map_impl.py_impl(FakeTensorMode)
+def map_fake_tensor_mode(f, num_mapped, *args):
+    return map_dense(f, num_mapped, *args)
+
+
+@map_impl.py_impl(DispatchKey.Functionalize)
+def map_func(f, num_mapped, *args):
+    reapply_views = torch._C._functionalization_reapply_views_tls()
+    xs = args[:num_mapped]
+    pos_args = args[num_mapped:]
+    unwrapped_xs = _unwrap_all_tensors_from_functional(xs, reapply_views=reapply_views)
+    unwrapped_args = _unwrap_all_tensors_from_functional(
+        pos_args, reapply_views=reapply_views
+    )
+    mode = "mutations_and_views" if reapply_views else "mutations"
+
+    with _ExcludeDispatchKeyGuard(DispatchKeySet(DispatchKey.Functionalize)):
+        functional_map_fn = functionalize(f, remove=mode)
+        with disable_proxy_modes_tracing():
+            example_inputs = (*_unstack_pytree(unwrapped_xs)[0], *unwrapped_args)
+
+        if _has_potential_branch_input_mutation(f, example_inputs):
+            raise UnsupportedAliasMutationException("torch.map is mutating the input!")
+
+        if _has_potential_branch_input_alias(f, example_inputs):
+            raise UnsupportedAliasMutationException("torch.map is aliasing the input!")
+
+        map_return = map_impl(
+            functional_map_fn, num_mapped, *unwrapped_xs, *unwrapped_args
+        )
+        return _wrap_all_tensors_to_functional(map_return, level=0)
+
+
+@map_impl.py_impl(torch._C._functorch.TransformType.Functionalize)
+def map_functionalize(interpreter, f, num_mapped, *args):
+    """
+    Functionalization implementation for torch.map. Currently:
+      1. We don't allow any input mutation inside the map function
+      2. Our check for above condition is not exhaustive
+    """
+    xs = args[:num_mapped]
+    pos_args = args[num_mapped:]
+    reapply_views = interpreter.functionalize_add_back_views()
+    mode = "mutations_and_views" if reapply_views else "mutations"
+    # At this point, we will see functionalized tensors, so need to unwrap them first
+    unwrapped_xs = _unwrap_all_tensors_from_functional(xs, reapply_views=reapply_views)
+    unwrapped_args = _unwrap_all_tensors_from_functional(
+        pos_args, reapply_views=reapply_views
+    )
+
+    functional_map_fn = functionalize(f, remove=mode)
+
+    with interpreter.lower():
+        with disable_proxy_modes_tracing():
+            example_inputs = (*_unstack_pytree(unwrapped_xs)[0], *unwrapped_args)
+        if _has_potential_branch_input_mutation(f, example_inputs):
+            raise UnsupportedAliasMutationException("torch.map is mutating the input!")
+
+        if _has_potential_branch_input_alias(f, example_inputs):
+            raise UnsupportedAliasMutationException("torch.map is aliasing the input!")
+
+        map_return = map_impl(
+            functional_map_fn, num_mapped, *unwrapped_xs, *unwrapped_args
+        )
+        return _wrap_all_tensors_to_functional(map_return, level=interpreter.level())
+
+
+# TODO(voz) Make this automatic for keys, this is very ugly atm
+map_impl.fallthrough(DispatchKey.PythonDispatcher)
+map_impl.fallthrough(DispatchKey.PythonTLSSnapshot)
+map_impl.fallthrough(DispatchKey.ADInplaceOrView)
+map_impl.fallthrough(DispatchKey.BackendSelect)
+map_impl.fallthrough(DispatchKey.AutocastCPU)
diff --git a/lib/python3.11/site-packages/functorch/experimental/control_flow.py b/lib/python3.11/site-packages/functorch/experimental/control_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddfdd69a767213eb4094ce24faccc57ab45856f3
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/experimental/control_flow.py
@@ -0,0 +1,6 @@
+from torch._higher_order_ops.cond import (  # noqa: F401
+    cond,
+    UnsupportedAliasMutationException,
+)
+
+from ._map import map  # noqa: F401
diff --git a/lib/python3.11/site-packages/functorch/experimental/ops.py b/lib/python3.11/site-packages/functorch/experimental/ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a502ef2b002cd824e7b67d08fccac872b313110
--- /dev/null
+++ b/lib/python3.11/site-packages/functorch/experimental/ops.py
@@ -0,0 +1 @@
+from torch._ops import HigherOrderOperator  # noqa: F401
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/INSTALLER b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/LICENSE b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/METADATA b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..0cb47c7eaa3e2cdb3db7a6a911a9e235a317c211
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/METADATA
@@ -0,0 +1,293 @@
+Metadata-Version: 2.1
+Name: huggingface-hub
+Version: 0.20.2
+Summary: Client library to download and publish models, datasets and other repos on the huggingface.co hub
+Home-page: https://github.com/huggingface/huggingface_hub
+Author: Hugging Face, Inc.
+Author-email: julien@huggingface.co
+License: Apache
+Keywords: model-hub machine-learning models natural-language-processing deep-learning pytorch pretrained-models
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: filelock
+Requires-Dist: fsspec >=2023.5.0
+Requires-Dist: requests
+Requires-Dist: tqdm >=4.42.1
+Requires-Dist: pyyaml >=5.1
+Requires-Dist: typing-extensions >=3.7.4.3
+Requires-Dist: packaging >=20.9
+Provides-Extra: all
+Requires-Dist: InquirerPy ==0.3.4 ; extra == 'all'
+Requires-Dist: aiohttp ; extra == 'all'
+Requires-Dist: jedi ; extra == 'all'
+Requires-Dist: Jinja2 ; extra == 'all'
+Requires-Dist: pytest ; extra == 'all'
+Requires-Dist: pytest-cov ; extra == 'all'
+Requires-Dist: pytest-env ; extra == 'all'
+Requires-Dist: pytest-xdist ; extra == 'all'
+Requires-Dist: pytest-vcr ; extra == 'all'
+Requires-Dist: pytest-asyncio ; extra == 'all'
+Requires-Dist: pytest-rerunfailures ; extra == 'all'
+Requires-Dist: urllib3 <2.0 ; extra == 'all'
+Requires-Dist: soundfile ; extra == 'all'
+Requires-Dist: Pillow ; extra == 'all'
+Requires-Dist: gradio ; extra == 'all'
+Requires-Dist: numpy ; extra == 'all'
+Requires-Dist: ruff >=0.1.3 ; extra == 'all'
+Requires-Dist: mypy ==1.5.1 ; extra == 'all'
+Requires-Dist: typing-extensions >=4.8.0 ; extra == 'all'
+Requires-Dist: types-PyYAML ; extra == 'all'
+Requires-Dist: types-requests ; extra == 'all'
+Requires-Dist: types-simplejson ; extra == 'all'
+Requires-Dist: types-toml ; extra == 'all'
+Requires-Dist: types-tqdm ; extra == 'all'
+Requires-Dist: types-urllib3 ; extra == 'all'
+Requires-Dist: pydantic <2.0,>1.1 ; (python_version == "3.8") and extra == 'all'
+Requires-Dist: pydantic <3.0,>1.1 ; (python_version > "3.8") and extra == 'all'
+Provides-Extra: cli
+Requires-Dist: InquirerPy ==0.3.4 ; extra == 'cli'
+Provides-Extra: dev
+Requires-Dist: InquirerPy ==0.3.4 ; extra == 'dev'
+Requires-Dist: aiohttp ; extra == 'dev'
+Requires-Dist: jedi ; extra == 'dev'
+Requires-Dist: Jinja2 ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest-cov ; extra == 'dev'
+Requires-Dist: pytest-env ; extra == 'dev'
+Requires-Dist: pytest-xdist ; extra == 'dev'
+Requires-Dist: pytest-vcr ; extra == 'dev'
+Requires-Dist: pytest-asyncio ; extra == 'dev'
+Requires-Dist: pytest-rerunfailures ; extra == 'dev'
+Requires-Dist: urllib3 <2.0 ; extra == 'dev'
+Requires-Dist: soundfile ; extra == 'dev'
+Requires-Dist: Pillow ; extra == 'dev'
+Requires-Dist: gradio ; extra == 'dev'
+Requires-Dist: numpy ; extra == 'dev'
+Requires-Dist: ruff >=0.1.3 ; extra == 'dev'
+Requires-Dist: mypy ==1.5.1 ; extra == 'dev'
+Requires-Dist: typing-extensions >=4.8.0 ; extra == 'dev'
+Requires-Dist: types-PyYAML ; extra == 'dev'
+Requires-Dist: types-requests ; extra == 'dev'
+Requires-Dist: types-simplejson ; extra == 'dev'
+Requires-Dist: types-toml ; extra == 'dev'
+Requires-Dist: types-tqdm ; extra == 'dev'
+Requires-Dist: types-urllib3 ; extra == 'dev'
+Requires-Dist: pydantic <2.0,>1.1 ; (python_version == "3.8") and extra == 'dev'
+Requires-Dist: pydantic <3.0,>1.1 ; (python_version > "3.8") and extra == 'dev'
+Provides-Extra: fastai
+Requires-Dist: toml ; extra == 'fastai'
+Requires-Dist: fastai >=2.4 ; extra == 'fastai'
+Requires-Dist: fastcore >=1.3.27 ; extra == 'fastai'
+Provides-Extra: inference
+Requires-Dist: aiohttp ; extra == 'inference'
+Requires-Dist: pydantic <2.0,>1.1 ; (python_version == "3.8") and extra == 'inference'
+Requires-Dist: pydantic <3.0,>1.1 ; (python_version > "3.8") and extra == 'inference'
+Provides-Extra: quality
+Requires-Dist: ruff >=0.1.3 ; extra == 'quality'
+Requires-Dist: mypy ==1.5.1 ; extra == 'quality'
+Provides-Extra: tensorflow
+Requires-Dist: tensorflow ; extra == 'tensorflow'
+Requires-Dist: pydot ; extra == 'tensorflow'
+Requires-Dist: graphviz ; extra == 'tensorflow'
+Provides-Extra: testing
+Requires-Dist: InquirerPy ==0.3.4 ; extra == 'testing'
+Requires-Dist: aiohttp ; extra == 'testing'
+Requires-Dist: jedi ; extra == 'testing'
+Requires-Dist: Jinja2 ; extra == 'testing'
+Requires-Dist: pytest ; extra == 'testing'
+Requires-Dist: pytest-cov ; extra == 'testing'
+Requires-Dist: pytest-env ; extra == 'testing'
+Requires-Dist: pytest-xdist ; extra == 'testing'
+Requires-Dist: pytest-vcr ; extra == 'testing'
+Requires-Dist: pytest-asyncio ; extra == 'testing'
+Requires-Dist: pytest-rerunfailures ; extra == 'testing'
+Requires-Dist: urllib3 <2.0 ; extra == 'testing'
+Requires-Dist: soundfile ; extra == 'testing'
+Requires-Dist: Pillow ; extra == 'testing'
+Requires-Dist: gradio ; extra == 'testing'
+Requires-Dist: numpy ; extra == 'testing'
+Requires-Dist: pydantic <2.0,>1.1 ; (python_version == "3.8") and extra == 'testing'
+Requires-Dist: pydantic <3.0,>1.1 ; (python_version > "3.8") and extra == 'testing'
+Provides-Extra: torch
+Requires-Dist: torch ; extra == 'torch'
+Provides-Extra: typing
+Requires-Dist: typing-extensions >=4.8.0 ; extra == 'typing'
+Requires-Dist: types-PyYAML ; extra == 'typing'
+Requires-Dist: types-requests ; extra == 'typing'
+Requires-Dist: types-simplejson ; extra == 'typing'
+Requires-Dist: types-toml ; extra == 'typing'
+Requires-Dist: types-tqdm ; extra == 'typing'
+Requires-Dist: types-urllib3 ; extra == 'typing'
+
+<p align="center">
+  <br/>
+    <img alt="huggingface_hub library logo" src="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/huggingface_hub.svg" width="376" height="59" style="max-width: 100%;">
+  <br/>
+</p>
+
+<p align="center">
+    <i>The official Python client for the Huggingface Hub.</i>
+</p>
+
+<p align="center">
+    <a href="https://huggingface.co/docs/huggingface_hub/en/index"><img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/huggingface_hub/index.svg?down_color=red&down_message=offline&up_message=online&label=doc"></a>
+    <a href="https://github.com/huggingface/huggingface_hub/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/huggingface_hub.svg"></a>
+    <a href="https://github.com/huggingface/huggingface_hub"><img alt="PyPi version" src="https://img.shields.io/pypi/pyversions/huggingface_hub.svg"></a>
+    <a href="https://pypi.org/project/huggingface-hub"><img alt="downloads" src="https://static.pepy.tech/badge/huggingface_hub/month"></a>
+    <a href="https://codecov.io/gh/huggingface/huggingface_hub"><img alt="Code coverage" src="https://codecov.io/gh/huggingface/huggingface_hub/branch/main/graph/badge.svg?token=RXP95LE2XL"></a>
+</p>
+
+<h4 align="center">
+    <p>
+        <b>English</b> |
+        <a href="https://github.com/huggingface/huggingface_hub/blob/main/README_de.md">Deutsch</a> |
+        <a href="https://github.com/huggingface/huggingface_hub/blob/main/README_hi.md">हिंदी</a> | 
+        <a href="https://github.com/huggingface/huggingface_hub/blob/main/README_ko.md">한국어</a>
+    <p>
+</h4>
+---
+
+**Documentation**: <a href="https://hf.co/docs/huggingface_hub" target="_blank">https://hf.co/docs/huggingface_hub</a>
+
+**Source Code**: <a href="https://github.com/huggingface/huggingface_hub" target="_blank">https://github.com/huggingface/huggingface_hub</a>
+
+---
+
+## Welcome to the huggingface_hub library
+
+The `huggingface_hub` library allows you to interact with the [Hugging Face Hub](https://huggingface.co/), a platform democratizing open-source Machine Learning for creators and collaborators. Discover pre-trained models and datasets for your projects or play with the thousands of machine learning apps hosted on the Hub. You can also create and share your own models, datasets and demos with the community. The `huggingface_hub` library provides a simple way to do all these things with Python.
+
+## Key features
+
+- [Download files](https://huggingface.co/docs/huggingface_hub/en/guides/download) from the Hub.
+- [Upload files](https://huggingface.co/docs/huggingface_hub/en/guides/upload) to the Hub.
+- [Manage your repositories](https://huggingface.co/docs/huggingface_hub/en/guides/repository).
+- [Run Inference](https://huggingface.co/docs/huggingface_hub/en/guides/inference) on deployed models.
+- [Search](https://huggingface.co/docs/huggingface_hub/en/guides/search) for models, datasets and Spaces.
+- [Share Model Cards](https://huggingface.co/docs/huggingface_hub/en/guides/model-cards) to document your models.
+- [Engage with the community](https://huggingface.co/docs/huggingface_hub/en/guides/community) through PRs and comments.
+
+## Installation
+
+Install the `huggingface_hub` package with [pip](https://pypi.org/project/huggingface-hub/):
+
+```bash
+pip install huggingface_hub
+```
+
+If you prefer, you can also install it with [conda](https://huggingface.co/docs/huggingface_hub/en/installation#install-with-conda).
+
+In order to keep the package minimal by default, `huggingface_hub` comes with optional dependencies useful for some use cases. For example, if you want have a complete experience for Inference, run:
+
+```bash
+pip install huggingface_hub[inference]
+```
+
+To learn more installation and optional dependencies, check out the [installation guide](https://huggingface.co/docs/huggingface_hub/en/installation).
+
+## Quick start
+
+### Download files
+
+Download a single file
+
+```py
+from huggingface_hub import hf_hub_download
+
+hf_hub_download(repo_id="tiiuae/falcon-7b-instruct", filename="config.json")
+```
+
+Or an entire repository
+
+```py
+from huggingface_hub import snapshot_download
+
+snapshot_download("stabilityai/stable-diffusion-2-1")
+```
+
+Files will be downloaded in a local cache folder. More details in [this guide](https://huggingface.co/docs/huggingface_hub/en/guides/manage-cache).
+
+### Login
+
+The Hugging Face Hub uses tokens to authenticate applications (see [docs](https://huggingface.co/docs/hub/security-tokens)). To login your machine, run the following CLI:
+
+```bash
+huggingface-cli login
+# or using an environment variable
+huggingface-cli login --token $HUGGINGFACE_TOKEN
+```
+
+### Create a repository
+
+```py
+from huggingface_hub import create_repo
+
+create_repo(repo_id="super-cool-model")
+```
+
+### Upload files
+
+Upload a single file
+
+```py
+from huggingface_hub import upload_file
+
+upload_file(
+    path_or_fileobj="/home/lysandre/dummy-test/README.md",
+    path_in_repo="README.md",
+    repo_id="lysandre/test-model",
+)
+```
+
+Or an entire folder
+
+```py
+from huggingface_hub import upload_folder
+
+upload_folder(
+    folder_path="/path/to/local/space",
+    repo_id="username/my-cool-space",
+    repo_type="space",
+)
+```
+
+For details in the [upload guide](https://huggingface.co/docs/huggingface_hub/en/guides/upload).
+
+## Integrating to the Hub.
+
+We're partnering with cool open source ML libraries to provide free model hosting and versioning. You can find the existing integrations [here](https://huggingface.co/docs/hub/libraries).
+
+The advantages are:
+
+- Free model or dataset hosting for libraries and their users.
+- Built-in file versioning, even with very large files, thanks to a git-based approach.
+- Hosted inference API for all models publicly available.
+- In-browser widgets to play with the uploaded models.
+- Anyone can upload a new model for your library, they just need to add the corresponding tag for the model to be discoverable.
+- Fast downloads! We use Cloudfront (a CDN) to geo-replicate downloads so they're blazing fast from anywhere on the globe.
+- Usage stats and more features to come.
+
+If you would like to integrate your library, feel free to open an issue to begin the discussion. We wrote a [step-by-step guide](https://huggingface.co/docs/hub/adding-a-library) with ❤️ showing how to do this integration.
+
+## Contributions (feature requests, bugs, etc.) are super welcome 💙💚💛💜🧡❤️
+
+Everyone is welcome to contribute, and we value everybody's contribution. Code is not the only way to help the community.
+Answering questions, helping others, reaching out and improving the documentations are immensely valuable to the community.
+We wrote a [contribution guide](https://github.com/huggingface/huggingface_hub/blob/main/CONTRIBUTING.md) to summarize
+how to get started to contribute to this repository.
+
+
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/RECORD b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..334815b8ad25413d83716720efcd25ce7e6958c5
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/RECORD
@@ -0,0 +1,147 @@
+../../../bin/huggingface-cli,sha256=42ZeW_3Nn1vHZKQItmZ_VOOsdDLj25vF8xg4DWUhluQ,302
+huggingface_hub-0.20.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+huggingface_hub-0.20.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+huggingface_hub-0.20.2.dist-info/METADATA,sha256=D1vK91f8NEHzMiWLSl7_TQs6rZ6cr0E4ecRkkFB0lMM,12930
+huggingface_hub-0.20.2.dist-info/RECORD,,
+huggingface_hub-0.20.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+huggingface_hub-0.20.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+huggingface_hub-0.20.2.dist-info/entry_points.txt,sha256=Y3Z2L02rBG7va_iE6RPXolIgwOdwUFONyRN3kXMxZ0g,131
+huggingface_hub-0.20.2.dist-info/top_level.txt,sha256=8KzlQJAY4miUvjAssOAJodqKOw3harNzuiwGQ9qLSSk,16
+huggingface_hub/__init__.py,sha256=ixK6-0G7PFdH1mCZ9c5g8ZuYHsxSpVo8TTuA7O0mun8,20809
+huggingface_hub/__pycache__/__init__.cpython-311.pyc,,
+huggingface_hub/__pycache__/_commit_api.cpython-311.pyc,,
+huggingface_hub/__pycache__/_commit_scheduler.cpython-311.pyc,,
+huggingface_hub/__pycache__/_inference_endpoints.cpython-311.pyc,,
+huggingface_hub/__pycache__/_login.cpython-311.pyc,,
+huggingface_hub/__pycache__/_multi_commits.cpython-311.pyc,,
+huggingface_hub/__pycache__/_snapshot_download.cpython-311.pyc,,
+huggingface_hub/__pycache__/_space_api.cpython-311.pyc,,
+huggingface_hub/__pycache__/_tensorboard_logger.cpython-311.pyc,,
+huggingface_hub/__pycache__/_webhooks_payload.cpython-311.pyc,,
+huggingface_hub/__pycache__/_webhooks_server.cpython-311.pyc,,
+huggingface_hub/__pycache__/community.cpython-311.pyc,,
+huggingface_hub/__pycache__/constants.cpython-311.pyc,,
+huggingface_hub/__pycache__/fastai_utils.cpython-311.pyc,,
+huggingface_hub/__pycache__/file_download.cpython-311.pyc,,
+huggingface_hub/__pycache__/hf_api.cpython-311.pyc,,
+huggingface_hub/__pycache__/hf_file_system.cpython-311.pyc,,
+huggingface_hub/__pycache__/hub_mixin.cpython-311.pyc,,
+huggingface_hub/__pycache__/inference_api.cpython-311.pyc,,
+huggingface_hub/__pycache__/keras_mixin.cpython-311.pyc,,
+huggingface_hub/__pycache__/lfs.cpython-311.pyc,,
+huggingface_hub/__pycache__/repocard.cpython-311.pyc,,
+huggingface_hub/__pycache__/repocard_data.cpython-311.pyc,,
+huggingface_hub/__pycache__/repository.cpython-311.pyc,,
+huggingface_hub/_commit_api.py,sha256=LWwx0PmTHzh-gwO6-cl0GWTrSnzCy8tfZ8DDCxnfb7Y,27795
+huggingface_hub/_commit_scheduler.py,sha256=FgfjYv3E0oK3iBxDdy45Y7t78FWkmjnBR4dRd5aZviU,13653
+huggingface_hub/_inference_endpoints.py,sha256=FW36nfm9UNNnc6L6hyL2KLiItglPGcQuYJ6DA2w4Gp4,14929
+huggingface_hub/_login.py,sha256=8Y_OlSayd185u5lInGvY4zeYzBKaaaMBwTJl7MhIgSE,15325
+huggingface_hub/_multi_commits.py,sha256=xEiS4N8ZmIrrDxVGS93mA33VoVrbhlAp5T8M_XQTMiA,12518
+huggingface_hub/_snapshot_download.py,sha256=-0Kpp1gG1m2Slkbyj4GhvdOZeqzDTChqMQ1TGFHNjnA,15377
+huggingface_hub/_space_api.py,sha256=Kr1rRpbMVoUs51U52KFY_FQcMA9TEC7RDCKGB4nzGus,5116
+huggingface_hub/_tensorboard_logger.py,sha256=3W8eUS3jhZ3WyVG9Hi6rVwZC-jcCyRunBns5vIniGfA,7165
+huggingface_hub/_webhooks_payload.py,sha256=raqcWHIw98bsFvam5kkqiSEbDA8W0TU055ZlpmbUrWs,2831
+huggingface_hub/_webhooks_server.py,sha256=u3Kua_O4okXPgnH60GDIhJTDEEyIiVX6Go4CUNX4ifE,15196
+huggingface_hub/commands/__init__.py,sha256=AkbM2a-iGh0Vq_xAWhK3mu3uZ44km8-X5uWjKcvcrUQ,928
+huggingface_hub/commands/__pycache__/__init__.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/_cli_utils.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/delete_cache.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/download.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/env.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/huggingface_cli.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/lfs.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/scan_cache.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/upload.cpython-311.pyc,,
+huggingface_hub/commands/__pycache__/user.cpython-311.pyc,,
+huggingface_hub/commands/_cli_utils.py,sha256=VA_3cHzIlsEQmKPnfNTgJNI36UtcrxRmfB44RdbP1LA,1970
+huggingface_hub/commands/delete_cache.py,sha256=9Nn2ihdORPpkULkhAzju6aYar2rsa4laSE38rt8645I,16130
+huggingface_hub/commands/download.py,sha256=sthMmLQD3E0uybAlGoYt1Mpk_8w7r_im7FyDGJrZWyo,9161
+huggingface_hub/commands/env.py,sha256=LJjOxo-m0DrvQdyhWGjnLGtWt91ec63BMI4FQ-5bWXQ,1225
+huggingface_hub/commands/huggingface_cli.py,sha256=o862C98OcZoyqCzY7mNpia1h0KaLJUgSb0y10ot8sxA,1924
+huggingface_hub/commands/lfs.py,sha256=6E769AoRxUDiIOapn1_QvTbNtdUnUiouu2F4Gopp4do,7318
+huggingface_hub/commands/scan_cache.py,sha256=nMEJxBScezxs00EWyAvJtWCjhwxCL1YlBE6qNfiT3RY,5182
+huggingface_hub/commands/upload.py,sha256=vrac37T3sYwzaf6gpVR5qWzwh4fOhqakRvDUrLEx4Kg,13621
+huggingface_hub/commands/user.py,sha256=QApZJOCQEHADhjunM3hlQ72uqHsearCiCE4SdpzGdcc,6893
+huggingface_hub/community.py,sha256=SHc_LOZYSzCuk5aA73InLObrrnW-0MJuv2e63FXwg50,12202
+huggingface_hub/constants.py,sha256=fYBWYCLnyFOOldgN6a8E8PLmDVuGNdnKhfm5Qu8SLfE,7717
+huggingface_hub/fastai_utils.py,sha256=5I7zAfgHJU_mZnxnf9wgWTHrCRu_EAV8VTangDVfE_o,16676
+huggingface_hub/file_download.py,sha256=g97wMUn2yYAG8Xm8ZJevkqZSUyrQO_7-l18E6f_b_DE,75284
+huggingface_hub/hf_api.py,sha256=NDG8cEpM_3Z2DddirrNbCELY9sQxDiamgOajO6sUBck,356971
+huggingface_hub/hf_file_system.py,sha256=tTVDwh_60rpH_Iqvrf6mo_Z0ZhcY_4mHjxs1sQ6snrE,29535
+huggingface_hub/hub_mixin.py,sha256=yoOrifi6Vq7N8L_DjXYtltvdURrfbx1XEyt59wyAaXs,16099
+huggingface_hub/inference/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+huggingface_hub/inference/__pycache__/__init__.cpython-311.pyc,,
+huggingface_hub/inference/__pycache__/_client.cpython-311.pyc,,
+huggingface_hub/inference/__pycache__/_common.cpython-311.pyc,,
+huggingface_hub/inference/__pycache__/_text_generation.cpython-311.pyc,,
+huggingface_hub/inference/__pycache__/_types.cpython-311.pyc,,
+huggingface_hub/inference/_client.py,sha256=hhJSPBmDw5dVw1LoH2255-pX4uwMo8vHSkrhB_m54xY,86559
+huggingface_hub/inference/_common.py,sha256=8GaagYW1hoSWjilWgMdbpJU4sK78l1RPKPBsvGHpXGU,11331
+huggingface_hub/inference/_generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+huggingface_hub/inference/_generated/__pycache__/__init__.cpython-311.pyc,,
+huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-311.pyc,,
+huggingface_hub/inference/_generated/_async_client.py,sha256=v6CRLNY2GJz1TCzlPQVvphmeJL_OZ6yfupG2fF_WmJg,89343
+huggingface_hub/inference/_text_generation.py,sha256=VGZ7bulJmUc2iXKDAr1zaArC3vgAktkfSdWWp9HzIR4,20349
+huggingface_hub/inference/_types.py,sha256=fRrORbJbZqCxZVQG4HK4Zx4xHwPej-Hppz_cb1wJ1I0,5664
+huggingface_hub/inference_api.py,sha256=UXOKu_Ez2I3hDsjguqCcCrj03WFDndehpngYiIAucdg,8331
+huggingface_hub/keras_mixin.py,sha256=fxVjwm742fwsLwbuNVt7Slo3KAjEX7sCcTudKnolPZM,18741
+huggingface_hub/lfs.py,sha256=CnXzAoDyGDSsNDN4b88-7hXhx1BFSsbFY6vGc3O2lRs,19122
+huggingface_hub/repocard.py,sha256=kJGupeVIE2eQqo4sOGrUWRf6vOdkKdQtryMdZKNxqoc,34257
+huggingface_hub/repocard_data.py,sha256=ESn22o1V5ynxwQp0JSxUSzSuWE9J0KBzj9FOEITNPCo,31077
+huggingface_hub/repository.py,sha256=8oNhKNvJRye3dr67cTn8faKkBSiWFgvj7bIBlOpI-8U,54489
+huggingface_hub/templates/datasetcard_template.md,sha256=tWvaTQhO3WkU9Igi8Odwb44my9oYKAakb2ArfnTn1AU,5502
+huggingface_hub/templates/modelcard_template.md,sha256=-z_riTFlcsX5pUja2FDd9ySGOkNy8vr6hroLct1hjJI,6874
+huggingface_hub/utils/__init__.py,sha256=1msx7YIf9N22P92k3rcpZel2zvLqs-TsAxylD9WDavo,3239
+huggingface_hub/utils/__pycache__/__init__.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_cache_assets.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_cache_manager.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_chunk_utils.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_datetime.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_deprecation.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_errors.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_experimental.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_fixes.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_git_credential.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_headers.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_hf_folder.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_http.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_pagination.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_paths.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_runtime.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_safetensors.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_subprocess.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_telemetry.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_token.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_typing.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/_validators.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/endpoint_helpers.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/insecure_hashlib.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/logging.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/sha.cpython-311.pyc,,
+huggingface_hub/utils/__pycache__/tqdm.cpython-311.pyc,,
+huggingface_hub/utils/_cache_assets.py,sha256=kai77HPQMfYpROouMBQCr_gdBCaeTm996Sqj0dExbNg,5728
+huggingface_hub/utils/_cache_manager.py,sha256=zRBo37DaHS6IDWyQ_53oCL4-U6p--inAGsC8DLtAQ_I,29103
+huggingface_hub/utils/_chunk_utils.py,sha256=6VRyjiGr2bPupPl1azSUTxKuJ51wdgELipwJ2YRfH5U,2129
+huggingface_hub/utils/_datetime.py,sha256=7pwXpJy2J4mNb4PwNxilYynvhPWMYX261pHiNbfUSEg,2918
+huggingface_hub/utils/_deprecation.py,sha256=HZhRGGUX_QMKBBBwHHlffLtmCSK01TOpeXHefZbPfwI,4872
+huggingface_hub/utils/_errors.py,sha256=nnvanhnSqX9nQ2LvOxNI38W5mYLYVYEQLhRr89LpQzc,13697
+huggingface_hub/utils/_experimental.py,sha256=rBx4gV2NU1dT_OfeRzsCmCWyIF4Wxcf0PdkmIASoT6o,2394
+huggingface_hub/utils/_fixes.py,sha256=wFvfTYj62Il2OwkQB_Qp0xONG6SARQ5oEkT3_FhB4rc,2437
+huggingface_hub/utils/_git_credential.py,sha256=NMfMmuqdub_QX3T2d32Jhpf3RBnf2eh4VnDhHoqyZRA,4595
+huggingface_hub/utils/_headers.py,sha256=wz0kPrpu9PHpeCIJAq8MBiHuR2HbNWGukd0QgWS6lWo,9344
+huggingface_hub/utils/_hf_folder.py,sha256=9FlyCbiMP-PuyR4MP8sh5wiYbphkCjP18sCma0P7XDw,4488
+huggingface_hub/utils/_http.py,sha256=qJ9wlsv-SU9L4Epr8FLHznY3COIcOrUUmGMjJXfrQvI,12889
+huggingface_hub/utils/_pagination.py,sha256=VfpmMLyNCRo24fw0o_yWysMK69d9M6sSg2-nWtuypO4,1840
+huggingface_hub/utils/_paths.py,sha256=nUaxXN-R2EcWfHE8ivFWfHqEKMIvXEdUeCGDC_QHMqc,4397
+huggingface_hub/utils/_runtime.py,sha256=6sMMfwixkJAJj7pqYAva9A1g3-MBNWenKtlvBB985aY,10186
+huggingface_hub/utils/_safetensors.py,sha256=EE9v9HflWBUqIegn0dCGHgNu9G9Db3v2aszvG4ldPF8,4876
+huggingface_hub/utils/_subprocess.py,sha256=LW9b8TWh9rsm3pW9_5b-mVV_AtYNyLXgC6e09SthkWI,4616
+huggingface_hub/utils/_telemetry.py,sha256=jHAdgWNcL9nVvMT3ec3i78O-cwL09GnlifuokzpQjMI,4641
+huggingface_hub/utils/_token.py,sha256=e3GGABkd6zPYLE4-RdUxnH6vyen4vsvNxEl2PgStiTA,5475
+huggingface_hub/utils/_typing.py,sha256=zTA0nTJAILGveXbJKyeh6u9uIagrFgPoRqr-uCEGDQI,921
+huggingface_hub/utils/_validators.py,sha256=3ZmHubjslDRwFYe1oKyaUw6DZrc3DsuV2gABPrx7PTw,9358
+huggingface_hub/utils/endpoint_helpers.py,sha256=reLS2ic6_BTe9RuZY5WLcd5dLjIWt5Klh5EHZ7XvHng,8533
+huggingface_hub/utils/insecure_hashlib.py,sha256=OjxlvtSQHpbLp9PWSrXBDJ0wHjxCBU-SQJgucEEXDbU,1058
+huggingface_hub/utils/logging.py,sha256=mARNwc5gY6apMQ9IM5zymn-RsYnFbYW3b0HDMYXmBS0,4729
+huggingface_hub/utils/sha.py,sha256=IVi7CfBthfu-ExLduY_CQltTy-tVGTbrvURCTOWKcLA,901
+huggingface_hub/utils/tqdm.py,sha256=zBWgoxxwHooOceABVREVqSNpJGcMpaByKFVDU8VbuUQ,6334
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/REQUESTED b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/WHEEL b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..98c0d20b7a64f4f998d7913e1d38a05dba20916c
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/entry_points.txt b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eb3dafd90f19de60b3e520aeaf8132402980214d
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/entry_points.txt
@@ -0,0 +1,6 @@
+[console_scripts]
+huggingface-cli = huggingface_hub.commands.huggingface_cli:main
+
+[fsspec.specs]
+hf=huggingface_hub.HfFileSystem
+
diff --git a/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/top_level.txt b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6b964ccca3c1b6766042b3fe3b2707ba25372924
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub-0.20.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+huggingface_hub
diff --git a/lib/python3.11/site-packages/huggingface_hub/__init__.py b/lib/python3.11/site-packages/huggingface_hub/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5487fa7576802a58aba9da751ae2305385d2bef6
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/__init__.py
@@ -0,0 +1,650 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ***********
+# `huggingface_hub` init has 2 modes:
+# - Normal usage:
+#       If imported to use it, all modules and functions are lazy-loaded. This means
+#       they exist at top level in module but are imported only the first time they are
+#       used. This way, `from huggingface_hub import something` will import `something`
+#       quickly without the hassle of importing all the features from `huggingface_hub`.
+# - Static check:
+#       If statically analyzed, all modules and functions are loaded normally. This way
+#       static typing check works properly as well as autocomplete in text editors and
+#       IDEs.
+#
+# The static model imports are done inside the `if TYPE_CHECKING:` statement at
+# the bottom of this file. Since module/functions imports are duplicated, it is
+# mandatory to make sure to add them twice when adding one. This is checked in the
+# `make quality` command.
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_static_imports.py --update-file
+#
+# # Or run style on codebase
+# make style
+# ```
+#
+# ***********
+# Lazy loader vendored from https://github.com/scientific-python/lazy_loader
+import importlib
+import os
+import sys
+from typing import TYPE_CHECKING
+
+
+__version__ = "0.20.2"
+
+# Alphabetical order of definitions is ensured in tests
+# WARNING: any comment added in this dictionary definition will be lost when
+# re-generating the file !
+_SUBMOD_ATTRS = {
+    "_commit_scheduler": [
+        "CommitScheduler",
+    ],
+    "_inference_endpoints": [
+        "InferenceEndpoint",
+        "InferenceEndpointError",
+        "InferenceEndpointStatus",
+        "InferenceEndpointTimeoutError",
+        "InferenceEndpointType",
+    ],
+    "_login": [
+        "interpreter_login",
+        "login",
+        "logout",
+        "notebook_login",
+    ],
+    "_multi_commits": [
+        "MultiCommitException",
+        "plan_multi_commits",
+    ],
+    "_snapshot_download": [
+        "snapshot_download",
+    ],
+    "_space_api": [
+        "SpaceHardware",
+        "SpaceRuntime",
+        "SpaceStage",
+        "SpaceStorage",
+        "SpaceVariable",
+    ],
+    "_tensorboard_logger": [
+        "HFSummaryWriter",
+    ],
+    "_webhooks_payload": [
+        "WebhookPayload",
+        "WebhookPayloadComment",
+        "WebhookPayloadDiscussion",
+        "WebhookPayloadDiscussionChanges",
+        "WebhookPayloadEvent",
+        "WebhookPayloadMovedTo",
+        "WebhookPayloadRepo",
+        "WebhookPayloadUrl",
+        "WebhookPayloadWebhook",
+    ],
+    "_webhooks_server": [
+        "WebhooksServer",
+        "webhook_endpoint",
+    ],
+    "community": [
+        "Discussion",
+        "DiscussionComment",
+        "DiscussionCommit",
+        "DiscussionEvent",
+        "DiscussionStatusChange",
+        "DiscussionTitleChange",
+        "DiscussionWithDetails",
+    ],
+    "constants": [
+        "CONFIG_NAME",
+        "FLAX_WEIGHTS_NAME",
+        "HUGGINGFACE_CO_URL_HOME",
+        "HUGGINGFACE_CO_URL_TEMPLATE",
+        "PYTORCH_WEIGHTS_NAME",
+        "REPO_TYPE_DATASET",
+        "REPO_TYPE_MODEL",
+        "REPO_TYPE_SPACE",
+        "TF2_WEIGHTS_NAME",
+        "TF_WEIGHTS_NAME",
+    ],
+    "fastai_utils": [
+        "_save_pretrained_fastai",
+        "from_pretrained_fastai",
+        "push_to_hub_fastai",
+    ],
+    "file_download": [
+        "HfFileMetadata",
+        "_CACHED_NO_EXIST",
+        "cached_download",
+        "get_hf_file_metadata",
+        "hf_hub_download",
+        "hf_hub_url",
+        "try_to_load_from_cache",
+    ],
+    "hf_api": [
+        "Collection",
+        "CollectionItem",
+        "CommitInfo",
+        "CommitOperation",
+        "CommitOperationAdd",
+        "CommitOperationCopy",
+        "CommitOperationDelete",
+        "GitCommitInfo",
+        "GitRefInfo",
+        "GitRefs",
+        "HfApi",
+        "RepoUrl",
+        "User",
+        "UserLikes",
+        "accept_access_request",
+        "add_collection_item",
+        "add_space_secret",
+        "add_space_variable",
+        "cancel_access_request",
+        "change_discussion_status",
+        "comment_discussion",
+        "create_branch",
+        "create_collection",
+        "create_commit",
+        "create_commits_on_pr",
+        "create_discussion",
+        "create_inference_endpoint",
+        "create_pull_request",
+        "create_repo",
+        "create_tag",
+        "dataset_info",
+        "delete_branch",
+        "delete_collection",
+        "delete_collection_item",
+        "delete_file",
+        "delete_folder",
+        "delete_inference_endpoint",
+        "delete_repo",
+        "delete_space_secret",
+        "delete_space_storage",
+        "delete_space_variable",
+        "delete_tag",
+        "duplicate_space",
+        "edit_discussion_comment",
+        "file_exists",
+        "get_collection",
+        "get_dataset_tags",
+        "get_discussion_details",
+        "get_full_repo_name",
+        "get_inference_endpoint",
+        "get_model_tags",
+        "get_paths_info",
+        "get_repo_discussions",
+        "get_safetensors_metadata",
+        "get_space_runtime",
+        "get_space_variables",
+        "get_token_permission",
+        "grant_access",
+        "like",
+        "list_accepted_access_requests",
+        "list_collections",
+        "list_datasets",
+        "list_files_info",
+        "list_inference_endpoints",
+        "list_liked_repos",
+        "list_metrics",
+        "list_models",
+        "list_pending_access_requests",
+        "list_rejected_access_requests",
+        "list_repo_commits",
+        "list_repo_files",
+        "list_repo_likers",
+        "list_repo_refs",
+        "list_repo_tree",
+        "list_spaces",
+        "merge_pull_request",
+        "model_info",
+        "move_repo",
+        "parse_safetensors_file_metadata",
+        "pause_inference_endpoint",
+        "pause_space",
+        "preupload_lfs_files",
+        "reject_access_request",
+        "rename_discussion",
+        "repo_exists",
+        "repo_info",
+        "repo_type_and_id_from_hf_id",
+        "request_space_hardware",
+        "request_space_storage",
+        "restart_space",
+        "resume_inference_endpoint",
+        "run_as_future",
+        "scale_to_zero_inference_endpoint",
+        "set_space_sleep_time",
+        "space_info",
+        "super_squash_history",
+        "unlike",
+        "update_collection_item",
+        "update_collection_metadata",
+        "update_inference_endpoint",
+        "update_repo_visibility",
+        "upload_file",
+        "upload_folder",
+        "whoami",
+    ],
+    "hf_file_system": [
+        "HfFileSystem",
+        "HfFileSystemFile",
+        "HfFileSystemResolvedPath",
+    ],
+    "hub_mixin": [
+        "ModelHubMixin",
+        "PyTorchModelHubMixin",
+    ],
+    "inference._client": [
+        "InferenceClient",
+        "InferenceTimeoutError",
+    ],
+    "inference._generated._async_client": [
+        "AsyncInferenceClient",
+    ],
+    "inference_api": [
+        "InferenceApi",
+    ],
+    "keras_mixin": [
+        "KerasModelHubMixin",
+        "from_pretrained_keras",
+        "push_to_hub_keras",
+        "save_pretrained_keras",
+    ],
+    "repocard": [
+        "DatasetCard",
+        "ModelCard",
+        "RepoCard",
+        "SpaceCard",
+        "metadata_eval_result",
+        "metadata_load",
+        "metadata_save",
+        "metadata_update",
+    ],
+    "repocard_data": [
+        "CardData",
+        "DatasetCardData",
+        "EvalResult",
+        "ModelCardData",
+        "SpaceCardData",
+    ],
+    "repository": [
+        "Repository",
+    ],
+    "utils": [
+        "CacheNotFound",
+        "CachedFileInfo",
+        "CachedRepoInfo",
+        "CachedRevisionInfo",
+        "CorruptedCacheException",
+        "DeleteCacheStrategy",
+        "HFCacheInfo",
+        "HfFolder",
+        "cached_assets_path",
+        "configure_http_backend",
+        "dump_environment_info",
+        "get_session",
+        "get_token",
+        "logging",
+        "scan_cache_dir",
+    ],
+    "utils.endpoint_helpers": [
+        "DatasetFilter",
+        "ModelFilter",
+    ],
+}
+
+
+def _attach(package_name, submodules=None, submod_attrs=None):
+    """Attach lazily loaded submodules, functions, or other attributes.
+
+    Typically, modules import submodules and attributes as follows:
+
+    ```py
+    import mysubmodule
+    import anothersubmodule
+
+    from .foo import someattr
+    ```
+
+    The idea is to replace a package's `__getattr__`, `__dir__`, and
+    `__all__`, such that all imports work exactly the way they would
+    with normal imports, except that the import occurs upon first use.
+
+    The typical way to call this function, replacing the above imports, is:
+
+    ```python
+    __getattr__, __dir__, __all__ = lazy.attach(
+        __name__,
+        ['mysubmodule', 'anothersubmodule'],
+        {'foo': ['someattr']}
+    )
+    ```
+    This functionality requires Python 3.7 or higher.
+
+    Args:
+        package_name (`str`):
+            Typically use `__name__`.
+        submodules (`set`):
+            List of submodules to attach.
+        submod_attrs (`dict`):
+            Dictionary of submodule -> list of attributes / functions.
+            These attributes are imported as they are used.
+
+    Returns:
+        __getattr__, __dir__, __all__
+
+    """
+    if submod_attrs is None:
+        submod_attrs = {}
+
+    if submodules is None:
+        submodules = set()
+    else:
+        submodules = set(submodules)
+
+    attr_to_modules = {attr: mod for mod, attrs in submod_attrs.items() for attr in attrs}
+
+    __all__ = list(submodules | attr_to_modules.keys())
+
+    def __getattr__(name):
+        if name in submodules:
+            return importlib.import_module(f"{package_name}.{name}")
+        elif name in attr_to_modules:
+            submod_path = f"{package_name}.{attr_to_modules[name]}"
+            submod = importlib.import_module(submod_path)
+            attr = getattr(submod, name)
+
+            # If the attribute lives in a file (module) with the same
+            # name as the attribute, ensure that the attribute and *not*
+            # the module is accessible on the package.
+            if name == attr_to_modules[name]:
+                pkg = sys.modules[package_name]
+                pkg.__dict__[name] = attr
+
+            return attr
+        else:
+            raise AttributeError(f"No {package_name} attribute {name}")
+
+    def __dir__():
+        return __all__
+
+    if os.environ.get("EAGER_IMPORT", ""):
+        for attr in set(attr_to_modules.keys()) | submodules:
+            __getattr__(attr)
+
+    return __getattr__, __dir__, list(__all__)
+
+
+__getattr__, __dir__, __all__ = _attach(__name__, submodules=[], submod_attrs=_SUBMOD_ATTRS)
+
+# WARNING: any content below this statement is generated automatically. Any manual edit
+# will be lost when re-generating this file !
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_static_imports.py --update-file
+#
+# # Or run style on codebase
+# make style
+# ```
+if TYPE_CHECKING:  # pragma: no cover
+    from ._commit_scheduler import CommitScheduler  # noqa: F401
+    from ._inference_endpoints import (
+        InferenceEndpoint,  # noqa: F401
+        InferenceEndpointError,  # noqa: F401
+        InferenceEndpointStatus,  # noqa: F401
+        InferenceEndpointTimeoutError,  # noqa: F401
+        InferenceEndpointType,  # noqa: F401
+    )
+    from ._login import (
+        interpreter_login,  # noqa: F401
+        login,  # noqa: F401
+        logout,  # noqa: F401
+        notebook_login,  # noqa: F401
+    )
+    from ._multi_commits import (
+        MultiCommitException,  # noqa: F401
+        plan_multi_commits,  # noqa: F401
+    )
+    from ._snapshot_download import snapshot_download  # noqa: F401
+    from ._space_api import (
+        SpaceHardware,  # noqa: F401
+        SpaceRuntime,  # noqa: F401
+        SpaceStage,  # noqa: F401
+        SpaceStorage,  # noqa: F401
+        SpaceVariable,  # noqa: F401
+    )
+    from ._tensorboard_logger import HFSummaryWriter  # noqa: F401
+    from ._webhooks_payload import (
+        WebhookPayload,  # noqa: F401
+        WebhookPayloadComment,  # noqa: F401
+        WebhookPayloadDiscussion,  # noqa: F401
+        WebhookPayloadDiscussionChanges,  # noqa: F401
+        WebhookPayloadEvent,  # noqa: F401
+        WebhookPayloadMovedTo,  # noqa: F401
+        WebhookPayloadRepo,  # noqa: F401
+        WebhookPayloadUrl,  # noqa: F401
+        WebhookPayloadWebhook,  # noqa: F401
+    )
+    from ._webhooks_server import (
+        WebhooksServer,  # noqa: F401
+        webhook_endpoint,  # noqa: F401
+    )
+    from .community import (
+        Discussion,  # noqa: F401
+        DiscussionComment,  # noqa: F401
+        DiscussionCommit,  # noqa: F401
+        DiscussionEvent,  # noqa: F401
+        DiscussionStatusChange,  # noqa: F401
+        DiscussionTitleChange,  # noqa: F401
+        DiscussionWithDetails,  # noqa: F401
+    )
+    from .constants import (
+        CONFIG_NAME,  # noqa: F401
+        FLAX_WEIGHTS_NAME,  # noqa: F401
+        HUGGINGFACE_CO_URL_HOME,  # noqa: F401
+        HUGGINGFACE_CO_URL_TEMPLATE,  # noqa: F401
+        PYTORCH_WEIGHTS_NAME,  # noqa: F401
+        REPO_TYPE_DATASET,  # noqa: F401
+        REPO_TYPE_MODEL,  # noqa: F401
+        REPO_TYPE_SPACE,  # noqa: F401
+        TF2_WEIGHTS_NAME,  # noqa: F401
+        TF_WEIGHTS_NAME,  # noqa: F401
+    )
+    from .fastai_utils import (
+        _save_pretrained_fastai,  # noqa: F401
+        from_pretrained_fastai,  # noqa: F401
+        push_to_hub_fastai,  # noqa: F401
+    )
+    from .file_download import (
+        _CACHED_NO_EXIST,  # noqa: F401
+        HfFileMetadata,  # noqa: F401
+        cached_download,  # noqa: F401
+        get_hf_file_metadata,  # noqa: F401
+        hf_hub_download,  # noqa: F401
+        hf_hub_url,  # noqa: F401
+        try_to_load_from_cache,  # noqa: F401
+    )
+    from .hf_api import (
+        Collection,  # noqa: F401
+        CollectionItem,  # noqa: F401
+        CommitInfo,  # noqa: F401
+        CommitOperation,  # noqa: F401
+        CommitOperationAdd,  # noqa: F401
+        CommitOperationCopy,  # noqa: F401
+        CommitOperationDelete,  # noqa: F401
+        GitCommitInfo,  # noqa: F401
+        GitRefInfo,  # noqa: F401
+        GitRefs,  # noqa: F401
+        HfApi,  # noqa: F401
+        RepoUrl,  # noqa: F401
+        User,  # noqa: F401
+        UserLikes,  # noqa: F401
+        accept_access_request,  # noqa: F401
+        add_collection_item,  # noqa: F401
+        add_space_secret,  # noqa: F401
+        add_space_variable,  # noqa: F401
+        cancel_access_request,  # noqa: F401
+        change_discussion_status,  # noqa: F401
+        comment_discussion,  # noqa: F401
+        create_branch,  # noqa: F401
+        create_collection,  # noqa: F401
+        create_commit,  # noqa: F401
+        create_commits_on_pr,  # noqa: F401
+        create_discussion,  # noqa: F401
+        create_inference_endpoint,  # noqa: F401
+        create_pull_request,  # noqa: F401
+        create_repo,  # noqa: F401
+        create_tag,  # noqa: F401
+        dataset_info,  # noqa: F401
+        delete_branch,  # noqa: F401
+        delete_collection,  # noqa: F401
+        delete_collection_item,  # noqa: F401
+        delete_file,  # noqa: F401
+        delete_folder,  # noqa: F401
+        delete_inference_endpoint,  # noqa: F401
+        delete_repo,  # noqa: F401
+        delete_space_secret,  # noqa: F401
+        delete_space_storage,  # noqa: F401
+        delete_space_variable,  # noqa: F401
+        delete_tag,  # noqa: F401
+        duplicate_space,  # noqa: F401
+        edit_discussion_comment,  # noqa: F401
+        file_exists,  # noqa: F401
+        get_collection,  # noqa: F401
+        get_dataset_tags,  # noqa: F401
+        get_discussion_details,  # noqa: F401
+        get_full_repo_name,  # noqa: F401
+        get_inference_endpoint,  # noqa: F401
+        get_model_tags,  # noqa: F401
+        get_paths_info,  # noqa: F401
+        get_repo_discussions,  # noqa: F401
+        get_safetensors_metadata,  # noqa: F401
+        get_space_runtime,  # noqa: F401
+        get_space_variables,  # noqa: F401
+        get_token_permission,  # noqa: F401
+        grant_access,  # noqa: F401
+        like,  # noqa: F401
+        list_accepted_access_requests,  # noqa: F401
+        list_collections,  # noqa: F401
+        list_datasets,  # noqa: F401
+        list_files_info,  # noqa: F401
+        list_inference_endpoints,  # noqa: F401
+        list_liked_repos,  # noqa: F401
+        list_metrics,  # noqa: F401
+        list_models,  # noqa: F401
+        list_pending_access_requests,  # noqa: F401
+        list_rejected_access_requests,  # noqa: F401
+        list_repo_commits,  # noqa: F401
+        list_repo_files,  # noqa: F401
+        list_repo_likers,  # noqa: F401
+        list_repo_refs,  # noqa: F401
+        list_repo_tree,  # noqa: F401
+        list_spaces,  # noqa: F401
+        merge_pull_request,  # noqa: F401
+        model_info,  # noqa: F401
+        move_repo,  # noqa: F401
+        parse_safetensors_file_metadata,  # noqa: F401
+        pause_inference_endpoint,  # noqa: F401
+        pause_space,  # noqa: F401
+        preupload_lfs_files,  # noqa: F401
+        reject_access_request,  # noqa: F401
+        rename_discussion,  # noqa: F401
+        repo_exists,  # noqa: F401
+        repo_info,  # noqa: F401
+        repo_type_and_id_from_hf_id,  # noqa: F401
+        request_space_hardware,  # noqa: F401
+        request_space_storage,  # noqa: F401
+        restart_space,  # noqa: F401
+        resume_inference_endpoint,  # noqa: F401
+        run_as_future,  # noqa: F401
+        scale_to_zero_inference_endpoint,  # noqa: F401
+        set_space_sleep_time,  # noqa: F401
+        space_info,  # noqa: F401
+        super_squash_history,  # noqa: F401
+        unlike,  # noqa: F401
+        update_collection_item,  # noqa: F401
+        update_collection_metadata,  # noqa: F401
+        update_inference_endpoint,  # noqa: F401
+        update_repo_visibility,  # noqa: F401
+        upload_file,  # noqa: F401
+        upload_folder,  # noqa: F401
+        whoami,  # noqa: F401
+    )
+    from .hf_file_system import (
+        HfFileSystem,  # noqa: F401
+        HfFileSystemFile,  # noqa: F401
+        HfFileSystemResolvedPath,  # noqa: F401
+    )
+    from .hub_mixin import (
+        ModelHubMixin,  # noqa: F401
+        PyTorchModelHubMixin,  # noqa: F401
+    )
+    from .inference._client import (
+        InferenceClient,  # noqa: F401
+        InferenceTimeoutError,  # noqa: F401
+    )
+    from .inference._generated._async_client import AsyncInferenceClient  # noqa: F401
+    from .inference_api import InferenceApi  # noqa: F401
+    from .keras_mixin import (
+        KerasModelHubMixin,  # noqa: F401
+        from_pretrained_keras,  # noqa: F401
+        push_to_hub_keras,  # noqa: F401
+        save_pretrained_keras,  # noqa: F401
+    )
+    from .repocard import (
+        DatasetCard,  # noqa: F401
+        ModelCard,  # noqa: F401
+        RepoCard,  # noqa: F401
+        SpaceCard,  # noqa: F401
+        metadata_eval_result,  # noqa: F401
+        metadata_load,  # noqa: F401
+        metadata_save,  # noqa: F401
+        metadata_update,  # noqa: F401
+    )
+    from .repocard_data import (
+        CardData,  # noqa: F401
+        DatasetCardData,  # noqa: F401
+        EvalResult,  # noqa: F401
+        ModelCardData,  # noqa: F401
+        SpaceCardData,  # noqa: F401
+    )
+    from .repository import Repository  # noqa: F401
+    from .utils import (
+        CachedFileInfo,  # noqa: F401
+        CachedRepoInfo,  # noqa: F401
+        CachedRevisionInfo,  # noqa: F401
+        CacheNotFound,  # noqa: F401
+        CorruptedCacheException,  # noqa: F401
+        DeleteCacheStrategy,  # noqa: F401
+        HFCacheInfo,  # noqa: F401
+        HfFolder,  # noqa: F401
+        cached_assets_path,  # noqa: F401
+        configure_http_backend,  # noqa: F401
+        dump_environment_info,  # noqa: F401
+        get_session,  # noqa: F401
+        get_token,  # noqa: F401
+        logging,  # noqa: F401
+        scan_cache_dir,  # noqa: F401
+    )
+    from .utils.endpoint_helpers import (
+        DatasetFilter,  # noqa: F401
+        ModelFilter,  # noqa: F401
+    )
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..85f2485c541d5cbde02a426982dd07709ae74c76
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5425d47a45ab74401b80c41fd3a10c8acf7b0b8f
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_scheduler.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_scheduler.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f4628a5ac16fa25434d8d0f5cba2e62765b885c
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_scheduler.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1aeeb33a5c4d0b7049a9fd067c8b6d45c95e35c2
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_login.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_login.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..641fe7c23cfcaf4183afce5f58d471e0b685efd7
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_login.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_multi_commits.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_multi_commits.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd51f3ccdfeca29d5d58c359fc4e7f19878ca01b
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_multi_commits.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..102b35241f1fe23d96fdd76ba39ee20a96e363f0
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_space_api.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_space_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed32760dcff5911baaf4006902db4d215addaf16
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_space_api.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tensorboard_logger.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tensorboard_logger.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7530ceae9c592fbad5d8def05814547a99d3e57a
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tensorboard_logger.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f04485cc6af900862ff2c1e0e6309036e26c445f
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_server.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_server.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fdca8689cddbc540be5e4c15c5a58b083710b3a3
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_server.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/community.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/community.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd91ddef05fb53cc5f99c4e7ad9f67f0ef5d9393
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/community.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/constants.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/constants.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d83b24f293b3efa488c4466a0a5696acd7ef610
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/constants.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53d6e3a7164419800e2770d3a40122d2dbb42381
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/file_download.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/file_download.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c12f3495291eff8fc66917ddd2f4bbfac1d69cfd
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/file_download.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b56645bd74fcc66208c38808279853d260be5f1
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_file_system.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_file_system.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f9b936f0948f670a1b4e7501b930d4ff7d5cb92
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_file_system.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9be80254684414cf5810b358d563e313e3e1372a
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/inference_api.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/inference_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eac61e5eca056b3d781c083728a7a89b352e2984
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/inference_api.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/keras_mixin.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/keras_mixin.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c19848b4857a5d029446ee737a79837832ad304d
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/keras_mixin.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/lfs.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/lfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c171404a0fb4fd76980f894bc6267b4f5f040db5
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/lfs.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52bc8273cfc505d61154d0db679afa107762bd74
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..226d29529302ba255a13bf41347e80fc0f835e2c
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/__pycache__/repository.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/__pycache__/repository.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a49bcd81e3570f42163a28bdbf6dab554f9db66
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/__pycache__/repository.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/_commit_api.py b/lib/python3.11/site-packages/huggingface_hub/_commit_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..763787e68adb9df66051e25da6d0ed2fc3a0f166
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_commit_api.py
@@ -0,0 +1,670 @@
+"""
+Type definitions and utilities for the `create_commit` API
+"""
+import base64
+import io
+import os
+import warnings
+from collections import defaultdict
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from itertools import groupby
+from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING, Any, BinaryIO, Dict, Iterable, Iterator, List, Literal, Optional, Tuple, Union
+
+from tqdm.contrib.concurrent import thread_map
+
+from huggingface_hub import get_session
+
+from .constants import ENDPOINT, HF_HUB_ENABLE_HF_TRANSFER
+from .lfs import UploadInfo, lfs_upload, post_lfs_batch_info
+from .utils import (
+    EntryNotFoundError,
+    build_hf_headers,
+    chunk_iterable,
+    hf_raise_for_status,
+    logging,
+    tqdm_stream_file,
+    validate_hf_hub_args,
+)
+from .utils import tqdm as hf_tqdm
+
+
+if TYPE_CHECKING:
+    from .hf_api import RepoFile
+
+
+logger = logging.get_logger(__name__)
+
+
+UploadMode = Literal["lfs", "regular"]
+
+# Max is 1,000 per request on the Hub for HfApi.get_paths_info
+# Otherwise we get:
+# HfHubHTTPError: 413 Client Error: Payload Too Large for url: https://huggingface.co/api/datasets/xxx (Request ID: xxx)\n\ntoo many parameters
+# See https://github.com/huggingface/huggingface_hub/issues/1503
+FETCH_LFS_BATCH_SIZE = 500
+
+
+@dataclass
+class CommitOperationDelete:
+    """
+    Data structure holding necessary info to delete a file or a folder from a repository
+    on the Hub.
+
+    Args:
+        path_in_repo (`str`):
+            Relative filepath in the repo, for example: `"checkpoints/1fec34a/weights.bin"`
+            for a file or `"checkpoints/1fec34a/"` for a folder.
+        is_folder (`bool` or `Literal["auto"]`, *optional*)
+            Whether the Delete Operation applies to a folder or not. If "auto", the path
+            type (file or folder) is guessed automatically by looking if path ends with
+            a "/" (folder) or not (file). To explicitly set the path type, you can set
+            `is_folder=True` or `is_folder=False`.
+    """
+
+    path_in_repo: str
+    is_folder: Union[bool, Literal["auto"]] = "auto"
+
+    def __post_init__(self):
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+
+        if self.is_folder == "auto":
+            self.is_folder = self.path_in_repo.endswith("/")
+        if not isinstance(self.is_folder, bool):
+            raise ValueError(
+                f"Wrong value for `is_folder`. Must be one of [`True`, `False`, `'auto'`]. Got '{self.is_folder}'."
+            )
+
+
+@dataclass
+class CommitOperationCopy:
+    """
+    Data structure holding necessary info to copy a file in a repository on the Hub.
+
+    Limitations:
+      - Only LFS files can be copied. To copy a regular file, you need to download it locally and re-upload it
+      - Cross-repository copies are not supported.
+
+    Note: you can combine a [`CommitOperationCopy`] and a [`CommitOperationDelete`] to rename an LFS file on the Hub.
+
+    Args:
+        src_path_in_repo (`str`):
+            Relative filepath in the repo of the file to be copied, e.g. `"checkpoints/1fec34a/weights.bin"`.
+        path_in_repo (`str`):
+            Relative filepath in the repo where to copy the file, e.g. `"checkpoints/1fec34a/weights_copy.bin"`.
+        src_revision (`str`, *optional*):
+            The git revision of the file to be copied. Can be any valid git revision.
+            Default to the target commit revision.
+    """
+
+    src_path_in_repo: str
+    path_in_repo: str
+    src_revision: Optional[str] = None
+
+    def __post_init__(self):
+        self.src_path_in_repo = _validate_path_in_repo(self.src_path_in_repo)
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+
+
+@dataclass
+class CommitOperationAdd:
+    """
+    Data structure holding necessary info to upload a file to a repository on the Hub.
+
+    Args:
+        path_in_repo (`str`):
+            Relative filepath in the repo, for example: `"checkpoints/1fec34a/weights.bin"`
+        path_or_fileobj (`str`, `Path`, `bytes`, or `BinaryIO`):
+            Either:
+            - a path to a local file (as `str` or `pathlib.Path`) to upload
+            - a buffer of bytes (`bytes`) holding the content of the file to upload
+            - a "file object" (subclass of `io.BufferedIOBase`), typically obtained
+                with `open(path, "rb")`. It must support `seek()` and `tell()` methods.
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is not one of `str`, `Path`, `bytes` or `io.BufferedIOBase`.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is a `str` or `Path` but not a path to an existing file.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is a `io.BufferedIOBase` but it doesn't support both
+            `seek()` and `tell()`.
+    """
+
+    path_in_repo: str
+    path_or_fileobj: Union[str, Path, bytes, BinaryIO]
+    upload_info: UploadInfo = field(init=False, repr=False)
+
+    # Internal attributes
+
+    # set to "lfs" or "regular" once known
+    _upload_mode: Optional[UploadMode] = field(init=False, repr=False, default=None)
+
+    # set to True if .gitignore rules prevent the file from being uploaded as LFS
+    # (server-side check)
+    _should_ignore: Optional[bool] = field(init=False, repr=False, default=None)
+
+    # set to True once the file has been uploaded as LFS
+    _is_uploaded: bool = field(init=False, repr=False, default=False)
+
+    # set to True once the file has been committed
+    _is_committed: bool = field(init=False, repr=False, default=False)
+
+    def __post_init__(self) -> None:
+        """Validates `path_or_fileobj` and compute `upload_info`."""
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+
+        # Validate `path_or_fileobj` value
+        if isinstance(self.path_or_fileobj, Path):
+            self.path_or_fileobj = str(self.path_or_fileobj)
+        if isinstance(self.path_or_fileobj, str):
+            path_or_fileobj = os.path.normpath(os.path.expanduser(self.path_or_fileobj))
+            if not os.path.isfile(path_or_fileobj):
+                raise ValueError(f"Provided path: '{path_or_fileobj}' is not a file on the local file system")
+        elif not isinstance(self.path_or_fileobj, (io.BufferedIOBase, bytes)):
+            # ^^ Inspired from: https://stackoverflow.com/questions/44584829/how-to-determine-if-file-is-opened-in-binary-or-text-mode
+            raise ValueError(
+                "path_or_fileobj must be either an instance of str, bytes or"
+                " io.BufferedIOBase. If you passed a file-like object, make sure it is"
+                " in binary mode."
+            )
+        if isinstance(self.path_or_fileobj, io.BufferedIOBase):
+            try:
+                self.path_or_fileobj.tell()
+                self.path_or_fileobj.seek(0, os.SEEK_CUR)
+            except (OSError, AttributeError) as exc:
+                raise ValueError(
+                    "path_or_fileobj is a file-like object but does not implement seek() and tell()"
+                ) from exc
+
+        # Compute "upload_info" attribute
+        if isinstance(self.path_or_fileobj, str):
+            self.upload_info = UploadInfo.from_path(self.path_or_fileobj)
+        elif isinstance(self.path_or_fileobj, bytes):
+            self.upload_info = UploadInfo.from_bytes(self.path_or_fileobj)
+        else:
+            self.upload_info = UploadInfo.from_fileobj(self.path_or_fileobj)
+
+    @contextmanager
+    def as_file(self, with_tqdm: bool = False) -> Iterator[BinaryIO]:
+        """
+        A context manager that yields a file-like object allowing to read the underlying
+        data behind `path_or_fileobj`.
+
+        Args:
+            with_tqdm (`bool`, *optional*, defaults to `False`):
+                If True, iterating over the file object will display a progress bar. Only
+                works if the file-like object is a path to a file. Pure bytes and buffers
+                are not supported.
+
+        Example:
+
+        ```python
+        >>> operation = CommitOperationAdd(
+        ...        path_in_repo="remote/dir/weights.h5",
+        ...        path_or_fileobj="./local/weights.h5",
+        ... )
+        CommitOperationAdd(path_in_repo='remote/dir/weights.h5', path_or_fileobj='./local/weights.h5')
+
+        >>> with operation.as_file() as file:
+        ...     content = file.read()
+
+        >>> with operation.as_file(with_tqdm=True) as file:
+        ...     while True:
+        ...         data = file.read(1024)
+        ...         if not data:
+        ...              break
+        config.json: 100%|█████████████████████████| 8.19k/8.19k [00:02<00:00, 3.72kB/s]
+
+        >>> with operation.as_file(with_tqdm=True) as file:
+        ...     requests.put(..., data=file)
+        config.json: 100%|█████████████████████████| 8.19k/8.19k [00:02<00:00, 3.72kB/s]
+        ```
+        """
+        if isinstance(self.path_or_fileobj, str) or isinstance(self.path_or_fileobj, Path):
+            if with_tqdm:
+                with tqdm_stream_file(self.path_or_fileobj) as file:
+                    yield file
+            else:
+                with open(self.path_or_fileobj, "rb") as file:
+                    yield file
+        elif isinstance(self.path_or_fileobj, bytes):
+            yield io.BytesIO(self.path_or_fileobj)
+        elif isinstance(self.path_or_fileobj, io.BufferedIOBase):
+            prev_pos = self.path_or_fileobj.tell()
+            yield self.path_or_fileobj
+            self.path_or_fileobj.seek(prev_pos, io.SEEK_SET)
+
+    def b64content(self) -> bytes:
+        """
+        The base64-encoded content of `path_or_fileobj`
+
+        Returns: `bytes`
+        """
+        with self.as_file() as file:
+            return base64.b64encode(file.read())
+
+
+def _validate_path_in_repo(path_in_repo: str) -> str:
+    # Validate `path_in_repo` value to prevent a server-side issue
+    if path_in_repo.startswith("/"):
+        path_in_repo = path_in_repo[1:]
+    if path_in_repo == "." or path_in_repo == ".." or path_in_repo.startswith("../"):
+        raise ValueError(f"Invalid `path_in_repo` in CommitOperation: '{path_in_repo}'")
+    if path_in_repo.startswith("./"):
+        path_in_repo = path_in_repo[2:]
+    if any(part == ".git" for part in path_in_repo.split("/")):
+        raise ValueError(
+            "Invalid `path_in_repo` in CommitOperation: cannot update files under a '.git/' folder (path:"
+            f" '{path_in_repo}')."
+        )
+    return path_in_repo
+
+
+CommitOperation = Union[CommitOperationAdd, CommitOperationCopy, CommitOperationDelete]
+
+
+def _warn_on_overwriting_operations(operations: List[CommitOperation]) -> None:
+    """
+    Warn user when a list of operations is expected to overwrite itself in a single
+    commit.
+
+    Rules:
+    - If a filepath is updated by multiple `CommitOperationAdd` operations, a warning
+      message is triggered.
+    - If a filepath is updated at least once by a `CommitOperationAdd` and then deleted
+      by a `CommitOperationDelete`, a warning is triggered.
+    - If a `CommitOperationDelete` deletes a filepath that is then updated by a
+      `CommitOperationAdd`, no warning is triggered. This is usually useless (no need to
+      delete before upload) but can happen if a user deletes an entire folder and then
+      add new files to it.
+    """
+    nb_additions_per_path: Dict[str, int] = defaultdict(int)
+    for operation in operations:
+        path_in_repo = operation.path_in_repo
+        if isinstance(operation, CommitOperationAdd):
+            if nb_additions_per_path[path_in_repo] > 0:
+                warnings.warn(
+                    "About to update multiple times the same file in the same commit:"
+                    f" '{path_in_repo}'. This can cause undesired inconsistencies in"
+                    " your repo."
+                )
+            nb_additions_per_path[path_in_repo] += 1
+            for parent in PurePosixPath(path_in_repo).parents:
+                # Also keep track of number of updated files per folder
+                # => warns if deleting a folder overwrite some contained files
+                nb_additions_per_path[str(parent)] += 1
+        if isinstance(operation, CommitOperationDelete):
+            if nb_additions_per_path[str(PurePosixPath(path_in_repo))] > 0:
+                if operation.is_folder:
+                    warnings.warn(
+                        "About to delete a folder containing files that have just been"
+                        f" updated within the same commit: '{path_in_repo}'. This can"
+                        " cause undesired inconsistencies in your repo."
+                    )
+                else:
+                    warnings.warn(
+                        "About to delete a file that have just been updated within the"
+                        f" same commit: '{path_in_repo}'. This can cause undesired"
+                        " inconsistencies in your repo."
+                    )
+
+
+@validate_hf_hub_args
+def _upload_lfs_files(
+    *,
+    additions: List[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    token: Optional[str],
+    endpoint: Optional[str] = None,
+    num_threads: int = 5,
+    revision: Optional[str] = None,
+):
+    """
+    Uploads the content of `additions` to the Hub using the large file storage protocol.
+
+    Relevant external documentation:
+        - LFS Batch API: https://github.com/git-lfs/git-lfs/blob/main/docs/api/batch.md
+
+    Args:
+        additions (`List` of `CommitOperationAdd`):
+            The files to be uploaded
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        token (`str`, *optional*):
+            An authentication token ( See https://huggingface.co/settings/tokens )
+        num_threads (`int`, *optional*):
+            The number of concurrent threads to use when uploading. Defaults to 5.
+        revision (`str`, *optional*):
+            The git revision to upload to.
+
+    Raises: `RuntimeError` if an upload failed for any reason
+
+    Raises: `ValueError` if the server returns malformed responses
+
+    Raises: `requests.HTTPError` if the LFS batch endpoint returned an HTTP
+        error
+
+    """
+    # Step 1: retrieve upload instructions from the LFS batch endpoint.
+    #         Upload instructions are retrieved by chunk of 256 files to avoid reaching
+    #         the payload limit.
+    batch_actions: List[Dict] = []
+    for chunk in chunk_iterable(additions, chunk_size=256):
+        batch_actions_chunk, batch_errors_chunk = post_lfs_batch_info(
+            upload_infos=[op.upload_info for op in chunk],
+            token=token,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            endpoint=endpoint,
+        )
+
+        # If at least 1 error, we do not retrieve information for other chunks
+        if batch_errors_chunk:
+            message = "\n".join(
+                [
+                    f'Encountered error for file with OID {err.get("oid")}: `{err.get("error", {}).get("message")}'
+                    for err in batch_errors_chunk
+                ]
+            )
+            raise ValueError(f"LFS batch endpoint returned errors:\n{message}")
+
+        batch_actions += batch_actions_chunk
+    oid2addop = {add_op.upload_info.sha256.hex(): add_op for add_op in additions}
+
+    # Step 2: ignore files that have already been uploaded
+    filtered_actions = []
+    for action in batch_actions:
+        if action.get("actions") is None:
+            logger.debug(
+                f"Content of file {oid2addop[action['oid']].path_in_repo} is already"
+                " present upstream - skipping upload."
+            )
+        else:
+            filtered_actions.append(action)
+
+    if len(filtered_actions) == 0:
+        logger.debug("No LFS files to upload.")
+        return
+
+    # Step 3: upload files concurrently according to these instructions
+    def _wrapped_lfs_upload(batch_action) -> None:
+        try:
+            operation = oid2addop[batch_action["oid"]]
+            lfs_upload(operation=operation, lfs_batch_action=batch_action, token=token)
+        except Exception as exc:
+            raise RuntimeError(f"Error while uploading '{operation.path_in_repo}' to the Hub.") from exc
+
+    if HF_HUB_ENABLE_HF_TRANSFER:
+        logger.debug(f"Uploading {len(filtered_actions)} LFS files to the Hub using `hf_transfer`.")
+        for action in hf_tqdm(filtered_actions):
+            _wrapped_lfs_upload(action)
+    elif len(filtered_actions) == 1:
+        logger.debug("Uploading 1 LFS file to the Hub")
+        _wrapped_lfs_upload(filtered_actions[0])
+    else:
+        logger.debug(
+            f"Uploading {len(filtered_actions)} LFS files to the Hub using up to {num_threads} threads concurrently"
+        )
+        thread_map(
+            _wrapped_lfs_upload,
+            filtered_actions,
+            desc=f"Upload {len(filtered_actions)} LFS files",
+            max_workers=num_threads,
+            tqdm_class=hf_tqdm,
+        )
+
+
+def _validate_preupload_info(preupload_info: dict):
+    files = preupload_info.get("files")
+    if not isinstance(files, list):
+        raise ValueError("preupload_info is improperly formatted")
+    for file_info in files:
+        if not (
+            isinstance(file_info, dict)
+            and isinstance(file_info.get("path"), str)
+            and isinstance(file_info.get("uploadMode"), str)
+            and (file_info["uploadMode"] in ("lfs", "regular"))
+        ):
+            raise ValueError("preupload_info is improperly formatted:")
+    return preupload_info
+
+
+@validate_hf_hub_args
+def _fetch_upload_modes(
+    additions: Iterable[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    token: Optional[str],
+    revision: str,
+    endpoint: Optional[str] = None,
+    create_pr: bool = False,
+    gitignore_content: Optional[str] = None,
+) -> None:
+    """
+    Requests the Hub "preupload" endpoint to determine whether each input file should be uploaded as a regular git blob
+    or as git LFS blob. Input `additions` are mutated in-place with the upload mode.
+
+    Args:
+        additions (`Iterable` of :class:`CommitOperationAdd`):
+            Iterable of :class:`CommitOperationAdd` describing the files to
+            upload to the Hub.
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        token (`str`, *optional*):
+            An authentication token ( See https://huggingface.co/settings/tokens )
+        revision (`str`):
+            The git revision to upload the files to. Can be any valid git revision.
+        gitignore_content (`str`, *optional*):
+            The content of the `.gitignore` file to know which files should be ignored. The order of priority
+            is to first check if `gitignore_content` is passed, then check if the `.gitignore` file is present
+            in the list of files to commit and finally default to the `.gitignore` file already hosted on the Hub
+            (if any).
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the Hub API response is improperly formatted.
+    """
+    endpoint = endpoint if endpoint is not None else ENDPOINT
+    headers = build_hf_headers(token=token)
+
+    # Fetch upload mode (LFS or regular) chunk by chunk.
+    upload_modes: Dict[str, UploadMode] = {}
+    should_ignore_info: Dict[str, bool] = {}
+
+    for chunk in chunk_iterable(additions, 256):
+        payload: Dict = {
+            "files": [
+                {
+                    "path": op.path_in_repo,
+                    "sample": base64.b64encode(op.upload_info.sample).decode("ascii"),
+                    "size": op.upload_info.size,
+                    "sha": op.upload_info.sha256.hex(),
+                }
+                for op in chunk
+            ]
+        }
+        if gitignore_content is not None:
+            payload["gitIgnore"] = gitignore_content
+
+        resp = get_session().post(
+            f"{endpoint}/api/{repo_type}s/{repo_id}/preupload/{revision}",
+            json=payload,
+            headers=headers,
+            params={"create_pr": "1"} if create_pr else None,
+        )
+        hf_raise_for_status(resp)
+        preupload_info = _validate_preupload_info(resp.json())
+        upload_modes.update(**{file["path"]: file["uploadMode"] for file in preupload_info["files"]})
+        should_ignore_info.update(**{file["path"]: file["shouldIgnore"] for file in preupload_info["files"]})
+
+    # Set upload mode for each addition operation
+    for addition in additions:
+        addition._upload_mode = upload_modes[addition.path_in_repo]
+        addition._should_ignore = should_ignore_info[addition.path_in_repo]
+
+    # Empty files cannot be uploaded as LFS (S3 would fail with a 501 Not Implemented)
+    # => empty files are uploaded as "regular" to still allow users to commit them.
+    for addition in additions:
+        if addition.upload_info.size == 0:
+            addition._upload_mode = "regular"
+
+
+@validate_hf_hub_args
+def _fetch_lfs_files_to_copy(
+    copies: Iterable[CommitOperationCopy],
+    repo_type: str,
+    repo_id: str,
+    token: Optional[str],
+    revision: str,
+    endpoint: Optional[str] = None,
+) -> Dict[Tuple[str, Optional[str]], "RepoFile"]:
+    """
+    Requests the Hub files information of the LFS files to be copied, including their sha256.
+
+    Args:
+        copies (`Iterable` of :class:`CommitOperationCopy`):
+            Iterable of :class:`CommitOperationCopy` describing the files to
+            copy on the Hub.
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        token (`str`, *optional*):
+            An authentication token ( See https://huggingface.co/settings/tokens )
+        revision (`str`):
+            The git revision to upload the files to. Can be any valid git revision.
+
+    Returns: `Dict[Tuple[str, Optional[str]], RepoFile]]`
+        Key is the file path and revision of the file to copy, value is the repo file.
+
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the Hub API response is improperly formatted.
+    """
+    from .hf_api import HfApi, RepoFolder
+
+    hf_api = HfApi(endpoint=endpoint, token=token)
+    files_to_copy = {}
+    for src_revision, operations in groupby(copies, key=lambda op: op.src_revision):
+        operations = list(operations)  # type: ignore
+        paths = [op.src_path_in_repo for op in operations]
+        for offset in range(0, len(paths), FETCH_LFS_BATCH_SIZE):
+            src_repo_files = hf_api.get_paths_info(
+                repo_id=repo_id,
+                paths=paths[offset : offset + FETCH_LFS_BATCH_SIZE],
+                revision=src_revision or revision,
+                repo_type=repo_type,
+            )
+            for src_repo_file in src_repo_files:
+                if isinstance(src_repo_file, RepoFolder):
+                    raise NotImplementedError("Copying a folder is not implemented.")
+                if not src_repo_file.lfs:
+                    raise NotImplementedError("Copying a non-LFS file is not implemented")
+                files_to_copy[(src_repo_file.rfilename, src_revision)] = src_repo_file
+        for operation in operations:
+            if (operation.src_path_in_repo, src_revision) not in files_to_copy:
+                raise EntryNotFoundError(
+                    f"Cannot copy {operation.src_path_in_repo} at revision "
+                    f"{src_revision or revision}: file is missing on repo."
+                )
+    return files_to_copy
+
+
+def _prepare_commit_payload(
+    operations: Iterable[CommitOperation],
+    files_to_copy: Dict[Tuple[str, Optional[str]], "RepoFile"],
+    commit_message: str,
+    commit_description: Optional[str] = None,
+    parent_commit: Optional[str] = None,
+) -> Iterable[Dict[str, Any]]:
+    """
+    Builds the payload to POST to the `/commit` API of the Hub.
+
+    Payload is returned as an iterator so that it can be streamed as a ndjson in the
+    POST request.
+
+    For more information, see:
+        - https://github.com/huggingface/huggingface_hub/issues/1085#issuecomment-1265208073
+        - http://ndjson.org/
+    """
+    commit_description = commit_description if commit_description is not None else ""
+
+    # 1. Send a header item with the commit metadata
+    header_value = {"summary": commit_message, "description": commit_description}
+    if parent_commit is not None:
+        header_value["parentCommit"] = parent_commit
+    yield {"key": "header", "value": header_value}
+
+    nb_ignored_files = 0
+
+    # 2. Send operations, one per line
+    for operation in operations:
+        # Skip ignored files
+        if isinstance(operation, CommitOperationAdd) and operation._should_ignore:
+            logger.debug(f"Skipping file '{operation.path_in_repo}' in commit (ignored by gitignore file).")
+            nb_ignored_files += 1
+            continue
+
+        # 2.a. Case adding a regular file
+        if isinstance(operation, CommitOperationAdd) and operation._upload_mode == "regular":
+            yield {
+                "key": "file",
+                "value": {
+                    "content": operation.b64content().decode(),
+                    "path": operation.path_in_repo,
+                    "encoding": "base64",
+                },
+            }
+        # 2.b. Case adding an LFS file
+        elif isinstance(operation, CommitOperationAdd) and operation._upload_mode == "lfs":
+            yield {
+                "key": "lfsFile",
+                "value": {
+                    "path": operation.path_in_repo,
+                    "algo": "sha256",
+                    "oid": operation.upload_info.sha256.hex(),
+                    "size": operation.upload_info.size,
+                },
+            }
+        # 2.c. Case deleting a file or folder
+        elif isinstance(operation, CommitOperationDelete):
+            yield {
+                "key": "deletedFolder" if operation.is_folder else "deletedFile",
+                "value": {"path": operation.path_in_repo},
+            }
+        # 2.d. Case copying a file or folder
+        elif isinstance(operation, CommitOperationCopy):
+            file_to_copy = files_to_copy[(operation.src_path_in_repo, operation.src_revision)]
+            if not file_to_copy.lfs:
+                raise NotImplementedError("Copying a non-LFS file is not implemented")
+            yield {
+                "key": "lfsFile",
+                "value": {
+                    "path": operation.path_in_repo,
+                    "algo": "sha256",
+                    "oid": file_to_copy.lfs["sha256"],
+                },
+            }
+        # 2.e. Never expected to happen
+        else:
+            raise ValueError(
+                f"Unknown operation to commit. Operation: {operation}. Upload mode:"
+                f" {getattr(operation, '_upload_mode', None)}"
+            )
+
+    if nb_ignored_files > 0:
+        logger.info(f"Skipped {nb_ignored_files} file(s) in commit (ignored by gitignore file).")
diff --git a/lib/python3.11/site-packages/huggingface_hub/_commit_scheduler.py b/lib/python3.11/site-packages/huggingface_hub/_commit_scheduler.py
new file mode 100644
index 0000000000000000000000000000000000000000..80d8dac7866a4eeef888d36cfbb974aa06a9930b
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_commit_scheduler.py
@@ -0,0 +1,327 @@
+import atexit
+import logging
+import os
+import time
+from concurrent.futures import Future
+from dataclasses import dataclass
+from io import SEEK_END, SEEK_SET, BytesIO
+from pathlib import Path
+from threading import Lock, Thread
+from typing import Dict, List, Optional, Union
+
+from .hf_api import IGNORE_GIT_FOLDER_PATTERNS, CommitInfo, CommitOperationAdd, HfApi
+from .utils import filter_repo_objects
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class _FileToUpload:
+    """Temporary dataclass to store info about files to upload. Not meant to be used directly."""
+
+    local_path: Path
+    path_in_repo: str
+    size_limit: int
+    last_modified: float
+
+
+class CommitScheduler:
+    """
+    Scheduler to upload a local folder to the Hub at regular intervals (e.g. push to hub every 5 minutes).
+
+    The scheduler is started when instantiated and run indefinitely. At the end of your script, a last commit is
+    triggered. Checkout the [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#scheduled-uploads)
+    to learn more about how to use it.
+
+    Args:
+        repo_id (`str`):
+            The id of the repo to commit to.
+        folder_path (`str` or `Path`):
+            Path to the local folder to upload regularly.
+        every (`int` or `float`, *optional*):
+            The number of minutes between each commit. Defaults to 5 minutes.
+        path_in_repo (`str`, *optional*):
+            Relative path of the directory in the repo, for example: `"checkpoints/"`. Defaults to the root folder
+            of the repository.
+        repo_type (`str`, *optional*):
+            The type of the repo to commit to. Defaults to `model`.
+        revision (`str`, *optional*):
+            The revision of the repo to commit to. Defaults to `main`.
+        private (`bool`, *optional*):
+            Whether to make the repo private. Defaults to `False`. This value is ignored if the repo already exist.
+        token (`str`, *optional*):
+            The token to use to commit to the repo. Defaults to the token saved on the machine.
+        allow_patterns (`List[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are uploaded.
+        ignore_patterns (`List[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not uploaded.
+        squash_history (`bool`, *optional*):
+            Whether to squash the history of the repo after each commit. Defaults to `False`. Squashing commits is
+            useful to avoid degraded performances on the repo when it grows too large.
+        hf_api (`HfApi`, *optional*):
+            The [`HfApi`] client to use to commit to the Hub. Can be set with custom settings (user agent, token,...).
+
+    Example:
+    ```py
+    >>> from pathlib import Path
+    >>> from huggingface_hub import CommitScheduler
+
+    # Scheduler uploads every 10 minutes
+    >>> csv_path = Path("watched_folder/data.csv")
+    >>> CommitScheduler(repo_id="test_scheduler", repo_type="dataset", folder_path=csv_path.parent, every=10)
+
+    >>> with csv_path.open("a") as f:
+    ...     f.write("first line")
+
+    # Some time later (...)
+    >>> with csv_path.open("a") as f:
+    ...     f.write("second line")
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        repo_id: str,
+        folder_path: Union[str, Path],
+        every: Union[int, float] = 5,
+        path_in_repo: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        private: bool = False,
+        token: Optional[str] = None,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        squash_history: bool = False,
+        hf_api: Optional["HfApi"] = None,
+    ) -> None:
+        self.api = hf_api or HfApi(token=token)
+
+        # Folder
+        self.folder_path = Path(folder_path).expanduser().resolve()
+        self.path_in_repo = path_in_repo or ""
+        self.allow_patterns = allow_patterns
+
+        if ignore_patterns is None:
+            ignore_patterns = []
+        elif isinstance(ignore_patterns, str):
+            ignore_patterns = [ignore_patterns]
+        self.ignore_patterns = ignore_patterns + IGNORE_GIT_FOLDER_PATTERNS
+
+        if self.folder_path.is_file():
+            raise ValueError(f"'folder_path' must be a directory, not a file: '{self.folder_path}'.")
+        self.folder_path.mkdir(parents=True, exist_ok=True)
+
+        # Repository
+        repo_url = self.api.create_repo(repo_id=repo_id, private=private, repo_type=repo_type, exist_ok=True)
+        self.repo_id = repo_url.repo_id
+        self.repo_type = repo_type
+        self.revision = revision
+        self.token = token
+
+        # Keep track of already uploaded files
+        self.last_uploaded: Dict[Path, float] = {}  # key is local path, value is timestamp
+
+        # Scheduler
+        if not every > 0:
+            raise ValueError(f"'every' must be a positive integer, not '{every}'.")
+        self.lock = Lock()
+        self.every = every
+        self.squash_history = squash_history
+
+        logger.info(f"Scheduled job to push '{self.folder_path}' to '{self.repo_id}' every {self.every} minutes.")
+        self._scheduler_thread = Thread(target=self._run_scheduler, daemon=True)
+        self._scheduler_thread.start()
+        atexit.register(self._push_to_hub)
+
+        self.__stopped = False
+
+    def stop(self) -> None:
+        """Stop the scheduler.
+
+        A stopped scheduler cannot be restarted. Mostly for tests purposes.
+        """
+        self.__stopped = True
+
+    def _run_scheduler(self) -> None:
+        """Dumb thread waiting between each scheduled push to Hub."""
+        while True:
+            self.last_future = self.trigger()
+            time.sleep(self.every * 60)
+            if self.__stopped:
+                break
+
+    def trigger(self) -> Future:
+        """Trigger a `push_to_hub` and return a future.
+
+        This method is automatically called every `every` minutes. You can also call it manually to trigger a commit
+        immediately, without waiting for the next scheduled commit.
+        """
+        return self.api.run_as_future(self._push_to_hub)
+
+    def _push_to_hub(self) -> Optional[CommitInfo]:
+        if self.__stopped:  # If stopped, already scheduled commits are ignored
+            return None
+
+        logger.info("(Background) scheduled commit triggered.")
+        try:
+            value = self.push_to_hub()
+            if self.squash_history:
+                logger.info("(Background) squashing repo history.")
+                self.api.super_squash_history(repo_id=self.repo_id, repo_type=self.repo_type, branch=self.revision)
+            return value
+        except Exception as e:
+            logger.error(f"Error while pushing to Hub: {e}")  # Depending on the setup, error might be silenced
+            raise
+
+    def push_to_hub(self) -> Optional[CommitInfo]:
+        """
+        Push folder to the Hub and return the commit info.
+
+        <Tip warning={true}>
+
+        This method is not meant to be called directly. It is run in the background by the scheduler, respecting a
+        queue mechanism to avoid concurrent commits. Making a direct call to the method might lead to concurrency
+        issues.
+
+        </Tip>
+
+        The default behavior of `push_to_hub` is to assume an append-only folder. It lists all files in the folder and
+        uploads only changed files. If no changes are found, the method returns without committing anything. If you want
+        to change this behavior, you can inherit from [`CommitScheduler`] and override this method. This can be useful
+        for example to compress data together in a single file before committing. For more details and examples, check
+        out our [integration guide](https://huggingface.co/docs/huggingface_hub/main/en/guides/upload#scheduled-uploads).
+        """
+        # Check files to upload (with lock)
+        with self.lock:
+            logger.debug("Listing files to upload for scheduled commit.")
+
+            # List files from folder (taken from `_prepare_upload_folder_additions`)
+            relpath_to_abspath = {
+                path.relative_to(self.folder_path).as_posix(): path
+                for path in sorted(self.folder_path.glob("**/*"))  # sorted to be deterministic
+                if path.is_file()
+            }
+            prefix = f"{self.path_in_repo.strip('/')}/" if self.path_in_repo else ""
+
+            # Filter with pattern + filter out unchanged files + retrieve current file size
+            files_to_upload: List[_FileToUpload] = []
+            for relpath in filter_repo_objects(
+                relpath_to_abspath.keys(), allow_patterns=self.allow_patterns, ignore_patterns=self.ignore_patterns
+            ):
+                local_path = relpath_to_abspath[relpath]
+                stat = local_path.stat()
+                if self.last_uploaded.get(local_path) is None or self.last_uploaded[local_path] != stat.st_mtime:
+                    files_to_upload.append(
+                        _FileToUpload(
+                            local_path=local_path,
+                            path_in_repo=prefix + relpath,
+                            size_limit=stat.st_size,
+                            last_modified=stat.st_mtime,
+                        )
+                    )
+
+        # Return if nothing to upload
+        if len(files_to_upload) == 0:
+            logger.debug("Dropping schedule commit: no changed file to upload.")
+            return None
+
+        # Convert `_FileToUpload` as `CommitOperationAdd` (=> compute file shas + limit to file size)
+        logger.debug("Removing unchanged files since previous scheduled commit.")
+        add_operations = [
+            CommitOperationAdd(
+                # Cap the file to its current size, even if the user append data to it while a scheduled commit is happening
+                path_or_fileobj=PartialFileIO(file_to_upload.local_path, size_limit=file_to_upload.size_limit),
+                path_in_repo=file_to_upload.path_in_repo,
+            )
+            for file_to_upload in files_to_upload
+        ]
+
+        # Upload files (append mode expected - no need for lock)
+        logger.debug("Uploading files for scheduled commit.")
+        commit_info = self.api.create_commit(
+            repo_id=self.repo_id,
+            repo_type=self.repo_type,
+            operations=add_operations,
+            commit_message="Scheduled Commit",
+            revision=self.revision,
+        )
+
+        # Successful commit: keep track of the latest "last_modified" for each file
+        for file in files_to_upload:
+            self.last_uploaded[file.local_path] = file.last_modified
+        return commit_info
+
+
+class PartialFileIO(BytesIO):
+    """A file-like object that reads only the first part of a file.
+
+    Useful to upload a file to the Hub when the user might still be appending data to it. Only the first part of the
+    file is uploaded (i.e. the part that was available when the filesystem was first scanned).
+
+    In practice, only used internally by the CommitScheduler to regularly push a folder to the Hub with minimal
+    disturbance for the user. The object is passed to `CommitOperationAdd`.
+
+    Only supports `read`, `tell` and `seek` methods.
+
+    Args:
+        file_path (`str` or `Path`):
+            Path to the file to read.
+        size_limit (`int`):
+            The maximum number of bytes to read from the file. If the file is larger than this, only the first part
+            will be read (and uploaded).
+    """
+
+    def __init__(self, file_path: Union[str, Path], size_limit: int) -> None:
+        self._file_path = Path(file_path)
+        self._file = self._file_path.open("rb")
+        self._size_limit = min(size_limit, os.fstat(self._file.fileno()).st_size)
+
+    def __del__(self) -> None:
+        self._file.close()
+        return super().__del__()
+
+    def __repr__(self) -> str:
+        return f"<PartialFileIO file_path={self._file_path} size_limit={self._size_limit}>"
+
+    def __len__(self) -> int:
+        return self._size_limit
+
+    def __getattribute__(self, name: str):
+        if name.startswith("_") or name in ("read", "tell", "seek"):  # only 3 public methods supported
+            return super().__getattribute__(name)
+        raise NotImplementedError(f"PartialFileIO does not support '{name}'.")
+
+    def tell(self) -> int:
+        """Return the current file position."""
+        return self._file.tell()
+
+    def seek(self, __offset: int, __whence: int = SEEK_SET) -> int:
+        """Change the stream position to the given offset.
+
+        Behavior is the same as a regular file, except that the position is capped to the size limit.
+        """
+        if __whence == SEEK_END:
+            # SEEK_END => set from the truncated end
+            __offset = len(self) + __offset
+            __whence = SEEK_SET
+
+        pos = self._file.seek(__offset, __whence)
+        if pos > self._size_limit:
+            return self._file.seek(self._size_limit)
+        return pos
+
+    def read(self, __size: Optional[int] = -1) -> bytes:
+        """Read at most `__size` bytes from the file.
+
+        Behavior is the same as a regular file, except that it is capped to the size limit.
+        """
+        current = self._file.tell()
+        if __size is None or __size < 0:
+            # Read until file limit
+            truncated_size = self._size_limit - current
+        else:
+            # Read until file limit or __size
+            truncated_size = min(__size, self._size_limit - current)
+        return self._file.read(truncated_size)
diff --git a/lib/python3.11/site-packages/huggingface_hub/_inference_endpoints.py b/lib/python3.11/site-packages/huggingface_hub/_inference_endpoints.py
new file mode 100644
index 0000000000000000000000000000000000000000..291e283672ecfcaf52228887519d09689f2ad940
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_inference_endpoints.py
@@ -0,0 +1,373 @@
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Dict, Optional
+
+from .inference._client import InferenceClient
+from .inference._generated._async_client import AsyncInferenceClient
+from .utils import logging, parse_datetime
+
+
+if TYPE_CHECKING:
+    from .hf_api import HfApi
+
+
+logger = logging.get_logger(__name__)
+
+
+class InferenceEndpointError(Exception):
+    """Generic exception when dealing with Inference Endpoints."""
+
+
+class InferenceEndpointTimeoutError(InferenceEndpointError, TimeoutError):
+    """Exception for timeouts while waiting for Inference Endpoint."""
+
+
+class InferenceEndpointStatus(str, Enum):
+    PENDING = "pending"
+    INITIALIZING = "initializing"
+    UPDATING = "updating"
+    UPDATE_FAILED = "updateFailed"
+    RUNNING = "running"
+    PAUSED = "paused"
+    FAILED = "failed"
+    SCALED_TO_ZERO = "scaledToZero"
+
+
+class InferenceEndpointType(str, Enum):
+    PUBlIC = "public"
+    PROTECTED = "protected"
+    PRIVATE = "private"
+
+
+@dataclass
+class InferenceEndpoint:
+    """
+    Contains information about a deployed Inference Endpoint.
+
+    Args:
+        name (`str`):
+            The unique name of the Inference Endpoint.
+        namespace (`str`):
+            The namespace where the Inference Endpoint is located.
+        repository (`str`):
+            The name of the model repository deployed on this Inference Endpoint.
+        status ([`InferenceEndpointStatus`]):
+            The current status of the Inference Endpoint.
+        url (`str`, *optional*):
+            The URL of the Inference Endpoint, if available. Only a deployed Inference Endpoint will have a URL.
+        framework (`str`):
+            The machine learning framework used for the model.
+        revision (`str`):
+            The specific model revision deployed on the Inference Endpoint.
+        task (`str`):
+            The task associated with the deployed model.
+        created_at (`datetime.datetime`):
+            The timestamp when the Inference Endpoint was created.
+        updated_at (`datetime.datetime`):
+            The timestamp of the last update of the Inference Endpoint.
+        type ([`InferenceEndpointType`]):
+            The type of the Inference Endpoint (public, protected, private).
+        raw (`Dict`):
+            The raw dictionary data returned from the API.
+        token (`str`, *optional*):
+            Authentication token for the Inference Endpoint, if set when requesting the API.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import get_inference_endpoint
+        >>> endpoint = get_inference_endpoint("my-text-to-image")
+        >>> endpoint
+        InferenceEndpoint(name='my-text-to-image', ...)
+
+        # Get status
+        >>> endpoint.status
+        'running'
+        >>> endpoint.url
+        'https://my-text-to-image.region.vendor.endpoints.huggingface.cloud'
+
+        # Run inference
+        >>> endpoint.client.text_to_image(...)
+
+        # Pause endpoint to save $$$
+        >>> endpoint.pause()
+
+        # ...
+        # Resume and wait for deployment
+        >>> endpoint.resume()
+        >>> endpoint.wait()
+        >>> endpoint.client.text_to_image(...)
+        ```
+    """
+
+    # Field in __repr__
+    name: str = field(init=False)
+    namespace: str
+    repository: str = field(init=False)
+    status: InferenceEndpointStatus = field(init=False)
+    url: Optional[str] = field(init=False)
+
+    # Other fields
+    framework: str = field(repr=False, init=False)
+    revision: str = field(repr=False, init=False)
+    task: str = field(repr=False, init=False)
+    created_at: datetime = field(repr=False, init=False)
+    updated_at: datetime = field(repr=False, init=False)
+    type: InferenceEndpointType = field(repr=False, init=False)
+
+    # Raw dict from the API
+    raw: Dict = field(repr=False)
+
+    # Internal fields
+    _token: Optional[str] = field(repr=False, compare=False)
+    _api: "HfApi" = field(repr=False, compare=False)
+
+    @classmethod
+    def from_raw(
+        cls, raw: Dict, namespace: str, token: Optional[str] = None, api: Optional["HfApi"] = None
+    ) -> "InferenceEndpoint":
+        """Initialize object from raw dictionary."""
+        if api is None:
+            from .hf_api import HfApi
+
+            api = HfApi()
+        if token is None:
+            token = api.token
+
+        # All other fields are populated in __post_init__
+        return cls(raw=raw, namespace=namespace, _token=token, _api=api)
+
+    def __post_init__(self) -> None:
+        """Populate fields from raw dictionary."""
+        self._populate_from_raw()
+
+    @property
+    def client(self) -> InferenceClient:
+        """Returns a client to make predictions on this Inference Endpoint.
+
+        Returns:
+            [`InferenceClient`]: an inference client pointing to the deployed endpoint.
+
+        Raises:
+            [`InferenceEndpointError`]: If the Inference Endpoint is not yet deployed.
+        """
+        if self.url is None:
+            raise InferenceEndpointError(
+                "Cannot create a client for this Inference Endpoint as it is not yet deployed. "
+                "Please wait for the Inference Endpoint to be deployed using `endpoint.wait()` and try again."
+            )
+        return InferenceClient(model=self.url, token=self._token)
+
+    @property
+    def async_client(self) -> AsyncInferenceClient:
+        """Returns a client to make predictions on this Inference Endpoint.
+
+        Returns:
+            [`AsyncInferenceClient`]: an asyncio-compatible inference client pointing to the deployed endpoint.
+
+        Raises:
+            [`InferenceEndpointError`]: If the Inference Endpoint is not yet deployed.
+        """
+        if self.url is None:
+            raise InferenceEndpointError(
+                "Cannot create a client for this Inference Endpoint as it is not yet deployed. "
+                "Please wait for the Inference Endpoint to be deployed using `endpoint.wait()` and try again."
+            )
+        return AsyncInferenceClient(model=self.url, token=self._token)
+
+    def wait(self, timeout: Optional[int] = None, refresh_every: int = 5) -> "InferenceEndpoint":
+        """Wait for the Inference Endpoint to be deployed.
+
+        Information from the server will be fetched every 1s. If the Inference Endpoint is not deployed after `timeout`
+        seconds, a [`InferenceEndpointTimeoutError`] will be raised. The [`InferenceEndpoint`] will be mutated in place with the latest
+        data.
+
+        Args:
+            timeout (`int`, *optional*):
+                The maximum time to wait for the Inference Endpoint to be deployed, in seconds. If `None`, will wait
+                indefinitely.
+            refresh_every (`int`, *optional*):
+                The time to wait between each fetch of the Inference Endpoint status, in seconds. Defaults to 5s.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        if self.url is not None:  # Means the endpoint is deployed
+            logger.info("Inference Endpoint is ready to be used.")
+            return self
+
+        if timeout is not None and timeout < 0:
+            raise ValueError("`timeout` cannot be negative.")
+        if refresh_every <= 0:
+            raise ValueError("`refresh_every` must be positive.")
+
+        start = time.time()
+        while True:
+            self.fetch()
+            if self.url is not None:  # Means the endpoint is deployed
+                logger.info("Inference Endpoint is ready to be used.")
+                return self
+            if timeout is not None:
+                if time.time() - start > timeout:
+                    raise InferenceEndpointTimeoutError("Timeout while waiting for Inference Endpoint to be deployed.")
+            logger.info(f"Inference Endpoint is not deployed yet ({self.status}). Waiting {refresh_every}s...")
+            time.sleep(refresh_every)
+
+    def fetch(self) -> "InferenceEndpoint":
+        """Fetch latest information about the Inference Endpoint.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.get_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def update(
+        self,
+        *,
+        # Compute update
+        accelerator: Optional[str] = None,
+        instance_size: Optional[str] = None,
+        instance_type: Optional[str] = None,
+        min_replica: Optional[int] = None,
+        max_replica: Optional[int] = None,
+        # Model update
+        repository: Optional[str] = None,
+        framework: Optional[str] = None,
+        revision: Optional[str] = None,
+        task: Optional[str] = None,
+    ) -> "InferenceEndpoint":
+        """Update the Inference Endpoint.
+
+        This method allows the update of either the compute configuration, the deployed model, or both. All arguments are
+        optional but at least one must be provided.
+
+        This is an alias for [`HfApi.update_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Args:
+            accelerator (`str`, *optional*):
+                The hardware accelerator to be used for inference (e.g. `"cpu"`).
+            instance_size (`str`, *optional*):
+                The size or type of the instance to be used for hosting the model (e.g. `"large"`).
+            instance_type (`str`, *optional*):
+                The cloud instance type where the Inference Endpoint will be deployed (e.g. `"c6i"`).
+            min_replica (`int`, *optional*):
+                The minimum number of replicas (instances) to keep running for the Inference Endpoint.
+            max_replica (`int`, *optional*):
+                The maximum number of replicas (instances) to scale to for the Inference Endpoint.
+
+            repository (`str`, *optional*):
+                The name of the model repository associated with the Inference Endpoint (e.g. `"gpt2"`).
+            framework (`str`, *optional*):
+                The machine learning framework used for the model (e.g. `"custom"`).
+            revision (`str`, *optional*):
+                The specific model revision to deploy on the Inference Endpoint (e.g. `"6c0e6080953db56375760c0471a8c5f2929baf11"`).
+            task (`str`, *optional*):
+                The task on which to deploy the model (e.g. `"text-classification"`).
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        # Make API call
+        obj = self._api.update_inference_endpoint(
+            name=self.name,
+            namespace=self.namespace,
+            accelerator=accelerator,
+            instance_size=instance_size,
+            instance_type=instance_type,
+            min_replica=min_replica,
+            max_replica=max_replica,
+            repository=repository,
+            framework=framework,
+            revision=revision,
+            task=task,
+            token=self._token,
+        )
+
+        # Mutate current object
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def pause(self) -> "InferenceEndpoint":
+        """Pause the Inference Endpoint.
+
+        A paused Inference Endpoint will not be charged. It can be resumed at any time using [`InferenceEndpoint.resume`].
+        This is different than scaling the Inference Endpoint to zero with [`InferenceEndpoint.scale_to_zero`], which
+        would be automatically restarted when a request is made to it.
+
+        This is an alias for [`HfApi.pause_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.pause_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def resume(self) -> "InferenceEndpoint":
+        """Resume the Inference Endpoint.
+
+        This is an alias for [`HfApi.resume_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.resume_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def scale_to_zero(self) -> "InferenceEndpoint":
+        """Scale Inference Endpoint to zero.
+
+        An Inference Endpoint scaled to zero will not be charged. It will be resume on the next request to it, with a
+        cold start delay. This is different than pausing the Inference Endpoint with [`InferenceEndpoint.pause`], which
+        would require a manual resume with [`InferenceEndpoint.resume`].
+
+        This is an alias for [`HfApi.scale_to_zero_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.scale_to_zero_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def delete(self) -> None:
+        """Delete the Inference Endpoint.
+
+        This operation is not reversible. If you don't want to be charged for an Inference Endpoint, it is preferable
+        to pause it with [`InferenceEndpoint.pause`] or scale it to zero with [`InferenceEndpoint.scale_to_zero`].
+
+        This is an alias for [`HfApi.delete_inference_endpoint`].
+        """
+        self._api.delete_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)
+
+    def _populate_from_raw(self) -> None:
+        """Populate fields from raw dictionary.
+
+        Called in __post_init__ + each time the Inference Endpoint is updated.
+        """
+        # Repr fields
+        self.name = self.raw["name"]
+        self.repository = self.raw["model"]["repository"]
+        self.status = self.raw["status"]["state"]
+        self.url = self.raw["status"].get("url")
+
+        # Other fields
+        self.framework = self.raw["model"]["framework"]
+        self.revision = self.raw["model"]["revision"]
+        self.task = self.raw["model"]["task"]
+        self.created_at = parse_datetime(self.raw["status"]["createdAt"])
+        self.updated_at = parse_datetime(self.raw["status"]["updatedAt"])
+        self.type = self.raw["type"]
diff --git a/lib/python3.11/site-packages/huggingface_hub/_login.py b/lib/python3.11/site-packages/huggingface_hub/_login.py
new file mode 100644
index 0000000000000000000000000000000000000000..576b8e67df24048dd20a7e05288597235dbfc5dd
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_login.py
@@ -0,0 +1,395 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains methods to login to the Hub."""
+import os
+import subprocess
+from functools import partial
+from getpass import getpass
+from pathlib import Path
+from typing import Optional
+
+from . import constants
+from .commands._cli_utils import ANSI
+from .utils import (
+    capture_output,
+    get_token,
+    is_google_colab,
+    is_notebook,
+    list_credential_helpers,
+    logging,
+    run_subprocess,
+    set_git_credential,
+    unset_git_credential,
+)
+from .utils._token import _get_token_from_environment, _get_token_from_google_colab
+
+
+logger = logging.get_logger(__name__)
+
+_HF_LOGO_ASCII = """
+    _|    _|  _|    _|    _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|_|_|_|    _|_|      _|_|_|  _|_|_|_|
+    _|    _|  _|    _|  _|        _|          _|    _|_|    _|  _|            _|        _|    _|  _|        _|
+    _|_|_|_|  _|    _|  _|  _|_|  _|  _|_|    _|    _|  _|  _|  _|  _|_|      _|_|_|    _|_|_|_|  _|        _|_|_|
+    _|    _|  _|    _|  _|    _|  _|    _|    _|    _|    _|_|  _|    _|      _|        _|    _|  _|        _|
+    _|    _|    _|_|      _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|        _|    _|    _|_|_|  _|_|_|_|
+"""
+
+
+def login(
+    token: Optional[str] = None,
+    add_to_git_credential: bool = False,
+    new_session: bool = True,
+    write_permission: bool = False,
+) -> None:
+    """Login the machine to access the Hub.
+
+    The `token` is persisted in cache and set as a git credential. Once done, the machine
+    is logged in and the access token will be available across all `huggingface_hub`
+    components. If `token` is not provided, it will be prompted to the user either with
+    a widget (in a notebook) or via the terminal.
+
+    To login from outside of a script, one can also use `huggingface-cli login` which is
+    a cli command that wraps [`login`].
+
+    <Tip>
+
+    [`login`] is a drop-in replacement method for [`notebook_login`] as it wraps and
+    extends its capabilities.
+
+    </Tip>
+
+    <Tip>
+
+    When the token is not passed, [`login`] will automatically detect if the script runs
+    in a notebook or not. However, this detection might not be accurate due to the
+    variety of notebooks that exists nowadays. If that is the case, you can always force
+    the UI by using [`notebook_login`] or [`interpreter_login`].
+
+    </Tip>
+
+    Args:
+        token (`str`, *optional*):
+            User access token to generate from https://huggingface.co/settings/token.
+        add_to_git_credential (`bool`, defaults to `False`):
+            If `True`, token will be set as git credential. If no git credential helper
+            is configured, a warning will be displayed to the user. If `token` is `None`,
+            the value of `add_to_git_credential` is ignored and will be prompted again
+            to the end user.
+        new_session (`bool`, defaults to `True`):
+            If `True`, will request a token even if one is already saved on the machine.
+        write_permission (`bool`, defaults to `False`):
+            If `True`, requires a token with write permission.
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If an organization token is passed. Only personal account tokens are valid
+            to login.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If token is invalid.
+        [`ImportError`](https://docs.python.org/3/library/exceptions.html#ImportError)
+            If running in a notebook but `ipywidgets` is not installed.
+    """
+    if token is not None:
+        if not add_to_git_credential:
+            print(
+                "Token will not been saved to git credential helper. Pass"
+                " `add_to_git_credential=True` if you want to set the git"
+                " credential as well."
+            )
+        _login(token, add_to_git_credential=add_to_git_credential, write_permission=write_permission)
+    elif is_notebook():
+        notebook_login(new_session=new_session, write_permission=write_permission)
+    else:
+        interpreter_login(new_session=new_session, write_permission=write_permission)
+
+
+def logout() -> None:
+    """Logout the machine from the Hub.
+
+    Token is deleted from the machine and removed from git credential.
+    """
+    if get_token() is None:
+        print("Not logged in!")
+        return
+
+    # Delete token from git credentials
+    unset_git_credential()
+
+    # Delete token file
+    try:
+        Path(constants.HF_TOKEN_PATH).unlink()
+    except FileNotFoundError:
+        pass
+
+    # Check if still logged in
+    if _get_token_from_google_colab() is not None:
+        raise EnvironmentError(
+            "You are automatically logged in using a Google Colab secret.\n"
+            "To log out, you must unset the `HF_TOKEN` secret in your Colab settings."
+        )
+    if _get_token_from_environment() is not None:
+        raise EnvironmentError(
+            "Token has been deleted from your machine but you are still logged in.\n"
+            "To log out, you must clear out both `HF_TOKEN` and `HUGGING_FACE_HUB_TOKEN` environment variables."
+        )
+
+    print("Successfully logged out.")
+
+
+###
+# Interpreter-based login (text)
+###
+
+
+def interpreter_login(new_session: bool = True, write_permission: bool = False) -> None:
+    """
+    Displays a prompt to login to the HF website and store the token.
+
+    This is equivalent to [`login`] without passing a token when not run in a notebook.
+    [`interpreter_login`] is useful if you want to force the use of the terminal prompt
+    instead of a notebook widget.
+
+    For more details, see [`login`].
+
+    Args:
+        new_session (`bool`, defaults to `True`):
+            If `True`, will request a token even if one is already saved on the machine.
+        write_permission (`bool`, defaults to `False`):
+            If `True`, requires a token with write permission.
+
+    """
+    if not new_session and _current_token_okay(write_permission=write_permission):
+        print("User is already logged in.")
+        return
+
+    from .commands.delete_cache import _ask_for_confirmation_no_tui
+
+    print(_HF_LOGO_ASCII)
+    if get_token() is not None:
+        print(
+            "    A token is already saved on your machine. Run `huggingface-cli"
+            " whoami` to get more information or `huggingface-cli logout` if you want"
+            " to log out."
+        )
+        print("    Setting a new token will erase the existing one.")
+
+    print("    To login, `huggingface_hub` requires a token generated from https://huggingface.co/settings/tokens .")
+    if os.name == "nt":
+        print("Token can be pasted using 'Right-Click'.")
+    token = getpass("Token: ")
+    add_to_git_credential = _ask_for_confirmation_no_tui("Add token as git credential?")
+
+    _login(token=token, add_to_git_credential=add_to_git_credential, write_permission=write_permission)
+
+
+###
+# Notebook-based login (widget)
+###
+
+NOTEBOOK_LOGIN_PASSWORD_HTML = """<center> <img
+src=https://huggingface.co/front/assets/huggingface_logo-noborder.svg
+alt='Hugging Face'> <br> Immediately click login after typing your password or
+it might be stored in plain text in this notebook file. </center>"""
+
+
+NOTEBOOK_LOGIN_TOKEN_HTML_START = """<center> <img
+src=https://huggingface.co/front/assets/huggingface_logo-noborder.svg
+alt='Hugging Face'> <br> Copy a token from <a
+href="https://huggingface.co/settings/tokens" target="_blank">your Hugging Face
+tokens page</a> and paste it below. <br> Immediately click login after copying
+your token or it might be stored in plain text in this notebook file. </center>"""
+
+
+NOTEBOOK_LOGIN_TOKEN_HTML_END = """
+<b>Pro Tip:</b> If you don't already have one, you can create a dedicated
+'notebooks' token with 'write' access, that you can then easily reuse for all
+notebooks. </center>"""
+
+
+def notebook_login(new_session: bool = True, write_permission: bool = False) -> None:
+    """
+    Displays a widget to login to the HF website and store the token.
+
+    This is equivalent to [`login`] without passing a token when run in a notebook.
+    [`notebook_login`] is useful if you want to force the use of the notebook widget
+    instead of a prompt in the terminal.
+
+    For more details, see [`login`].
+
+    Args:
+        new_session (`bool`, defaults to `True`):
+            If `True`, will request a token even if one is already saved on the machine.
+        write_permission (`bool`, defaults to `False`):
+            If `True`, requires a token with write permission.
+    """
+    try:
+        import ipywidgets.widgets as widgets  # type: ignore
+        from IPython.display import display  # type: ignore
+    except ImportError:
+        raise ImportError(
+            "The `notebook_login` function can only be used in a notebook (Jupyter or"
+            " Colab) and you need the `ipywidgets` module: `pip install ipywidgets`."
+        )
+    if not new_session and _current_token_okay(write_permission=write_permission):
+        print("User is already logged in.")
+        return
+
+    box_layout = widgets.Layout(display="flex", flex_flow="column", align_items="center", width="50%")
+
+    token_widget = widgets.Password(description="Token:")
+    git_checkbox_widget = widgets.Checkbox(value=True, description="Add token as git credential?")
+    token_finish_button = widgets.Button(description="Login")
+
+    login_token_widget = widgets.VBox(
+        [
+            widgets.HTML(NOTEBOOK_LOGIN_TOKEN_HTML_START),
+            token_widget,
+            git_checkbox_widget,
+            token_finish_button,
+            widgets.HTML(NOTEBOOK_LOGIN_TOKEN_HTML_END),
+        ],
+        layout=box_layout,
+    )
+    display(login_token_widget)
+
+    # On click events
+    def login_token_event(t, write_permission: bool = False):
+        """
+        Event handler for the login button.
+
+        Args:
+            write_permission (`bool`, defaults to `False`):
+                If `True`, requires a token with write permission.
+        """
+        token = token_widget.value
+        add_to_git_credential = git_checkbox_widget.value
+        # Erase token and clear value to make sure it's not saved in the notebook.
+        token_widget.value = ""
+        # Hide inputs
+        login_token_widget.children = [widgets.Label("Connecting...")]
+        try:
+            with capture_output() as captured:
+                _login(token, add_to_git_credential=add_to_git_credential, write_permission=write_permission)
+            message = captured.getvalue()
+        except Exception as error:
+            message = str(error)
+        # Print result (success message or error)
+        login_token_widget.children = [widgets.Label(line) for line in message.split("\n") if line.strip()]
+
+    token_finish_button.on_click(partial(login_token_event, write_permission=write_permission))
+
+
+###
+# Login private helpers
+###
+
+
+def _login(token: str, add_to_git_credential: bool, write_permission: bool = False) -> None:
+    from .hf_api import get_token_permission  # avoid circular import
+
+    if token.startswith("api_org"):
+        raise ValueError("You must use your personal account token, not an organization token.")
+
+    permission = get_token_permission(token)
+    if permission is None:
+        raise ValueError("Invalid token passed!")
+    elif write_permission and permission != "write":
+        raise ValueError(
+            "Token is valid but is 'read-only' and a 'write' token is required.\nPlease provide a new token with"
+            " correct permission."
+        )
+    print(f"Token is valid (permission: {permission}).")
+
+    if add_to_git_credential:
+        if _is_git_credential_helper_configured():
+            set_git_credential(token)
+            print(
+                "Your token has been saved in your configured git credential helpers"
+                + f" ({','.join(list_credential_helpers())})."
+            )
+        else:
+            print("Token has not been saved to git credential helper.")
+
+    # Save token
+    path = Path(constants.HF_TOKEN_PATH)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(token)
+    print(f"Your token has been saved to {constants.HF_TOKEN_PATH}")
+    print("Login successful")
+
+
+def _current_token_okay(write_permission: bool = False):
+    """Check if the current token is valid.
+
+    Args:
+        write_permission (`bool`, defaults to `False`):
+            If `True`, requires a token with write permission.
+
+    Returns:
+        `bool`: `True` if the current token is valid, `False` otherwise.
+    """
+    from .hf_api import get_token_permission  # avoid circular import
+
+    permission = get_token_permission()
+    if permission is None or (write_permission and permission != "write"):
+        return False
+    return True
+
+
+def _is_git_credential_helper_configured() -> bool:
+    """Check if a git credential helper is configured.
+
+    Warns user if not the case (except for Google Colab where "store" is set by default
+    by `huggingface_hub`).
+    """
+    helpers = list_credential_helpers()
+    if len(helpers) > 0:
+        return True  # Do not warn: at least 1 helper is set
+
+    # Only in Google Colab to avoid the warning message
+    # See https://github.com/huggingface/huggingface_hub/issues/1043#issuecomment-1247010710
+    if is_google_colab():
+        _set_store_as_git_credential_helper_globally()
+        return True  # Do not warn: "store" is used by default in Google Colab
+
+    # Otherwise, warn user
+    print(
+        ANSI.red(
+            "Cannot authenticate through git-credential as no helper is defined on your"
+            " machine.\nYou might have to re-authenticate when pushing to the Hugging"
+            " Face Hub.\nRun the following command in your terminal in case you want to"
+            " set the 'store' credential helper as default.\n\ngit config --global"
+            " credential.helper store\n\nRead"
+            " https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage for more"
+            " details."
+        )
+    )
+    return False
+
+
+def _set_store_as_git_credential_helper_globally() -> None:
+    """Set globally the credential.helper to `store`.
+
+    To be used only in Google Colab as we assume the user doesn't care about the git
+    credential config. It is the only particular case where we don't want to display the
+    warning message in [`notebook_login()`].
+
+    Related:
+    - https://github.com/huggingface/huggingface_hub/issues/1043
+    - https://github.com/huggingface/huggingface_hub/issues/1051
+    - https://git-scm.com/docs/git-credential-store
+    """
+    try:
+        run_subprocess("git config --global credential.helper store")
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
diff --git a/lib/python3.11/site-packages/huggingface_hub/_multi_commits.py b/lib/python3.11/site-packages/huggingface_hub/_multi_commits.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc04d547ff587f49b11149bafd457720b1c74233
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_multi_commits.py
@@ -0,0 +1,305 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to multi-commits (i.e. push changes iteratively on a PR)."""
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Iterable, List, Optional, Set, Tuple, Union
+
+from ._commit_api import CommitOperationAdd, CommitOperationDelete
+from .community import DiscussionWithDetails
+from .utils import experimental
+from .utils._cache_manager import _format_size
+from .utils.insecure_hashlib import sha256
+
+
+if TYPE_CHECKING:
+    from .hf_api import HfApi
+
+
+class MultiCommitException(Exception):
+    """Base exception for any exception happening while doing a multi-commit."""
+
+
+MULTI_COMMIT_PR_DESCRIPTION_TEMPLATE = """
+## {commit_message}
+
+{commit_description}
+
+**Multi commit ID:** {multi_commit_id}
+
+Scheduled commits:
+
+{multi_commit_strategy}
+
+_This is a PR opened using the `huggingface_hub` library in the context of a multi-commit. PR can be commented as a usual PR. However, please be aware that manually updating the PR description, changing the PR status, or pushing new commits, is not recommended as it might corrupt the commit process. Learn more about multi-commits [in this guide](https://huggingface.co/docs/huggingface_hub/main/guides/upload)._
+"""
+
+MULTI_COMMIT_PR_COMPLETION_COMMENT_TEMPLATE = """
+Multi-commit is now completed! You can ping the repo owner to review the changes. This PR can now be commented or modified without risking to corrupt it.
+
+_This is a comment posted using the `huggingface_hub` library in the context of a multi-commit. Learn more about multi-commits [in this guide](https://huggingface.co/docs/huggingface_hub/main/guides/upload)._
+"""
+
+MULTI_COMMIT_PR_CLOSING_COMMENT_TEMPLATE = """
+`create_pr=False` has been passed so PR is automatically merged.
+
+_This is a comment posted using the `huggingface_hub` library in the context of a multi-commit. Learn more about multi-commits [in this guide](https://huggingface.co/docs/huggingface_hub/main/guides/upload)._
+"""
+
+MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_NO_CHANGES_TEMPLATE = """
+Cannot merge Pull Requests as no changes are associated. This PR will be closed automatically.
+
+_This is a comment posted using the `huggingface_hub` library in the context of a multi-commit. Learn more about multi-commits [in this guide](https://huggingface.co/docs/huggingface_hub/main/guides/upload)._
+"""
+
+MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_BAD_REQUEST_TEMPLATE = """
+An error occurred while trying to merge the Pull Request: `{error_message}`.
+
+_This is a comment posted using the `huggingface_hub` library in the context of a multi-commit. Learn more about multi-commits [in this guide](https://huggingface.co/docs/huggingface_hub/main/guides/upload)._
+"""
+
+
+STEP_ID_REGEX = re.compile(r"- \[(?P<completed>[ |x])\].*(?P<step_id>[a-fA-F0-9]{64})", flags=re.MULTILINE)
+
+
+@experimental
+def plan_multi_commits(
+    operations: Iterable[Union[CommitOperationAdd, CommitOperationDelete]],
+    max_operations_per_commit: int = 50,
+    max_upload_size_per_commit: int = 2 * 1024 * 1024 * 1024,
+) -> Tuple[List[List[CommitOperationAdd]], List[List[CommitOperationDelete]]]:
+    """Split a list of operations in a list of commits to perform.
+
+    Implementation follows a sub-optimal (yet simple) algorithm:
+    1. Delete operations are grouped together by commits of maximum `max_operations_per_commits` operations.
+    2. All additions exceeding `max_upload_size_per_commit` are committed 1 by 1.
+    3. All remaining additions are grouped together and split each time the `max_operations_per_commit` or the
+       `max_upload_size_per_commit` limit is reached.
+
+    We do not try to optimize the splitting to get the lowest number of commits as this is a NP-hard problem (see
+    [bin packing problem](https://en.wikipedia.org/wiki/Bin_packing_problem)). For our use case, it is not problematic
+    to use a sub-optimal solution so we favored an easy-to-explain implementation.
+
+    Args:
+        operations (`List` of [`~hf_api.CommitOperation`]):
+            The list of operations to split into commits.
+        max_operations_per_commit (`int`):
+            Maximum number of operations in a single commit. Defaults to 50.
+        max_upload_size_per_commit (`int`):
+            Maximum size to upload (in bytes) in a single commit. Defaults to 2GB. Files bigger than this limit are
+            uploaded, 1 per commit.
+
+    Returns:
+        `Tuple[List[List[CommitOperationAdd]], List[List[CommitOperationDelete]]]`: a tuple. First item is a list of
+        lists of [`CommitOperationAdd`] representing the addition commits to push. The second item is a list of lists
+        of [`CommitOperationDelete`] representing the deletion commits.
+
+    <Tip warning={true}>
+
+    `plan_multi_commits` is experimental. Its API and behavior is subject to change in the future without prior notice.
+
+    </Tip>
+
+    Example:
+    ```python
+    >>> from huggingface_hub import HfApi, plan_multi_commits
+    >>> addition_commits, deletion_commits = plan_multi_commits(
+    ...     operations=[
+    ...          CommitOperationAdd(...),
+    ...          CommitOperationAdd(...),
+    ...          CommitOperationDelete(...),
+    ...          CommitOperationDelete(...),
+    ...          CommitOperationAdd(...),
+    ...     ],
+    ... )
+    >>> HfApi().create_commits_on_pr(
+    ...     repo_id="my-cool-model",
+    ...     addition_commits=addition_commits,
+    ...     deletion_commits=deletion_commits,
+    ...     (...)
+    ...     verbose=True,
+    ... )
+    ```
+
+    <Tip warning={true}>
+
+    The initial order of the operations is not guaranteed! All deletions will be performed before additions. If you are
+    not updating multiple times the same file, you are fine.
+
+    </Tip>
+    """
+    addition_commits: List[List[CommitOperationAdd]] = []
+    deletion_commits: List[List[CommitOperationDelete]] = []
+
+    additions: List[CommitOperationAdd] = []
+    additions_size = 0
+    deletions: List[CommitOperationDelete] = []
+    for op in operations:
+        if isinstance(op, CommitOperationDelete):
+            # Group delete operations together
+            deletions.append(op)
+            if len(deletions) >= max_operations_per_commit:
+                deletion_commits.append(deletions)
+                deletions = []
+
+        elif op.upload_info.size >= max_upload_size_per_commit:
+            # Upload huge files 1 by 1
+            addition_commits.append([op])
+
+        elif additions_size + op.upload_info.size < max_upload_size_per_commit:
+            # Group other additions and split if size limit is reached (either max_nb_files or max_upload_size)
+            additions.append(op)
+            additions_size += op.upload_info.size
+
+        else:
+            addition_commits.append(additions)
+            additions = [op]
+            additions_size = op.upload_info.size
+
+        if len(additions) >= max_operations_per_commit:
+            addition_commits.append(additions)
+            additions = []
+            additions_size = 0
+
+    if len(additions) > 0:
+        addition_commits.append(additions)
+    if len(deletions) > 0:
+        deletion_commits.append(deletions)
+
+    return addition_commits, deletion_commits
+
+
+@dataclass
+class MultiCommitStep:
+    """Dataclass containing a list of CommitOperation to commit at once.
+
+    A [`MultiCommitStep`] is one atomic part of a [`MultiCommitStrategy`]. Each step is identified by its own
+    deterministic ID based on the list of commit operations (hexadecimal sha256). ID is persistent between re-runs if
+    the list of commits is kept the same.
+    """
+
+    operations: List[Union[CommitOperationAdd, CommitOperationDelete]]
+
+    id: str = field(init=False)
+    completed: bool = False
+
+    def __post_init__(self) -> None:
+        if len(self.operations) == 0:
+            raise ValueError("A MultiCommitStep must have at least 1 commit operation, got 0.")
+
+        # Generate commit id
+        sha = sha256()
+        for op in self.operations:
+            if isinstance(op, CommitOperationAdd):
+                sha.update(b"ADD")
+                sha.update(op.path_in_repo.encode())
+                sha.update(op.upload_info.sha256)
+            elif isinstance(op, CommitOperationDelete):
+                sha.update(b"DELETE")
+                sha.update(op.path_in_repo.encode())
+                sha.update(str(op.is_folder).encode())
+            else:
+                NotImplementedError()
+        self.id = sha.hexdigest()
+
+    def __str__(self) -> str:
+        """Format a step for PR description.
+
+        Formatting can be changed in the future as long as it is single line, starts with `- [ ]`/`- [x]` and contains
+        `self.id`. Must be able to match `STEP_ID_REGEX`.
+        """
+        additions = [op for op in self.operations if isinstance(op, CommitOperationAdd)]
+        file_deletions = [op for op in self.operations if isinstance(op, CommitOperationDelete) and not op.is_folder]
+        folder_deletions = [op for op in self.operations if isinstance(op, CommitOperationDelete) and op.is_folder]
+        if len(additions) > 0:
+            return (
+                f"- [{'x' if self.completed else ' '}] Upload {len(additions)} file(s) "
+                f"totalling {_format_size(sum(add.upload_info.size for add in additions))}"
+                f" ({self.id})"
+            )
+        else:
+            return (
+                f"- [{'x' if self.completed else ' '}] Delete {len(file_deletions)} file(s) and"
+                f" {len(folder_deletions)} folder(s) ({self.id})"
+            )
+
+
+@dataclass
+class MultiCommitStrategy:
+    """Dataclass containing a list of [`MultiCommitStep`] to commit iteratively.
+
+    A strategy is identified by its own deterministic ID based on the list of its steps (hexadecimal sha256). ID is
+    persistent between re-runs if the list of commits is kept the same.
+    """
+
+    addition_commits: List[MultiCommitStep]
+    deletion_commits: List[MultiCommitStep]
+
+    id: str = field(init=False)
+    all_steps: Set[str] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.all_steps = {step.id for step in self.addition_commits + self.deletion_commits}
+        if len(self.all_steps) < len(self.addition_commits) + len(self.deletion_commits):
+            raise ValueError("Got duplicate commits in MultiCommitStrategy. All commits must be unique.")
+
+        if len(self.all_steps) == 0:
+            raise ValueError("A MultiCommitStrategy must have at least 1 commit, got 0.")
+
+        # Generate strategy id
+        sha = sha256()
+        for step in self.addition_commits + self.deletion_commits:
+            sha.update("new step".encode())
+            sha.update(step.id.encode())
+        self.id = sha.hexdigest()
+
+
+def multi_commit_create_pull_request(
+    api: "HfApi",
+    repo_id: str,
+    commit_message: str,
+    commit_description: Optional[str],
+    strategy: MultiCommitStrategy,
+    token: Optional[str],
+    repo_type: Optional[str],
+) -> DiscussionWithDetails:
+    return api.create_pull_request(
+        repo_id=repo_id,
+        title=f"[WIP] {commit_message} (multi-commit {strategy.id})",
+        description=multi_commit_generate_comment(
+            commit_message=commit_message, commit_description=commit_description, strategy=strategy
+        ),
+        token=token,
+        repo_type=repo_type,
+    )
+
+
+def multi_commit_generate_comment(
+    commit_message: str,
+    commit_description: Optional[str],
+    strategy: MultiCommitStrategy,
+) -> str:
+    return MULTI_COMMIT_PR_DESCRIPTION_TEMPLATE.format(
+        commit_message=commit_message,
+        commit_description=commit_description or "",
+        multi_commit_id=strategy.id,
+        multi_commit_strategy="\n".join(
+            str(commit) for commit in strategy.deletion_commits + strategy.addition_commits
+        ),
+    )
+
+
+def multi_commit_parse_pr_description(description: str) -> Set[str]:
+    return {match[1] for match in STEP_ID_REGEX.findall(description)}
diff --git a/lib/python3.11/site-packages/huggingface_hub/_snapshot_download.py b/lib/python3.11/site-packages/huggingface_hub/_snapshot_download.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a520b36de9bfe799a2e87eb3be80d4809efc049
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_snapshot_download.py
@@ -0,0 +1,319 @@
+import os
+from pathlib import Path
+from typing import Dict, List, Literal, Optional, Union
+
+import requests
+from tqdm.auto import tqdm as base_tqdm
+from tqdm.contrib.concurrent import thread_map
+
+from .constants import (
+    DEFAULT_ETAG_TIMEOUT,
+    DEFAULT_REVISION,
+    HF_HUB_CACHE,
+    HF_HUB_ENABLE_HF_TRANSFER,
+    REPO_TYPES,
+)
+from .file_download import REGEX_COMMIT_HASH, hf_hub_download, repo_folder_name
+from .hf_api import DatasetInfo, HfApi, ModelInfo, SpaceInfo
+from .utils import (
+    GatedRepoError,
+    LocalEntryNotFoundError,
+    OfflineModeIsEnabled,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+    filter_repo_objects,
+    logging,
+    validate_hf_hub_args,
+)
+from .utils import tqdm as hf_tqdm
+
+
+logger = logging.get_logger(__name__)
+
+
+@validate_hf_hub_args
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: Optional[str] = None,
+    revision: Optional[str] = None,
+    cache_dir: Union[str, Path, None] = None,
+    local_dir: Union[str, Path, None] = None,
+    local_dir_use_symlinks: Union[bool, Literal["auto"]] = "auto",
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    user_agent: Optional[Union[Dict, str]] = None,
+    proxies: Optional[Dict] = None,
+    etag_timeout: float = DEFAULT_ETAG_TIMEOUT,
+    resume_download: bool = False,
+    force_download: bool = False,
+    token: Optional[Union[bool, str]] = None,
+    local_files_only: bool = False,
+    allow_patterns: Optional[Union[List[str], str]] = None,
+    ignore_patterns: Optional[Union[List[str], str]] = None,
+    max_workers: int = 8,
+    tqdm_class: Optional[base_tqdm] = None,
+    endpoint: Optional[str] = None,
+) -> str:
+    """Download repo files.
+
+    Download a whole snapshot of a repo's files at the specified revision. This is useful when you want all files from
+    a repo, because you don't know which ones you will need a priori. All files are nested inside a folder in order
+    to keep their actual filename relative to that folder. You can also filter which files to download using
+    `allow_patterns` and `ignore_patterns`.
+
+    If `local_dir` is provided, the file structure from the repo will be replicated in this location. You can configure
+    how you want to move those files:
+      - If `local_dir_use_symlinks="auto"` (default), files are downloaded and stored in the cache directory as blob
+        files. Small files (<5MB) are duplicated in `local_dir` while a symlink is created for bigger files. The goal
+        is to be able to manually edit and save small files without corrupting the cache while saving disk space for
+        binary files. The 5MB threshold can be configured with the `HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD`
+        environment variable.
+      - If `local_dir_use_symlinks=True`, files are downloaded, stored in the cache directory and symlinked in `local_dir`.
+        This is optimal in term of disk usage but files must not be manually edited.
+      - If `local_dir_use_symlinks=False` and the blob files exist in the cache directory, they are duplicated in the
+        local dir. This means disk usage is not optimized.
+      - Finally, if `local_dir_use_symlinks=False` and the blob files do not exist in the cache directory, then the
+        files are downloaded and directly placed under `local_dir`. This means if you need to download them again later,
+        they will be re-downloaded entirely.
+
+    An alternative would be to clone the repo but this requires git and git-lfs to be installed and properly
+    configured. It is also not possible to filter which files to download when cloning a repository using git.
+
+    Args:
+        repo_id (`str`):
+            A user or an organization name and a repo name separated by a `/`.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"` or `"space"` if downloading from a dataset or space,
+            `None` or `"model"` if downloading from a model. Default is `None`.
+        revision (`str`, *optional*):
+            An optional Git revision id which can be a branch name, a tag, or a
+            commit hash.
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored.
+        local_dir (`str` or `Path`, *optional*):
+            If provided, the downloaded files will be placed under this directory, either as symlinks (default) or
+            regular files (see description for more details).
+        local_dir_use_symlinks (`"auto"` or `bool`, defaults to `"auto"`):
+            To be used with `local_dir`. If set to "auto", the cache directory will be used and the file will be either
+            duplicated or symlinked to the local directory depending on its size. It set to `True`, a symlink will be
+            created, no matter the file size. If set to `False`, the file will either be duplicated from cache (if
+            already exists) or downloaded from the Hub and not cached. See description for more details.
+        library_name (`str`, *optional*):
+            The name of the library to which the object corresponds.
+        library_version (`str`, *optional*):
+            The version of the library.
+        user_agent (`str`, `dict`, *optional*):
+            The user-agent info in the form of a dictionary or a string.
+        proxies (`dict`, *optional*):
+            Dictionary mapping protocol to the URL of the proxy passed to
+            `requests.request`.
+        etag_timeout (`float`, *optional*, defaults to `10`):
+            When fetching ETag, how many seconds to wait for the server to send
+            data before giving up which is passed to `requests.request`.
+        resume_download (`bool`, *optional*, defaults to `False):
+            If `True`, resume a previously interrupted download.
+        force_download (`bool`, *optional*, defaults to `False`):
+            Whether the file should be downloaded even if it already exists in the local cache.
+        token (`str`, `bool`, *optional*):
+            A token to be used for the download.
+                - If `True`, the token is read from the HuggingFace config
+                  folder.
+                - If a string, it's used as the authentication token.
+        local_files_only (`bool`, *optional*, defaults to `False`):
+            If `True`, avoid downloading the file and return the path to the
+            local cached file if it exists.
+        allow_patterns (`List[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are downloaded.
+        ignore_patterns (`List[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not downloaded.
+        max_workers (`int`, *optional*):
+            Number of concurrent threads to download files (1 thread = 1 file download).
+            Defaults to 8.
+        tqdm_class (`tqdm`, *optional*):
+            If provided, overwrites the default behavior for the progress bar. Passed
+            argument must inherit from `tqdm.auto.tqdm` or at least mimic its behavior.
+            Note that the `tqdm_class` is not passed to each individual download.
+            Defaults to the custom HF progress bar that can be disabled by setting
+            `HF_HUB_DISABLE_PROGRESS_BARS` environment variable.
+
+    Returns:
+        Local folder path (string) of repo snapshot
+
+    <Tip>
+
+    Raises the following errors:
+
+    - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+      if `token=True` and the token cannot be found.
+    - [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError) if
+      ETag cannot be determined.
+    - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+      if some parameter value is invalid
+
+    </Tip>
+    """
+    if cache_dir is None:
+        cache_dir = HF_HUB_CACHE
+    if revision is None:
+        revision = DEFAULT_REVISION
+    if isinstance(cache_dir, Path):
+        cache_dir = str(cache_dir)
+
+    if repo_type is None:
+        repo_type = "model"
+    if repo_type not in REPO_TYPES:
+        raise ValueError(f"Invalid repo type: {repo_type}. Accepted repo types are: {str(REPO_TYPES)}")
+
+    storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type))
+
+    repo_info: Union[ModelInfo, DatasetInfo, SpaceInfo, None] = None
+    api_call_error: Optional[Exception] = None
+    if not local_files_only:
+        # try/except logic to handle different errors => taken from `hf_hub_download`
+        try:
+            # if we have internet connection we want to list files to download
+            api = HfApi(
+                library_name=library_name, library_version=library_version, user_agent=user_agent, endpoint=endpoint
+            )
+            repo_info = api.repo_info(repo_id=repo_id, repo_type=repo_type, revision=revision, token=token)
+        except (requests.exceptions.SSLError, requests.exceptions.ProxyError):
+            # Actually raise for those subclasses of ConnectionError
+            raise
+        except (
+            requests.exceptions.ConnectionError,
+            requests.exceptions.Timeout,
+            OfflineModeIsEnabled,
+        ) as error:
+            # Internet connection is down
+            # => will try to use local files only
+            api_call_error = error
+            pass
+        except RevisionNotFoundError:
+            # The repo was found but the revision doesn't exist on the Hub (never existed or got deleted)
+            raise
+        except requests.HTTPError as error:
+            # Multiple reasons for an http error:
+            # - Repository is private and invalid/missing token sent
+            # - Repository is gated and invalid/missing token sent
+            # - Hub is down (error 500 or 504)
+            # => let's switch to 'local_files_only=True' to check if the files are already cached.
+            #    (if it's not the case, the error will be re-raised)
+            api_call_error = error
+            pass
+
+    # At this stage, if `repo_info` is None it means either:
+    # - internet connection is down
+    # - internet connection is deactivated (local_files_only=True or HF_HUB_OFFLINE=True)
+    # - repo is private/gated and invalid/missing token sent
+    # - Hub is down
+    # => let's look if we can find the appropriate folder in the cache:
+    #    - if the specified revision is a commit hash, look inside "snapshots".
+    #    - f the specified revision is a branch or tag, look inside "refs".
+    if repo_info is None:
+        # Try to get which commit hash corresponds to the specified revision
+        commit_hash = None
+        if REGEX_COMMIT_HASH.match(revision):
+            commit_hash = revision
+        else:
+            ref_path = os.path.join(storage_folder, "refs", revision)
+            if os.path.exists(ref_path):
+                # retrieve commit_hash from refs file
+                with open(ref_path) as f:
+                    commit_hash = f.read()
+
+        # Try to locate snapshot folder for this commit hash
+        if commit_hash is not None:
+            snapshot_folder = os.path.join(storage_folder, "snapshots", commit_hash)
+            if os.path.exists(snapshot_folder):
+                # Snapshot folder exists => let's return it
+                # (but we can't check if all the files are actually there)
+                return snapshot_folder
+
+        # If we couldn't find the appropriate folder on disk, raise an error.
+        if local_files_only:
+            raise LocalEntryNotFoundError(
+                "Cannot find an appropriate cached snapshot folder for the specified revision on the local disk and "
+                "outgoing traffic has been disabled. To enable repo look-ups and downloads online, pass "
+                "'local_files_only=False' as input."
+            )
+        elif isinstance(api_call_error, OfflineModeIsEnabled):
+            raise LocalEntryNotFoundError(
+                "Cannot find an appropriate cached snapshot folder for the specified revision on the local disk and "
+                "outgoing traffic has been disabled. To enable repo look-ups and downloads online, set "
+                "'HF_HUB_OFFLINE=0' as environment variable."
+            ) from api_call_error
+        elif isinstance(api_call_error, RepositoryNotFoundError) or isinstance(api_call_error, GatedRepoError):
+            # Repo not found => let's raise the actual error
+            raise api_call_error
+        else:
+            # Otherwise: most likely a connection issue or Hub downtime => let's warn the user
+            raise LocalEntryNotFoundError(
+                "An error happened while trying to locate the files on the Hub and we cannot find the appropriate"
+                " snapshot folder for the specified revision on the local disk. Please check your internet connection"
+                " and try again."
+            ) from api_call_error
+
+    # At this stage, internet connection is up and running
+    # => let's download the files!
+    assert repo_info.sha is not None, "Repo info returned from server must have a revision sha."
+    assert repo_info.siblings is not None, "Repo info returned from server must have a siblings list."
+    filtered_repo_files = list(
+        filter_repo_objects(
+            items=[f.rfilename for f in repo_info.siblings],
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+        )
+    )
+    commit_hash = repo_info.sha
+    snapshot_folder = os.path.join(storage_folder, "snapshots", commit_hash)
+    # if passed revision is not identical to commit_hash
+    # then revision has to be a branch name or tag name.
+    # In that case store a ref.
+    if revision != commit_hash:
+        ref_path = os.path.join(storage_folder, "refs", revision)
+        os.makedirs(os.path.dirname(ref_path), exist_ok=True)
+        with open(ref_path, "w") as f:
+            f.write(commit_hash)
+
+    # we pass the commit_hash to hf_hub_download
+    # so no network call happens if we already
+    # have the file locally.
+    def _inner_hf_hub_download(repo_file: str):
+        return hf_hub_download(
+            repo_id,
+            filename=repo_file,
+            repo_type=repo_type,
+            revision=commit_hash,
+            endpoint=endpoint,
+            cache_dir=cache_dir,
+            local_dir=local_dir,
+            local_dir_use_symlinks=local_dir_use_symlinks,
+            library_name=library_name,
+            library_version=library_version,
+            user_agent=user_agent,
+            proxies=proxies,
+            etag_timeout=etag_timeout,
+            resume_download=resume_download,
+            force_download=force_download,
+            token=token,
+        )
+
+    if HF_HUB_ENABLE_HF_TRANSFER:
+        # when using hf_transfer we don't want extra parallelism
+        # from the one hf_transfer provides
+        for file in filtered_repo_files:
+            _inner_hf_hub_download(file)
+    else:
+        thread_map(
+            _inner_hf_hub_download,
+            filtered_repo_files,
+            desc=f"Fetching {len(filtered_repo_files)} files",
+            max_workers=max_workers,
+            # User can use its own tqdm class or the default one from `huggingface_hub.utils`
+            tqdm_class=tqdm_class or hf_tqdm,
+        )
+
+    if local_dir is not None:
+        return str(os.path.realpath(local_dir))
+    return snapshot_folder
diff --git a/lib/python3.11/site-packages/huggingface_hub/_space_api.py b/lib/python3.11/site-packages/huggingface_hub/_space_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddfcd041d656b26add6b53d2c3d475de3443eef2
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_space_api.py
@@ -0,0 +1,154 @@
+# coding=utf-8
+# Copyright 2019-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Dict, Optional
+
+from huggingface_hub.utils import parse_datetime
+
+
+class SpaceStage(str, Enum):
+    """
+    Enumeration of possible stage of a Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceStage.BUILDING == "BUILDING"
+    ```
+
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceInfo.ts#L61 (private url).
+    """
+
+    # Copied from moon-landing > server > repo_types > SpaceInfo.ts (private repo)
+    NO_APP_FILE = "NO_APP_FILE"
+    CONFIG_ERROR = "CONFIG_ERROR"
+    BUILDING = "BUILDING"
+    BUILD_ERROR = "BUILD_ERROR"
+    RUNNING = "RUNNING"
+    RUNNING_BUILDING = "RUNNING_BUILDING"
+    RUNTIME_ERROR = "RUNTIME_ERROR"
+    DELETING = "DELETING"
+    STOPPED = "STOPPED"
+    PAUSED = "PAUSED"
+
+
+class SpaceHardware(str, Enum):
+    """
+    Enumeration of hardwares available to run your Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceHardware.CPU_BASIC == "cpu-basic"
+    ```
+
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceInfo.ts#L73 (private url).
+    """
+
+    CPU_BASIC = "cpu-basic"
+    CPU_UPGRADE = "cpu-upgrade"
+    T4_SMALL = "t4-small"
+    T4_MEDIUM = "t4-medium"
+    ZERO_A10G = "zero-a10g"
+    A10G_SMALL = "a10g-small"
+    A10G_LARGE = "a10g-large"
+    A10G_LARGEX2 = "a10g-largex2"
+    A10G_LARGEX4 = "a10g-largex4"
+    A100_LARGE = "a100-large"
+
+
+class SpaceStorage(str, Enum):
+    """
+    Enumeration of persistent storage available for your Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceStorage.SMALL == "small"
+    ```
+
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceHardwareFlavor.ts#L24 (private url).
+    """
+
+    SMALL = "small"
+    MEDIUM = "medium"
+    LARGE = "large"
+
+
+@dataclass
+class SpaceRuntime:
+    """
+    Contains information about the current runtime of a Space.
+
+    Args:
+        stage (`str`):
+            Current stage of the space. Example: RUNNING.
+        hardware (`str` or `None`):
+            Current hardware of the space. Example: "cpu-basic". Can be `None` if Space
+            is `BUILDING` for the first time.
+        requested_hardware (`str` or `None`):
+            Requested hardware. Can be different than `hardware` especially if the request
+            has just been made. Example: "t4-medium". Can be `None` if no hardware has
+            been requested yet.
+        sleep_time (`int` or `None`):
+            Number of seconds the Space will be kept alive after the last request. By default (if value is `None`), the
+            Space will never go to sleep if it's running on an upgraded hardware, while it will go to sleep after 48
+            hours on a free 'cpu-basic' hardware. For more details, see https://huggingface.co/docs/hub/spaces-gpus#sleep-time.
+        raw (`dict`):
+            Raw response from the server. Contains more information about the Space
+            runtime like number of replicas, number of cpu, memory size,...
+    """
+
+    stage: SpaceStage
+    hardware: Optional[SpaceHardware]
+    requested_hardware: Optional[SpaceHardware]
+    sleep_time: Optional[int]
+    storage: Optional[SpaceStorage]
+    raw: Dict
+
+    def __init__(self, data: Dict) -> None:
+        self.stage = data["stage"]
+        self.hardware = data.get("hardware", {}).get("current")
+        self.requested_hardware = data.get("hardware", {}).get("requested")
+        self.sleep_time = data.get("gcTimeout")
+        self.storage = data.get("storage")
+        self.raw = data
+
+
+@dataclass
+class SpaceVariable:
+    """
+    Contains information about the current variables of a Space.
+
+    Args:
+        key (`str`):
+            Variable key. Example: `"MODEL_REPO_ID"`
+        value (`str`):
+            Variable value. Example: `"the_model_repo_id"`.
+        description (`str` or None):
+            Description of the variable. Example: `"Model Repo ID of the implemented model"`.
+        updatedAt (`datetime`):
+            datetime of the last update of the variable.
+    """
+
+    key: str
+    value: str
+    description: Optional[str]
+    updated_at: datetime
+
+    def __init__(self, key: str, values: Dict) -> None:
+        self.key = key
+        self.value = values["value"]
+        self.description = values.get("description")
+        self.updated_at = parse_datetime(values["updatedAt"])
diff --git a/lib/python3.11/site-packages/huggingface_hub/_tensorboard_logger.py b/lib/python3.11/site-packages/huggingface_hub/_tensorboard_logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..94631ce433d430b57677c92303ac36948527a5f7
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_tensorboard_logger.py
@@ -0,0 +1,168 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains a logger to push training logs to the Hub, using Tensorboard."""
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from huggingface_hub._commit_scheduler import CommitScheduler
+
+from .utils import experimental, is_tensorboard_available
+
+
+if is_tensorboard_available():
+    from tensorboardX import SummaryWriter
+
+    # TODO: clarify: should we import from torch.utils.tensorboard ?
+
+else:
+    SummaryWriter = object  # Dummy class to avoid failing at import. Will raise on instance creation.
+
+if TYPE_CHECKING:
+    from tensorboardX import SummaryWriter
+
+
+class HFSummaryWriter(SummaryWriter):
+    """
+    Wrapper around the tensorboard's `SummaryWriter` to push training logs to the Hub.
+
+    Data is logged locally and then pushed to the Hub asynchronously. Pushing data to the Hub is done in a separate
+    thread to avoid blocking the training script. In particular, if the upload fails for any reason (e.g. a connection
+    issue), the main script will not be interrupted. Data is automatically pushed to the Hub every `commit_every`
+    minutes (default to every 5 minutes).
+
+    <Tip warning={true}>
+
+    `HFSummaryWriter` is experimental. Its API is subject to change in the future without prior notice.
+
+    </Tip>
+
+    Args:
+        repo_id (`str`):
+            The id of the repo to which the logs will be pushed.
+        logdir (`str`, *optional*):
+            The directory where the logs will be written. If not specified, a local directory will be created by the
+            underlying `SummaryWriter` object.
+        commit_every (`int` or `float`, *optional*):
+            The frequency (in minutes) at which the logs will be pushed to the Hub. Defaults to 5 minutes.
+        squash_history (`bool`, *optional*):
+            Whether to squash the history of the repo after each commit. Defaults to `False`. Squashing commits is
+            useful to avoid degraded performances on the repo when it grows too large.
+        repo_type (`str`, *optional*):
+            The type of the repo to which the logs will be pushed. Defaults to "model".
+        repo_revision (`str`, *optional*):
+            The revision of the repo to which the logs will be pushed. Defaults to "main".
+        repo_private (`bool`, *optional*):
+            Whether to create a private repo or not. Defaults to False. This argument is ignored if the repo already
+            exists.
+        path_in_repo (`str`, *optional*):
+            The path to the folder in the repo where the logs will be pushed. Defaults to "tensorboard/".
+        repo_allow_patterns (`List[str]` or `str`, *optional*):
+            A list of patterns to include in the upload. Defaults to `"*.tfevents.*"`. Check out the
+            [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-folder) for more details.
+        repo_ignore_patterns (`List[str]` or `str`, *optional*):
+            A list of patterns to exclude in the upload. Check out the
+            [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-folder) for more details.
+        token (`str`, *optional*):
+            Authentication token. Will default to the stored token. See https://huggingface.co/settings/token for more
+            details
+        kwargs:
+            Additional keyword arguments passed to `SummaryWriter`.
+
+    Examples:
+    ```py
+    >>> from huggingface_hub import HFSummaryWriter
+
+    # Logs are automatically pushed every 15 minutes
+    >>> logger = HFSummaryWriter(repo_id="test_hf_logger", commit_every=15)
+    >>> logger.add_scalar("a", 1)
+    >>> logger.add_scalar("b", 2)
+    ...
+
+    # You can also trigger a push manually
+    >>> logger.scheduler.trigger()
+    ```
+
+    ```py
+    >>> from huggingface_hub import HFSummaryWriter
+
+    # Logs are automatically pushed every 5 minutes (default) + when exiting the context manager
+    >>> with HFSummaryWriter(repo_id="test_hf_logger") as logger:
+    ...     logger.add_scalar("a", 1)
+    ...     logger.add_scalar("b", 2)
+    ```
+    """
+
+    @experimental
+    def __new__(cls, *args, **kwargs) -> "HFSummaryWriter":
+        if not is_tensorboard_available():
+            raise ImportError(
+                "You must have `tensorboard` installed to use `HFSummaryWriter`. Please run `pip install --upgrade"
+                " tensorboardX` first."
+            )
+        return super().__new__(cls)
+
+    def __init__(
+        self,
+        repo_id: str,
+        *,
+        logdir: Optional[str] = None,
+        commit_every: Union[int, float] = 5,
+        squash_history: bool = False,
+        repo_type: Optional[str] = None,
+        repo_revision: Optional[str] = None,
+        repo_private: bool = False,
+        path_in_repo: Optional[str] = "tensorboard",
+        repo_allow_patterns: Optional[Union[List[str], str]] = "*.tfevents.*",
+        repo_ignore_patterns: Optional[Union[List[str], str]] = None,
+        token: Optional[str] = None,
+        **kwargs,
+    ):
+        # Initialize SummaryWriter
+        super().__init__(logdir=logdir, **kwargs)
+
+        # Check logdir has been correctly initialized and fail early otherwise. In practice, SummaryWriter takes care of it.
+        if not isinstance(self.logdir, str):
+            raise ValueError(f"`self.logdir` must be a string. Got '{self.logdir}' of type {type(self.logdir)}.")
+
+        # Append logdir name to `path_in_repo`
+        if path_in_repo is None or path_in_repo == "":
+            path_in_repo = Path(self.logdir).name
+        else:
+            path_in_repo = path_in_repo.strip("/") + "/" + Path(self.logdir).name
+
+        # Initialize scheduler
+        self.scheduler = CommitScheduler(
+            folder_path=self.logdir,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=repo_revision,
+            private=repo_private,
+            token=token,
+            allow_patterns=repo_allow_patterns,
+            ignore_patterns=repo_ignore_patterns,
+            every=commit_every,
+            squash_history=squash_history,
+        )
+
+        # Exposing some high-level info at root level
+        self.repo_id = self.scheduler.repo_id
+        self.repo_type = self.scheduler.repo_type
+        self.repo_revision = self.scheduler.revision
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Push to hub in a non-blocking way when exiting the logger's context manager."""
+        super().__exit__(exc_type, exc_val, exc_tb)
+        future = self.scheduler.trigger()
+        future.result()
diff --git a/lib/python3.11/site-packages/huggingface_hub/_webhooks_payload.py b/lib/python3.11/site-packages/huggingface_hub/_webhooks_payload.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4d224cc99a799bac815d68a77c2d31fae08ce25
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_webhooks_payload.py
@@ -0,0 +1,115 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains data structures to parse the webhooks payload."""
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel
+
+
+# This is an adaptation of the ReportV3 interface implemented in moon-landing. V0, V1 and V2 have been ignored as they
+# are not in used anymore. To keep in sync when format is updated in
+# https://github.com/huggingface/moon-landing/blob/main/server/lib/HFWebhooks.ts (internal link).
+
+
+WebhookEvent_T = Literal[
+    "create",
+    "delete",
+    "move",
+    "update",
+]
+RepoChangeEvent_T = Literal[
+    "add",
+    "move",
+    "remove",
+    "update",
+]
+RepoType_T = Literal[
+    "dataset",
+    "model",
+    "space",
+]
+DiscussionStatus_T = Literal[
+    "closed",
+    "draft",
+    "open",
+    "merged",
+]
+SupportedWebhookVersion = Literal[3]
+
+
+class ObjectId(BaseModel):
+    id: str
+
+
+class WebhookPayloadUrl(BaseModel):
+    web: str
+    api: Optional[str] = None
+
+
+class WebhookPayloadMovedTo(BaseModel):
+    name: str
+    owner: ObjectId
+
+
+class WebhookPayloadWebhook(ObjectId):
+    version: SupportedWebhookVersion
+
+
+class WebhookPayloadEvent(BaseModel):
+    action: WebhookEvent_T
+    scope: str
+
+
+class WebhookPayloadDiscussionChanges(BaseModel):
+    base: str
+    mergeCommitId: Optional[str] = None
+
+
+class WebhookPayloadComment(ObjectId):
+    author: ObjectId
+    hidden: bool
+    content: Optional[str] = None
+    url: WebhookPayloadUrl
+
+
+class WebhookPayloadDiscussion(ObjectId):
+    num: int
+    author: ObjectId
+    url: WebhookPayloadUrl
+    title: str
+    isPullRequest: bool
+    status: DiscussionStatus_T
+    changes: Optional[WebhookPayloadDiscussionChanges] = None
+    pinned: Optional[bool] = None
+
+
+class WebhookPayloadRepo(ObjectId):
+    owner: ObjectId
+    head_sha: Optional[str] = None
+    name: str
+    private: bool
+    subdomain: Optional[str] = None
+    tags: Optional[List[str]] = None
+    type: Literal["dataset", "model", "space"]
+    url: WebhookPayloadUrl
+
+
+class WebhookPayload(BaseModel):
+    event: WebhookPayloadEvent
+    repo: WebhookPayloadRepo
+    discussion: Optional[WebhookPayloadDiscussion] = None
+    comment: Optional[WebhookPayloadComment] = None
+    webhook: WebhookPayloadWebhook
+    movedTo: Optional[WebhookPayloadMovedTo] = None
diff --git a/lib/python3.11/site-packages/huggingface_hub/_webhooks_server.py b/lib/python3.11/site-packages/huggingface_hub/_webhooks_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a8fa061f7cfab99e91c19f483206e7ebebef2d1
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/_webhooks_server.py
@@ -0,0 +1,379 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains `WebhooksServer` and `webhook_endpoint` to create a webhook server easily."""
+import atexit
+import inspect
+import os
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
+
+from .utils import experimental, is_gradio_available
+from .utils._deprecation import _deprecate_method
+
+
+if TYPE_CHECKING:
+    import gradio as gr
+
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+
+_global_app: Optional["WebhooksServer"] = None
+_is_local = os.getenv("SYSTEM") != "spaces"
+
+
+@experimental
+class WebhooksServer:
+    """
+    The [`WebhooksServer`] class lets you create an instance of a Gradio app that can receive Huggingface webhooks.
+    These webhooks can be registered using the [`~WebhooksServer.add_webhook`] decorator. Webhook endpoints are added to
+    the app as a POST endpoint to the FastAPI router. Once all the webhooks are registered, the `run` method has to be
+    called to start the app.
+
+    It is recommended to accept [`WebhookPayload`] as the first argument of the webhook function. It is a Pydantic
+    model that contains all the information about the webhook event. The data will be parsed automatically for you.
+
+    Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to setup your
+    WebhooksServer and deploy it on a Space.
+
+    <Tip warning={true}>
+
+    `WebhooksServer` is experimental. Its API is subject to change in the future.
+
+    </Tip>
+
+    <Tip warning={true}>
+
+    You must have `gradio` installed to use `WebhooksServer` (`pip install --upgrade gradio`).
+
+    </Tip>
+
+    Args:
+        ui (`gradio.Blocks`, optional):
+            A Gradio UI instance to be used as the Space landing page. If `None`, a UI displaying instructions
+            about the configured webhooks is created.
+        webhook_secret (`str`, optional):
+            A secret key to verify incoming webhook requests. You can set this value to any secret you want as long as
+            you also configure it in your [webhooks settings panel](https://huggingface.co/settings/webhooks). You
+            can also set this value as the `WEBHOOK_SECRET` environment variable. If no secret is provided, the
+            webhook endpoints are opened without any security.
+
+    Example:
+
+        ```python
+        import gradio as gr
+        from huggingface_hub import WebhooksServer, WebhookPayload
+
+        with gr.Blocks() as ui:
+            ...
+
+        app = WebhooksServer(ui=ui, webhook_secret="my_secret_key")
+
+        @app.add_webhook("/say_hello")
+        async def hello(payload: WebhookPayload):
+            return {"message": "hello"}
+
+        app.run()
+        ```
+    """
+
+    def __new__(cls, *args, **kwargs) -> "WebhooksServer":
+        if not is_gradio_available():
+            raise ImportError(
+                "You must have `gradio` installed to use `WebhooksServer`. Please run `pip install --upgrade gradio`"
+                " first."
+            )
+        return super().__new__(cls)
+
+    def __init__(
+        self,
+        ui: Optional["gr.Blocks"] = None,
+        webhook_secret: Optional[str] = None,
+    ) -> None:
+        self._ui = ui
+
+        self.webhook_secret = webhook_secret or os.getenv("WEBHOOK_SECRET")
+        self.registered_webhooks: Dict[str, Callable] = {}
+        _warn_on_empty_secret(self.webhook_secret)
+
+    def add_webhook(self, path: Optional[str] = None) -> Callable:
+        """
+        Decorator to add a webhook to the [`WebhooksServer`] server.
+
+        Args:
+            path (`str`, optional):
+                The URL path to register the webhook function. If not provided, the function name will be used as the
+                path. In any case, all webhooks are registered under `/webhooks`.
+
+        Raises:
+            ValueError: If the provided path is already registered as a webhook.
+
+        Example:
+            ```python
+            from huggingface_hub import WebhooksServer, WebhookPayload
+
+            app = WebhooksServer()
+
+            @app.add_webhook
+            async def trigger_training(payload: WebhookPayload):
+                if payload.repo.type == "dataset" and payload.event.action == "update":
+                    # Trigger a training job if a dataset is updated
+                    ...
+
+            app.run()
+        ```
+        """
+        # Usage: directly as decorator. Example: `@app.add_webhook`
+        if callable(path):
+            # If path is a function, it means it was used as a decorator without arguments
+            return self.add_webhook()(path)
+
+        # Usage: provide a path. Example: `@app.add_webhook(...)`
+        @wraps(FastAPI.post)
+        def _inner_post(*args, **kwargs):
+            func = args[0]
+            abs_path = f"/webhooks/{(path or func.__name__).strip('/')}"
+            if abs_path in self.registered_webhooks:
+                raise ValueError(f"Webhook {abs_path} already exists.")
+            self.registered_webhooks[abs_path] = func
+
+        return _inner_post
+
+    def launch(self, prevent_thread_lock: bool = False, **launch_kwargs: Any) -> None:
+        """Launch the Gradio app and register webhooks to the underlying FastAPI server.
+
+        Input parameters are forwarded to Gradio when launching the app.
+        """
+        ui = self._ui or self._get_default_ui()
+
+        # Start Gradio App
+        #   - as non-blocking so that webhooks can be added afterwards
+        #   - as shared if launch locally (to debug webhooks)
+        launch_kwargs.setdefault("share", _is_local)
+        self.fastapi_app, _, _ = ui.launch(prevent_thread_lock=True, **launch_kwargs)
+
+        # Register webhooks to FastAPI app
+        for path, func in self.registered_webhooks.items():
+            # Add secret check if required
+            if self.webhook_secret is not None:
+                func = _wrap_webhook_to_check_secret(func, webhook_secret=self.webhook_secret)
+
+            # Add route to FastAPI app
+            self.fastapi_app.post(path)(func)
+
+        # Print instructions and block main thread
+        url = (ui.share_url or ui.local_url).strip("/")
+        message = "\nWebhooks are correctly setup and ready to use:"
+        message += "\n" + "\n".join(f"  - POST {url}{webhook}" for webhook in self.registered_webhooks)
+        message += "\nGo to https://huggingface.co/settings/webhooks to setup your webhooks."
+        print(message)
+
+        if not prevent_thread_lock:
+            ui.block_thread()
+
+    @_deprecate_method(version="0.23", message="Use `WebhooksServer.launch` instead.")
+    def run(self) -> None:
+        return self.launch()
+
+    def _get_default_ui(self) -> "gr.Blocks":
+        """Default UI if not provided (lists webhooks and provides basic instructions)."""
+        import gradio as gr
+
+        with gr.Blocks() as ui:
+            gr.Markdown("# This is an app to process 🤗 Webhooks")
+            gr.Markdown(
+                "Webhooks are a foundation for MLOps-related features. They allow you to listen for new changes on"
+                " specific repos or to all repos belonging to particular set of users/organizations (not just your"
+                " repos, but any repo). Check out this [guide](https://huggingface.co/docs/hub/webhooks) to get to"
+                " know more about webhooks on the Huggingface Hub."
+            )
+            gr.Markdown(
+                f"{len(self.registered_webhooks)} webhook(s) are registered:"
+                + "\n\n"
+                + "\n ".join(
+                    f"- [{webhook_path}]({_get_webhook_doc_url(webhook.__name__, webhook_path)})"
+                    for webhook_path, webhook in self.registered_webhooks.items()
+                )
+            )
+            gr.Markdown(
+                "Go to https://huggingface.co/settings/webhooks to setup your webhooks."
+                + "\nYou app is running locally. Please look at the logs to check the full URL you need to set."
+                if _is_local
+                else (
+                    "\nThis app is running on a Space. You can find the corresponding URL in the options menu"
+                    " (top-right) > 'Embed the Space'. The URL looks like 'https://{username}-{repo_name}.hf.space'."
+                )
+            )
+        return ui
+
+
+@experimental
+def webhook_endpoint(path: Optional[str] = None) -> Callable:
+    """Decorator to start a [`WebhooksServer`] and register the decorated function as a webhook endpoint.
+
+    This is a helper to get started quickly. If you need more flexibility (custom landing page or webhook secret),
+    you can use [`WebhooksServer`] directly. You can register multiple webhook endpoints (to the same server) by using
+    this decorator multiple times.
+
+    Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to setup your
+    server and deploy it on a Space.
+
+    <Tip warning={true}>
+
+    `webhook_endpoint` is experimental. Its API is subject to change in the future.
+
+    </Tip>
+
+    <Tip warning={true}>
+
+    You must have `gradio` installed to use `webhook_endpoint` (`pip install --upgrade gradio`).
+
+    </Tip>
+
+    Args:
+        path (`str`, optional):
+            The URL path to register the webhook function. If not provided, the function name will be used as the path.
+            In any case, all webhooks are registered under `/webhooks`.
+
+    Examples:
+        The default usage is to register a function as a webhook endpoint. The function name will be used as the path.
+        The server will be started automatically at exit (i.e. at the end of the script).
+
+        ```python
+        from huggingface_hub import webhook_endpoint, WebhookPayload
+
+        @webhook_endpoint
+        async def trigger_training(payload: WebhookPayload):
+            if payload.repo.type == "dataset" and payload.event.action == "update":
+                # Trigger a training job if a dataset is updated
+                ...
+
+        # Server is automatically started at the end of the script.
+        ```
+
+        Advanced usage: register a function as a webhook endpoint and start the server manually. This is useful if you
+        are running it in a notebook.
+
+        ```python
+        from huggingface_hub import webhook_endpoint, WebhookPayload
+
+        @webhook_endpoint
+        async def trigger_training(payload: WebhookPayload):
+            if payload.repo.type == "dataset" and payload.event.action == "update":
+                # Trigger a training job if a dataset is updated
+                ...
+
+        # Start the server manually
+        trigger_training.run()
+        ```
+    """
+    if callable(path):
+        # If path is a function, it means it was used as a decorator without arguments
+        return webhook_endpoint()(path)
+
+    @wraps(WebhooksServer.add_webhook)
+    def _inner(func: Callable) -> Callable:
+        app = _get_global_app()
+        app.add_webhook(path)(func)
+        if len(app.registered_webhooks) == 1:
+            # Register `app.run` to run at exit (only once)
+            atexit.register(app.run)
+
+        @wraps(app.run)
+        def _run_now():
+            # Run the app directly (without waiting atexit)
+            atexit.unregister(app.run)
+            app.run()
+
+        func.run = _run_now  # type: ignore
+        return func
+
+    return _inner
+
+
+def _get_global_app() -> WebhooksServer:
+    global _global_app
+    if _global_app is None:
+        _global_app = WebhooksServer()
+    return _global_app
+
+
+def _warn_on_empty_secret(webhook_secret: Optional[str]) -> None:
+    if webhook_secret is None:
+        print("Webhook secret is not defined. This means your webhook endpoints will be open to everyone.")
+        print(
+            "To add a secret, set `WEBHOOK_SECRET` as environment variable or pass it at initialization: "
+            "\n\t`app = WebhooksServer(webhook_secret='my_secret', ...)`"
+        )
+        print(
+            "For more details about webhook secrets, please refer to"
+            " https://huggingface.co/docs/hub/webhooks#webhook-secret."
+        )
+    else:
+        print("Webhook secret is correctly defined.")
+
+
+def _get_webhook_doc_url(webhook_name: str, webhook_path: str) -> str:
+    """Returns the anchor to a given webhook in the docs (experimental)"""
+    return "/docs#/default/" + webhook_name + webhook_path.replace("/", "_") + "_post"
+
+
+def _wrap_webhook_to_check_secret(func: Callable, webhook_secret: str) -> Callable:
+    """Wraps a webhook function to check the webhook secret before calling the function.
+
+    This is a hacky way to add the `request` parameter to the function signature. Since FastAPI based itself on route
+    parameters to inject the values to the function, we need to hack the function signature to retrieve the `Request`
+    object (and hence the headers). A far cleaner solution would be to use a middleware. However, since
+    `fastapi==0.90.1`, a middleware cannot be added once the app has started. And since the FastAPI app is started by
+    Gradio internals (and not by us), we cannot add a middleware.
+
+    This method is called only when a secret has been defined by the user. If a request is sent without the
+    "x-webhook-secret", the function will return a 401 error (unauthorized). If the header is sent but is incorrect,
+    the function will return a 403 error (forbidden).
+
+    Inspired by https://stackoverflow.com/a/33112180.
+    """
+    initial_sig = inspect.signature(func)
+
+    @wraps(func)
+    async def _protected_func(request: Request, **kwargs):
+        request_secret = request.headers.get("x-webhook-secret")
+        if request_secret is None:
+            return JSONResponse({"error": "x-webhook-secret header not set."}, status_code=401)
+        if request_secret != webhook_secret:
+            return JSONResponse({"error": "Invalid webhook secret."}, status_code=403)
+
+        # Inject `request` in kwargs if required
+        if "request" in initial_sig.parameters:
+            kwargs["request"] = request
+
+        # Handle both sync and async routes
+        if inspect.iscoroutinefunction(func):
+            return await func(**kwargs)
+        else:
+            return func(**kwargs)
+
+    # Update signature to include request
+    if "request" not in initial_sig.parameters:
+        _protected_func.__signature__ = initial_sig.replace(  # type: ignore
+            parameters=(
+                inspect.Parameter(name="request", kind=inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=Request),
+            )
+            + tuple(initial_sig.parameters.values())
+        )
+
+    # Return protected route
+    return _protected_func
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__init__.py b/lib/python3.11/site-packages/huggingface_hub/commands/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..49d088214505b9604964ab142e7f8a5b38ccd5ef
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+from argparse import _SubParsersAction
+
+
+class BaseHuggingfaceCLICommand(ABC):
+    @staticmethod
+    @abstractmethod
+    def register_subcommand(parser: _SubParsersAction):
+        raise NotImplementedError()
+
+    @abstractmethod
+    def run(self):
+        raise NotImplementedError()
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..551346e239cb6f09b6bad9a9625478012c648f2f
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/_cli_utils.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/_cli_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b56583529fe15b0c732b6392a2a37f15d7dbf522
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/_cli_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/delete_cache.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/delete_cache.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5999c7d7f10399e43453e3ea178c9e2f36901c78
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/delete_cache.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/download.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/download.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bbc185d08294124aedf737803ee1fd15eb05a859
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/download.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/env.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/env.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7d34d6b085cf611adacdd8f0313f5efa70b7f571
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/env.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/huggingface_cli.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/huggingface_cli.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c75932cf159e5378d97eac8c199e4420022c4995
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/huggingface_cli.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/lfs.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/lfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..34b3ff0d2532396bd957c8128718d8d28461574a
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/lfs.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/scan_cache.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/scan_cache.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06dd636b655d9297f341b7a0a68fa02855362827
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/scan_cache.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/upload.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/upload.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..efad172ae526ed03020e5777624e6f60440e0920
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/upload.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/user.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/user.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4aa71111ad8aeddbb1834bbec4625caa5eec623d
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/commands/__pycache__/user.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/_cli_utils.py b/lib/python3.11/site-packages/huggingface_hub/commands/_cli_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbf17e887e901e58461b09e6648d614bb2caabbb
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/_cli_utils.py
@@ -0,0 +1,63 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains a utility for good-looking prints."""
+import os
+from typing import List, Union
+
+
+class ANSI:
+    """
+    Helper for en.wikipedia.org/wiki/ANSI_escape_code
+    """
+
+    _bold = "\u001b[1m"
+    _gray = "\u001b[90m"
+    _red = "\u001b[31m"
+    _reset = "\u001b[0m"
+
+    @classmethod
+    def bold(cls, s: str) -> str:
+        return cls._format(s, cls._bold)
+
+    @classmethod
+    def gray(cls, s: str) -> str:
+        return cls._format(s, cls._gray)
+
+    @classmethod
+    def red(cls, s: str) -> str:
+        return cls._format(s, cls._bold + cls._red)
+
+    @classmethod
+    def _format(cls, s: str, code: str) -> str:
+        if os.environ.get("NO_COLOR"):
+            # See https://no-color.org/
+            return s
+        return f"{code}{s}{cls._reset}"
+
+
+def tabulate(rows: List[List[Union[str, int]]], headers: List[str]) -> str:
+    """
+    Inspired by:
+
+    - stackoverflow.com/a/8356620/593036
+    - stackoverflow.com/questions/9535954/printing-lists-as-tabular-data
+    """
+    col_widths = [max(len(str(x)) for x in col) for col in zip(*rows, headers)]
+    row_format = ("{{:{}}} " * len(headers)).format(*col_widths)
+    lines = []
+    lines.append(row_format.format(*headers))
+    lines.append(row_format.format(*["-" * w for w in col_widths]))
+    for row in rows:
+        lines.append(row_format.format(*row))
+    return "\n".join(lines)
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/delete_cache.py b/lib/python3.11/site-packages/huggingface_hub/commands/delete_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..c61863f55d3cde2773e4b0e14988514d9c476b01
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/delete_cache.py
@@ -0,0 +1,427 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to delete some revisions from the HF cache directory.
+
+Usage:
+    huggingface-cli delete-cache
+    huggingface-cli delete-cache --disable-tui
+    huggingface-cli delete-cache --dir ~/.cache/huggingface/hub
+
+NOTE:
+    This command is based on `InquirerPy` to build the multiselect menu in the terminal.
+    This dependency has to be installed with `pip install huggingface_hub[cli]`. Since
+    we want to avoid as much as possible cross-platform issues, I chose a library that
+    is built on top of `python-prompt-toolkit` which seems to be a reference in terminal
+    GUI (actively maintained on both Unix and Windows, 7.9k stars).
+
+    For the moment, the TUI feature is in beta.
+
+    See:
+    - https://github.com/kazhala/InquirerPy
+    - https://inquirerpy.readthedocs.io/en/latest/
+    - https://github.com/prompt-toolkit/python-prompt-toolkit
+
+    Other solutions could have been:
+    - `simple_term_menu`: would be good as well for our use case but some issues suggest
+      that Windows is less supported.
+      See: https://github.com/IngoMeyer441/simple-term-menu
+    - `PyInquirer`: very similar to `InquirerPy` but older and not maintained anymore.
+      In particular, no support of Python3.10.
+      See: https://github.com/CITGuru/PyInquirer
+    - `pick` (or `pickpack`): easy to use and flexible but built on top of Python's
+      standard library `curses` that is specific to Unix (not implemented on Windows).
+      See https://github.com/wong2/pick and https://github.com/anafvana/pickpack.
+    - `inquirer`: lot of traction (700 stars) but explicitly states "experimental
+      support of Windows". Not built on top of `python-prompt-toolkit`.
+      See https://github.com/magmax/python-inquirer
+
+TODO: add support for `huggingface-cli delete-cache aaaaaa bbbbbb cccccc (...)` ?
+TODO: add "--keep-last" arg to delete revisions that are not on `main` ref
+TODO: add "--filter" arg to filter repositories by name ?
+TODO: add "--sort" arg to sort by size ?
+TODO: add "--limit" arg to limit to X repos ?
+TODO: add "-y" arg for immediate deletion ?
+See discussions in https://github.com/huggingface/huggingface_hub/issues/1025.
+"""
+import os
+from argparse import Namespace, _SubParsersAction
+from functools import wraps
+from tempfile import mkstemp
+from typing import Any, Callable, Iterable, List, Optional, Union
+
+from ..utils import CachedRepoInfo, CachedRevisionInfo, HFCacheInfo, scan_cache_dir
+from . import BaseHuggingfaceCLICommand
+from ._cli_utils import ANSI
+
+
+try:
+    from InquirerPy import inquirer
+    from InquirerPy.base.control import Choice
+    from InquirerPy.separator import Separator
+
+    _inquirer_py_available = True
+except ImportError:
+    _inquirer_py_available = False
+
+
+def require_inquirer_py(fn: Callable) -> Callable:
+    """Decorator to flag methods that require `InquirerPy`."""
+
+    # TODO: refactor this + imports in a unified pattern across codebase
+    @wraps(fn)
+    def _inner(*args, **kwargs):
+        if not _inquirer_py_available:
+            raise ImportError(
+                "The `delete-cache` command requires extra dependencies to work with"
+                " the TUI.\nPlease run `pip install huggingface_hub[cli]` to install"
+                " them.\nOtherwise, disable TUI using the `--disable-tui` flag."
+            )
+
+        return fn(*args, **kwargs)
+
+    return _inner
+
+
+# Possibility for the user to cancel deletion
+_CANCEL_DELETION_STR = "CANCEL_DELETION"
+
+
+class DeleteCacheCommand(BaseHuggingfaceCLICommand):
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        delete_cache_parser = parser.add_parser("delete-cache", help="Delete revisions from the cache directory.")
+
+        delete_cache_parser.add_argument(
+            "--dir",
+            type=str,
+            default=None,
+            help="cache directory (optional). Default to the default HuggingFace cache.",
+        )
+
+        delete_cache_parser.add_argument(
+            "--disable-tui",
+            action="store_true",
+            help=(
+                "Disable Terminal User Interface (TUI) mode. Useful if your"
+                " platform/terminal doesn't support the multiselect menu."
+            ),
+        )
+
+        delete_cache_parser.set_defaults(func=DeleteCacheCommand)
+
+    def __init__(self, args: Namespace) -> None:
+        self.cache_dir: Optional[str] = args.dir
+        self.disable_tui: bool = args.disable_tui
+
+    def run(self):
+        """Run `delete-cache` command with or without TUI."""
+        # Scan cache directory
+        hf_cache_info = scan_cache_dir(self.cache_dir)
+
+        # Manual review from the user
+        if self.disable_tui:
+            selected_hashes = _manual_review_no_tui(hf_cache_info, preselected=[])
+        else:
+            selected_hashes = _manual_review_tui(hf_cache_info, preselected=[])
+
+        # If deletion is not cancelled
+        if len(selected_hashes) > 0 and _CANCEL_DELETION_STR not in selected_hashes:
+            confirm_message = _get_expectations_str(hf_cache_info, selected_hashes) + " Confirm deletion ?"
+
+            # Confirm deletion
+            if self.disable_tui:
+                confirmed = _ask_for_confirmation_no_tui(confirm_message)
+            else:
+                confirmed = _ask_for_confirmation_tui(confirm_message)
+
+            # Deletion is confirmed
+            if confirmed:
+                strategy = hf_cache_info.delete_revisions(*selected_hashes)
+                print("Start deletion.")
+                strategy.execute()
+                print(
+                    f"Done. Deleted {len(strategy.repos)} repo(s) and"
+                    f" {len(strategy.snapshots)} revision(s) for a total of"
+                    f" {strategy.expected_freed_size_str}."
+                )
+                return
+
+        # Deletion is cancelled
+        print("Deletion is cancelled. Do nothing.")
+
+
+@require_inquirer_py
+def _manual_review_tui(hf_cache_info: HFCacheInfo, preselected: List[str]) -> List[str]:
+    """Ask the user for a manual review of the revisions to delete.
+
+    Displays a multi-select menu in the terminal (TUI).
+    """
+    # Define multiselect list
+    choices = _get_tui_choices_from_scan(repos=hf_cache_info.repos, preselected=preselected)
+    checkbox = inquirer.checkbox(
+        message="Select revisions to delete:",
+        choices=choices,  # List of revisions with some pre-selection
+        cycle=False,  # No loop between top and bottom
+        height=100,  # Large list if possible
+        # We use the instruction to display to the user the expected effect of the
+        # deletion.
+        instruction=_get_expectations_str(
+            hf_cache_info,
+            selected_hashes=[c.value for c in choices if isinstance(c, Choice) and c.enabled],
+        ),
+        # We use the long instruction to should keybindings instructions to the user
+        long_instruction="Press <space> to select, <enter> to validate and <ctrl+c> to quit without modification.",
+        # Message that is displayed once the user validates its selection.
+        transformer=lambda result: f"{len(result)} revision(s) selected.",
+    )
+
+    # Add a callback to update the information line when a revision is
+    # selected/unselected
+    def _update_expectations(_) -> None:
+        # Hacky way to dynamically set an instruction message to the checkbox when
+        # a revision hash is selected/unselected.
+        checkbox._instruction = _get_expectations_str(
+            hf_cache_info,
+            selected_hashes=[choice["value"] for choice in checkbox.content_control.choices if choice["enabled"]],
+        )
+
+    checkbox.kb_func_lookup["toggle"].append({"func": _update_expectations})
+
+    # Finally display the form to the user.
+    try:
+        return checkbox.execute()
+    except KeyboardInterrupt:
+        return []  # Quit without deletion
+
+
+@require_inquirer_py
+def _ask_for_confirmation_tui(message: str, default: bool = True) -> bool:
+    """Ask for confirmation using Inquirer."""
+    return inquirer.confirm(message, default=default).execute()
+
+
+def _get_tui_choices_from_scan(repos: Iterable[CachedRepoInfo], preselected: List[str]) -> List:
+    """Build a list of choices from the scanned repos.
+
+    Args:
+        repos (*Iterable[`CachedRepoInfo`]*):
+            List of scanned repos on which we want to delete revisions.
+        preselected (*List[`str`]*):
+            List of revision hashes that will be preselected.
+
+    Return:
+        The list of choices to pass to `inquirer.checkbox`.
+    """
+    choices: List[Union[Choice, Separator]] = []
+
+    # First choice is to cancel the deletion. If selected, nothing will be deleted,
+    # no matter the other selected items.
+    choices.append(
+        Choice(
+            _CANCEL_DELETION_STR,
+            name="None of the following (if selected, nothing will be deleted).",
+            enabled=False,
+        )
+    )
+
+    # Display a separator per repo and a Choice for each revisions of the repo
+    for repo in sorted(repos, key=_repo_sorting_order):
+        # Repo as separator
+        choices.append(
+            Separator(
+                f"\n{repo.repo_type.capitalize()} {repo.repo_id} ({repo.size_on_disk_str},"
+                f" used {repo.last_accessed_str})"
+            )
+        )
+        for revision in sorted(repo.revisions, key=_revision_sorting_order):
+            # Revision as choice
+            choices.append(
+                Choice(
+                    revision.commit_hash,
+                    name=(
+                        f"{revision.commit_hash[:8]}:"
+                        f" {', '.join(sorted(revision.refs)) or '(detached)'} #"
+                        f" modified {revision.last_modified_str}"
+                    ),
+                    enabled=revision.commit_hash in preselected,
+                )
+            )
+
+    # Return choices
+    return choices
+
+
+def _manual_review_no_tui(hf_cache_info: HFCacheInfo, preselected: List[str]) -> List[str]:
+    """Ask the user for a manual review of the revisions to delete.
+
+    Used when TUI is disabled. Manual review happens in a separate tmp file that the
+    user can manually edit.
+    """
+    # 1. Generate temporary file with delete commands.
+    fd, tmp_path = mkstemp(suffix=".txt")  # suffix to make it easier to find by editors
+    os.close(fd)
+
+    lines = []
+    for repo in sorted(hf_cache_info.repos, key=_repo_sorting_order):
+        lines.append(
+            f"\n# {repo.repo_type.capitalize()} {repo.repo_id} ({repo.size_on_disk_str},"
+            f" used {repo.last_accessed_str})"
+        )
+        for revision in sorted(repo.revisions, key=_revision_sorting_order):
+            lines.append(
+                # Deselect by prepending a '#'
+                f"{'' if revision.commit_hash in preselected else '#'}   "
+                f" {revision.commit_hash} # Refs:"
+                # Print `refs` as comment on same line
+                f" {', '.join(sorted(revision.refs)) or '(detached)'} # modified"
+                # Print `last_modified` as comment on same line
+                f" {revision.last_modified_str}"
+            )
+
+    with open(tmp_path, "w") as f:
+        f.write(_MANUAL_REVIEW_NO_TUI_INSTRUCTIONS)
+        f.write("\n".join(lines))
+
+    # 2. Prompt instructions to user.
+    instructions = f"""
+    TUI is disabled. In order to select which revisions you want to delete, please edit
+    the following file using the text editor of your choice. Instructions for manual
+    editing are located at the beginning of the file. Edit the file, save it and confirm
+    to continue.
+    File to edit: {ANSI.bold(tmp_path)}
+    """
+    print("\n".join(line.strip() for line in instructions.strip().split("\n")))
+
+    # 3. Wait for user confirmation.
+    while True:
+        selected_hashes = _read_manual_review_tmp_file(tmp_path)
+        if _ask_for_confirmation_no_tui(
+            _get_expectations_str(hf_cache_info, selected_hashes) + " Continue ?",
+            default=False,
+        ):
+            break
+
+    # 4. Return selected_hashes
+    os.remove(tmp_path)
+    return selected_hashes
+
+
+def _ask_for_confirmation_no_tui(message: str, default: bool = True) -> bool:
+    """Ask for confirmation using pure-python."""
+    YES = ("y", "yes", "1")
+    NO = ("n", "no", "0")
+    DEFAULT = ""
+    ALL = YES + NO + (DEFAULT,)
+    full_message = message + (" (Y/n) " if default else " (y/N) ")
+    while True:
+        answer = input(full_message).lower()
+        if answer == DEFAULT:
+            return default
+        if answer in YES:
+            return True
+        if answer in NO:
+            return False
+        print(f"Invalid input. Must be one of {ALL}")
+
+
+def _get_expectations_str(hf_cache_info: HFCacheInfo, selected_hashes: List[str]) -> str:
+    """Format a string to display to the user how much space would be saved.
+
+    Example:
+    ```
+    >>> _get_expectations_str(hf_cache_info, selected_hashes)
+    '7 revisions selected counting for 4.3G.'
+    ```
+    """
+    if _CANCEL_DELETION_STR in selected_hashes:
+        return "Nothing will be deleted."
+    strategy = hf_cache_info.delete_revisions(*selected_hashes)
+    return f"{len(selected_hashes)} revisions selected counting for {strategy.expected_freed_size_str}."
+
+
+def _read_manual_review_tmp_file(tmp_path: str) -> List[str]:
+    """Read the manually reviewed instruction file and return a list of revision hash.
+
+    Example:
+        ```txt
+        # This is the tmp file content
+        ###
+
+        # Commented out line
+        123456789 # revision hash
+
+        # Something else
+        #      a_newer_hash # 2 days ago
+            an_older_hash # 3 days ago
+        ```
+
+        ```py
+        >>> _read_manual_review_tmp_file(tmp_path)
+        ['123456789', 'an_older_hash']
+        ```
+    """
+    with open(tmp_path) as f:
+        content = f.read()
+
+    # Split lines
+    lines = [line.strip() for line in content.split("\n")]
+
+    # Filter commented lines
+    selected_lines = [line for line in lines if not line.startswith("#")]
+
+    # Select only before comment
+    selected_hashes = [line.split("#")[0].strip() for line in selected_lines]
+
+    # Return revision hashes
+    return [hash for hash in selected_hashes if len(hash) > 0]
+
+
+_MANUAL_REVIEW_NO_TUI_INSTRUCTIONS = f"""
+# INSTRUCTIONS
+# ------------
+# This is a temporary file created by running `huggingface-cli delete-cache` with the
+# `--disable-tui` option. It contains a set of revisions that can be deleted from your
+# local cache directory.
+#
+# Please manually review the revisions you want to delete:
+#   - Revision hashes can be commented out with '#'.
+#   - Only non-commented revisions in this file will be deleted.
+#   - Revision hashes that are removed from this file are ignored as well.
+#   - If `{_CANCEL_DELETION_STR}` line is uncommented, the all cache deletion is cancelled and
+#     no changes will be applied.
+#
+# Once you've manually reviewed this file, please confirm deletion in the terminal. This
+# file will be automatically removed once done.
+# ------------
+
+# KILL SWITCH
+# ------------
+# Un-comment following line to completely cancel the deletion process
+# {_CANCEL_DELETION_STR}
+# ------------
+
+# REVISIONS
+# ------------
+""".strip()
+
+
+def _repo_sorting_order(repo: CachedRepoInfo) -> Any:
+    # First split by Dataset/Model, then sort by last accessed (oldest first)
+    return (repo.repo_type, repo.last_accessed)
+
+
+def _revision_sorting_order(revision: CachedRevisionInfo) -> Any:
+    # Sort by last modified (oldest first)
+    return revision.last_modified
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/download.py b/lib/python3.11/site-packages/huggingface_hub/commands/download.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ac5205e842fcc1e1711333983a40157bb863a7b
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/download.py
@@ -0,0 +1,214 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to download files from the Hub with the CLI.
+
+Usage:
+    huggingface-cli download --help
+
+    # Download file
+    huggingface-cli download gpt2 config.json
+
+    # Download entire repo
+    huggingface-cli download fffiloni/zeroscope --repo-type=space --revision=refs/pr/78
+
+    # Download repo with filters
+    huggingface-cli download gpt2 --include="*.safetensors"
+
+    # Download with token
+    huggingface-cli download Wauplin/private-model --token=hf_***
+
+    # Download quietly (no progress bar, no warnings, only the returned path)
+    huggingface-cli download gpt2 config.json --quiet
+
+    # Download to local dir
+    huggingface-cli download gpt2 --local-dir=./models/gpt2
+"""
+import warnings
+from argparse import Namespace, _SubParsersAction
+from typing import List, Literal, Optional, Union
+
+from huggingface_hub import logging
+from huggingface_hub._snapshot_download import snapshot_download
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.constants import HF_HUB_ENABLE_HF_TRANSFER
+from huggingface_hub.file_download import hf_hub_download
+from huggingface_hub.utils import disable_progress_bars, enable_progress_bars
+
+
+logger = logging.get_logger(__name__)
+
+
+class DownloadCommand(BaseHuggingfaceCLICommand):
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        download_parser = parser.add_parser("download", help="Download files from the Hub")
+        download_parser.add_argument(
+            "repo_id", type=str, help="ID of the repo to download from (e.g. `username/repo-name`)."
+        )
+        download_parser.add_argument(
+            "filenames", type=str, nargs="*", help="Files to download (e.g. `config.json`, `data/metadata.jsonl`)."
+        )
+        download_parser.add_argument(
+            "--repo-type",
+            choices=["model", "dataset", "space"],
+            default="model",
+            help="Type of repo to download from (e.g. `dataset`).",
+        )
+        download_parser.add_argument(
+            "--revision",
+            type=str,
+            help="An optional Git revision id which can be a branch name, a tag, or a commit hash.",
+        )
+        download_parser.add_argument(
+            "--include", nargs="*", type=str, help="Glob patterns to match files to download."
+        )
+        download_parser.add_argument(
+            "--exclude", nargs="*", type=str, help="Glob patterns to exclude from files to download."
+        )
+        download_parser.add_argument(
+            "--cache-dir", type=str, help="Path to the directory where to save the downloaded files."
+        )
+        download_parser.add_argument(
+            "--local-dir",
+            type=str,
+            help=(
+                "If set, the downloaded file will be placed under this directory either as a symlink (default) or a"
+                " regular file. Check out"
+                " https://huggingface.co/docs/huggingface_hub/guides/download#download-files-to-local-folder for more"
+                " details."
+            ),
+        )
+        download_parser.add_argument(
+            "--local-dir-use-symlinks",
+            choices=["auto", "True", "False"],
+            default="auto",
+            help=(
+                "To be used with `local_dir`. If set to 'auto', the cache directory will be used and the file will be"
+                " either duplicated or symlinked to the local directory depending on its size. It set to `True`, a"
+                " symlink will be created, no matter the file size. If set to `False`, the file will either be"
+                " duplicated from cache (if already exists) or downloaded from the Hub and not cached."
+            ),
+        )
+        download_parser.add_argument(
+            "--force-download",
+            action="store_true",
+            help="If True, the files will be downloaded even if they are already cached.",
+        )
+        download_parser.add_argument(
+            "--resume-download", action="store_true", help="If True, resume a previously interrupted download."
+        )
+        download_parser.add_argument(
+            "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens"
+        )
+        download_parser.add_argument(
+            "--quiet",
+            action="store_true",
+            help="If True, progress bars are disabled and only the path to the download files is printed.",
+        )
+        download_parser.set_defaults(func=DownloadCommand)
+
+    def __init__(self, args: Namespace) -> None:
+        self.token = args.token
+        self.repo_id: str = args.repo_id
+        self.filenames: List[str] = args.filenames
+        self.repo_type: str = args.repo_type
+        self.revision: Optional[str] = args.revision
+        self.include: Optional[List[str]] = args.include
+        self.exclude: Optional[List[str]] = args.exclude
+        self.cache_dir: Optional[str] = args.cache_dir
+        self.local_dir: Optional[str] = args.local_dir
+        self.force_download: bool = args.force_download
+        self.resume_download: bool = args.resume_download
+        self.quiet: bool = args.quiet
+
+        # Raise if local_dir_use_symlinks is invalid
+        self.local_dir_use_symlinks: Union[Literal["auto"], bool]
+        use_symlinks_lowercase = args.local_dir_use_symlinks.lower()
+        if use_symlinks_lowercase == "true":
+            self.local_dir_use_symlinks = True
+        elif use_symlinks_lowercase == "false":
+            self.local_dir_use_symlinks = False
+        elif use_symlinks_lowercase == "auto":
+            self.local_dir_use_symlinks = "auto"
+        else:
+            raise ValueError(
+                f"'{args.local_dir_use_symlinks}' is not a valid value for `local_dir_use_symlinks`. It must be either"
+                " 'auto', 'True' or 'False'."
+            )
+
+    def run(self) -> None:
+        if self.quiet:
+            disable_progress_bars()
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                print(self._download())  # Print path to downloaded files
+            enable_progress_bars()
+        else:
+            logging.set_verbosity_info()
+            print(self._download())  # Print path to downloaded files
+            logging.set_verbosity_warning()
+
+    def _download(self) -> str:
+        # Warn user if patterns are ignored
+        if len(self.filenames) > 0:
+            if self.include is not None and len(self.include) > 0:
+                warnings.warn("Ignoring `--include` since filenames have being explicitly set.")
+            if self.exclude is not None and len(self.exclude) > 0:
+                warnings.warn("Ignoring `--exclude` since filenames have being explicitly set.")
+
+        if not HF_HUB_ENABLE_HF_TRANSFER:
+            logger.info(
+                "Consider using `hf_transfer` for faster downloads. This solution comes with some limitations. See"
+                " https://huggingface.co/docs/huggingface_hub/hf_transfer for more details."
+            )
+
+        # Single file to download: use `hf_hub_download`
+        if len(self.filenames) == 1:
+            return hf_hub_download(
+                repo_id=self.repo_id,
+                repo_type=self.repo_type,
+                revision=self.revision,
+                filename=self.filenames[0],
+                cache_dir=self.cache_dir,
+                resume_download=self.resume_download,
+                force_download=self.force_download,
+                token=self.token,
+                local_dir=self.local_dir,
+                local_dir_use_symlinks=self.local_dir_use_symlinks,
+                library_name="huggingface-cli",
+            )
+
+        # Otherwise: use `snapshot_download` to ensure all files comes from same revision
+        elif len(self.filenames) == 0:
+            allow_patterns = self.include
+            ignore_patterns = self.exclude
+        else:
+            allow_patterns = self.filenames
+            ignore_patterns = None
+
+        return snapshot_download(
+            repo_id=self.repo_id,
+            repo_type=self.repo_type,
+            revision=self.revision,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            resume_download=self.resume_download,
+            force_download=self.force_download,
+            cache_dir=self.cache_dir,
+            token=self.token,
+            local_dir=self.local_dir,
+            local_dir_use_symlinks=self.local_dir_use_symlinks,
+            library_name="huggingface-cli",
+        )
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/env.py b/lib/python3.11/site-packages/huggingface_hub/commands/env.py
new file mode 100644
index 0000000000000000000000000000000000000000..26d0d7fb151125703d5a0c84fa5d78d68f1eb8d8
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/env.py
@@ -0,0 +1,35 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to print information about the environment.
+
+Usage:
+    huggingface-cli env
+"""
+from argparse import _SubParsersAction
+
+from ..utils import dump_environment_info
+from . import BaseHuggingfaceCLICommand
+
+
+class EnvironmentCommand(BaseHuggingfaceCLICommand):
+    def __init__(self, args):
+        self.args = args
+
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        env_parser = parser.add_parser("env", help="Print information about the environment.")
+        env_parser.set_defaults(func=EnvironmentCommand)
+
+    def run(self) -> None:
+        dump_environment_info()
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/huggingface_cli.py b/lib/python3.11/site-packages/huggingface_hub/commands/huggingface_cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..39b6dfe49ab681f80dea6751e473843e5f685ff3
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/huggingface_cli.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from argparse import ArgumentParser
+
+from huggingface_hub.commands.delete_cache import DeleteCacheCommand
+from huggingface_hub.commands.download import DownloadCommand
+from huggingface_hub.commands.env import EnvironmentCommand
+from huggingface_hub.commands.lfs import LfsCommands
+from huggingface_hub.commands.scan_cache import ScanCacheCommand
+from huggingface_hub.commands.upload import UploadCommand
+from huggingface_hub.commands.user import UserCommands
+
+
+def main():
+    parser = ArgumentParser("huggingface-cli", usage="huggingface-cli <command> [<args>]")
+    commands_parser = parser.add_subparsers(help="huggingface-cli command helpers")
+
+    # Register commands
+    EnvironmentCommand.register_subcommand(commands_parser)
+    UserCommands.register_subcommand(commands_parser)
+    UploadCommand.register_subcommand(commands_parser)
+    DownloadCommand.register_subcommand(commands_parser)
+    LfsCommands.register_subcommand(commands_parser)
+    ScanCacheCommand.register_subcommand(commands_parser)
+    DeleteCacheCommand.register_subcommand(commands_parser)
+
+    # Let's go
+    args = parser.parse_args()
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        exit(1)
+
+    # Run
+    service = args.func(args)
+    service.run()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/lfs.py b/lib/python3.11/site-packages/huggingface_hub/commands/lfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..4dbf3cf55c67beebf4e6959ef180b30e29341a7c
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/lfs.py
@@ -0,0 +1,199 @@
+"""
+Implementation of a custom transfer agent for the transfer type "multipart" for
+git-lfs.
+
+Inspired by:
+github.com/cbartz/git-lfs-swift-transfer-agent/blob/master/git_lfs_swift_transfer.py
+
+Spec is: github.com/git-lfs/git-lfs/blob/master/docs/custom-transfers.md
+
+
+To launch debugger while developing:
+
+``` [lfs "customtransfer.multipart"]
+path = /path/to/huggingface_hub/.env/bin/python args = -m debugpy --listen 5678
+--wait-for-client
+/path/to/huggingface_hub/src/huggingface_hub/commands/huggingface_cli.py
+lfs-multipart-upload ```"""
+
+import json
+import os
+import subprocess
+import sys
+from argparse import _SubParsersAction
+from typing import Dict, List, Optional
+
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.lfs import LFS_MULTIPART_UPLOAD_COMMAND, SliceFileObj
+
+from ..utils import get_session, hf_raise_for_status, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+class LfsCommands(BaseHuggingfaceCLICommand):
+    """
+    Implementation of a custom transfer agent for the transfer type "multipart"
+    for git-lfs. This lets users upload large files >5GB 🔥. Spec for LFS custom
+    transfer agent is:
+    https://github.com/git-lfs/git-lfs/blob/master/docs/custom-transfers.md
+
+    This introduces two commands to the CLI:
+
+    1. $ huggingface-cli lfs-enable-largefiles
+
+    This should be executed once for each model repo that contains a model file
+    >5GB. It's documented in the error message you get if you just try to git
+    push a 5GB file without having enabled it before.
+
+    2. $ huggingface-cli lfs-multipart-upload
+
+    This command is called by lfs directly and is not meant to be called by the
+    user.
+    """
+
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        enable_parser = parser.add_parser(
+            "lfs-enable-largefiles", help="Configure your repository to enable upload of files > 5GB."
+        )
+        enable_parser.add_argument("path", type=str, help="Local path to repository you want to configure.")
+        enable_parser.set_defaults(func=lambda args: LfsEnableCommand(args))
+
+        # Command will get called by git-lfs, do not call it directly.
+        upload_parser = parser.add_parser(LFS_MULTIPART_UPLOAD_COMMAND, add_help=False)
+        upload_parser.set_defaults(func=lambda args: LfsUploadCommand(args))
+
+
+class LfsEnableCommand:
+    def __init__(self, args):
+        self.args = args
+
+    def run(self):
+        local_path = os.path.abspath(self.args.path)
+        if not os.path.isdir(local_path):
+            print("This does not look like a valid git repo.")
+            exit(1)
+        subprocess.run(
+            "git config lfs.customtransfer.multipart.path huggingface-cli".split(),
+            check=True,
+            cwd=local_path,
+        )
+        subprocess.run(
+            f"git config lfs.customtransfer.multipart.args {LFS_MULTIPART_UPLOAD_COMMAND}".split(),
+            check=True,
+            cwd=local_path,
+        )
+        print("Local repo set up for largefiles")
+
+
+def write_msg(msg: Dict):
+    """Write out the message in Line delimited JSON."""
+    msg_str = json.dumps(msg) + "\n"
+    sys.stdout.write(msg_str)
+    sys.stdout.flush()
+
+
+def read_msg() -> Optional[Dict]:
+    """Read Line delimited JSON from stdin."""
+    msg = json.loads(sys.stdin.readline().strip())
+
+    if "terminate" in (msg.get("type"), msg.get("event")):
+        # terminate message received
+        return None
+
+    if msg.get("event") not in ("download", "upload"):
+        logger.critical("Received unexpected message")
+        sys.exit(1)
+
+    return msg
+
+
+class LfsUploadCommand:
+    def __init__(self, args) -> None:
+        self.args = args
+
+    def run(self) -> None:
+        # Immediately after invoking a custom transfer process, git-lfs
+        # sends initiation data to the process over stdin.
+        # This tells the process useful information about the configuration.
+        init_msg = json.loads(sys.stdin.readline().strip())
+        if not (init_msg.get("event") == "init" and init_msg.get("operation") == "upload"):
+            write_msg({"error": {"code": 32, "message": "Wrong lfs init operation"}})
+            sys.exit(1)
+
+        # The transfer process should use the information it needs from the
+        # initiation structure, and also perform any one-off setup tasks it
+        # needs to do. It should then respond on stdout with a simple empty
+        # confirmation structure, as follows:
+        write_msg({})
+
+        # After the initiation exchange, git-lfs will send any number of
+        # transfer requests to the stdin of the transfer process, in a serial sequence.
+        while True:
+            msg = read_msg()
+            if msg is None:
+                # When all transfers have been processed, git-lfs will send
+                # a terminate event to the stdin of the transfer process.
+                # On receiving this message the transfer process should
+                # clean up and terminate. No response is expected.
+                sys.exit(0)
+
+            oid = msg["oid"]
+            filepath = msg["path"]
+            completion_url = msg["action"]["href"]
+            header = msg["action"]["header"]
+            chunk_size = int(header.pop("chunk_size"))
+            presigned_urls: List[str] = list(header.values())
+
+            # Send a "started" progress event to allow other workers to start.
+            # Otherwise they're delayed until first "progress" event is reported,
+            # i.e. after the first 5GB by default (!)
+            write_msg(
+                {
+                    "event": "progress",
+                    "oid": oid,
+                    "bytesSoFar": 1,
+                    "bytesSinceLast": 0,
+                }
+            )
+
+            parts = []
+            with open(filepath, "rb") as file:
+                for i, presigned_url in enumerate(presigned_urls):
+                    with SliceFileObj(
+                        file,
+                        seek_from=i * chunk_size,
+                        read_limit=chunk_size,
+                    ) as data:
+                        r = get_session().put(presigned_url, data=data)
+                        hf_raise_for_status(r)
+                        parts.append(
+                            {
+                                "etag": r.headers.get("etag"),
+                                "partNumber": i + 1,
+                            }
+                        )
+                        # In order to support progress reporting while data is uploading / downloading,
+                        # the transfer process should post messages to stdout
+                        write_msg(
+                            {
+                                "event": "progress",
+                                "oid": oid,
+                                "bytesSoFar": (i + 1) * chunk_size,
+                                "bytesSinceLast": chunk_size,
+                            }
+                        )
+                        # Not precise but that's ok.
+
+            r = get_session().post(
+                completion_url,
+                json={
+                    "oid": oid,
+                    "parts": parts,
+                },
+            )
+            hf_raise_for_status(r)
+
+            write_msg({"event": "complete", "oid": oid})
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/scan_cache.py b/lib/python3.11/site-packages/huggingface_hub/commands/scan_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..392bec966e11aa9c8a3a80f60c760c54329b403c
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/scan_cache.py
@@ -0,0 +1,138 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to scan the HF cache directory.
+
+Usage:
+    huggingface-cli scan-cache
+    huggingface-cli scan-cache -v
+    huggingface-cli scan-cache -vvv
+    huggingface-cli scan-cache --dir ~/.cache/huggingface/hub
+"""
+import time
+from argparse import Namespace, _SubParsersAction
+from typing import Optional
+
+from ..utils import CacheNotFound, HFCacheInfo, scan_cache_dir
+from . import BaseHuggingfaceCLICommand
+from ._cli_utils import ANSI, tabulate
+
+
+class ScanCacheCommand(BaseHuggingfaceCLICommand):
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        scan_cache_parser = parser.add_parser("scan-cache", help="Scan cache directory.")
+
+        scan_cache_parser.add_argument(
+            "--dir",
+            type=str,
+            default=None,
+            help="cache directory to scan (optional). Default to the default HuggingFace cache.",
+        )
+        scan_cache_parser.add_argument(
+            "-v",
+            "--verbose",
+            action="count",
+            default=0,
+            help="show a more verbose output",
+        )
+        scan_cache_parser.set_defaults(func=ScanCacheCommand)
+
+    def __init__(self, args: Namespace) -> None:
+        self.verbosity: int = args.verbose
+        self.cache_dir: Optional[str] = args.dir
+
+    def run(self):
+        try:
+            t0 = time.time()
+            hf_cache_info = scan_cache_dir(self.cache_dir)
+            t1 = time.time()
+        except CacheNotFound as exc:
+            cache_dir = exc.cache_dir
+            print(f"Cache directory not found: {cache_dir}")
+            return
+
+        self._print_hf_cache_info_as_table(hf_cache_info)
+
+        print(
+            f"\nDone in {round(t1-t0,1)}s. Scanned {len(hf_cache_info.repos)} repo(s)"
+            f" for a total of {ANSI.red(hf_cache_info.size_on_disk_str)}."
+        )
+        if len(hf_cache_info.warnings) > 0:
+            message = f"Got {len(hf_cache_info.warnings)} warning(s) while scanning."
+            if self.verbosity >= 3:
+                print(ANSI.gray(message))
+                for warning in hf_cache_info.warnings:
+                    print(ANSI.gray(warning))
+            else:
+                print(ANSI.gray(message + " Use -vvv to print details."))
+
+    def _print_hf_cache_info_as_table(self, hf_cache_info: HFCacheInfo) -> None:
+        if self.verbosity == 0:
+            print(
+                tabulate(
+                    rows=[
+                        [
+                            repo.repo_id,
+                            repo.repo_type,
+                            "{:>12}".format(repo.size_on_disk_str),
+                            repo.nb_files,
+                            repo.last_accessed_str,
+                            repo.last_modified_str,
+                            ", ".join(sorted(repo.refs)),
+                            str(repo.repo_path),
+                        ]
+                        for repo in sorted(hf_cache_info.repos, key=lambda repo: repo.repo_path)
+                    ],
+                    headers=[
+                        "REPO ID",
+                        "REPO TYPE",
+                        "SIZE ON DISK",
+                        "NB FILES",
+                        "LAST_ACCESSED",
+                        "LAST_MODIFIED",
+                        "REFS",
+                        "LOCAL PATH",
+                    ],
+                )
+            )
+        else:
+            print(
+                tabulate(
+                    rows=[
+                        [
+                            repo.repo_id,
+                            repo.repo_type,
+                            revision.commit_hash,
+                            "{:>12}".format(revision.size_on_disk_str),
+                            revision.nb_files,
+                            revision.last_modified_str,
+                            ", ".join(sorted(revision.refs)),
+                            str(revision.snapshot_path),
+                        ]
+                        for repo in sorted(hf_cache_info.repos, key=lambda repo: repo.repo_path)
+                        for revision in sorted(repo.revisions, key=lambda revision: revision.commit_hash)
+                    ],
+                    headers=[
+                        "REPO ID",
+                        "REPO TYPE",
+                        "REVISION",
+                        "SIZE ON DISK",
+                        "NB FILES",
+                        "LAST_MODIFIED",
+                        "REFS",
+                        "LOCAL PATH",
+                    ],
+                )
+            )
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/upload.py b/lib/python3.11/site-packages/huggingface_hub/commands/upload.py
new file mode 100644
index 0000000000000000000000000000000000000000..703eed5a47fb1648efe99a41b31715f42dcd394b
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/upload.py
@@ -0,0 +1,297 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to upload a repo or file with the CLI.
+
+Usage:
+    # Upload file (implicit)
+    huggingface-cli upload my-cool-model ./my-cool-model.safetensors
+
+    # Upload file (explicit)
+    huggingface-cli upload my-cool-model ./my-cool-model.safetensors  model.safetensors
+
+    # Upload directory (implicit). If `my-cool-model/` is a directory it will be uploaded, otherwise an exception is raised.
+    huggingface-cli upload my-cool-model
+
+    # Upload directory (explicit)
+    huggingface-cli upload my-cool-model ./models/my-cool-model .
+
+    # Upload filtered directory (example: tensorboard logs except for the last run)
+    huggingface-cli upload my-cool-model ./model/training /logs --include "*.tfevents.*" --exclude "*20230905*"
+
+    # Upload private dataset
+    huggingface-cli upload Wauplin/my-cool-dataset ./data . --repo-type=dataset --private
+
+    # Upload with token
+    huggingface-cli upload Wauplin/my-cool-model --token=hf_****
+
+    # Sync local Space with Hub (upload new files, delete removed files)
+    huggingface-cli upload Wauplin/space-example --repo-type=space --exclude="/logs/*" --delete="*" --commit-message="Sync local Space with Hub"
+
+    # Schedule commits every 30 minutes
+    huggingface-cli upload Wauplin/my-cool-model --every=30
+"""
+import os
+import time
+import warnings
+from argparse import Namespace, _SubParsersAction
+from typing import List, Optional
+
+from huggingface_hub import logging
+from huggingface_hub._commit_scheduler import CommitScheduler
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.constants import HF_HUB_ENABLE_HF_TRANSFER
+from huggingface_hub.hf_api import HfApi
+from huggingface_hub.utils import RevisionNotFoundError, disable_progress_bars, enable_progress_bars
+
+
+logger = logging.get_logger(__name__)
+
+
+class UploadCommand(BaseHuggingfaceCLICommand):
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        upload_parser = parser.add_parser("upload", help="Upload a file or a folder to a repo on the Hub")
+        upload_parser.add_argument(
+            "repo_id", type=str, help="The ID of the repo to upload to (e.g. `username/repo-name`)."
+        )
+        upload_parser.add_argument(
+            "local_path", nargs="?", help="Local path to the file or folder to upload. Defaults to current directory."
+        )
+        upload_parser.add_argument(
+            "path_in_repo",
+            nargs="?",
+            help="Path of the file or folder in the repo. Defaults to the relative path of the file or folder.",
+        )
+        upload_parser.add_argument(
+            "--repo-type",
+            choices=["model", "dataset", "space"],
+            default="model",
+            help="Type of the repo to upload to (e.g. `dataset`).",
+        )
+        upload_parser.add_argument(
+            "--revision",
+            type=str,
+            help=(
+                "An optional Git revision to push to. It can be a branch name or a PR reference. If revision does not"
+                " exist and `--create-pr` is not set, a branch will be automatically created."
+            ),
+        )
+        upload_parser.add_argument(
+            "--private",
+            action="store_true",
+            help=(
+                "Whether to create a private repo if repo doesn't exist on the Hub. Ignored if the repo already"
+                " exists."
+            ),
+        )
+        upload_parser.add_argument("--include", nargs="*", type=str, help="Glob patterns to match files to upload.")
+        upload_parser.add_argument(
+            "--exclude", nargs="*", type=str, help="Glob patterns to exclude from files to upload."
+        )
+        upload_parser.add_argument(
+            "--delete",
+            nargs="*",
+            type=str,
+            help="Glob patterns for file to be deleted from the repo while committing.",
+        )
+        upload_parser.add_argument(
+            "--commit-message", type=str, help="The summary / title / first line of the generated commit."
+        )
+        upload_parser.add_argument("--commit-description", type=str, help="The description of the generated commit.")
+        upload_parser.add_argument(
+            "--create-pr", action="store_true", help="Whether to upload content as a new Pull Request."
+        )
+        upload_parser.add_argument(
+            "--every",
+            type=float,
+            help="If set, a background job is scheduled to create commits every `every` minutes.",
+        )
+        upload_parser.add_argument(
+            "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens"
+        )
+        upload_parser.add_argument(
+            "--quiet",
+            action="store_true",
+            help="If True, progress bars are disabled and only the path to the uploaded files is printed.",
+        )
+        upload_parser.set_defaults(func=UploadCommand)
+
+    def __init__(self, args: Namespace) -> None:
+        self.repo_id: str = args.repo_id
+        self.repo_type: Optional[str] = args.repo_type
+        self.revision: Optional[str] = args.revision
+        self.private: bool = args.private
+
+        self.include: Optional[List[str]] = args.include
+        self.exclude: Optional[List[str]] = args.exclude
+        self.delete: Optional[List[str]] = args.delete
+
+        self.commit_message: Optional[str] = args.commit_message
+        self.commit_description: Optional[str] = args.commit_description
+        self.create_pr: bool = args.create_pr
+        self.api: HfApi = HfApi(token=args.token, library_name="huggingface-cli")
+        self.quiet: bool = args.quiet  # disable warnings and progress bars
+
+        # Check `--every` is valid
+        if args.every is not None and args.every <= 0:
+            raise ValueError(f"`every` must be a positive value (got '{args.every}')")
+        self.every: Optional[float] = args.every
+
+        # Resolve `local_path` and `path_in_repo`
+        repo_name: str = args.repo_id.split("/")[-1]  # e.g. "Wauplin/my-cool-model" => "my-cool-model"
+        self.local_path: str
+        self.path_in_repo: str
+        if args.local_path is None and os.path.isfile(repo_name):
+            # Implicit case 1: user provided only a repo_id which happen to be a local file as well => upload it with same name
+            self.local_path = repo_name
+            self.path_in_repo = repo_name
+        elif args.local_path is None and os.path.isdir(repo_name):
+            # Implicit case 2: user provided only a repo_id which happen to be a local folder as well => upload it at root
+            self.local_path = repo_name
+            self.path_in_repo = "."
+        elif args.local_path is None:
+            # Implicit case 3: user provided only a repo_id that does not match a local file or folder
+            # => the user must explicitly provide a local_path => raise exception
+            raise ValueError(f"'{repo_name}' is not a local file or folder. Please set `local_path` explicitly.")
+        elif args.path_in_repo is None and os.path.isfile(args.local_path):
+            # Explicit local path to file, no path in repo => upload it at root with same name
+            self.local_path = args.local_path
+            self.path_in_repo = os.path.basename(args.local_path)
+        elif args.path_in_repo is None:
+            # Explicit local path to folder, no path in repo => upload at root
+            self.local_path = args.local_path
+            self.path_in_repo = "."
+        else:
+            # Finally, if both paths are explicit
+            self.local_path = args.local_path
+            self.path_in_repo = args.path_in_repo
+
+    def run(self) -> None:
+        if self.quiet:
+            disable_progress_bars()
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                print(self._upload())
+            enable_progress_bars()
+        else:
+            logging.set_verbosity_info()
+            print(self._upload())
+            logging.set_verbosity_warning()
+
+    def _upload(self) -> str:
+        if os.path.isfile(self.local_path):
+            if self.include is not None and len(self.include) > 0:
+                warnings.warn("Ignoring `--include` since a single file is uploaded.")
+            if self.exclude is not None and len(self.exclude) > 0:
+                warnings.warn("Ignoring `--exclude` since a single file is uploaded.")
+            if self.delete is not None and len(self.delete) > 0:
+                warnings.warn("Ignoring `--delete` since a single file is uploaded.")
+
+        if not HF_HUB_ENABLE_HF_TRANSFER:
+            logger.info(
+                "Consider using `hf_transfer` for faster uploads. This solution comes with some limitations. See"
+                " https://huggingface.co/docs/huggingface_hub/hf_transfer for more details."
+            )
+
+        # Schedule commits if `every` is set
+        if self.every is not None:
+            if os.path.isfile(self.local_path):
+                # If file => watch entire folder + use allow_patterns
+                folder_path = os.path.dirname(self.local_path)
+                path_in_repo = (
+                    self.path_in_repo[: -len(self.local_path)]  # remove filename from path_in_repo
+                    if self.path_in_repo.endswith(self.local_path)
+                    else self.path_in_repo
+                )
+                allow_patterns = [self.local_path]
+                ignore_patterns = []
+            else:
+                folder_path = self.local_path
+                path_in_repo = self.path_in_repo
+                allow_patterns = self.include or []
+                ignore_patterns = self.exclude or []
+                if self.delete is not None and len(self.delete) > 0:
+                    warnings.warn("Ignoring `--delete` when uploading with scheduled commits.")
+
+            scheduler = CommitScheduler(
+                folder_path=folder_path,
+                repo_id=self.repo_id,
+                repo_type=self.repo_type,
+                revision=self.revision,
+                allow_patterns=allow_patterns,
+                ignore_patterns=ignore_patterns,
+                path_in_repo=path_in_repo,
+                private=self.private,
+                every=self.every,
+                hf_api=self.api,
+            )
+            print(f"Scheduling commits every {self.every} minutes to {scheduler.repo_id}.")
+            try:  # Block main thread until KeyboardInterrupt
+                while True:
+                    time.sleep(100)
+            except KeyboardInterrupt:
+                scheduler.stop()
+                return "Stopped scheduled commits."
+
+        # Otherwise, create repo and proceed with the upload
+        if not os.path.isfile(self.local_path) and not os.path.isdir(self.local_path):
+            raise FileNotFoundError(f"No such file or directory: '{self.local_path}'.")
+        repo_id = self.api.create_repo(
+            repo_id=self.repo_id,
+            repo_type=self.repo_type,
+            exist_ok=True,
+            private=self.private,
+            space_sdk="gradio" if self.repo_type == "space" else None,
+            # ^ We don't want it to fail when uploading to a Space => let's set Gradio by default.
+            # ^ I'd rather not add CLI args to set it explicitly as we already have `huggingface-cli repo create` for that.
+        ).repo_id
+
+        # Check if branch already exists and if not, create it
+        if self.revision is not None and not self.create_pr:
+            try:
+                self.api.repo_info(repo_id=repo_id, repo_type=self.repo_type, revision=self.revision)
+            except RevisionNotFoundError:
+                logger.info(f"Branch '{self.revision}' not found. Creating it...")
+                self.api.create_branch(repo_id=repo_id, repo_type=self.repo_type, branch=self.revision, exist_ok=True)
+                # ^ `exist_ok=True` to avoid race concurrency issues
+
+        # File-based upload
+        if os.path.isfile(self.local_path):
+            return self.api.upload_file(
+                path_or_fileobj=self.local_path,
+                path_in_repo=self.path_in_repo,
+                repo_id=repo_id,
+                repo_type=self.repo_type,
+                revision=self.revision,
+                commit_message=self.commit_message,
+                commit_description=self.commit_description,
+                create_pr=self.create_pr,
+            )
+
+        # Folder-based upload
+        else:
+            return self.api.upload_folder(
+                folder_path=self.local_path,
+                path_in_repo=self.path_in_repo,
+                repo_id=repo_id,
+                repo_type=self.repo_type,
+                revision=self.revision,
+                commit_message=self.commit_message,
+                commit_description=self.commit_description,
+                create_pr=self.create_pr,
+                allow_patterns=self.include,
+                ignore_patterns=self.exclude,
+                delete_patterns=self.delete,
+            )
diff --git a/lib/python3.11/site-packages/huggingface_hub/commands/user.py b/lib/python3.11/site-packages/huggingface_hub/commands/user.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cde3ac04c8a0773cad0a767a8d14b36dce4ee2e
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/commands/user.py
@@ -0,0 +1,188 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import subprocess
+from argparse import _SubParsersAction
+
+from requests.exceptions import HTTPError
+
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.constants import (
+    ENDPOINT,
+    REPO_TYPES,
+    REPO_TYPES_URL_PREFIXES,
+    SPACES_SDK_TYPES,
+)
+from huggingface_hub.hf_api import HfApi
+
+from .._login import (  # noqa: F401 # for backward compatibility  # noqa: F401 # for backward compatibility
+    NOTEBOOK_LOGIN_PASSWORD_HTML,
+    NOTEBOOK_LOGIN_TOKEN_HTML_END,
+    NOTEBOOK_LOGIN_TOKEN_HTML_START,
+    login,
+    logout,
+    notebook_login,
+)
+from ..utils import get_token
+from ._cli_utils import ANSI
+
+
+class UserCommands(BaseHuggingfaceCLICommand):
+    @staticmethod
+    def register_subcommand(parser: _SubParsersAction):
+        login_parser = parser.add_parser("login", help="Log in using a token from huggingface.co/settings/tokens")
+        login_parser.add_argument(
+            "--token",
+            type=str,
+            help="Token generated from https://huggingface.co/settings/tokens",
+        )
+        login_parser.add_argument(
+            "--add-to-git-credential",
+            action="store_true",
+            help="Optional: Save token to git credential helper.",
+        )
+        login_parser.set_defaults(func=lambda args: LoginCommand(args))
+        whoami_parser = parser.add_parser("whoami", help="Find out which huggingface.co account you are logged in as.")
+        whoami_parser.set_defaults(func=lambda args: WhoamiCommand(args))
+        logout_parser = parser.add_parser("logout", help="Log out")
+        logout_parser.set_defaults(func=lambda args: LogoutCommand(args))
+
+        # new system: git-based repo system
+        repo_parser = parser.add_parser("repo", help="{create} Commands to interact with your huggingface.co repos.")
+        repo_subparsers = repo_parser.add_subparsers(help="huggingface.co repos related commands")
+        repo_create_parser = repo_subparsers.add_parser("create", help="Create a new repo on huggingface.co")
+        repo_create_parser.add_argument(
+            "name",
+            type=str,
+            help="Name for your repo. Will be namespaced under your username to build the repo id.",
+        )
+        repo_create_parser.add_argument(
+            "--type",
+            type=str,
+            help='Optional: repo_type: set to "dataset" or "space" if creating a dataset or space, default is model.',
+        )
+        repo_create_parser.add_argument("--organization", type=str, help="Optional: organization namespace.")
+        repo_create_parser.add_argument(
+            "--space_sdk",
+            type=str,
+            help='Optional: Hugging Face Spaces SDK type. Required when --type is set to "space".',
+            choices=SPACES_SDK_TYPES,
+        )
+        repo_create_parser.add_argument(
+            "-y",
+            "--yes",
+            action="store_true",
+            help="Optional: answer Yes to the prompt",
+        )
+        repo_create_parser.set_defaults(func=lambda args: RepoCreateCommand(args))
+
+
+class BaseUserCommand:
+    def __init__(self, args):
+        self.args = args
+        self._api = HfApi()
+
+
+class LoginCommand(BaseUserCommand):
+    def run(self):
+        login(token=self.args.token, add_to_git_credential=self.args.add_to_git_credential)
+
+
+class LogoutCommand(BaseUserCommand):
+    def run(self):
+        logout()
+
+
+class WhoamiCommand(BaseUserCommand):
+    def run(self):
+        token = get_token()
+        if token is None:
+            print("Not logged in")
+            exit()
+        try:
+            info = self._api.whoami(token)
+            print(info["name"])
+            orgs = [org["name"] for org in info["orgs"]]
+            if orgs:
+                print(ANSI.bold("orgs: "), ",".join(orgs))
+
+            if ENDPOINT != "https://huggingface.co":
+                print(f"Authenticated through private endpoint: {ENDPOINT}")
+        except HTTPError as e:
+            print(e)
+            print(ANSI.red(e.response.text))
+            exit(1)
+
+
+class RepoCreateCommand(BaseUserCommand):
+    def run(self):
+        token = get_token()
+        if token is None:
+            print("Not logged in")
+            exit(1)
+        try:
+            stdout = subprocess.check_output(["git", "--version"]).decode("utf-8")
+            print(ANSI.gray(stdout.strip()))
+        except FileNotFoundError:
+            print("Looks like you do not have git installed, please install.")
+
+        try:
+            stdout = subprocess.check_output(["git-lfs", "--version"]).decode("utf-8")
+            print(ANSI.gray(stdout.strip()))
+        except FileNotFoundError:
+            print(
+                ANSI.red(
+                    "Looks like you do not have git-lfs installed, please install."
+                    " You can install from https://git-lfs.github.com/."
+                    " Then run `git lfs install` (you only have to do this once)."
+                )
+            )
+        print("")
+
+        user = self._api.whoami(token)["name"]
+        namespace = self.args.organization if self.args.organization is not None else user
+
+        repo_id = f"{namespace}/{self.args.name}"
+
+        if self.args.type not in REPO_TYPES:
+            print("Invalid repo --type")
+            exit(1)
+
+        if self.args.type in REPO_TYPES_URL_PREFIXES:
+            prefixed_repo_id = REPO_TYPES_URL_PREFIXES[self.args.type] + repo_id
+        else:
+            prefixed_repo_id = repo_id
+
+        print(f"You are about to create {ANSI.bold(prefixed_repo_id)}")
+
+        if not self.args.yes:
+            choice = input("Proceed? [Y/n] ").lower()
+            if not (choice == "" or choice == "y" or choice == "yes"):
+                print("Abort")
+                exit()
+        try:
+            url = self._api.create_repo(
+                repo_id=repo_id,
+                token=token,
+                repo_type=self.args.type,
+                space_sdk=self.args.space_sdk,
+            )
+        except HTTPError as e:
+            print(e)
+            print(ANSI.red(e.response.text))
+            exit(1)
+        print("\nYour repo now lives at:")
+        print(f"  {ANSI.bold(url)}")
+        print("\nYou can clone it locally with the command below, and commit/push as usual.")
+        print(f"\n  git clone {url}")
+        print("")
diff --git a/lib/python3.11/site-packages/huggingface_hub/community.py b/lib/python3.11/site-packages/huggingface_hub/community.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0ed0ddf17b7de94785ec8696741de928f02ff71
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/community.py
@@ -0,0 +1,354 @@
+"""
+Data structures to interact with Discussions and Pull Requests on the Hub.
+
+See [the Discussions and Pull Requests guide](https://huggingface.co/docs/hub/repositories-pull-requests-discussions)
+for more information on Pull Requests, Discussions, and the community tab.
+"""
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Literal, Optional, Union
+
+from .constants import REPO_TYPE_MODEL
+from .utils import parse_datetime
+
+
+DiscussionStatus = Literal["open", "closed", "merged", "draft"]
+
+
+@dataclass
+class Discussion:
+    """
+    A Discussion or Pull Request on the Hub.
+
+    This dataclass is not intended to be instantiated directly.
+
+    Attributes:
+        title (`str`):
+            The title of the Discussion / Pull Request
+        status (`str`):
+            The status of the Discussion / Pull Request.
+            It must be one of:
+                * `"open"`
+                * `"closed"`
+                * `"merged"` (only for Pull Requests )
+                * `"draft"` (only for Pull Requests )
+        num (`int`):
+            The number of the Discussion / Pull Request.
+        repo_id (`str`):
+            The id (`"{namespace}/{repo_name}"`) of the repo on which
+            the Discussion / Pull Request was open.
+        repo_type (`str`):
+            The type of the repo on which the Discussion / Pull Request was open.
+            Possible values are: `"model"`, `"dataset"`, `"space"`.
+        author (`str`):
+            The username of the Discussion / Pull Request author.
+            Can be `"deleted"` if the user has been deleted since.
+        is_pull_request (`bool`):
+            Whether or not this is a Pull Request.
+        created_at (`datetime`):
+            The `datetime` of creation of the Discussion / Pull Request.
+        endpoint (`str`):
+            Endpoint of the Hub. Default is https://huggingface.co.
+        git_reference (`str`, *optional*):
+            (property) Git reference to which changes can be pushed if this is a Pull Request, `None` otherwise.
+        url (`str`):
+            (property) URL of the discussion on the Hub.
+    """
+
+    title: str
+    status: DiscussionStatus
+    num: int
+    repo_id: str
+    repo_type: str
+    author: str
+    is_pull_request: bool
+    created_at: datetime
+    endpoint: str
+
+    @property
+    def git_reference(self) -> Optional[str]:
+        """
+        If this is a Pull Request , returns the git reference to which changes can be pushed.
+        Returns `None` otherwise.
+        """
+        if self.is_pull_request:
+            return f"refs/pr/{self.num}"
+        return None
+
+    @property
+    def url(self) -> str:
+        """Returns the URL of the discussion on the Hub."""
+        if self.repo_type is None or self.repo_type == REPO_TYPE_MODEL:
+            return f"{self.endpoint}/{self.repo_id}/discussions/{self.num}"
+        return f"{self.endpoint}/{self.repo_type}s/{self.repo_id}/discussions/{self.num}"
+
+
+@dataclass
+class DiscussionWithDetails(Discussion):
+    """
+    Subclass of [`Discussion`].
+
+    Attributes:
+        title (`str`):
+            The title of the Discussion / Pull Request
+        status (`str`):
+            The status of the Discussion / Pull Request.
+            It can be one of:
+                * `"open"`
+                * `"closed"`
+                * `"merged"` (only for Pull Requests )
+                * `"draft"` (only for Pull Requests )
+        num (`int`):
+            The number of the Discussion / Pull Request.
+        repo_id (`str`):
+            The id (`"{namespace}/{repo_name}"`) of the repo on which
+            the Discussion / Pull Request was open.
+        repo_type (`str`):
+            The type of the repo on which the Discussion / Pull Request was open.
+            Possible values are: `"model"`, `"dataset"`, `"space"`.
+        author (`str`):
+            The username of the Discussion / Pull Request author.
+            Can be `"deleted"` if the user has been deleted since.
+        is_pull_request (`bool`):
+            Whether or not this is a Pull Request.
+        created_at (`datetime`):
+            The `datetime` of creation of the Discussion / Pull Request.
+        events (`list` of [`DiscussionEvent`])
+            The list of [`DiscussionEvents`] in this Discussion or Pull Request.
+        conflicting_files (`Union[List[str], bool, None]`, *optional*):
+            A list of conflicting files if this is a Pull Request.
+            `None` if `self.is_pull_request` is `False`.
+            `True` if there are conflicting files but the list can't be retrieved.
+        target_branch (`str`, *optional*):
+            The branch into which changes are to be merged if this is a
+            Pull Request . `None`  if `self.is_pull_request` is `False`.
+        merge_commit_oid (`str`, *optional*):
+            If this is a merged Pull Request , this is set to the OID / SHA of
+            the merge commit, `None` otherwise.
+        diff (`str`, *optional*):
+            The git diff if this is a Pull Request , `None` otherwise.
+        endpoint (`str`):
+            Endpoint of the Hub. Default is https://huggingface.co.
+        git_reference (`str`, *optional*):
+            (property) Git reference to which changes can be pushed if this is a Pull Request, `None` otherwise.
+        url (`str`):
+            (property) URL of the discussion on the Hub.
+    """
+
+    events: List["DiscussionEvent"]
+    conflicting_files: Union[List[str], bool, None]
+    target_branch: Optional[str]
+    merge_commit_oid: Optional[str]
+    diff: Optional[str]
+
+
+@dataclass
+class DiscussionEvent:
+    """
+    An event in a Discussion or Pull Request.
+
+    Use concrete classes:
+        * [`DiscussionComment`]
+        * [`DiscussionStatusChange`]
+        * [`DiscussionCommit`]
+        * [`DiscussionTitleChange`]
+
+    Attributes:
+        id (`str`):
+            The ID of the event. An hexadecimal string.
+        type (`str`):
+            The type of the event.
+        created_at (`datetime`):
+            A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime)
+            object holding the creation timestamp for the event.
+        author (`str`):
+            The username of the Discussion / Pull Request author.
+            Can be `"deleted"` if the user has been deleted since.
+    """
+
+    id: str
+    type: str
+    created_at: datetime
+    author: str
+
+    _event: dict
+    """Stores the original event data, in case we need to access it later."""
+
+
+@dataclass
+class DiscussionComment(DiscussionEvent):
+    """A comment in a Discussion / Pull Request.
+
+    Subclass of [`DiscussionEvent`].
+
+
+    Attributes:
+        id (`str`):
+            The ID of the event. An hexadecimal string.
+        type (`str`):
+            The type of the event.
+        created_at (`datetime`):
+            A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime)
+            object holding the creation timestamp for the event.
+        author (`str`):
+            The username of the Discussion / Pull Request author.
+            Can be `"deleted"` if the user has been deleted since.
+        content (`str`):
+            The raw markdown content of the comment. Mentions, links and images are not rendered.
+        edited (`bool`):
+            Whether or not this comment has been edited.
+        hidden (`bool`):
+            Whether or not this comment has been hidden.
+    """
+
+    content: str
+    edited: bool
+    hidden: bool
+
+    @property
+    def rendered(self) -> str:
+        """The rendered comment, as a HTML string"""
+        return self._event["data"]["latest"]["html"]
+
+    @property
+    def last_edited_at(self) -> datetime:
+        """The last edit time, as a `datetime` object."""
+        return parse_datetime(self._event["data"]["latest"]["updatedAt"])
+
+    @property
+    def last_edited_by(self) -> str:
+        """The last edit time, as a `datetime` object."""
+        return self._event["data"]["latest"].get("author", {}).get("name", "deleted")
+
+    @property
+    def edit_history(self) -> List[dict]:
+        """The edit history of the comment"""
+        return self._event["data"]["history"]
+
+    @property
+    def number_of_edits(self) -> int:
+        return len(self.edit_history)
+
+
+@dataclass
+class DiscussionStatusChange(DiscussionEvent):
+    """A change of status in a Discussion / Pull Request.
+
+    Subclass of [`DiscussionEvent`].
+
+    Attributes:
+        id (`str`):
+            The ID of the event. An hexadecimal string.
+        type (`str`):
+            The type of the event.
+        created_at (`datetime`):
+            A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime)
+            object holding the creation timestamp for the event.
+        author (`str`):
+            The username of the Discussion / Pull Request author.
+            Can be `"deleted"` if the user has been deleted since.
+        new_status (`str`):
+            The status of the Discussion / Pull Request after the change.
+            It can be one of:
+                * `"open"`
+                * `"closed"`
+                * `"merged"` (only for Pull Requests )
+    """
+
+    new_status: str
+
+
+@dataclass
+class DiscussionCommit(DiscussionEvent):
+    """A commit in a Pull Request.
+
+    Subclass of [`DiscussionEvent`].
+
+    Attributes:
+        id (`str`):
+            The ID of the event. An hexadecimal string.
+        type (`str`):
+            The type of the event.
+        created_at (`datetime`):
+            A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime)
+            object holding the creation timestamp for the event.
+        author (`str`):
+            The username of the Discussion / Pull Request author.
+            Can be `"deleted"` if the user has been deleted since.
+        summary (`str`):
+            The summary of the commit.
+        oid (`str`):
+            The OID / SHA of the commit, as a hexadecimal string.
+    """
+
+    summary: str
+    oid: str
+
+
+@dataclass
+class DiscussionTitleChange(DiscussionEvent):
+    """A rename event in a Discussion / Pull Request.
+
+    Subclass of [`DiscussionEvent`].
+
+    Attributes:
+        id (`str`):
+            The ID of the event. An hexadecimal string.
+        type (`str`):
+            The type of the event.
+        created_at (`datetime`):
+            A [`datetime`](https://docs.python.org/3/library/datetime.html?highlight=datetime#datetime.datetime)
+            object holding the creation timestamp for the event.
+        author (`str`):
+            The username of the Discussion / Pull Request author.
+            Can be `"deleted"` if the user has been deleted since.
+        old_title (`str`):
+            The previous title for the Discussion / Pull Request.
+        new_title (`str`):
+            The new title.
+    """
+
+    old_title: str
+    new_title: str
+
+
+def deserialize_event(event: dict) -> DiscussionEvent:
+    """Instantiates a [`DiscussionEvent`] from a dict"""
+    event_id: str = event["id"]
+    event_type: str = event["type"]
+    created_at = parse_datetime(event["createdAt"])
+
+    common_args = dict(
+        id=event_id,
+        type=event_type,
+        created_at=created_at,
+        author=event.get("author", {}).get("name", "deleted"),
+        _event=event,
+    )
+
+    if event_type == "comment":
+        return DiscussionComment(
+            **common_args,
+            edited=event["data"]["edited"],
+            hidden=event["data"]["hidden"],
+            content=event["data"]["latest"]["raw"],
+        )
+    if event_type == "status-change":
+        return DiscussionStatusChange(
+            **common_args,
+            new_status=event["data"]["status"],
+        )
+    if event_type == "commit":
+        return DiscussionCommit(
+            **common_args,
+            summary=event["data"]["subject"],
+            oid=event["data"]["oid"],
+        )
+    if event_type == "title-change":
+        return DiscussionTitleChange(
+            **common_args,
+            old_title=event["data"]["from"],
+            new_title=event["data"]["to"],
+        )
+
+    return DiscussionEvent(**common_args)
diff --git a/lib/python3.11/site-packages/huggingface_hub/constants.py b/lib/python3.11/site-packages/huggingface_hub/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d691b305447aef589c5cf9d29f2de47341fc4ca
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/constants.py
@@ -0,0 +1,213 @@
+import os
+import re
+import typing
+from typing import Literal, Optional, Tuple
+
+
+# Possible values for env variables
+
+
+ENV_VARS_TRUE_VALUES = {"1", "ON", "YES", "TRUE"}
+ENV_VARS_TRUE_AND_AUTO_VALUES = ENV_VARS_TRUE_VALUES.union({"AUTO"})
+
+
+def _is_true(value: Optional[str]) -> bool:
+    if value is None:
+        return False
+    return value.upper() in ENV_VARS_TRUE_VALUES
+
+
+def _as_int(value: Optional[str]) -> Optional[int]:
+    if value is None:
+        return None
+    return int(value)
+
+
+# Constants for file downloads
+
+PYTORCH_WEIGHTS_NAME = "pytorch_model.bin"
+TF2_WEIGHTS_NAME = "tf_model.h5"
+TF_WEIGHTS_NAME = "model.ckpt"
+FLAX_WEIGHTS_NAME = "flax_model.msgpack"
+CONFIG_NAME = "config.json"
+REPOCARD_NAME = "README.md"
+DEFAULT_ETAG_TIMEOUT = 10
+DEFAULT_DOWNLOAD_TIMEOUT = 10
+DEFAULT_REQUEST_TIMEOUT = 10
+DOWNLOAD_CHUNK_SIZE = 10 * 1024 * 1024
+HF_TRANSFER_CONCURRENCY = 100
+
+# Constants for safetensors repos
+
+SAFETENSORS_SINGLE_FILE = "model.safetensors"
+SAFETENSORS_INDEX_FILE = "model.safetensors.index.json"
+SAFETENSORS_MAX_HEADER_LENGTH = 25_000_000
+
+# Git-related constants
+
+DEFAULT_REVISION = "main"
+REGEX_COMMIT_OID = re.compile(r"[A-Fa-f0-9]{5,40}")
+
+HUGGINGFACE_CO_URL_HOME = "https://huggingface.co/"
+
+_staging_mode = _is_true(os.environ.get("HUGGINGFACE_CO_STAGING"))
+
+ENDPOINT = os.getenv("HF_ENDPOINT") or ("https://hub-ci.huggingface.co" if _staging_mode else "https://huggingface.co")
+
+HUGGINGFACE_CO_URL_TEMPLATE = ENDPOINT + "/{repo_id}/resolve/{revision}/{filename}"
+HUGGINGFACE_HEADER_X_REPO_COMMIT = "X-Repo-Commit"
+HUGGINGFACE_HEADER_X_LINKED_ETAG = "X-Linked-Etag"
+HUGGINGFACE_HEADER_X_LINKED_SIZE = "X-Linked-Size"
+
+INFERENCE_ENDPOINT = os.environ.get("HF_INFERENCE_ENDPOINT", "https://api-inference.huggingface.co")
+
+# See https://huggingface.co/docs/inference-endpoints/index
+INFERENCE_ENDPOINTS_ENDPOINT = "https://api.endpoints.huggingface.cloud/v2"
+
+
+REPO_ID_SEPARATOR = "--"
+# ^ this substring is not allowed in repo_ids on hf.co
+# and is the canonical one we use for serialization of repo ids elsewhere.
+
+
+REPO_TYPE_DATASET = "dataset"
+REPO_TYPE_SPACE = "space"
+REPO_TYPE_MODEL = "model"
+REPO_TYPES = [None, REPO_TYPE_MODEL, REPO_TYPE_DATASET, REPO_TYPE_SPACE]
+SPACES_SDK_TYPES = ["gradio", "streamlit", "docker", "static"]
+
+REPO_TYPES_URL_PREFIXES = {
+    REPO_TYPE_DATASET: "datasets/",
+    REPO_TYPE_SPACE: "spaces/",
+}
+REPO_TYPES_MAPPING = {
+    "datasets": REPO_TYPE_DATASET,
+    "spaces": REPO_TYPE_SPACE,
+    "models": REPO_TYPE_MODEL,
+}
+
+DiscussionTypeFilter = Literal["all", "discussion", "pull_request"]
+DISCUSSION_TYPES: Tuple[DiscussionTypeFilter, ...] = typing.get_args(DiscussionTypeFilter)
+DiscussionStatusFilter = Literal["all", "open", "closed"]
+DISCUSSION_STATUS: Tuple[DiscussionTypeFilter, ...] = typing.get_args(DiscussionStatusFilter)
+
+# default cache
+default_home = os.path.join(os.path.expanduser("~"), ".cache")
+HF_HOME = os.path.expanduser(
+    os.getenv(
+        "HF_HOME",
+        os.path.join(os.getenv("XDG_CACHE_HOME", default_home), "huggingface"),
+    )
+)
+hf_cache_home = HF_HOME  # for backward compatibility. TODO: remove this in 1.0.0
+
+default_cache_path = os.path.join(HF_HOME, "hub")
+default_assets_cache_path = os.path.join(HF_HOME, "assets")
+
+# Legacy env variables
+HUGGINGFACE_HUB_CACHE = os.getenv("HUGGINGFACE_HUB_CACHE", default_cache_path)
+HUGGINGFACE_ASSETS_CACHE = os.getenv("HUGGINGFACE_ASSETS_CACHE", default_assets_cache_path)
+
+# New env variables
+HF_HUB_CACHE = os.getenv("HF_HUB_CACHE", HUGGINGFACE_HUB_CACHE)
+HF_ASSETS_CACHE = os.getenv("HF_ASSETS_CACHE", HUGGINGFACE_ASSETS_CACHE)
+
+HF_HUB_OFFLINE = _is_true(os.environ.get("HF_HUB_OFFLINE") or os.environ.get("TRANSFORMERS_OFFLINE"))
+
+# Opt-out from telemetry requests
+HF_HUB_DISABLE_TELEMETRY = (
+    _is_true(os.environ.get("HF_HUB_DISABLE_TELEMETRY"))  # HF-specific env variable
+    or _is_true(os.environ.get("DISABLE_TELEMETRY"))
+    or _is_true(os.environ.get("DO_NOT_TRACK"))  # https://consoledonottrack.com/
+)
+
+# In the past, token was stored in a hardcoded location
+# `_OLD_HF_TOKEN_PATH` is deprecated and will be removed "at some point".
+# See https://github.com/huggingface/huggingface_hub/issues/1232
+_OLD_HF_TOKEN_PATH = os.path.expanduser("~/.huggingface/token")
+HF_TOKEN_PATH = os.path.join(HF_HOME, "token")
+
+
+if _staging_mode:
+    # In staging mode, we use a different cache to ensure we don't mix up production and staging data or tokens
+    _staging_home = os.path.join(os.path.expanduser("~"), ".cache", "huggingface_staging")
+    HUGGINGFACE_HUB_CACHE = os.path.join(_staging_home, "hub")
+    _OLD_HF_TOKEN_PATH = os.path.join(_staging_home, "_old_token")
+    HF_TOKEN_PATH = os.path.join(_staging_home, "token")
+
+# Here, `True` will disable progress bars globally without possibility of enabling it
+# programmatically. `False` will enable them without possibility of disabling them.
+# If environment variable is not set (None), then the user is free to enable/disable
+# them programmatically.
+# TL;DR: env variable has priority over code
+__HF_HUB_DISABLE_PROGRESS_BARS = os.environ.get("HF_HUB_DISABLE_PROGRESS_BARS")
+HF_HUB_DISABLE_PROGRESS_BARS: Optional[bool] = (
+    _is_true(__HF_HUB_DISABLE_PROGRESS_BARS) if __HF_HUB_DISABLE_PROGRESS_BARS is not None else None
+)
+
+# Disable warning on machines that do not support symlinks (e.g. Windows non-developer)
+HF_HUB_DISABLE_SYMLINKS_WARNING: bool = _is_true(os.environ.get("HF_HUB_DISABLE_SYMLINKS_WARNING"))
+
+# Disable warning when using experimental features
+HF_HUB_DISABLE_EXPERIMENTAL_WARNING: bool = _is_true(os.environ.get("HF_HUB_DISABLE_EXPERIMENTAL_WARNING"))
+
+# Disable sending the cached token by default is all HTTP requests to the Hub
+HF_HUB_DISABLE_IMPLICIT_TOKEN: bool = _is_true(os.environ.get("HF_HUB_DISABLE_IMPLICIT_TOKEN"))
+
+# Enable fast-download using external dependency "hf_transfer"
+# See:
+# - https://pypi.org/project/hf-transfer/
+# - https://github.com/huggingface/hf_transfer (private)
+HF_HUB_ENABLE_HF_TRANSFER: bool = _is_true(os.environ.get("HF_HUB_ENABLE_HF_TRANSFER"))
+
+
+# Used if download to `local_dir` and `local_dir_use_symlinks="auto"`
+# Files smaller than 5MB are copy-pasted while bigger files are symlinked. The idea is to save disk-usage by symlinking
+# huge files (i.e. LFS files most of the time) while allowing small files to be manually edited in local folder.
+HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD: int = (
+    _as_int(os.environ.get("HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD")) or 5 * 1024 * 1024
+)
+
+# Used to override the etag timeout on a system level
+HF_HUB_ETAG_TIMEOUT: int = _as_int(os.environ.get("HF_HUB_ETAG_TIMEOUT")) or DEFAULT_ETAG_TIMEOUT
+
+# Used to override the get request timeout on a system level
+HF_HUB_DOWNLOAD_TIMEOUT: int = _as_int(os.environ.get("HF_HUB_DOWNLOAD_TIMEOUT")) or DEFAULT_DOWNLOAD_TIMEOUT
+
+# List frameworks that are handled by the InferenceAPI service. Useful to scan endpoints and check which models are
+# deployed and running. Since 95% of the models are using the top 4 frameworks listed below, we scan only those by
+# default. We still keep the full list of supported frameworks in case we want to scan all of them.
+MAIN_INFERENCE_API_FRAMEWORKS = [
+    "diffusers",
+    "sentence-transformers",
+    "text-generation-inference",
+    "transformers",
+]
+
+ALL_INFERENCE_API_FRAMEWORKS = MAIN_INFERENCE_API_FRAMEWORKS + [
+    "adapter-transformers",
+    "allennlp",
+    "asteroid",
+    "bertopic",
+    "doctr",
+    "espnet",
+    "fairseq",
+    "fastai",
+    "fasttext",
+    "flair",
+    "generic",
+    "k2",
+    "keras",
+    "mindspore",
+    "nemo",
+    "open_clip",
+    "paddlenlp",
+    "peft",
+    "pyannote-audio",
+    "sklearn",
+    "spacy",
+    "span-marker",
+    "speechbrain",
+    "stanza",
+    "timm",
+]
diff --git a/lib/python3.11/site-packages/huggingface_hub/fastai_utils.py b/lib/python3.11/site-packages/huggingface_hub/fastai_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e586e8663c39e8d5bab3f57f667dbd878514e59d
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/fastai_utils.py
@@ -0,0 +1,425 @@
+import json
+import os
+from pathlib import Path
+from pickle import DEFAULT_PROTOCOL, PicklingError
+from typing import Any, Dict, List, Optional, Union
+
+from packaging import version
+
+from huggingface_hub import snapshot_download
+from huggingface_hub.constants import CONFIG_NAME
+from huggingface_hub.hf_api import HfApi
+from huggingface_hub.utils import (
+    SoftTemporaryDirectory,
+    get_fastai_version,
+    get_fastcore_version,
+    get_python_version,
+)
+
+from .utils import logging, validate_hf_hub_args
+from .utils._runtime import _PY_VERSION  # noqa: F401 # for backward compatibility...
+
+
+logger = logging.get_logger(__name__)
+
+
+def _check_fastai_fastcore_versions(
+    fastai_min_version: str = "2.4",
+    fastcore_min_version: str = "1.3.27",
+):
+    """
+    Checks that the installed fastai and fastcore versions are compatible for pickle serialization.
+
+    Args:
+        fastai_min_version (`str`, *optional*):
+            The minimum fastai version supported.
+        fastcore_min_version (`str`, *optional*):
+            The minimum fastcore version supported.
+
+    <Tip>
+    Raises the following error:
+
+        - [`ImportError`](https://docs.python.org/3/library/exceptions.html#ImportError)
+          if the fastai or fastcore libraries are not available or are of an invalid version.
+
+    </Tip>
+    """
+
+    if (get_fastcore_version() or get_fastai_version()) == "N/A":
+        raise ImportError(
+            f"fastai>={fastai_min_version} and fastcore>={fastcore_min_version} are"
+            f" required. Currently using fastai=={get_fastai_version()} and"
+            f" fastcore=={get_fastcore_version()}."
+        )
+
+    current_fastai_version = version.Version(get_fastai_version())
+    current_fastcore_version = version.Version(get_fastcore_version())
+
+    if current_fastai_version < version.Version(fastai_min_version):
+        raise ImportError(
+            "`push_to_hub_fastai` and `from_pretrained_fastai` require a"
+            f" fastai>={fastai_min_version} version, but you are using fastai version"
+            f" {get_fastai_version()} which is incompatible. Upgrade with `pip install"
+            " fastai==2.5.6`."
+        )
+
+    if current_fastcore_version < version.Version(fastcore_min_version):
+        raise ImportError(
+            "`push_to_hub_fastai` and `from_pretrained_fastai` require a"
+            f" fastcore>={fastcore_min_version} version, but you are using fastcore"
+            f" version {get_fastcore_version()} which is incompatible. Upgrade with"
+            " `pip install fastcore==1.3.27`."
+        )
+
+
+def _check_fastai_fastcore_pyproject_versions(
+    storage_folder: str,
+    fastai_min_version: str = "2.4",
+    fastcore_min_version: str = "1.3.27",
+):
+    """
+    Checks that the `pyproject.toml` file in the directory `storage_folder` has fastai and fastcore versions
+    that are compatible with `from_pretrained_fastai` and `push_to_hub_fastai`. If `pyproject.toml` does not exist
+    or does not contain versions for fastai and fastcore, then it logs a warning.
+
+    Args:
+        storage_folder (`str`):
+            Folder to look for the `pyproject.toml` file.
+        fastai_min_version (`str`, *optional*):
+            The minimum fastai version supported.
+        fastcore_min_version (`str`, *optional*):
+            The minimum fastcore version supported.
+
+    <Tip>
+    Raises the following errors:
+
+        - [`ImportError`](https://docs.python.org/3/library/exceptions.html#ImportError)
+          if the `toml` module is not installed.
+        - [`ImportError`](https://docs.python.org/3/library/exceptions.html#ImportError)
+          if the `pyproject.toml` indicates a lower than minimum supported version of fastai or fastcore.
+
+    </Tip>
+    """
+
+    try:
+        import toml
+    except ModuleNotFoundError:
+        raise ImportError(
+            "`push_to_hub_fastai` and `from_pretrained_fastai` require the toml module."
+            " Install it with `pip install toml`."
+        )
+
+    # Checks that a `pyproject.toml`, with `build-system` and `requires` sections, exists in the repository. If so, get a list of required packages.
+    if not os.path.isfile(f"{storage_folder}/pyproject.toml"):
+        logger.warning(
+            "There is no `pyproject.toml` in the repository that contains the fastai"
+            " `Learner`. The `pyproject.toml` would allow us to verify that your fastai"
+            " and fastcore versions are compatible with those of the model you want to"
+            " load."
+        )
+        return
+    pyproject_toml = toml.load(f"{storage_folder}/pyproject.toml")
+
+    if "build-system" not in pyproject_toml.keys():
+        logger.warning(
+            "There is no `build-system` section in the pyproject.toml of the repository"
+            " that contains the fastai `Learner`. The `build-system` would allow us to"
+            " verify that your fastai and fastcore versions are compatible with those"
+            " of the model you want to load."
+        )
+        return
+    build_system_toml = pyproject_toml["build-system"]
+
+    if "requires" not in build_system_toml.keys():
+        logger.warning(
+            "There is no `requires` section in the pyproject.toml of the repository"
+            " that contains the fastai `Learner`. The `requires` would allow us to"
+            " verify that your fastai and fastcore versions are compatible with those"
+            " of the model you want to load."
+        )
+        return
+    package_versions = build_system_toml["requires"]
+
+    # Extracts contains fastai and fastcore versions from `pyproject.toml` if available.
+    # If the package is specified but not the version (e.g. "fastai" instead of "fastai=2.4"), the default versions are the highest.
+    fastai_packages = [pck for pck in package_versions if pck.startswith("fastai")]
+    if len(fastai_packages) == 0:
+        logger.warning("The repository does not have a fastai version specified in the `pyproject.toml`.")
+    # fastai_version is an empty string if not specified
+    else:
+        fastai_version = str(fastai_packages[0]).partition("=")[2]
+        if fastai_version != "" and version.Version(fastai_version) < version.Version(fastai_min_version):
+            raise ImportError(
+                "`from_pretrained_fastai` requires"
+                f" fastai>={fastai_min_version} version but the model to load uses"
+                f" {fastai_version} which is incompatible."
+            )
+
+    fastcore_packages = [pck for pck in package_versions if pck.startswith("fastcore")]
+    if len(fastcore_packages) == 0:
+        logger.warning("The repository does not have a fastcore version specified in the `pyproject.toml`.")
+    # fastcore_version is an empty string if not specified
+    else:
+        fastcore_version = str(fastcore_packages[0]).partition("=")[2]
+        if fastcore_version != "" and version.Version(fastcore_version) < version.Version(fastcore_min_version):
+            raise ImportError(
+                "`from_pretrained_fastai` requires"
+                f" fastcore>={fastcore_min_version} version, but you are using fastcore"
+                f" version {fastcore_version} which is incompatible."
+            )
+
+
+README_TEMPLATE = """---
+tags:
+- fastai
+---
+
+# Amazing!
+
+🥳 Congratulations on hosting your fastai model on the Hugging Face Hub!
+
+# Some next steps
+1. Fill out this model card with more information (see the template below and the [documentation here](https://huggingface.co/docs/hub/model-repos))!
+
+2. Create a demo in Gradio or Streamlit using 🤗 Spaces ([documentation here](https://huggingface.co/docs/hub/spaces)).
+
+3. Join the fastai community on the [Fastai Discord](https://discord.com/invite/YKrxeNn)!
+
+Greetings fellow fastlearner 🤝! Don't forget to delete this content from your model card.
+
+
+---
+
+
+# Model card
+
+## Model description
+More information needed
+
+## Intended uses & limitations
+More information needed
+
+## Training and evaluation data
+More information needed
+"""
+
+PYPROJECT_TEMPLATE = f"""[build-system]
+requires = ["setuptools>=40.8.0", "wheel", "python={get_python_version()}", "fastai={get_fastai_version()}", "fastcore={get_fastcore_version()}"]
+build-backend = "setuptools.build_meta:__legacy__"
+"""
+
+
+def _create_model_card(repo_dir: Path):
+    """
+    Creates a model card for the repository.
+
+    Args:
+        repo_dir (`Path`):
+            Directory where model card is created.
+    """
+    readme_path = repo_dir / "README.md"
+
+    if not readme_path.exists():
+        with readme_path.open("w", encoding="utf-8") as f:
+            f.write(README_TEMPLATE)
+
+
+def _create_model_pyproject(repo_dir: Path):
+    """
+    Creates a `pyproject.toml` for the repository.
+
+    Args:
+        repo_dir (`Path`):
+            Directory where `pyproject.toml` is created.
+    """
+    pyproject_path = repo_dir / "pyproject.toml"
+
+    if not pyproject_path.exists():
+        with pyproject_path.open("w", encoding="utf-8") as f:
+            f.write(PYPROJECT_TEMPLATE)
+
+
+def _save_pretrained_fastai(
+    learner,
+    save_directory: Union[str, Path],
+    config: Optional[Dict[str, Any]] = None,
+):
+    """
+    Saves a fastai learner to `save_directory` in pickle format using the default pickle protocol for the version of python used.
+
+    Args:
+        learner (`Learner`):
+            The `fastai.Learner` you'd like to save.
+        save_directory (`str` or `Path`):
+            Specific directory in which you want to save the fastai learner.
+        config (`dict`, *optional*):
+            Configuration object. Will be uploaded as a .json file. Example: 'https://huggingface.co/espejelomar/fastai-pet-breeds-classification/blob/main/config.json'.
+
+    <Tip>
+
+    Raises the following error:
+
+        - [`RuntimeError`](https://docs.python.org/3/library/exceptions.html#RuntimeError)
+          if the config file provided is not a dictionary.
+
+    </Tip>
+    """
+    _check_fastai_fastcore_versions()
+
+    os.makedirs(save_directory, exist_ok=True)
+
+    # if the user provides config then we update it with the fastai and fastcore versions in CONFIG_TEMPLATE.
+    if config is not None:
+        if not isinstance(config, dict):
+            raise RuntimeError(f"Provided config should be a dict. Got: '{type(config)}'")
+        path = os.path.join(save_directory, CONFIG_NAME)
+        with open(path, "w") as f:
+            json.dump(config, f)
+
+    _create_model_card(Path(save_directory))
+    _create_model_pyproject(Path(save_directory))
+
+    # learner.export saves the model in `self.path`.
+    learner.path = Path(save_directory)
+    os.makedirs(save_directory, exist_ok=True)
+    try:
+        learner.export(
+            fname="model.pkl",
+            pickle_protocol=DEFAULT_PROTOCOL,
+        )
+    except PicklingError:
+        raise PicklingError(
+            "You are using a lambda function, i.e., an anonymous function. `pickle`"
+            " cannot pickle function objects and requires that all functions have"
+            " names. One possible solution is to name the function."
+        )
+
+
+@validate_hf_hub_args
+def from_pretrained_fastai(
+    repo_id: str,
+    revision: Optional[str] = None,
+):
+    """
+    Load pretrained fastai model from the Hub or from a local directory.
+
+    Args:
+        repo_id (`str`):
+            The location where the pickled fastai.Learner is. It can be either of the two:
+                - Hosted on the Hugging Face Hub. E.g.: 'espejelomar/fatai-pet-breeds-classification' or 'distilgpt2'.
+                  You can add a `revision` by appending `@` at the end of `repo_id`. E.g.: `dbmdz/bert-base-german-cased@main`.
+                  Revision is the specific model version to use. Since we use a git-based system for storing models and other
+                  artifacts on the Hugging Face Hub, it can be a branch name, a tag name, or a commit id.
+                - Hosted locally. `repo_id` would be a directory containing the pickle and a pyproject.toml
+                  indicating the fastai and fastcore versions used to build the `fastai.Learner`. E.g.: `./my_model_directory/`.
+        revision (`str`, *optional*):
+            Revision at which the repo's files are downloaded. See documentation of `snapshot_download`.
+
+    Returns:
+        The `fastai.Learner` model in the `repo_id` repo.
+    """
+    _check_fastai_fastcore_versions()
+
+    # Load the `repo_id` repo.
+    # `snapshot_download` returns the folder where the model was stored.
+    # `cache_dir` will be the default '/root/.cache/huggingface/hub'
+    if not os.path.isdir(repo_id):
+        storage_folder = snapshot_download(
+            repo_id=repo_id,
+            revision=revision,
+            library_name="fastai",
+            library_version=get_fastai_version(),
+        )
+    else:
+        storage_folder = repo_id
+
+    _check_fastai_fastcore_pyproject_versions(storage_folder)
+
+    from fastai.learner import load_learner  # type: ignore
+
+    return load_learner(os.path.join(storage_folder, "model.pkl"))
+
+
+@validate_hf_hub_args
+def push_to_hub_fastai(
+    learner,
+    *,
+    repo_id: str,
+    commit_message: str = "Push FastAI model using huggingface_hub.",
+    private: bool = False,
+    token: Optional[str] = None,
+    config: Optional[dict] = None,
+    branch: Optional[str] = None,
+    create_pr: Optional[bool] = None,
+    allow_patterns: Optional[Union[List[str], str]] = None,
+    ignore_patterns: Optional[Union[List[str], str]] = None,
+    delete_patterns: Optional[Union[List[str], str]] = None,
+    api_endpoint: Optional[str] = None,
+):
+    """
+    Upload learner checkpoint files to the Hub.
+
+    Use `allow_patterns` and `ignore_patterns` to precisely filter which files should be pushed to the hub. Use
+    `delete_patterns` to delete existing remote files in the same commit. See [`upload_folder`] reference for more
+    details.
+
+    Args:
+        learner (`Learner`):
+            The `fastai.Learner' you'd like to push to the Hub.
+        repo_id (`str`):
+            The repository id for your model in Hub in the format of "namespace/repo_name". The namespace can be your individual account or an organization to which you have write access (for example, 'stanfordnlp/stanza-de').
+        commit_message (`str`, *optional*):
+            Message to commit while pushing. Will default to :obj:`"add model"`.
+        private (`bool`, *optional*, defaults to `False`):
+            Whether or not the repository created should be private.
+        token (`str`, *optional*):
+            The Hugging Face account token to use as HTTP bearer authorization for remote files. If :obj:`None`, the token will be asked by a prompt.
+        config (`dict`, *optional*):
+            Configuration object to be saved alongside the model weights.
+        branch (`str`, *optional*):
+            The git branch on which to push the model. This defaults to
+            the default branch as specified in your repository, which
+            defaults to `"main"`.
+        create_pr (`boolean`, *optional*):
+            Whether or not to create a Pull Request from `branch` with that commit.
+            Defaults to `False`.
+        api_endpoint (`str`, *optional*):
+            The API endpoint to use when pushing the model to the hub.
+        allow_patterns (`List[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are pushed.
+        ignore_patterns (`List[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not pushed.
+        delete_patterns (`List[str]` or `str`, *optional*):
+            If provided, remote files matching any of the patterns will be deleted from the repo.
+
+    Returns:
+        The url of the commit of your model in the given repository.
+
+    <Tip>
+
+    Raises the following error:
+
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+          if the user is not log on to the Hugging Face Hub.
+
+    </Tip>
+    """
+    _check_fastai_fastcore_versions()
+    api = HfApi(endpoint=api_endpoint)
+    repo_id = api.create_repo(repo_id=repo_id, token=token, private=private, exist_ok=True).repo_id
+
+    # Push the files to the repo in a single commit
+    with SoftTemporaryDirectory() as tmp:
+        saved_path = Path(tmp) / repo_id
+        _save_pretrained_fastai(learner, saved_path, config=config)
+        return api.upload_folder(
+            repo_id=repo_id,
+            token=token,
+            folder_path=saved_path,
+            commit_message=commit_message,
+            revision=branch,
+            create_pr=create_pr,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            delete_patterns=delete_patterns,
+        )
diff --git a/lib/python3.11/site-packages/huggingface_hub/file_download.py b/lib/python3.11/site-packages/huggingface_hub/file_download.py
new file mode 100644
index 0000000000000000000000000000000000000000..169211736c4ea190a59638e362475cf720b97816
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/file_download.py
@@ -0,0 +1,1727 @@
+import copy
+import fnmatch
+import inspect
+import io
+import json
+import os
+import re
+import shutil
+import stat
+import tempfile
+import time
+import uuid
+import warnings
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import partial
+from pathlib import Path
+from typing import Any, BinaryIO, Dict, Generator, Literal, Optional, Tuple, Union
+from urllib.parse import quote, urlparse
+
+import requests
+from filelock import FileLock
+
+from huggingface_hub import constants
+
+from . import __version__  # noqa: F401 # for backward compatibility
+from .constants import (
+    DEFAULT_ETAG_TIMEOUT,
+    DEFAULT_REQUEST_TIMEOUT,
+    DEFAULT_REVISION,
+    DOWNLOAD_CHUNK_SIZE,
+    ENDPOINT,
+    HF_HUB_CACHE,
+    HF_HUB_DISABLE_SYMLINKS_WARNING,
+    HF_HUB_DOWNLOAD_TIMEOUT,
+    HF_HUB_ENABLE_HF_TRANSFER,
+    HF_HUB_ETAG_TIMEOUT,
+    HF_TRANSFER_CONCURRENCY,
+    HUGGINGFACE_CO_URL_TEMPLATE,
+    HUGGINGFACE_HEADER_X_LINKED_ETAG,
+    HUGGINGFACE_HEADER_X_LINKED_SIZE,
+    HUGGINGFACE_HEADER_X_REPO_COMMIT,
+    HUGGINGFACE_HUB_CACHE,  # noqa: F401 # for backward compatibility
+    REPO_ID_SEPARATOR,
+    REPO_TYPES,
+    REPO_TYPES_URL_PREFIXES,
+)
+from .utils import (
+    EntryNotFoundError,
+    FileMetadataError,
+    GatedRepoError,
+    LocalEntryNotFoundError,
+    OfflineModeIsEnabled,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+    SoftTemporaryDirectory,
+    build_hf_headers,
+    get_fastai_version,  # noqa: F401 # for backward compatibility
+    get_fastcore_version,  # noqa: F401 # for backward compatibility
+    get_graphviz_version,  # noqa: F401 # for backward compatibility
+    get_jinja_version,  # noqa: F401 # for backward compatibility
+    get_pydot_version,  # noqa: F401 # for backward compatibility
+    get_session,
+    get_tf_version,  # noqa: F401 # for backward compatibility
+    get_torch_version,  # noqa: F401 # for backward compatibility
+    hf_raise_for_status,
+    is_fastai_available,  # noqa: F401 # for backward compatibility
+    is_fastcore_available,  # noqa: F401 # for backward compatibility
+    is_graphviz_available,  # noqa: F401 # for backward compatibility
+    is_jinja_available,  # noqa: F401 # for backward compatibility
+    is_pydot_available,  # noqa: F401 # for backward compatibility
+    is_tf_available,  # noqa: F401 # for backward compatibility
+    is_torch_available,  # noqa: F401 # for backward compatibility
+    logging,
+    reset_sessions,
+    tqdm,
+    validate_hf_hub_args,
+)
+from .utils._deprecation import _deprecate_method
+from .utils._headers import _http_user_agent
+from .utils._runtime import _PY_VERSION  # noqa: F401 # for backward compatibility
+from .utils._typing import HTTP_METHOD_T
+from .utils.insecure_hashlib import sha256
+
+
+logger = logging.get_logger(__name__)
+
+# Regex to get filename from a "Content-Disposition" header for CDN-served files
+HEADER_FILENAME_PATTERN = re.compile(r'filename="(?P<filename>.*?)";')
+
+
+_are_symlinks_supported_in_dir: Dict[str, bool] = {}
+
+
+def are_symlinks_supported(cache_dir: Union[str, Path, None] = None) -> bool:
+    """Return whether the symlinks are supported on the machine.
+
+    Since symlinks support can change depending on the mounted disk, we need to check
+    on the precise cache folder. By default, the default HF cache directory is checked.
+
+    Args:
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored.
+
+    Returns: [bool] Whether symlinks are supported in the directory.
+    """
+    # Defaults to HF cache
+    if cache_dir is None:
+        cache_dir = HF_HUB_CACHE
+    cache_dir = str(Path(cache_dir).expanduser().resolve())  # make it unique
+
+    # Check symlink compatibility only once (per cache directory) at first time use
+    if cache_dir not in _are_symlinks_supported_in_dir:
+        _are_symlinks_supported_in_dir[cache_dir] = True
+
+        os.makedirs(cache_dir, exist_ok=True)
+        with SoftTemporaryDirectory(dir=cache_dir) as tmpdir:
+            src_path = Path(tmpdir) / "dummy_file_src"
+            src_path.touch()
+            dst_path = Path(tmpdir) / "dummy_file_dst"
+
+            # Relative source path as in `_create_symlink``
+            relative_src = os.path.relpath(src_path, start=os.path.dirname(dst_path))
+            try:
+                os.symlink(relative_src, dst_path)
+            except OSError:
+                # Likely running on Windows
+                _are_symlinks_supported_in_dir[cache_dir] = False
+
+                if not HF_HUB_DISABLE_SYMLINKS_WARNING:
+                    message = (
+                        "`huggingface_hub` cache-system uses symlinks by default to"
+                        " efficiently store duplicated files but your machine does not"
+                        f" support them in {cache_dir}. Caching files will still work"
+                        " but in a degraded version that might require more space on"
+                        " your disk. This warning can be disabled by setting the"
+                        " `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For"
+                        " more details, see"
+                        " https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations."
+                    )
+                    if os.name == "nt":
+                        message += (
+                            "\nTo support symlinks on Windows, you either need to"
+                            " activate Developer Mode or to run Python as an"
+                            " administrator. In order to see activate developer mode,"
+                            " see this article:"
+                            " https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development"
+                        )
+                    warnings.warn(message)
+
+    return _are_symlinks_supported_in_dir[cache_dir]
+
+
+# Return value when trying to load a file from cache but the file does not exist in the distant repo.
+_CACHED_NO_EXIST = object()
+_CACHED_NO_EXIST_T = Any
+REGEX_COMMIT_HASH = re.compile(r"^[0-9a-f]{40}$")
+
+
+@dataclass(frozen=True)
+class HfFileMetadata:
+    """Data structure containing information about a file versioned on the Hub.
+
+    Returned by [`get_hf_file_metadata`] based on a URL.
+
+    Args:
+        commit_hash (`str`, *optional*):
+            The commit_hash related to the file.
+        etag (`str`, *optional*):
+            Etag of the file on the server.
+        location (`str`):
+            Location where to download the file. Can be a Hub url or not (CDN).
+        size (`size`):
+            Size of the file. In case of an LFS file, contains the size of the actual
+            LFS file, not the pointer.
+    """
+
+    commit_hash: Optional[str]
+    etag: Optional[str]
+    location: str
+    size: Optional[int]
+
+
+@validate_hf_hub_args
+def hf_hub_url(
+    repo_id: str,
+    filename: str,
+    *,
+    subfolder: Optional[str] = None,
+    repo_type: Optional[str] = None,
+    revision: Optional[str] = None,
+    endpoint: Optional[str] = None,
+) -> str:
+    """Construct the URL of a file from the given information.
+
+    The resolved address can either be a huggingface.co-hosted url, or a link to
+    Cloudfront (a Content Delivery Network, or CDN) for large files which are
+    more than a few MBs.
+
+    Args:
+        repo_id (`str`):
+            A namespace (user or an organization) name and a repo name separated
+            by a `/`.
+        filename (`str`):
+            The name of the file in the repo.
+        subfolder (`str`, *optional*):
+            An optional value corresponding to a folder inside the repo.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"` or `"space"` if downloading from a dataset or space,
+            `None` or `"model"` if downloading from a model. Default is `None`.
+        revision (`str`, *optional*):
+            An optional Git revision id which can be a branch name, a tag, or a
+            commit hash.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub import hf_hub_url
+
+    >>> hf_hub_url(
+    ...     repo_id="julien-c/EsperBERTo-small", filename="pytorch_model.bin"
+    ... )
+    'https://huggingface.co/julien-c/EsperBERTo-small/resolve/main/pytorch_model.bin'
+    ```
+
+    <Tip>
+
+    Notes:
+
+        Cloudfront is replicated over the globe so downloads are way faster for
+        the end user (and it also lowers our bandwidth costs).
+
+        Cloudfront aggressively caches files by default (default TTL is 24
+        hours), however this is not an issue here because we implement a
+        git-based versioning system on huggingface.co, which means that we store
+        the files on S3/Cloudfront in a content-addressable way (i.e., the file
+        name is its hash). Using content-addressable filenames means cache can't
+        ever be stale.
+
+        In terms of client-side caching from this library, we base our caching
+        on the objects' entity tag (`ETag`), which is an identifier of a
+        specific version of a resource [1]_. An object's ETag is: its git-sha1
+        if stored in git, or its sha256 if stored in git-lfs.
+
+    </Tip>
+
+    References:
+
+    -  [1] https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag
+    """
+    if subfolder == "":
+        subfolder = None
+    if subfolder is not None:
+        filename = f"{subfolder}/{filename}"
+
+    if repo_type not in REPO_TYPES:
+        raise ValueError("Invalid repo type")
+
+    if repo_type in REPO_TYPES_URL_PREFIXES:
+        repo_id = REPO_TYPES_URL_PREFIXES[repo_type] + repo_id
+
+    if revision is None:
+        revision = DEFAULT_REVISION
+    url = HUGGINGFACE_CO_URL_TEMPLATE.format(
+        repo_id=repo_id, revision=quote(revision, safe=""), filename=quote(filename)
+    )
+    # Update endpoint if provided
+    if endpoint is not None and url.startswith(ENDPOINT):
+        url = endpoint + url[len(ENDPOINT) :]
+    return url
+
+
+def url_to_filename(url: str, etag: Optional[str] = None) -> str:
+    """Generate a local filename from a url.
+
+    Convert `url` into a hashed filename in a reproducible way. If `etag` is
+    specified, append its hash to the url's, delimited by a period. If the url
+    ends with .h5 (Keras HDF5 weights) adds '.h5' to the name so that TF 2.0 can
+    identify it as a HDF5 file (see
+    https://github.com/tensorflow/tensorflow/blob/00fad90125b18b80fe054de1055770cfb8fe4ba3/tensorflow/python/keras/engine/network.py#L1380)
+
+    Args:
+        url (`str`):
+            The address to the file.
+        etag (`str`, *optional*):
+            The ETag of the file.
+
+    Returns:
+        The generated filename.
+    """
+    url_bytes = url.encode("utf-8")
+    filename = sha256(url_bytes).hexdigest()
+
+    if etag:
+        etag_bytes = etag.encode("utf-8")
+        filename += "." + sha256(etag_bytes).hexdigest()
+
+    if url.endswith(".h5"):
+        filename += ".h5"
+
+    return filename
+
+
+def filename_to_url(
+    filename,
+    cache_dir: Optional[str] = None,
+    legacy_cache_layout: bool = False,
+) -> Tuple[str, str]:
+    """
+    Return the url and etag (which may be `None`) stored for `filename`. Raise
+    `EnvironmentError` if `filename` or its stored metadata do not exist.
+
+    Args:
+        filename (`str`):
+            The name of the file
+        cache_dir (`str`, *optional*):
+            The cache directory to use instead of the default one.
+        legacy_cache_layout (`bool`, *optional*, defaults to `False`):
+            If `True`, uses the legacy file cache layout i.e. just call `hf_hub_url`
+            then `cached_download`. This is deprecated as the new cache layout is
+            more powerful.
+    """
+    if not legacy_cache_layout:
+        warnings.warn(
+            "`filename_to_url` uses the legacy way cache file layout",
+            FutureWarning,
+        )
+
+    if cache_dir is None:
+        cache_dir = HF_HUB_CACHE
+    if isinstance(cache_dir, Path):
+        cache_dir = str(cache_dir)
+
+    cache_path = os.path.join(cache_dir, filename)
+    if not os.path.exists(cache_path):
+        raise EnvironmentError(f"file {cache_path} not found")
+
+    meta_path = cache_path + ".json"
+    if not os.path.exists(meta_path):
+        raise EnvironmentError(f"file {meta_path} not found")
+
+    with open(meta_path, encoding="utf-8") as meta_file:
+        metadata = json.load(meta_file)
+    url = metadata["url"]
+    etag = metadata["etag"]
+
+    return url, etag
+
+
+@_deprecate_method(version="0.22.0", message="Use `huggingface_hub.utils.build_hf_headers` instead.")
+def http_user_agent(
+    *,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    user_agent: Union[Dict, str, None] = None,
+) -> str:
+    """Deprecated in favor of [`build_hf_headers`]."""
+    return _http_user_agent(
+        library_name=library_name,
+        library_version=library_version,
+        user_agent=user_agent,
+    )
+
+
+def _request_wrapper(
+    method: HTTP_METHOD_T, url: str, *, follow_relative_redirects: bool = False, **params
+) -> requests.Response:
+    """Wrapper around requests methods to follow relative redirects if `follow_relative_redirects=True` even when
+    `allow_redirection=False`.
+
+    Args:
+        method (`str`):
+            HTTP method, such as 'GET' or 'HEAD'.
+        url (`str`):
+            The URL of the resource to fetch.
+        follow_relative_redirects (`bool`, *optional*, defaults to `False`)
+            If True, relative redirection (redirection to the same site) will be resolved even when `allow_redirection`
+            kwarg is set to False. Useful when we want to follow a redirection to a renamed repository without
+            following redirection to a CDN.
+        **params (`dict`, *optional*):
+            Params to pass to `requests.request`.
+    """
+    # Recursively follow relative redirects
+    if follow_relative_redirects:
+        response = _request_wrapper(
+            method=method,
+            url=url,
+            follow_relative_redirects=False,
+            **params,
+        )
+
+        # If redirection, we redirect only relative paths.
+        # This is useful in case of a renamed repository.
+        if 300 <= response.status_code <= 399:
+            parsed_target = urlparse(response.headers["Location"])
+            if parsed_target.netloc == "":
+                # This means it is a relative 'location' headers, as allowed by RFC 7231.
+                # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
+                # We want to follow this relative redirect !
+                #
+                # Highly inspired by `resolve_redirects` from requests library.
+                # See https://github.com/psf/requests/blob/main/requests/sessions.py#L159
+                next_url = urlparse(url)._replace(path=parsed_target.path).geturl()
+                return _request_wrapper(method=method, url=next_url, follow_relative_redirects=True, **params)
+        return response
+
+    # Perform request and return if status_code is not in the retry list.
+    response = get_session().request(method=method, url=url, **params)
+    hf_raise_for_status(response)
+    return response
+
+
+def http_get(
+    url: str,
+    temp_file: BinaryIO,
+    *,
+    proxies=None,
+    resume_size: float = 0,
+    headers: Optional[Dict[str, str]] = None,
+    expected_size: Optional[int] = None,
+    _nb_retries: int = 5,
+):
+    """
+    Download a remote file. Do not gobble up errors, and will return errors tailored to the Hugging Face Hub.
+
+    If ConnectionError (SSLError) or ReadTimeout happen while streaming data from the server, it is most likely a
+    transient error (network outage?). We log a warning message and try to resume the download a few times before
+    giving up. The method gives up after 5 attempts if no new data has being received from the server.
+    """
+    hf_transfer = None
+    if HF_HUB_ENABLE_HF_TRANSFER:
+        if resume_size != 0:
+            warnings.warn("'hf_transfer' does not support `resume_size`: falling back to regular download method")
+        elif proxies is not None:
+            warnings.warn("'hf_transfer' does not support `proxies`: falling back to regular download method")
+        else:
+            try:
+                import hf_transfer  # type: ignore[no-redef]
+            except ImportError:
+                raise ValueError(
+                    "Fast download using 'hf_transfer' is enabled"
+                    " (HF_HUB_ENABLE_HF_TRANSFER=1) but 'hf_transfer' package is not"
+                    " available in your environment. Try `pip install hf_transfer`."
+                )
+
+    initial_headers = headers
+    headers = copy.deepcopy(headers) or {}
+    if resume_size > 0:
+        headers["Range"] = "bytes=%d-" % (resume_size,)
+
+    r = _request_wrapper(
+        method="GET", url=url, stream=True, proxies=proxies, headers=headers, timeout=HF_HUB_DOWNLOAD_TIMEOUT
+    )
+    hf_raise_for_status(r)
+    content_length = r.headers.get("Content-Length")
+
+    # NOTE: 'total' is the total number of bytes to download, not the number of bytes in the file.
+    #       If the file is compressed, the number of bytes in the saved file will be higher than 'total'.
+    total = resume_size + int(content_length) if content_length is not None else None
+
+    displayed_name = url
+    content_disposition = r.headers.get("Content-Disposition")
+    if content_disposition is not None:
+        match = HEADER_FILENAME_PATTERN.search(content_disposition)
+        if match is not None:
+            # Means file is on CDN
+            displayed_name = match.groupdict()["filename"]
+
+    # Truncate filename if too long to display
+    if len(displayed_name) > 40:
+        displayed_name = f"(…){displayed_name[-40:]}"
+
+    consistency_error_message = (
+        f"Consistency check failed: file should be of size {expected_size} but has size"
+        f" {{actual_size}} ({displayed_name}).\nWe are sorry for the inconvenience. Please retry download and"
+        " pass `force_download=True, resume_download=False` as argument.\nIf the issue persists, please let us"
+        " know by opening an issue on https://github.com/huggingface/huggingface_hub."
+    )
+
+    # Stream file to buffer
+    with tqdm(
+        unit="B",
+        unit_scale=True,
+        total=total,
+        initial=resume_size,
+        desc=displayed_name,
+        disable=bool(logger.getEffectiveLevel() == logging.NOTSET),
+    ) as progress:
+        if hf_transfer and total is not None and total > 5 * DOWNLOAD_CHUNK_SIZE:
+            supports_callback = "callback" in inspect.signature(hf_transfer.download).parameters
+            if not supports_callback:
+                warnings.warn(
+                    "You are using an outdated version of `hf_transfer`. "
+                    "Consider upgrading to latest version to enable progress bars "
+                    "using `pip install -U hf_transfer`."
+                )
+            try:
+                hf_transfer.download(
+                    url=url,
+                    filename=temp_file.name,
+                    max_files=HF_TRANSFER_CONCURRENCY,
+                    chunk_size=DOWNLOAD_CHUNK_SIZE,
+                    headers=headers,
+                    parallel_failures=3,
+                    max_retries=5,
+                    **({"callback": progress.update} if supports_callback else {}),
+                )
+            except Exception as e:
+                raise RuntimeError(
+                    "An error occurred while downloading using `hf_transfer`. Consider"
+                    " disabling HF_HUB_ENABLE_HF_TRANSFER for better error handling."
+                ) from e
+            if not supports_callback:
+                progress.update(total)
+            if expected_size is not None and expected_size != os.path.getsize(temp_file.name):
+                raise EnvironmentError(
+                    consistency_error_message.format(
+                        actual_size=os.path.getsize(temp_file.name),
+                    )
+                )
+            return
+        new_resume_size = resume_size
+        try:
+            for chunk in r.iter_content(chunk_size=DOWNLOAD_CHUNK_SIZE):
+                if chunk:  # filter out keep-alive new chunks
+                    progress.update(len(chunk))
+                    temp_file.write(chunk)
+                    new_resume_size += len(chunk)
+                    # Some data has been downloaded from the server so we reset the number of retries.
+                    _nb_retries = 5
+        except (requests.ConnectionError, requests.ReadTimeout) as e:
+            # If ConnectionError (SSLError) or ReadTimeout happen while streaming data from the server, it is most likely
+            # a transient error (network outage?). We log a warning message and try to resume the download a few times
+            # before giving up. Tre retry mechanism is basic but should be enough in most cases.
+            if _nb_retries <= 0:
+                logger.warning("Error while downloading from %s: %s\nMax retries exceeded.", url, str(e))
+                raise
+            logger.warning("Error while downloading from %s: %s\nTrying to resume download...", url, str(e))
+            time.sleep(1)
+            reset_sessions()  # In case of SSLError it's best to reset the shared requests.Session objects
+            return http_get(
+                url=url,
+                temp_file=temp_file,
+                proxies=proxies,
+                resume_size=new_resume_size,
+                headers=initial_headers,
+                expected_size=expected_size,
+                _nb_retries=_nb_retries - 1,
+            )
+
+        if expected_size is not None and expected_size != temp_file.tell():
+            raise EnvironmentError(
+                consistency_error_message.format(
+                    actual_size=temp_file.tell(),
+                )
+            )
+
+
+@validate_hf_hub_args
+def cached_download(
+    url: str,
+    *,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    cache_dir: Union[str, Path, None] = None,
+    user_agent: Union[Dict, str, None] = None,
+    force_download: bool = False,
+    force_filename: Optional[str] = None,
+    proxies: Optional[Dict] = None,
+    etag_timeout: float = DEFAULT_ETAG_TIMEOUT,
+    resume_download: bool = False,
+    token: Union[bool, str, None] = None,
+    local_files_only: bool = False,
+    legacy_cache_layout: bool = False,
+) -> str:
+    """
+    Download from a given URL and cache it if it's not already present in the
+    local cache.
+
+    Given a URL, this function looks for the corresponding file in the local
+    cache. If it's not there, download it. Then return the path to the cached
+    file.
+
+    Will raise errors tailored to the Hugging Face Hub.
+
+    Args:
+        url (`str`):
+            The path to the file to be downloaded.
+        library_name (`str`, *optional*):
+            The name of the library to which the object corresponds.
+        library_version (`str`, *optional*):
+            The version of the library.
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored.
+        user_agent (`dict`, `str`, *optional*):
+            The user-agent info in the form of a dictionary or a string.
+        force_download (`bool`, *optional*, defaults to `False`):
+            Whether the file should be downloaded even if it already exists in
+            the local cache.
+        force_filename (`str`, *optional*):
+            Use this name instead of a generated file name.
+        proxies (`dict`, *optional*):
+            Dictionary mapping protocol to the URL of the proxy passed to
+            `requests.request`.
+        etag_timeout (`float`, *optional* defaults to `10`):
+            When fetching ETag, how many seconds to wait for the server to send
+            data before giving up which is passed to `requests.request`.
+        resume_download (`bool`, *optional*, defaults to `False`):
+            If `True`, resume a previously interrupted download.
+        token (`bool`, `str`, *optional*):
+            A token to be used for the download.
+                - If `True`, the token is read from the HuggingFace config
+                  folder.
+                - If a string, it's used as the authentication token.
+        local_files_only (`bool`, *optional*, defaults to `False`):
+            If `True`, avoid downloading the file and return the path to the
+            local cached file if it exists.
+        legacy_cache_layout (`bool`, *optional*, defaults to `False`):
+            Set this parameter to `True` to mention that you'd like to continue
+            the old cache layout. Putting this to `True` manually will not raise
+            any warning when using `cached_download`. We recommend using
+            `hf_hub_download` to take advantage of the new cache.
+
+    Returns:
+        Local path (string) of file or if networking is off, last version of
+        file cached on disk.
+
+    <Tip>
+
+    Raises the following errors:
+
+        - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+          if `token=True` and the token cannot be found.
+        - [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError)
+          if ETag cannot be determined.
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+          if some parameter value is invalid
+        - [`~utils.RepositoryNotFoundError`]
+          If the repository to download from cannot be found. This may be because it doesn't exist,
+          or because it is set to `private` and you do not have access.
+        - [`~utils.RevisionNotFoundError`]
+          If the revision to download from cannot be found.
+        - [`~utils.EntryNotFoundError`]
+          If the file to download cannot be found.
+        - [`~utils.LocalEntryNotFoundError`]
+          If network is disabled or unavailable and file is not found in cache.
+
+    </Tip>
+    """
+    if HF_HUB_ETAG_TIMEOUT != DEFAULT_ETAG_TIMEOUT:
+        # Respect environment variable above user value
+        etag_timeout = HF_HUB_ETAG_TIMEOUT
+
+    if not legacy_cache_layout:
+        warnings.warn(
+            "'cached_download' is the legacy way to download files from the HF hub, please consider upgrading to"
+            " 'hf_hub_download'",
+            FutureWarning,
+        )
+
+    if cache_dir is None:
+        cache_dir = HF_HUB_CACHE
+    if isinstance(cache_dir, Path):
+        cache_dir = str(cache_dir)
+
+    os.makedirs(cache_dir, exist_ok=True)
+
+    headers = build_hf_headers(
+        token=token,
+        library_name=library_name,
+        library_version=library_version,
+        user_agent=user_agent,
+    )
+
+    url_to_download = url
+    etag = None
+    expected_size = None
+    if not local_files_only:
+        try:
+            # Temporary header: we want the full (decompressed) content size returned to be able to check the
+            # downloaded file size
+            headers["Accept-Encoding"] = "identity"
+            r = _request_wrapper(
+                method="HEAD",
+                url=url,
+                headers=headers,
+                allow_redirects=False,
+                follow_relative_redirects=True,
+                proxies=proxies,
+                timeout=etag_timeout,
+            )
+            headers.pop("Accept-Encoding", None)
+            hf_raise_for_status(r)
+            etag = r.headers.get(HUGGINGFACE_HEADER_X_LINKED_ETAG) or r.headers.get("ETag")
+            # We favor a custom header indicating the etag of the linked resource, and
+            # we fallback to the regular etag header.
+            # If we don't have any of those, raise an error.
+            if etag is None:
+                raise FileMetadataError(
+                    "Distant resource does not have an ETag, we won't be able to reliably ensure reproducibility."
+                )
+            # We get the expected size of the file, to check the download went well.
+            expected_size = _int_or_none(r.headers.get("Content-Length"))
+            # In case of a redirect, save an extra redirect on the request.get call,
+            # and ensure we download the exact atomic version even if it changed
+            # between the HEAD and the GET (unlikely, but hey).
+            # Useful for lfs blobs that are stored on a CDN.
+            if 300 <= r.status_code <= 399:
+                url_to_download = r.headers["Location"]
+                headers.pop("authorization", None)
+                expected_size = None  # redirected -> can't know the expected size
+        except (requests.exceptions.SSLError, requests.exceptions.ProxyError):
+            # Actually raise for those subclasses of ConnectionError
+            raise
+        except (
+            requests.exceptions.ConnectionError,
+            requests.exceptions.Timeout,
+            OfflineModeIsEnabled,
+        ):
+            # Otherwise, our Internet connection is down.
+            # etag is None
+            pass
+
+    filename = force_filename if force_filename is not None else url_to_filename(url, etag)
+
+    # get cache path to put the file
+    cache_path = os.path.join(cache_dir, filename)
+
+    # etag is None == we don't have a connection or we passed local_files_only.
+    # try to get the last downloaded one
+    if etag is None:
+        if os.path.exists(cache_path) and not force_download:
+            return cache_path
+        else:
+            matching_files = [
+                file
+                for file in fnmatch.filter(os.listdir(cache_dir), filename.split(".")[0] + ".*")
+                if not file.endswith(".json") and not file.endswith(".lock")
+            ]
+            if len(matching_files) > 0 and not force_download and force_filename is None:
+                return os.path.join(cache_dir, matching_files[-1])
+            else:
+                # If files cannot be found and local_files_only=True,
+                # the models might've been found if local_files_only=False
+                # Notify the user about that
+                if local_files_only:
+                    raise LocalEntryNotFoundError(
+                        "Cannot find the requested files in the cached path and"
+                        " outgoing traffic has been disabled. To enable model look-ups"
+                        " and downloads online, set 'local_files_only' to False."
+                    )
+                else:
+                    raise LocalEntryNotFoundError(
+                        "Connection error, and we cannot find the requested files in"
+                        " the cached path. Please try again or make sure your Internet"
+                        " connection is on."
+                    )
+
+    # From now on, etag is not None.
+    if os.path.exists(cache_path) and not force_download:
+        return cache_path
+
+    # Prevent parallel downloads of the same file with a lock.
+    lock_path = cache_path + ".lock"
+
+    # Some Windows versions do not allow for paths longer than 255 characters.
+    # In this case, we must specify it is an extended path by using the "\\?\" prefix.
+    if os.name == "nt" and len(os.path.abspath(lock_path)) > 255:
+        lock_path = "\\\\?\\" + os.path.abspath(lock_path)
+
+    if os.name == "nt" and len(os.path.abspath(cache_path)) > 255:
+        cache_path = "\\\\?\\" + os.path.abspath(cache_path)
+
+    with FileLock(lock_path):
+        # If the download just completed while the lock was activated.
+        if os.path.exists(cache_path) and not force_download:
+            # Even if returning early like here, the lock will be released.
+            return cache_path
+
+        if resume_download:
+            incomplete_path = cache_path + ".incomplete"
+
+            @contextmanager
+            def _resumable_file_manager() -> Generator[io.BufferedWriter, None, None]:
+                with open(incomplete_path, "ab") as f:
+                    yield f
+
+            temp_file_manager = _resumable_file_manager
+            if os.path.exists(incomplete_path):
+                resume_size = os.stat(incomplete_path).st_size
+            else:
+                resume_size = 0
+        else:
+            temp_file_manager = partial(  # type: ignore
+                tempfile.NamedTemporaryFile, mode="wb", dir=cache_dir, delete=False
+            )
+            resume_size = 0
+
+        # Download to temporary file, then copy to cache dir once finished.
+        # Otherwise you get corrupt cache entries if the download gets interrupted.
+        with temp_file_manager() as temp_file:
+            logger.info("downloading %s to %s", url, temp_file.name)
+
+            http_get(
+                url_to_download,
+                temp_file,
+                proxies=proxies,
+                resume_size=resume_size,
+                headers=headers,
+                expected_size=expected_size,
+            )
+
+        logger.info("storing %s in cache at %s", url, cache_path)
+        _chmod_and_replace(temp_file.name, cache_path)
+
+        if force_filename is None:
+            logger.info("creating metadata file for %s", cache_path)
+            meta = {"url": url, "etag": etag}
+            meta_path = cache_path + ".json"
+            with open(meta_path, "w") as meta_file:
+                json.dump(meta, meta_file)
+
+    return cache_path
+
+
+def _normalize_etag(etag: Optional[str]) -> Optional[str]:
+    """Normalize ETag HTTP header, so it can be used to create nice filepaths.
+
+    The HTTP spec allows two forms of ETag:
+      ETag: W/"<etag_value>"
+      ETag: "<etag_value>"
+
+    For now, we only expect the second form from the server, but we want to be future-proof so we support both. For
+    more context, see `TestNormalizeEtag` tests and https://github.com/huggingface/huggingface_hub/pull/1428.
+
+    Args:
+        etag (`str`, *optional*): HTTP header
+
+    Returns:
+        `str` or `None`: string that can be used as a nice directory name.
+        Returns `None` if input is None.
+    """
+    if etag is None:
+        return None
+    return etag.lstrip("W/").strip('"')
+
+
+def _create_relative_symlink(src: str, dst: str, new_blob: bool = False) -> None:
+    """Alias method used in `transformers` conversion script."""
+    return _create_symlink(src=src, dst=dst, new_blob=new_blob)
+
+
+def _create_symlink(src: str, dst: str, new_blob: bool = False) -> None:
+    """Create a symbolic link named dst pointing to src.
+
+    By default, it will try to create a symlink using a relative path. Relative paths have 2 advantages:
+    - If the cache_folder is moved (example: back-up on a shared drive), relative paths within the cache folder will
+      not brake.
+    - Relative paths seems to be better handled on Windows. Issue was reported 3 times in less than a week when
+      changing from relative to absolute paths. See https://github.com/huggingface/huggingface_hub/issues/1398,
+      https://github.com/huggingface/diffusers/issues/2729 and https://github.com/huggingface/transformers/pull/22228.
+      NOTE: The issue with absolute paths doesn't happen on admin mode.
+    When creating a symlink from the cache to a local folder, it is possible that a relative path cannot be created.
+    This happens when paths are not on the same volume. In that case, we use absolute paths.
+
+
+    The result layout looks something like
+        └── [ 128]  snapshots
+            ├── [ 128]  2439f60ef33a0d46d85da5001d52aeda5b00ce9f
+            │   ├── [  52]  README.md -> ../../../blobs/d7edf6bd2a681fb0175f7735299831ee1b22b812
+            │   └── [  76]  pytorch_model.bin -> ../../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+
+    If symlinks cannot be created on this platform (most likely to be Windows), the workaround is to avoid symlinks by
+    having the actual file in `dst`. If it is a new file (`new_blob=True`), we move it to `dst`. If it is not a new file
+    (`new_blob=False`), we don't know if the blob file is already referenced elsewhere. To avoid breaking existing
+    cache, the file is duplicated on the disk.
+
+    In case symlinks are not supported, a warning message is displayed to the user once when loading `huggingface_hub`.
+    The warning message can be disable with the `DISABLE_SYMLINKS_WARNING` environment variable.
+    """
+    try:
+        os.remove(dst)
+    except OSError:
+        pass
+
+    abs_src = os.path.abspath(os.path.expanduser(src))
+    abs_dst = os.path.abspath(os.path.expanduser(dst))
+    abs_dst_folder = os.path.dirname(abs_dst)
+
+    # Use relative_dst in priority
+    try:
+        relative_src = os.path.relpath(abs_src, abs_dst_folder)
+    except ValueError:
+        # Raised on Windows if src and dst are not on the same volume. This is the case when creating a symlink to a
+        # local_dir instead of within the cache directory.
+        # See https://docs.python.org/3/library/os.path.html#os.path.relpath
+        relative_src = None
+
+    try:
+        commonpath = os.path.commonpath([abs_src, abs_dst])
+        _support_symlinks = are_symlinks_supported(commonpath)
+    except ValueError:
+        # Raised if src and dst are not on the same volume. Symlinks will still work on Linux/Macos.
+        # See https://docs.python.org/3/library/os.path.html#os.path.commonpath
+        _support_symlinks = os.name != "nt"
+    except PermissionError:
+        # Permission error means src and dst are not in the same volume (e.g. destination path has been provided
+        # by the user via `local_dir`. Let's test symlink support there)
+        _support_symlinks = are_symlinks_supported(abs_dst_folder)
+
+    # Symlinks are supported => let's create a symlink.
+    if _support_symlinks:
+        src_rel_or_abs = relative_src or abs_src
+        logger.debug(f"Creating pointer from {src_rel_or_abs} to {abs_dst}")
+        try:
+            os.symlink(src_rel_or_abs, abs_dst)
+            return
+        except FileExistsError:
+            if os.path.islink(abs_dst) and os.path.realpath(abs_dst) == os.path.realpath(abs_src):
+                # `abs_dst` already exists and is a symlink to the `abs_src` blob. It is most likely that the file has
+                # been cached twice concurrently (exactly between `os.remove` and `os.symlink`). Do nothing.
+                return
+            else:
+                # Very unlikely to happen. Means a file `dst` has been created exactly between `os.remove` and
+                # `os.symlink` and is not a symlink to the `abs_src` blob file. Raise exception.
+                raise
+        except PermissionError:
+            # Permission error means src and dst are not in the same volume (e.g. download to local dir) and symlink
+            # is supported on both volumes but not between them. Let's just make a hard copy in that case.
+            pass
+
+    # Symlinks are not supported => let's move or copy the file.
+    if new_blob:
+        logger.info(f"Symlink not supported. Moving file from {abs_src} to {abs_dst}")
+        shutil.move(abs_src, abs_dst)
+    else:
+        logger.info(f"Symlink not supported. Copying file from {abs_src} to {abs_dst}")
+        shutil.copyfile(abs_src, abs_dst)
+
+
+def _cache_commit_hash_for_specific_revision(storage_folder: str, revision: str, commit_hash: str) -> None:
+    """Cache reference between a revision (tag, branch or truncated commit hash) and the corresponding commit hash.
+
+    Does nothing if `revision` is already a proper `commit_hash` or reference is already cached.
+    """
+    if revision != commit_hash:
+        ref_path = Path(storage_folder) / "refs" / revision
+        ref_path.parent.mkdir(parents=True, exist_ok=True)
+        if not ref_path.exists() or commit_hash != ref_path.read_text():
+            # Update ref only if has been updated. Could cause useless error in case
+            # repo is already cached and user doesn't have write access to cache folder.
+            # See https://github.com/huggingface/huggingface_hub/issues/1216.
+            ref_path.write_text(commit_hash)
+
+
+@validate_hf_hub_args
+def repo_folder_name(*, repo_id: str, repo_type: str) -> str:
+    """Return a serialized version of a hf.co repo name and type, safe for disk storage
+    as a single non-nested folder.
+
+    Example: models--julien-c--EsperBERTo-small
+    """
+    # remove all `/` occurrences to correctly convert repo to directory name
+    parts = [f"{repo_type}s", *repo_id.split("/")]
+    return REPO_ID_SEPARATOR.join(parts)
+
+
+def _check_disk_space(expected_size: int, target_dir: Union[str, Path]) -> None:
+    """Check disk usage and log a warning if there is not enough disk space to download the file.
+
+    Args:
+        expected_size (`int`):
+            The expected size of the file in bytes.
+        target_dir (`str`):
+            The directory where the file will be stored after downloading.
+    """
+
+    target_dir = Path(target_dir)  # format as `Path`
+    for path in [target_dir] + list(target_dir.parents):  # first check target_dir, then each parents one by one
+        try:
+            target_dir_free = shutil.disk_usage(path).free
+            if target_dir_free < expected_size:
+                warnings.warn(
+                    "Not enough free disk space to download the file. "
+                    f"The expected file size is: {expected_size / 1e6:.2f} MB. "
+                    f"The target location {target_dir} only has {target_dir_free / 1e6:.2f} MB free disk space."
+                )
+            return
+        except OSError:  # raise on anything: file does not exist or space disk cannot be checked
+            pass
+
+
+@validate_hf_hub_args
+def hf_hub_download(
+    repo_id: str,
+    filename: str,
+    *,
+    subfolder: Optional[str] = None,
+    repo_type: Optional[str] = None,
+    revision: Optional[str] = None,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    cache_dir: Union[str, Path, None] = None,
+    local_dir: Union[str, Path, None] = None,
+    local_dir_use_symlinks: Union[bool, Literal["auto"]] = "auto",
+    user_agent: Union[Dict, str, None] = None,
+    force_download: bool = False,
+    force_filename: Optional[str] = None,
+    proxies: Optional[Dict] = None,
+    etag_timeout: float = DEFAULT_ETAG_TIMEOUT,
+    resume_download: bool = False,
+    token: Union[bool, str, None] = None,
+    local_files_only: bool = False,
+    legacy_cache_layout: bool = False,
+    endpoint: Optional[str] = None,
+) -> str:
+    """Download a given file if it's not already present in the local cache.
+
+    The new cache file layout looks like this:
+    - The cache directory contains one subfolder per repo_id (namespaced by repo type)
+    - inside each repo folder:
+        - refs is a list of the latest known revision => commit_hash pairs
+        - blobs contains the actual file blobs (identified by their git-sha or sha256, depending on
+          whether they're LFS files or not)
+        - snapshots contains one subfolder per commit, each "commit" contains the subset of the files
+          that have been resolved at that particular commit. Each filename is a symlink to the blob
+          at that particular commit.
+
+    If `local_dir` is provided, the file structure from the repo will be replicated in this location. You can configure
+    how you want to move those files:
+      - If `local_dir_use_symlinks="auto"` (default), files are downloaded and stored in the cache directory as blob
+        files. Small files (<5MB) are duplicated in `local_dir` while a symlink is created for bigger files. The goal
+        is to be able to manually edit and save small files without corrupting the cache while saving disk space for
+        binary files. The 5MB threshold can be configured with the `HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD`
+        environment variable.
+      - If `local_dir_use_symlinks=True`, files are downloaded, stored in the cache directory and symlinked in `local_dir`.
+        This is optimal in term of disk usage but files must not be manually edited.
+      - If `local_dir_use_symlinks=False` and the blob files exist in the cache directory, they are duplicated in the
+        local dir. This means disk usage is not optimized.
+      - Finally, if `local_dir_use_symlinks=False` and the blob files do not exist in the cache directory, then the
+        files are downloaded and directly placed under `local_dir`. This means if you need to download them again later,
+        they will be re-downloaded entirely.
+
+    ```
+    [  96]  .
+    └── [ 160]  models--julien-c--EsperBERTo-small
+        ├── [ 160]  blobs
+        │   ├── [321M]  403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+        │   ├── [ 398]  7cb18dc9bafbfcf74629a4b760af1b160957a83e
+        │   └── [1.4K]  d7edf6bd2a681fb0175f7735299831ee1b22b812
+        ├── [  96]  refs
+        │   └── [  40]  main
+        └── [ 128]  snapshots
+            ├── [ 128]  2439f60ef33a0d46d85da5001d52aeda5b00ce9f
+            │   ├── [  52]  README.md -> ../../blobs/d7edf6bd2a681fb0175f7735299831ee1b22b812
+            │   └── [  76]  pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+            └── [ 128]  bbc77c8132af1cc5cf678da3f1ddf2de43606d48
+                ├── [  52]  README.md -> ../../blobs/7cb18dc9bafbfcf74629a4b760af1b160957a83e
+                └── [  76]  pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+    ```
+
+    Args:
+        repo_id (`str`):
+            A user or an organization name and a repo name separated by a `/`.
+        filename (`str`):
+            The name of the file in the repo.
+        subfolder (`str`, *optional*):
+            An optional value corresponding to a folder inside the model repo.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"` or `"space"` if downloading from a dataset or space,
+            `None` or `"model"` if downloading from a model. Default is `None`.
+        revision (`str`, *optional*):
+            An optional Git revision id which can be a branch name, a tag, or a
+            commit hash.
+        library_name (`str`, *optional*):
+            The name of the library to which the object corresponds.
+        library_version (`str`, *optional*):
+            The version of the library.
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored.
+        local_dir (`str` or `Path`, *optional*):
+            If provided, the downloaded file will be placed under this directory, either as a symlink (default) or
+            a regular file (see description for more details).
+        local_dir_use_symlinks (`"auto"` or `bool`, defaults to `"auto"`):
+            To be used with `local_dir`. If set to "auto", the cache directory will be used and the file will be either
+            duplicated or symlinked to the local directory depending on its size. It set to `True`, a symlink will be
+            created, no matter the file size. If set to `False`, the file will either be duplicated from cache (if
+            already exists) or downloaded from the Hub and not cached. See description for more details.
+        user_agent (`dict`, `str`, *optional*):
+            The user-agent info in the form of a dictionary or a string.
+        force_download (`bool`, *optional*, defaults to `False`):
+            Whether the file should be downloaded even if it already exists in
+            the local cache.
+        proxies (`dict`, *optional*):
+            Dictionary mapping protocol to the URL of the proxy passed to
+            `requests.request`.
+        etag_timeout (`float`, *optional*, defaults to `10`):
+            When fetching ETag, how many seconds to wait for the server to send
+            data before giving up which is passed to `requests.request`.
+        resume_download (`bool`, *optional*, defaults to `False`):
+            If `True`, resume a previously interrupted download.
+        token (`str`, `bool`, *optional*):
+            A token to be used for the download.
+                - If `True`, the token is read from the HuggingFace config
+                  folder.
+                - If a string, it's used as the authentication token.
+        local_files_only (`bool`, *optional*, defaults to `False`):
+            If `True`, avoid downloading the file and return the path to the
+            local cached file if it exists.
+        legacy_cache_layout (`bool`, *optional*, defaults to `False`):
+            If `True`, uses the legacy file cache layout i.e. just call [`hf_hub_url`]
+            then `cached_download`. This is deprecated as the new cache layout is
+            more powerful.
+
+    Returns:
+        Local path (string) of file or if networking is off, last version of
+        file cached on disk.
+
+    <Tip>
+
+    Raises the following errors:
+
+        - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+          if `token=True` and the token cannot be found.
+        - [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError)
+          if ETag cannot be determined.
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+          if some parameter value is invalid
+        - [`~utils.RepositoryNotFoundError`]
+          If the repository to download from cannot be found. This may be because it doesn't exist,
+          or because it is set to `private` and you do not have access.
+        - [`~utils.RevisionNotFoundError`]
+          If the revision to download from cannot be found.
+        - [`~utils.EntryNotFoundError`]
+          If the file to download cannot be found.
+        - [`~utils.LocalEntryNotFoundError`]
+          If network is disabled or unavailable and file is not found in cache.
+
+    </Tip>
+    """
+    if HF_HUB_ETAG_TIMEOUT != DEFAULT_ETAG_TIMEOUT:
+        # Respect environment variable above user value
+        etag_timeout = HF_HUB_ETAG_TIMEOUT
+
+    if force_filename is not None:
+        warnings.warn(
+            "The `force_filename` parameter is deprecated as a new caching system, "
+            "which keeps the filenames as they are on the Hub, is now in place.",
+            FutureWarning,
+        )
+        legacy_cache_layout = True
+
+    if legacy_cache_layout:
+        url = hf_hub_url(
+            repo_id,
+            filename,
+            subfolder=subfolder,
+            repo_type=repo_type,
+            revision=revision,
+            endpoint=endpoint,
+        )
+
+        return cached_download(
+            url,
+            library_name=library_name,
+            library_version=library_version,
+            cache_dir=cache_dir,
+            user_agent=user_agent,
+            force_download=force_download,
+            force_filename=force_filename,
+            proxies=proxies,
+            etag_timeout=etag_timeout,
+            resume_download=resume_download,
+            token=token,
+            local_files_only=local_files_only,
+            legacy_cache_layout=legacy_cache_layout,
+        )
+
+    if cache_dir is None:
+        cache_dir = HF_HUB_CACHE
+    if revision is None:
+        revision = DEFAULT_REVISION
+    if isinstance(cache_dir, Path):
+        cache_dir = str(cache_dir)
+    if isinstance(local_dir, Path):
+        local_dir = str(local_dir)
+    locks_dir = os.path.join(cache_dir, ".locks")
+
+    if subfolder == "":
+        subfolder = None
+    if subfolder is not None:
+        # This is used to create a URL, and not a local path, hence the forward slash.
+        filename = f"{subfolder}/{filename}"
+
+    if repo_type is None:
+        repo_type = "model"
+    if repo_type not in REPO_TYPES:
+        raise ValueError(f"Invalid repo type: {repo_type}. Accepted repo types are: {str(REPO_TYPES)}")
+
+    storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type))
+    os.makedirs(storage_folder, exist_ok=True)
+
+    # cross platform transcription of filename, to be used as a local file path.
+    relative_filename = os.path.join(*filename.split("/"))
+    if os.name == "nt":
+        if relative_filename.startswith("..\\") or "\\..\\" in relative_filename:
+            raise ValueError(
+                f"Invalid filename: cannot handle filename '{relative_filename}' on Windows. Please ask the repository"
+                " owner to rename this file."
+            )
+
+    # if user provides a commit_hash and they already have the file on disk,
+    # shortcut everything.
+    if REGEX_COMMIT_HASH.match(revision):
+        pointer_path = _get_pointer_path(storage_folder, revision, relative_filename)
+        if os.path.exists(pointer_path):
+            if local_dir is not None:
+                return _to_local_dir(pointer_path, local_dir, relative_filename, use_symlinks=local_dir_use_symlinks)
+            return pointer_path
+
+    url = hf_hub_url(repo_id, filename, repo_type=repo_type, revision=revision, endpoint=endpoint)
+
+    headers = build_hf_headers(
+        token=token,
+        library_name=library_name,
+        library_version=library_version,
+        user_agent=user_agent,
+    )
+
+    url_to_download = url
+    etag = None
+    commit_hash = None
+    expected_size = None
+    head_call_error: Optional[Exception] = None
+    if not local_files_only:
+        try:
+            try:
+                metadata = get_hf_file_metadata(
+                    url=url,
+                    token=token,
+                    proxies=proxies,
+                    timeout=etag_timeout,
+                    library_name=library_name,
+                    library_version=library_version,
+                    user_agent=user_agent,
+                )
+            except EntryNotFoundError as http_error:
+                # Cache the non-existence of the file and raise
+                commit_hash = http_error.response.headers.get(HUGGINGFACE_HEADER_X_REPO_COMMIT)
+                if commit_hash is not None and not legacy_cache_layout:
+                    no_exist_file_path = Path(storage_folder) / ".no_exist" / commit_hash / relative_filename
+                    no_exist_file_path.parent.mkdir(parents=True, exist_ok=True)
+                    no_exist_file_path.touch()
+                    _cache_commit_hash_for_specific_revision(storage_folder, revision, commit_hash)
+                raise
+
+            # Commit hash must exist
+            commit_hash = metadata.commit_hash
+            if commit_hash is None:
+                raise FileMetadataError(
+                    "Distant resource does not seem to be on huggingface.co. It is possible that a configuration issue"
+                    " prevents you from downloading resources from https://huggingface.co. Please check your firewall"
+                    " and proxy settings and make sure your SSL certificates are updated."
+                )
+
+            # Etag must exist
+            etag = metadata.etag
+            # We favor a custom header indicating the etag of the linked resource, and
+            # we fallback to the regular etag header.
+            # If we don't have any of those, raise an error.
+            if etag is None:
+                raise FileMetadataError(
+                    "Distant resource does not have an ETag, we won't be able to reliably ensure reproducibility."
+                )
+
+            # Expected (uncompressed) size
+            expected_size = metadata.size
+
+            # In case of a redirect, save an extra redirect on the request.get call,
+            # and ensure we download the exact atomic version even if it changed
+            # between the HEAD and the GET (unlikely, but hey).
+            # Useful for lfs blobs that are stored on a CDN.
+            if metadata.location != url:
+                url_to_download = metadata.location
+                # Remove authorization header when downloading a LFS blob
+                headers.pop("authorization", None)
+        except (requests.exceptions.SSLError, requests.exceptions.ProxyError):
+            # Actually raise for those subclasses of ConnectionError
+            raise
+        except (
+            requests.exceptions.ConnectionError,
+            requests.exceptions.Timeout,
+            OfflineModeIsEnabled,
+        ) as error:
+            # Otherwise, our Internet connection is down.
+            # etag is None
+            head_call_error = error
+            pass
+        except (RevisionNotFoundError, EntryNotFoundError):
+            # The repo was found but the revision or entry doesn't exist on the Hub (never existed or got deleted)
+            raise
+        except requests.HTTPError as error:
+            # Multiple reasons for an http error:
+            # - Repository is private and invalid/missing token sent
+            # - Repository is gated and invalid/missing token sent
+            # - Hub is down (error 500 or 504)
+            # => let's switch to 'local_files_only=True' to check if the files are already cached.
+            #    (if it's not the case, the error will be re-raised)
+            head_call_error = error
+            pass
+        except FileMetadataError as error:
+            # Multiple reasons for a FileMetadataError:
+            # - Wrong network configuration (proxy, firewall, SSL certificates)
+            # - Inconsistency on the Hub
+            # => let's switch to 'local_files_only=True' to check if the files are already cached.
+            #    (if it's not the case, the error will be re-raised)
+            head_call_error = error
+            pass
+
+    # etag can be None for several reasons:
+    # 1. we passed local_files_only.
+    # 2. we don't have a connection
+    # 3. Hub is down (HTTP 500 or 504)
+    # 4. repo is not found -for example private or gated- and invalid/missing token sent
+    # 5. Hub is blocked by a firewall or proxy is not set correctly.
+    # => Try to get the last downloaded one from the specified revision.
+    #
+    # If the specified revision is a commit hash, look inside "snapshots".
+    # If the specified revision is a branch or tag, look inside "refs".
+    if etag is None:
+        # In those cases, we cannot force download.
+        if force_download:
+            raise ValueError(
+                "We have no connection or you passed local_files_only, so force_download is not an accepted option."
+            )
+
+        # Try to get "commit_hash" from "revision"
+        commit_hash = None
+        if REGEX_COMMIT_HASH.match(revision):
+            commit_hash = revision
+        else:
+            ref_path = os.path.join(storage_folder, "refs", revision)
+            if os.path.isfile(ref_path):
+                with open(ref_path) as f:
+                    commit_hash = f.read()
+
+        # Return pointer file if exists
+        if commit_hash is not None:
+            pointer_path = _get_pointer_path(storage_folder, commit_hash, relative_filename)
+            if os.path.exists(pointer_path):
+                if local_dir is not None:
+                    return _to_local_dir(
+                        pointer_path, local_dir, relative_filename, use_symlinks=local_dir_use_symlinks
+                    )
+                return pointer_path
+
+        # If we couldn't find an appropriate file on disk, raise an error.
+        # If files cannot be found and local_files_only=True,
+        # the models might've been found if local_files_only=False
+        # Notify the user about that
+        if local_files_only:
+            raise LocalEntryNotFoundError(
+                "Cannot find the requested files in the disk cache and outgoing traffic has been disabled. To enable"
+                " hf.co look-ups and downloads online, set 'local_files_only' to False."
+            )
+        elif isinstance(head_call_error, RepositoryNotFoundError) or isinstance(head_call_error, GatedRepoError):
+            # Repo not found => let's raise the actual error
+            raise head_call_error
+        else:
+            # Otherwise: most likely a connection issue or Hub downtime => let's warn the user
+            raise LocalEntryNotFoundError(
+                "An error happened while trying to locate the file on the Hub and we cannot find the requested files"
+                " in the local cache. Please check your connection and try again or make sure your Internet connection"
+                " is on."
+            ) from head_call_error
+
+    # From now on, etag and commit_hash are not None.
+    assert etag is not None, "etag must have been retrieved from server"
+    assert commit_hash is not None, "commit_hash must have been retrieved from server"
+    blob_path = os.path.join(storage_folder, "blobs", etag)
+    pointer_path = _get_pointer_path(storage_folder, commit_hash, relative_filename)
+
+    os.makedirs(os.path.dirname(blob_path), exist_ok=True)
+    os.makedirs(os.path.dirname(pointer_path), exist_ok=True)
+    # if passed revision is not identical to commit_hash
+    # then revision has to be a branch name or tag name.
+    # In that case store a ref.
+    _cache_commit_hash_for_specific_revision(storage_folder, revision, commit_hash)
+
+    if os.path.exists(pointer_path) and not force_download:
+        if local_dir is not None:
+            return _to_local_dir(pointer_path, local_dir, relative_filename, use_symlinks=local_dir_use_symlinks)
+        return pointer_path
+
+    if os.path.exists(blob_path) and not force_download:
+        # we have the blob already, but not the pointer
+        if local_dir is not None:  # to local dir
+            return _to_local_dir(blob_path, local_dir, relative_filename, use_symlinks=local_dir_use_symlinks)
+        else:  # or in snapshot cache
+            _create_symlink(blob_path, pointer_path, new_blob=False)
+            return pointer_path
+
+    # Prevent parallel downloads of the same file with a lock.
+    # etag could be duplicated across repos,
+    lock_path = os.path.join(locks_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type), f"{etag}.lock")
+
+    # Some Windows versions do not allow for paths longer than 255 characters.
+    # In this case, we must specify it is an extended path by using the "\\?\" prefix.
+    if os.name == "nt" and len(os.path.abspath(lock_path)) > 255:
+        lock_path = "\\\\?\\" + os.path.abspath(lock_path)
+
+    if os.name == "nt" and len(os.path.abspath(blob_path)) > 255:
+        blob_path = "\\\\?\\" + os.path.abspath(blob_path)
+
+    Path(lock_path).parent.mkdir(parents=True, exist_ok=True)
+    with FileLock(lock_path):
+        # If the download just completed while the lock was activated.
+        if os.path.exists(pointer_path) and not force_download:
+            # Even if returning early like here, the lock will be released.
+            if local_dir is not None:
+                return _to_local_dir(pointer_path, local_dir, relative_filename, use_symlinks=local_dir_use_symlinks)
+            return pointer_path
+
+        if resume_download:
+            incomplete_path = blob_path + ".incomplete"
+
+            @contextmanager
+            def _resumable_file_manager() -> Generator[io.BufferedWriter, None, None]:
+                with open(incomplete_path, "ab") as f:
+                    yield f
+
+            temp_file_manager = _resumable_file_manager
+            if os.path.exists(incomplete_path):
+                resume_size = os.stat(incomplete_path).st_size
+            else:
+                resume_size = 0
+        else:
+            temp_file_manager = partial(  # type: ignore
+                tempfile.NamedTemporaryFile, mode="wb", dir=cache_dir, delete=False
+            )
+            resume_size = 0
+
+        # Download to temporary file, then copy to cache dir once finished.
+        # Otherwise you get corrupt cache entries if the download gets interrupted.
+        with temp_file_manager() as temp_file:
+            logger.info("downloading %s to %s", url, temp_file.name)
+
+            if expected_size is not None:  # might be None if HTTP header not set correctly
+                # Check tmp path
+                _check_disk_space(expected_size, os.path.dirname(temp_file.name))
+
+                # Check destination
+                _check_disk_space(expected_size, os.path.dirname(blob_path))
+                if local_dir is not None:
+                    _check_disk_space(expected_size, local_dir)
+
+            http_get(
+                url_to_download,
+                temp_file,
+                proxies=proxies,
+                resume_size=resume_size,
+                headers=headers,
+                expected_size=expected_size,
+            )
+
+        if local_dir is None:
+            logger.debug(f"Storing {url} in cache at {blob_path}")
+            _chmod_and_replace(temp_file.name, blob_path)
+            _create_symlink(blob_path, pointer_path, new_blob=True)
+        else:
+            local_dir_filepath = os.path.join(local_dir, relative_filename)
+            os.makedirs(os.path.dirname(local_dir_filepath), exist_ok=True)
+
+            # If "auto" (default) copy-paste small files to ease manual editing but symlink big files to save disk
+            # In both cases, blob file is cached.
+            is_big_file = os.stat(temp_file.name).st_size > constants.HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD
+            if local_dir_use_symlinks is True or (local_dir_use_symlinks == "auto" and is_big_file):
+                logger.debug(f"Storing {url} in cache at {blob_path}")
+                _chmod_and_replace(temp_file.name, blob_path)
+                logger.debug("Create symlink to local dir")
+                _create_symlink(blob_path, local_dir_filepath, new_blob=False)
+            elif local_dir_use_symlinks == "auto" and not is_big_file:
+                logger.debug(f"Storing {url} in cache at {blob_path}")
+                _chmod_and_replace(temp_file.name, blob_path)
+                logger.debug("Duplicate in local dir (small file and use_symlink set to 'auto')")
+                shutil.copyfile(blob_path, local_dir_filepath)
+            else:
+                logger.debug(f"Storing {url} in local_dir at {local_dir_filepath} (not cached).")
+                _chmod_and_replace(temp_file.name, local_dir_filepath)
+            pointer_path = local_dir_filepath  # for return value
+
+    return pointer_path
+
+
+@validate_hf_hub_args
+def try_to_load_from_cache(
+    repo_id: str,
+    filename: str,
+    cache_dir: Union[str, Path, None] = None,
+    revision: Optional[str] = None,
+    repo_type: Optional[str] = None,
+) -> Union[str, _CACHED_NO_EXIST_T, None]:
+    """
+    Explores the cache to return the latest cached file for a given revision if found.
+
+    This function will not raise any exception if the file in not cached.
+
+    Args:
+        cache_dir (`str` or `os.PathLike`):
+            The folder where the cached files lie.
+        repo_id (`str`):
+            The ID of the repo on huggingface.co.
+        filename (`str`):
+            The filename to look for inside `repo_id`.
+        revision (`str`, *optional*):
+            The specific model version to use. Will default to `"main"` if it's not provided and no `commit_hash` is
+            provided either.
+        repo_type (`str`, *optional*):
+            The type of the repository. Will default to `"model"`.
+
+    Returns:
+        `Optional[str]` or `_CACHED_NO_EXIST`:
+            Will return `None` if the file was not cached. Otherwise:
+            - The exact path to the cached file if it's found in the cache
+            - A special value `_CACHED_NO_EXIST` if the file does not exist at the given commit hash and this fact was
+              cached.
+
+    Example:
+
+    ```python
+    from huggingface_hub import try_to_load_from_cache, _CACHED_NO_EXIST
+
+    filepath = try_to_load_from_cache()
+    if isinstance(filepath, str):
+        # file exists and is cached
+        ...
+    elif filepath is _CACHED_NO_EXIST:
+        # non-existence of file is cached
+        ...
+    else:
+        # file is not cached
+        ...
+    ```
+    """
+    if revision is None:
+        revision = "main"
+    if repo_type is None:
+        repo_type = "model"
+    if repo_type not in REPO_TYPES:
+        raise ValueError(f"Invalid repo type: {repo_type}. Accepted repo types are: {str(REPO_TYPES)}")
+    if cache_dir is None:
+        cache_dir = HF_HUB_CACHE
+
+    object_id = repo_id.replace("/", "--")
+    repo_cache = os.path.join(cache_dir, f"{repo_type}s--{object_id}")
+    if not os.path.isdir(repo_cache):
+        # No cache for this model
+        return None
+
+    refs_dir = os.path.join(repo_cache, "refs")
+    snapshots_dir = os.path.join(repo_cache, "snapshots")
+    no_exist_dir = os.path.join(repo_cache, ".no_exist")
+
+    # Resolve refs (for instance to convert main to the associated commit sha)
+    if os.path.isdir(refs_dir):
+        revision_file = os.path.join(refs_dir, revision)
+        if os.path.isfile(revision_file):
+            with open(revision_file) as f:
+                revision = f.read()
+
+    # Check if file is cached as "no_exist"
+    if os.path.isfile(os.path.join(no_exist_dir, revision, filename)):
+        return _CACHED_NO_EXIST
+
+    # Check if revision folder exists
+    if not os.path.exists(snapshots_dir):
+        return None
+    cached_shas = os.listdir(snapshots_dir)
+    if revision not in cached_shas:
+        # No cache for this revision and we won't try to return a random revision
+        return None
+
+    # Check if file exists in cache
+    cached_file = os.path.join(snapshots_dir, revision, filename)
+    return cached_file if os.path.isfile(cached_file) else None
+
+
+@validate_hf_hub_args
+def get_hf_file_metadata(
+    url: str,
+    token: Union[bool, str, None] = None,
+    proxies: Optional[Dict] = None,
+    timeout: Optional[float] = DEFAULT_REQUEST_TIMEOUT,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    user_agent: Union[Dict, str, None] = None,
+) -> HfFileMetadata:
+    """Fetch metadata of a file versioned on the Hub for a given url.
+
+    Args:
+        url (`str`):
+            File url, for example returned by [`hf_hub_url`].
+        token (`str` or `bool`, *optional*):
+            A token to be used for the download.
+                - If `True`, the token is read from the HuggingFace config
+                  folder.
+                - If `False` or `None`, no token is provided.
+                - If a string, it's used as the authentication token.
+        proxies (`dict`, *optional*):
+            Dictionary mapping protocol to the URL of the proxy passed to
+            `requests.request`.
+        timeout (`float`, *optional*, defaults to 10):
+            How many seconds to wait for the server to send metadata before giving up.
+        library_name (`str`, *optional*):
+            The name of the library to which the object corresponds.
+        library_version (`str`, *optional*):
+            The version of the library.
+        user_agent (`dict`, `str`, *optional*):
+            The user-agent info in the form of a dictionary or a string.
+
+    Returns:
+        A [`HfFileMetadata`] object containing metadata such as location, etag, size and
+        commit_hash.
+    """
+    headers = build_hf_headers(
+        token=token, library_name=library_name, library_version=library_version, user_agent=user_agent
+    )
+    headers["Accept-Encoding"] = "identity"  # prevent any compression => we want to know the real size of the file
+
+    # Retrieve metadata
+    r = _request_wrapper(
+        method="HEAD",
+        url=url,
+        headers=headers,
+        allow_redirects=False,
+        follow_relative_redirects=True,
+        proxies=proxies,
+        timeout=timeout,
+    )
+    hf_raise_for_status(r)
+
+    # Return
+    return HfFileMetadata(
+        commit_hash=r.headers.get(HUGGINGFACE_HEADER_X_REPO_COMMIT),
+        # We favor a custom header indicating the etag of the linked resource, and
+        # we fallback to the regular etag header.
+        etag=_normalize_etag(r.headers.get(HUGGINGFACE_HEADER_X_LINKED_ETAG) or r.headers.get("ETag")),
+        # Either from response headers (if redirected) or defaults to request url
+        # Do not use directly `url`, as `_request_wrapper` might have followed relative
+        # redirects.
+        location=r.headers.get("Location") or r.request.url,  # type: ignore
+        size=_int_or_none(r.headers.get(HUGGINGFACE_HEADER_X_LINKED_SIZE) or r.headers.get("Content-Length")),
+    )
+
+
+def _int_or_none(value: Optional[str]) -> Optional[int]:
+    try:
+        return int(value)  # type: ignore
+    except (TypeError, ValueError):
+        return None
+
+
+def _chmod_and_replace(src: str, dst: str) -> None:
+    """Set correct permission before moving a blob from tmp directory to cache dir.
+
+    Do not take into account the `umask` from the process as there is no convenient way
+    to get it that is thread-safe.
+
+    See:
+    - About umask: https://docs.python.org/3/library/os.html#os.umask
+    - Thread-safety: https://stackoverflow.com/a/70343066
+    - About solution: https://github.com/huggingface/huggingface_hub/pull/1220#issuecomment-1326211591
+    - Fix issue: https://github.com/huggingface/huggingface_hub/issues/1141
+    - Fix issue: https://github.com/huggingface/huggingface_hub/issues/1215
+    """
+    # Get umask by creating a temporary file in the cached repo folder.
+    tmp_file = Path(dst).parent.parent / f"tmp_{uuid.uuid4()}"
+    try:
+        tmp_file.touch()
+        cache_dir_mode = Path(tmp_file).stat().st_mode
+        os.chmod(src, stat.S_IMODE(cache_dir_mode))
+    finally:
+        tmp_file.unlink()
+
+    shutil.move(src, dst)
+
+
+def _get_pointer_path(storage_folder: str, revision: str, relative_filename: str) -> str:
+    # Using `os.path.abspath` instead of `Path.resolve()` to avoid resolving symlinks
+    snapshot_path = os.path.join(storage_folder, "snapshots")
+    pointer_path = os.path.join(snapshot_path, revision, relative_filename)
+    if Path(os.path.abspath(snapshot_path)) not in Path(os.path.abspath(pointer_path)).parents:
+        raise ValueError(
+            "Invalid pointer path: cannot create pointer path in snapshot folder if"
+            f" `storage_folder='{storage_folder}'`, `revision='{revision}'` and"
+            f" `relative_filename='{relative_filename}'`."
+        )
+    return pointer_path
+
+
+def _to_local_dir(
+    path: str, local_dir: str, relative_filename: str, use_symlinks: Union[bool, Literal["auto"]]
+) -> str:
+    """Place a file in a local dir (different than cache_dir).
+
+    Either symlink to blob file in cache or duplicate file depending on `use_symlinks` and file size.
+    """
+    # Using `os.path.abspath` instead of `Path.resolve()` to avoid resolving symlinks
+    local_dir_filepath = os.path.join(local_dir, relative_filename)
+    if Path(os.path.abspath(local_dir)) not in Path(os.path.abspath(local_dir_filepath)).parents:
+        raise ValueError(
+            f"Cannot copy file '{relative_filename}' to local dir '{local_dir}': file would not be in the local"
+            " directory."
+        )
+
+    os.makedirs(os.path.dirname(local_dir_filepath), exist_ok=True)
+    real_blob_path = os.path.realpath(path)
+
+    # If "auto" (default) copy-paste small files to ease manual editing but symlink big files to save disk
+    if use_symlinks == "auto":
+        use_symlinks = os.stat(real_blob_path).st_size > constants.HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD
+
+    if use_symlinks:
+        _create_symlink(real_blob_path, local_dir_filepath, new_blob=False)
+    else:
+        shutil.copyfile(real_blob_path, local_dir_filepath)
+    return local_dir_filepath
diff --git a/lib/python3.11/site-packages/huggingface_hub/hf_api.py b/lib/python3.11/site-packages/huggingface_hub/hf_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..6698da0f715228ec1331fadc9eb3376e52a98f76
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/hf_api.py
@@ -0,0 +1,8405 @@
+# coding=utf-8
+# Copyright 2019-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import inspect
+import json
+import re
+import struct
+import warnings
+from concurrent.futures import Future, ThreadPoolExecutor
+from dataclasses import dataclass, field
+from datetime import datetime
+from functools import wraps
+from itertools import islice
+from pathlib import Path
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypedDict,
+    TypeVar,
+    Union,
+    overload,
+)
+from urllib.parse import quote, urlencode
+
+import requests
+from requests.exceptions import HTTPError
+from tqdm.auto import tqdm as base_tqdm
+from tqdm.contrib.concurrent import thread_map
+
+from ._commit_api import (
+    CommitOperation,
+    CommitOperationAdd,
+    CommitOperationCopy,
+    CommitOperationDelete,
+    _fetch_lfs_files_to_copy,
+    _fetch_upload_modes,
+    _prepare_commit_payload,
+    _upload_lfs_files,
+    _warn_on_overwriting_operations,
+)
+from ._inference_endpoints import InferenceEndpoint, InferenceEndpointType
+from ._multi_commits import (
+    MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_BAD_REQUEST_TEMPLATE,
+    MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_NO_CHANGES_TEMPLATE,
+    MULTI_COMMIT_PR_CLOSING_COMMENT_TEMPLATE,
+    MULTI_COMMIT_PR_COMPLETION_COMMENT_TEMPLATE,
+    MultiCommitException,
+    MultiCommitStep,
+    MultiCommitStrategy,
+    multi_commit_create_pull_request,
+    multi_commit_generate_comment,
+    multi_commit_parse_pr_description,
+    plan_multi_commits,
+)
+from ._space_api import SpaceHardware, SpaceRuntime, SpaceStorage, SpaceVariable
+from .community import (
+    Discussion,
+    DiscussionComment,
+    DiscussionStatusChange,
+    DiscussionTitleChange,
+    DiscussionWithDetails,
+    deserialize_event,
+)
+from .constants import (
+    DEFAULT_ETAG_TIMEOUT,
+    DEFAULT_REQUEST_TIMEOUT,
+    DEFAULT_REVISION,
+    DISCUSSION_STATUS,
+    DISCUSSION_TYPES,
+    ENDPOINT,
+    INFERENCE_ENDPOINTS_ENDPOINT,
+    REGEX_COMMIT_OID,
+    REPO_TYPE_MODEL,
+    REPO_TYPES,
+    REPO_TYPES_MAPPING,
+    REPO_TYPES_URL_PREFIXES,
+    SAFETENSORS_INDEX_FILE,
+    SAFETENSORS_MAX_HEADER_LENGTH,
+    SAFETENSORS_SINGLE_FILE,
+    SPACES_SDK_TYPES,
+    DiscussionStatusFilter,
+    DiscussionTypeFilter,
+)
+from .file_download import HfFileMetadata, get_hf_file_metadata, hf_hub_url
+from .repocard_data import DatasetCardData, ModelCardData, SpaceCardData
+from .utils import (  # noqa: F401 # imported for backward compatibility
+    IGNORE_GIT_FOLDER_PATTERNS,
+    BadRequestError,
+    EntryNotFoundError,
+    GatedRepoError,
+    HfFolder,
+    HfHubHTTPError,
+    LocalTokenNotFoundError,
+    NotASafetensorsRepoError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+    SafetensorsFileMetadata,
+    SafetensorsParsingError,
+    SafetensorsRepoMetadata,
+    TensorInfo,
+    build_hf_headers,
+    experimental,
+    filter_repo_objects,
+    get_session,
+    hf_raise_for_status,
+    logging,
+    paginate,
+    parse_datetime,
+    validate_hf_hub_args,
+)
+from .utils import tqdm as hf_tqdm
+from .utils._deprecation import _deprecate_method
+from .utils._typing import CallableT
+from .utils.endpoint_helpers import (
+    DatasetFilter,
+    ModelFilter,
+    _is_emission_within_treshold,
+)
+
+
+R = TypeVar("R")  # Return type
+CollectionItemType_T = Literal["model", "dataset", "space", "paper"]
+
+USERNAME_PLACEHOLDER = "hf_user"
+_REGEX_DISCUSSION_URL = re.compile(r".*/discussions/(\d+)$")
+
+_CREATE_COMMIT_NO_REPO_ERROR_MESSAGE = (
+    "\nNote: Creating a commit assumes that the repo already exists on the"
+    " Huggingface Hub. Please use `create_repo` if it's not the case."
+)
+
+logger = logging.get_logger(__name__)
+
+
+def repo_type_and_id_from_hf_id(hf_id: str, hub_url: Optional[str] = None) -> Tuple[Optional[str], Optional[str], str]:
+    """
+    Returns the repo type and ID from a huggingface.co URL linking to a
+    repository
+
+    Args:
+        hf_id (`str`):
+            An URL or ID of a repository on the HF hub. Accepted values are:
+
+            - https://huggingface.co/<repo_type>/<namespace>/<repo_id>
+            - https://huggingface.co/<namespace>/<repo_id>
+            - hf://<repo_type>/<namespace>/<repo_id>
+            - hf://<namespace>/<repo_id>
+            - <repo_type>/<namespace>/<repo_id>
+            - <namespace>/<repo_id>
+            - <repo_id>
+        hub_url (`str`, *optional*):
+            The URL of the HuggingFace Hub, defaults to https://huggingface.co
+
+    Returns:
+        A tuple with three items: repo_type (`str` or `None`), namespace (`str` or
+        `None`) and repo_id (`str`).
+
+    Raises:
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If URL cannot be parsed.
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `repo_type` is unknown.
+    """
+    input_hf_id = hf_id
+    hub_url = re.sub(r"https?://", "", hub_url if hub_url is not None else ENDPOINT)
+    is_hf_url = hub_url in hf_id and "@" not in hf_id
+
+    HFFS_PREFIX = "hf://"
+    if hf_id.startswith(HFFS_PREFIX):  # Remove "hf://" prefix if exists
+        hf_id = hf_id[len(HFFS_PREFIX) :]
+
+    url_segments = hf_id.split("/")
+    is_hf_id = len(url_segments) <= 3
+
+    namespace: Optional[str]
+    if is_hf_url:
+        namespace, repo_id = url_segments[-2:]
+        if namespace == hub_url:
+            namespace = None
+        if len(url_segments) > 2 and hub_url not in url_segments[-3]:
+            repo_type = url_segments[-3]
+        elif namespace in REPO_TYPES_MAPPING:
+            # Mean canonical dataset or model
+            repo_type = REPO_TYPES_MAPPING[namespace]
+            namespace = None
+        else:
+            repo_type = None
+    elif is_hf_id:
+        if len(url_segments) == 3:
+            # Passed <repo_type>/<user>/<model_id> or <repo_type>/<org>/<model_id>
+            repo_type, namespace, repo_id = url_segments[-3:]
+        elif len(url_segments) == 2:
+            if url_segments[0] in REPO_TYPES_MAPPING:
+                # Passed '<model_id>' or 'datasets/<dataset_id>' for a canonical model or dataset
+                repo_type = REPO_TYPES_MAPPING[url_segments[0]]
+                namespace = None
+                repo_id = hf_id.split("/")[-1]
+            else:
+                # Passed <user>/<model_id> or <org>/<model_id>
+                namespace, repo_id = hf_id.split("/")[-2:]
+                repo_type = None
+        else:
+            # Passed <model_id>
+            repo_id = url_segments[0]
+            namespace, repo_type = None, None
+    else:
+        raise ValueError(f"Unable to retrieve user and repo ID from the passed HF ID: {hf_id}")
+
+    # Check if repo type is known (mapping "spaces" => "space" + empty value => `None`)
+    if repo_type in REPO_TYPES_MAPPING:
+        repo_type = REPO_TYPES_MAPPING[repo_type]
+    if repo_type == "":
+        repo_type = None
+    if repo_type not in REPO_TYPES:
+        raise ValueError(f"Unknown `repo_type`: '{repo_type}' ('{input_hf_id}')")
+
+    return repo_type, namespace, repo_id
+
+
+class LastCommitInfo(TypedDict, total=False):
+    oid: str
+    title: str
+    date: datetime
+
+
+class BlobLfsInfo(TypedDict, total=False):
+    size: int
+    sha256: str
+    pointer_size: int
+
+
+class BlobSecurityInfo(TypedDict, total=False):
+    safe: bool
+    av_scan: Optional[Dict]
+    pickle_import_scan: Optional[Dict]
+
+
+class TransformersInfo(TypedDict, total=False):
+    auto_model: str
+    custom_class: Optional[str]
+    # possible `pipeline_tag` values: https://github.com/huggingface/huggingface.js/blob/3ee32554b8620644a6287e786b2a83bf5caf559c/packages/tasks/src/pipelines.ts#L72
+    pipeline_tag: Optional[str]
+    processor: Optional[str]
+
+
+class SafeTensorsInfo(TypedDict, total=False):
+    parameters: List[Dict[str, int]]
+    total: int
+
+
+@dataclass
+class CommitInfo(str):
+    """Data structure containing information about a newly created commit.
+
+    Returned by any method that creates a commit on the Hub: [`create_commit`], [`upload_file`], [`upload_folder`],
+    [`delete_file`], [`delete_folder`]. It inherits from `str` for backward compatibility but using methods specific
+    to `str` is deprecated.
+
+    Attributes:
+        commit_url (`str`):
+            Url where to find the commit.
+
+        commit_message (`str`):
+            The summary (first line) of the commit that has been created.
+
+        commit_description (`str`):
+            Description of the commit that has been created. Can be empty.
+
+        oid (`str`):
+            Commit hash id. Example: `"91c54ad1727ee830252e457677f467be0bfd8a57"`.
+
+        pr_url (`str`, *optional*):
+            Url to the PR that has been created, if any. Populated when `create_pr=True`
+            is passed.
+
+        pr_revision (`str`, *optional*):
+            Revision of the PR that has been created, if any. Populated when
+            `create_pr=True` is passed. Example: `"refs/pr/1"`.
+
+        pr_num (`int`, *optional*):
+            Number of the PR discussion that has been created, if any. Populated when
+            `create_pr=True` is passed. Can be passed as `discussion_num` in
+            [`get_discussion_details`]. Example: `1`.
+
+        _url (`str`, *optional*):
+            Legacy url for `str` compatibility. Can be the url to the uploaded file on the Hub (if returned by
+            [`upload_file`]), to the uploaded folder on the Hub (if returned by [`upload_folder`]) or to the commit on
+            the Hub (if returned by [`create_commit`]). Defaults to `commit_url`. It is deprecated to use this
+            attribute. Please use `commit_url` instead.
+    """
+
+    commit_url: str
+    commit_message: str
+    commit_description: str
+    oid: str
+    pr_url: Optional[str] = None
+
+    # Computed from `pr_url` in `__post_init__`
+    pr_revision: Optional[str] = field(init=False)
+    pr_num: Optional[str] = field(init=False)
+
+    # legacy url for `str` compatibility (ex: url to uploaded file, url to uploaded folder, url to PR, etc.)
+    _url: str = field(repr=False, default=None)  # type: ignore  # defaults to `commit_url`
+
+    def __new__(cls, *args, commit_url: str, _url: Optional[str] = None, **kwargs):
+        return str.__new__(cls, _url or commit_url)
+
+    def __post_init__(self):
+        """Populate pr-related fields after initialization.
+
+        See https://docs.python.org/3.10/library/dataclasses.html#post-init-processing.
+        """
+        if self.pr_url is not None:
+            self.pr_revision = _parse_revision_from_pr_url(self.pr_url)
+            self.pr_num = int(self.pr_revision.split("/")[-1])
+        else:
+            self.pr_revision = None
+            self.pr_num = None
+
+
+@dataclass
+class AccessRequest:
+    """Data structure containing information about a user access request.
+
+    Attributes:
+        username (`str`):
+            Username of the user who requested access.
+        fullname (`str`):
+            Fullname of the user who requested access.
+        email (`str`):
+            Email of the user who requested access.
+        timestamp (`datetime`):
+            Timestamp of the request.
+        status (`Literal["pending", "accepted", "rejected"]`):
+            Status of the request. Can be one of `["pending", "accepted", "rejected"]`.
+        fields (`Dict[str, Any]`, *optional*):
+            Additional fields filled by the user in the gate form.
+    """
+
+    username: str
+    fullname: str
+    email: str
+    timestamp: datetime
+    status: Literal["pending", "accepted", "rejected"]
+
+    # Additional fields filled by the user in the gate form
+    fields: Optional[Dict[str, Any]] = None
+
+
+class RepoUrl(str):
+    """Subclass of `str` describing a repo URL on the Hub.
+
+    `RepoUrl` is returned by `HfApi.create_repo`. It inherits from `str` for backward
+    compatibility. At initialization, the URL is parsed to populate properties:
+    - endpoint (`str`)
+    - namespace (`Optional[str]`)
+    - repo_name (`str`)
+    - repo_id (`str`)
+    - repo_type (`Literal["model", "dataset", "space"]`)
+    - url (`str`)
+
+    Args:
+        url (`Any`):
+            String value of the repo url.
+        endpoint (`str`, *optional*):
+            Endpoint of the Hub. Defaults to <https://huggingface.co>.
+
+    Example:
+    ```py
+    >>> RepoUrl('https://huggingface.co/gpt2')
+    RepoUrl('https://huggingface.co/gpt2', endpoint='https://huggingface.co', repo_type='model', repo_id='gpt2')
+
+    >>> RepoUrl('https://hub-ci.huggingface.co/datasets/dummy_user/dummy_dataset', endpoint='https://hub-ci.huggingface.co')
+    RepoUrl('https://hub-ci.huggingface.co/datasets/dummy_user/dummy_dataset', endpoint='https://hub-ci.huggingface.co', repo_type='dataset', repo_id='dummy_user/dummy_dataset')
+
+    >>> RepoUrl('hf://datasets/my-user/my-dataset')
+    RepoUrl('hf://datasets/my-user/my-dataset', endpoint='https://huggingface.co', repo_type='dataset', repo_id='user/dataset')
+
+    >>> HfApi.create_repo("dummy_model")
+    RepoUrl('https://huggingface.co/Wauplin/dummy_model', endpoint='https://huggingface.co', repo_type='model', repo_id='Wauplin/dummy_model')
+    ```
+
+    Raises:
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If URL cannot be parsed.
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `repo_type` is unknown.
+    """
+
+    def __new__(cls, url: Any, endpoint: Optional[str] = None):
+        return super(RepoUrl, cls).__new__(cls, url)
+
+    def __init__(self, url: Any, endpoint: Optional[str] = None) -> None:
+        super().__init__()
+        # Parse URL
+        self.endpoint = endpoint or ENDPOINT
+        repo_type, namespace, repo_name = repo_type_and_id_from_hf_id(self, hub_url=self.endpoint)
+
+        # Populate fields
+        self.namespace = namespace
+        self.repo_name = repo_name
+        self.repo_id = repo_name if namespace is None else f"{namespace}/{repo_name}"
+        self.repo_type = repo_type or REPO_TYPE_MODEL
+        self.url = str(self)  # just in case it's needed
+
+    def __repr__(self) -> str:
+        return f"RepoUrl('{self}', endpoint='{self.endpoint}', repo_type='{self.repo_type}', repo_id='{self.repo_id}')"
+
+
+@dataclass
+class RepoSibling:
+    """
+    Contains basic information about a repo file inside a repo on the Hub.
+
+    <Tip>
+
+    All attributes of this class are optional except `rfilename`. This is because only the file names are returned when
+    listing repositories on the Hub (with [`list_models`], [`list_datasets`] or [`list_spaces`]). If you need more
+    information like file size, blob id or lfs details, you must request them specifically from one repo at a time
+    (using [`model_info`], [`dataset_info`] or [`space_info`]) as it adds more constraints on the backend server to
+    retrieve these.
+
+    </Tip>
+
+    Attributes:
+        rfilename (str):
+            file name, relative to the repo root.
+        size (`int`, *optional*):
+            The file's size, in bytes. This attribute is defined when `files_metadata` argument of [`repo_info`] is set
+            to `True`. It's `None` otherwise.
+        blob_id (`str`, *optional*):
+            The file's git OID. This attribute is defined when `files_metadata` argument of [`repo_info`] is set to
+            `True`. It's `None` otherwise.
+        lfs (`BlobLfsInfo`, *optional*):
+            The file's LFS metadata. This attribute is defined when`files_metadata` argument of [`repo_info`] is set to
+            `True` and the file is stored with Git LFS. It's `None` otherwise.
+    """
+
+    rfilename: str
+    size: Optional[int] = None
+    blob_id: Optional[str] = None
+    lfs: Optional[BlobLfsInfo] = None
+
+
+@dataclass
+class RepoFile:
+    """
+    Contains information about a file on the Hub.
+
+    Attributes:
+        path (str):
+            file path relative to the repo root.
+        size (`int`):
+            The file's size, in bytes.
+        blob_id (`str`):
+            The file's git OID.
+        lfs (`BlobLfsInfo`):
+            The file's LFS metadata.
+        last_commit (`LastCommitInfo`, *optional*):
+            The file's last commit metadata. Only defined if [`list_files_info`], [`list_repo_tree`] and [`get_paths_info`]
+            are called with `expand=True`.
+        security (`BlobSecurityInfo`, *optional*):
+            The file's security scan metadata. Only defined if [`list_files_info`], [`list_repo_tree`] and [`get_paths_info`]
+            are called with `expand=True`.
+    """
+
+    path: str
+    size: int
+    blob_id: str
+    lfs: Optional[BlobLfsInfo] = None
+    last_commit: Optional[LastCommitInfo] = None
+    security: Optional[BlobSecurityInfo] = None
+
+    def __init__(self, **kwargs):
+        self.path = kwargs.pop("path")
+        self.size = kwargs.pop("size")
+        self.blob_id = kwargs.pop("oid")
+        lfs = kwargs.pop("lfs", None)
+        if lfs is not None:
+            lfs = BlobLfsInfo(size=lfs["size"], sha256=lfs["oid"], pointer_size=lfs["pointerSize"])
+        self.lfs = lfs
+        last_commit = kwargs.pop("lastCommit", None) or kwargs.pop("last_commit", None)
+        if last_commit is not None:
+            last_commit = LastCommitInfo(
+                oid=last_commit["id"], title=last_commit["title"], date=parse_datetime(last_commit["date"])
+            )
+        self.last_commit = last_commit
+        security = kwargs.pop("security", None)
+        if security is not None:
+            security = BlobSecurityInfo(
+                safe=security["safe"], av_scan=security["avScan"], pickle_import_scan=security["pickleImportScan"]
+            )
+        self.security = security
+
+        # backwards compatibility
+        self.rfilename = self.path
+        self.lastCommit = self.last_commit
+
+
+@dataclass
+class RepoFolder:
+    """
+    Contains information about a folder on the Hub.
+
+    Attributes:
+        path (str):
+            folder path relative to the repo root.
+        tree_id (`str`):
+            The folder's git OID.
+        last_commit (`LastCommitInfo`, *optional*):
+            The folder's last commit metadata. Only defined if [`list_repo_tree`] and [`get_paths_info`]
+            are called with `expand=True`.
+    """
+
+    path: str
+    tree_id: str
+    last_commit: Optional[LastCommitInfo] = None
+
+    def __init__(self, **kwargs):
+        self.path = kwargs.pop("path")
+        self.tree_id = kwargs.pop("oid")
+        last_commit = kwargs.pop("lastCommit", None) or kwargs.pop("last_commit", None)
+        if last_commit is not None:
+            last_commit = LastCommitInfo(
+                oid=last_commit["id"], title=last_commit["title"], date=parse_datetime(last_commit["date"])
+            )
+        self.last_commit = last_commit
+
+
+@dataclass
+class ModelInfo:
+    """
+    Contains information about a model on the Hub.
+
+    <Tip>
+
+    Most attributes of this class are optional. This is because the data returned by the Hub depends on the query made.
+    In general, the more specific the query, the more information is returned. On the contrary, when listing models
+    using [`list_models`] only a subset of the attributes are returned.
+
+    </Tip>
+
+    Attributes:
+        id (`str`):
+            ID of model.
+        author (`str`, *optional*):
+            Author of the model.
+        sha (`str`, *optional*):
+            Repo SHA at this particular revision.
+        created_at (`datetime`, *optional*):
+            Date of creation of the repo on the Hub. Note that the lowest value is `2022-03-02T23:29:04.000Z`,
+            corresponding to the date when we began to store creation dates.
+        last_modified (`datetime`, *optional*):
+            Date of last commit to the repo.
+        private (`bool`):
+            Is the repo private.
+        disabled (`bool`, *optional*):
+            Is the repo disabled.
+        gated (`Literal["auto", "manual", False]`, *optional*):
+            Is the repo gated.
+            If so, whether there is manual or automatic approval.
+        downloads (`int`):
+            Number of downloads of the model.
+        likes (`int`):
+            Number of likes of the model.
+        library_name (`str`, *optional*):
+            Library associated with the model.
+        tags (`List[str]`):
+            List of tags of the model. Compared to `card_data.tags`, contains extra tags computed by the Hub
+            (e.g. supported libraries, model's arXiv).
+        pipeline_tag (`str`, *optional*):
+            Pipeline tag associated with the model.
+        mask_token (`str`, *optional*):
+            Mask token used by the model.
+        widget_data (`Any`, *optional*):
+            Widget data associated with the model.
+        model_index (`Dict`, *optional*):
+            Model index for evaluation.
+        config (`Dict`, *optional*):
+            Model configuration.
+        transformers_info (`TransformersInfo`, *optional*):
+            Transformers-specific info (auto class, processor, etc.) associated with the model.
+        card_data (`ModelCardData`, *optional*):
+            Model Card Metadata  as a [`huggingface_hub.repocard_data.ModelCardData`] object.
+        siblings (`List[RepoSibling]`):
+            List of [`huggingface_hub.hf_api.RepoSibling`] objects that constitute the model.
+        spaces (`List[str]`, *optional*):
+            List of spaces using the model.
+        safetensors (`SafeTensorsInfo`, *optional*):
+            Model's safetensors information.
+    """
+
+    id: str
+    author: Optional[str]
+    sha: Optional[str]
+    created_at: Optional[datetime]
+    last_modified: Optional[datetime]
+    private: bool
+    gated: Optional[Literal["auto", "manual", False]]
+    disabled: Optional[bool]
+    downloads: int
+    likes: int
+    library_name: Optional[str]
+    tags: List[str]
+    pipeline_tag: Optional[str]
+    mask_token: Optional[str]
+    card_data: Optional[ModelCardData]
+    widget_data: Optional[Any]
+    model_index: Optional[Dict]
+    config: Optional[Dict]
+    transformers_info: Optional[TransformersInfo]
+    siblings: Optional[List[RepoSibling]]
+    spaces: Optional[List[str]]
+    safetensors: Optional[SafeTensorsInfo]
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.author = kwargs.pop("author", None)
+        self.sha = kwargs.pop("sha", None)
+        last_modified = kwargs.pop("lastModified", None) or kwargs.pop("last_modified", None)
+        self.last_modified = parse_datetime(last_modified) if last_modified else None
+        created_at = kwargs.pop("createdAt", None) or kwargs.pop("created_at", None)
+        self.created_at = parse_datetime(created_at) if created_at else None
+        self.private = kwargs.pop("private")
+        self.gated = kwargs.pop("gated", None)
+        self.disabled = kwargs.pop("disabled", None)
+        self.downloads = kwargs.pop("downloads")
+        self.likes = kwargs.pop("likes")
+        self.library_name = kwargs.pop("library_name", None)
+        self.tags = kwargs.pop("tags")
+        self.pipeline_tag = kwargs.pop("pipeline_tag", None)
+        self.mask_token = kwargs.pop("mask_token", None)
+        card_data = kwargs.pop("cardData", None) or kwargs.pop("card_data", None)
+        self.card_data = (
+            ModelCardData(**card_data, ignore_metadata_errors=True) if isinstance(card_data, dict) else card_data
+        )
+
+        self.widget_data = kwargs.pop("widget_data", None)
+        self.model_index = kwargs.pop("model-index", None) or kwargs.pop("model_index", None)
+        self.config = kwargs.pop("config", None)
+        transformers_info = kwargs.pop("transformersInfo", None) or kwargs.pop("transformers_info", None)
+        self.transformers_info = TransformersInfo(**transformers_info) if transformers_info else None
+        siblings = kwargs.pop("siblings", None)
+        self.siblings = (
+            [
+                RepoSibling(
+                    rfilename=sibling["rfilename"],
+                    size=sibling.get("size"),
+                    blob_id=sibling.get("blobId"),
+                    lfs=(
+                        BlobLfsInfo(
+                            size=sibling["lfs"]["size"],
+                            sha256=sibling["lfs"]["sha256"],
+                            pointer_size=sibling["lfs"]["pointerSize"],
+                        )
+                        if sibling.get("lfs")
+                        else None
+                    ),
+                )
+                for sibling in siblings
+            ]
+            if siblings
+            else None
+        )
+        self.spaces = kwargs.pop("spaces", None)
+        safetensors = kwargs.pop("safetensors", None)
+        self.safetensors = SafeTensorsInfo(**safetensors) if safetensors else None
+
+        # backwards compatibility
+        self.lastModified = self.last_modified
+        self.cardData = self.card_data
+        self.transformersInfo = self.transformers_info
+        self.__dict__.update(**kwargs)
+
+
+@dataclass
+class DatasetInfo:
+    """
+    Contains information about a dataset on the Hub.
+
+    <Tip>
+
+    Most attributes of this class are optional. This is because the data returned by the Hub depends on the query made.
+    In general, the more specific the query, the more information is returned. On the contrary, when listing datasets
+    using [`list_datasets`] only a subset of the attributes are returned.
+
+    </Tip>
+
+    Attributes:
+        id (`str`):
+            ID of dataset.
+        author (`str`):
+            Author of the dataset.
+        sha (`str`):
+            Repo SHA at this particular revision.
+        created_at (`datetime`, *optional*):
+            Date of creation of the repo on the Hub. Note that the lowest value is `2022-03-02T23:29:04.000Z`,
+            corresponding to the date when we began to store creation dates.
+        last_modified (`datetime`, *optional*):
+            Date of last commit to the repo.
+        private (`bool`):
+            Is the repo private.
+        disabled (`bool`, *optional*):
+            Is the repo disabled.
+        gated (`Literal["auto", "manual", False]`, *optional*):
+            Is the repo gated.
+            If so, whether there is manual or automatic approval.
+        downloads (`int`):
+            Number of downloads of the dataset.
+        likes (`int`):
+            Number of likes of the dataset.
+        tags (`List[str]`):
+            List of tags of the dataset.
+        card_data (`DatasetCardData`, *optional*):
+            Model Card Metadata  as a [`huggingface_hub.repocard_data.DatasetCardData`] object.
+        siblings (`List[RepoSibling]`):
+            List of [`huggingface_hub.hf_api.RepoSibling`] objects that constitute the dataset.
+    """
+
+    id: str
+    author: Optional[str]
+    sha: Optional[str]
+    created_at: Optional[datetime]
+    last_modified: Optional[datetime]
+    private: bool
+    gated: Optional[Literal["auto", "manual", False]]
+    disabled: Optional[bool]
+    downloads: int
+    likes: int
+    paperswithcode_id: Optional[str]
+    tags: List[str]
+    card_data: Optional[DatasetCardData]
+    siblings: Optional[List[RepoSibling]]
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.author = kwargs.pop("author", None)
+        self.sha = kwargs.pop("sha", None)
+        created_at = kwargs.pop("createdAt", None) or kwargs.pop("created_at", None)
+        self.created_at = parse_datetime(created_at) if created_at else None
+        last_modified = kwargs.pop("lastModified", None) or kwargs.pop("last_modified", None)
+        self.last_modified = parse_datetime(last_modified) if last_modified else None
+        self.private = kwargs.pop("private")
+        self.gated = kwargs.pop("gated", None)
+        self.disabled = kwargs.pop("disabled", None)
+        self.downloads = kwargs.pop("downloads")
+        self.likes = kwargs.pop("likes")
+        self.paperswithcode_id = kwargs.pop("paperswithcode_id", None)
+        self.tags = kwargs.pop("tags")
+        card_data = kwargs.pop("cardData", None) or kwargs.pop("card_data", None)
+        self.card_data = (
+            DatasetCardData(**card_data, ignore_metadata_errors=True) if isinstance(card_data, dict) else card_data
+        )
+        siblings = kwargs.pop("siblings", None)
+        self.siblings = (
+            [
+                RepoSibling(
+                    rfilename=sibling["rfilename"],
+                    size=sibling.get("size"),
+                    blob_id=sibling.get("blobId"),
+                    lfs=(
+                        BlobLfsInfo(
+                            size=sibling["lfs"]["size"],
+                            sha256=sibling["lfs"]["sha256"],
+                            pointer_size=sibling["lfs"]["pointerSize"],
+                        )
+                        if sibling.get("lfs")
+                        else None
+                    ),
+                )
+                for sibling in siblings
+            ]
+            if siblings
+            else None
+        )
+
+        # backwards compatibility
+        self.lastModified = self.last_modified
+        self.cardData = self.card_data
+        self.__dict__.update(**kwargs)
+
+
+@dataclass
+class SpaceInfo:
+    """
+    Contains information about a Space on the Hub.
+
+    <Tip>
+
+    Most attributes of this class are optional. This is because the data returned by the Hub depends on the query made.
+    In general, the more specific the query, the more information is returned. On the contrary, when listing spaces
+    using [`list_spaces`] only a subset of the attributes are returned.
+
+    </Tip>
+
+    Attributes:
+        id (`str`):
+            ID of the Space.
+        author (`str`, *optional*):
+            Author of the Space.
+        sha (`str`, *optional*):
+            Repo SHA at this particular revision.
+        created_at (`datetime`, *optional*):
+            Date of creation of the repo on the Hub. Note that the lowest value is `2022-03-02T23:29:04.000Z`,
+            corresponding to the date when we began to store creation dates.
+        last_modified (`datetime`, *optional*):
+            Date of last commit to the repo.
+        private (`bool`):
+            Is the repo private.
+        gated (`Literal["auto", "manual", False]`, *optional*):
+            Is the repo gated.
+            If so, whether there is manual or automatic approval.
+        disabled (`bool`, *optional*):
+            Is the Space disabled.
+        host (`str`, *optional*):
+            Host URL of the Space.
+        subdomain (`str`, *optional*):
+            Subdomain of the Space.
+        likes (`int`):
+            Number of likes of the Space.
+        tags (`List[str]`):
+            List of tags of the Space.
+        siblings (`List[RepoSibling]`):
+            List of [`huggingface_hub.hf_api.RepoSibling`] objects that constitute the Space.
+        card_data (`SpaceCardData`, *optional*):
+            Space Card Metadata  as a [`huggingface_hub.repocard_data.SpaceCardData`] object.
+        runtime (`SpaceRuntime`, *optional*):
+            Space runtime information as a [`huggingface_hub.hf_api.SpaceRuntime`] object.
+        sdk (`str`, *optional*):
+            SDK used by the Space.
+        models (`List[str]`, *optional*):
+            List of models used by the Space.
+        datasets (`List[str]`, *optional*):
+            List of datasets used by the Space.
+    """
+
+    id: str
+    author: Optional[str]
+    sha: Optional[str]
+    created_at: Optional[datetime]
+    last_modified: Optional[datetime]
+    private: bool
+    gated: Optional[Literal["auto", "manual", False]]
+    disabled: Optional[bool]
+    host: Optional[str]
+    subdomain: Optional[str]
+    likes: int
+    sdk: Optional[str]
+    tags: List[str]
+    siblings: Optional[List[RepoSibling]]
+    card_data: Optional[SpaceCardData]
+    runtime: Optional[SpaceRuntime]
+    models: Optional[List[str]]
+    datasets: Optional[List[str]]
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.author = kwargs.pop("author", None)
+        self.sha = kwargs.pop("sha", None)
+        created_at = kwargs.pop("createdAt", None) or kwargs.pop("created_at", None)
+        self.created_at = parse_datetime(created_at) if created_at else None
+        last_modified = kwargs.pop("lastModified", None) or kwargs.pop("last_modified", None)
+        self.last_modified = parse_datetime(last_modified) if last_modified else None
+        self.private = kwargs.pop("private")
+        self.gated = kwargs.pop("gated", None)
+        self.disabled = kwargs.pop("disabled", None)
+        self.host = kwargs.pop("host", None)
+        self.subdomain = kwargs.pop("subdomain", None)
+        self.likes = kwargs.pop("likes")
+        self.sdk = kwargs.pop("sdk", None)
+        self.tags = kwargs.pop("tags")
+        card_data = kwargs.pop("cardData", None) or kwargs.pop("card_data", None)
+        self.card_data = (
+            SpaceCardData(**card_data, ignore_metadata_errors=True) if isinstance(card_data, dict) else card_data
+        )
+        siblings = kwargs.pop("siblings", None)
+        self.siblings = (
+            [
+                RepoSibling(
+                    rfilename=sibling["rfilename"],
+                    size=sibling.get("size"),
+                    blob_id=sibling.get("blobId"),
+                    lfs=(
+                        BlobLfsInfo(
+                            size=sibling["lfs"]["size"],
+                            sha256=sibling["lfs"]["sha256"],
+                            pointer_size=sibling["lfs"]["pointerSize"],
+                        )
+                        if sibling.get("lfs")
+                        else None
+                    ),
+                )
+                for sibling in siblings
+            ]
+            if siblings
+            else None
+        )
+        runtime = kwargs.pop("runtime", None)
+        self.runtime = SpaceRuntime(runtime) if runtime else None
+        self.models = kwargs.pop("models", None)
+        self.datasets = kwargs.pop("datasets", None)
+
+        # backwards compatibility
+        self.lastModified = self.last_modified
+        self.cardData = self.card_data
+        self.__dict__.update(**kwargs)
+
+
+@dataclass
+class MetricInfo:
+    """
+    Contains information about a metric on the Hub.
+
+    Attributes:
+        id (`str`):
+            ID of the metric. E.g. `"accuracy"`.
+        space_id (`str`):
+            ID of the space associated with the metric. E.g. `"Accuracy"`.
+        description (`str`):
+            Description of the metric.
+    """
+
+    id: str
+    space_id: str
+    description: Optional[str]
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.space_id = kwargs.pop("spaceId")
+        self.description = kwargs.pop("description", None)
+        # backwards compatibility
+        self.spaceId = self.space_id
+        self.__dict__.update(**kwargs)
+
+
+@dataclass
+class CollectionItem:
+    """
+    Contains information about an item of a Collection (model, dataset, Space or paper).
+
+    Attributes:
+        item_object_id (`str`):
+            Unique ID of the item in the collection.
+        item_id (`str`):
+            ID of the underlying object on the Hub. Can be either a repo_id or a paper id
+            e.g. `"jbilcke-hf/ai-comic-factory"`, `"2307.09288"`.
+        item_type (`str`):
+            Type of the underlying object. Can be one of `"model"`, `"dataset"`, `"space"` or `"paper"`.
+        position (`int`):
+            Position of the item in the collection.
+        note (`str`, *optional*):
+            Note associated with the item, as plain text.
+    """
+
+    item_object_id: str  # id in database
+    item_id: str  # repo_id or paper id
+    item_type: str
+    position: int
+    note: Optional[str] = None
+
+    def __init__(
+        self, _id: str, id: str, type: CollectionItemType_T, position: int, note: Optional[Dict] = None, **kwargs
+    ) -> None:
+        self.item_object_id: str = _id  # id in database
+        self.item_id: str = id  # repo_id or paper id
+        self.item_type: CollectionItemType_T = type
+        self.position: int = position
+        self.note: str = note["text"] if note is not None else None
+
+
+@dataclass
+class Collection:
+    """
+    Contains information about a Collection on the Hub.
+
+    Attributes:
+        slug (`str`):
+            Slug of the collection. E.g. `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
+        title (`str`):
+            Title of the collection. E.g. `"Recent models"`.
+        owner (`str`):
+            Owner of the collection. E.g. `"TheBloke"`.
+        items (`List[CollectionItem]`):
+            List of items in the collection.
+        last_updated (`datetime`):
+            Date of the last update of the collection.
+        position (`int`):
+            Position of the collection in the list of collections of the owner.
+        private (`bool`):
+            Whether the collection is private or not.
+        theme (`str`):
+            Theme of the collection. E.g. `"green"`.
+        upvotes (`int`):
+            Number of upvotes of the collection.
+        description (`str`, *optional*):
+            Description of the collection, as plain text.
+        url (`str`):
+            (property) URL of the collection on the Hub.
+    """
+
+    slug: str
+    title: str
+    owner: str
+    items: List[CollectionItem]
+    last_updated: datetime
+    position: int
+    private: bool
+    theme: str
+    upvotes: int
+    description: Optional[str] = None
+
+    def __init__(self, **kwargs) -> None:
+        self.slug = kwargs.pop("slug")
+        self.title = kwargs.pop("title")
+        self.owner = kwargs.pop("owner")
+        self.items = [CollectionItem(**item) for item in kwargs.pop("items")]
+        self.last_updated = parse_datetime(kwargs.pop("lastUpdated"))
+        self.position = kwargs.pop("position")
+        self.private = kwargs.pop("private")
+        self.theme = kwargs.pop("theme")
+        self.upvotes = kwargs.pop("upvotes")
+        self.description = kwargs.pop("description", None)
+        endpoint = kwargs.pop("endpoint", None)
+        if endpoint is None:
+            endpoint = ENDPOINT
+        self._url = f"{endpoint}/collections/{self.slug}"
+
+    @property
+    def url(self) -> str:
+        """Returns the URL of the collection on the Hub."""
+        return self._url
+
+
+@dataclass
+class GitRefInfo:
+    """
+    Contains information about a git reference for a repo on the Hub.
+
+    Attributes:
+        name (`str`):
+            Name of the reference (e.g. tag name or branch name).
+        ref (`str`):
+            Full git ref on the Hub (e.g. `"refs/heads/main"` or `"refs/tags/v1.0"`).
+        target_commit (`str`):
+            OID of the target commit for the ref (e.g. `"e7da7f221d5bf496a48136c0cd264e630fe9fcc8"`)
+    """
+
+    name: str
+    ref: str
+    target_commit: str
+
+
+@dataclass
+class GitRefs:
+    """
+    Contains information about all git references for a repo on the Hub.
+
+    Object is returned by [`list_repo_refs`].
+
+    Attributes:
+        branches (`List[GitRefInfo]`):
+            A list of [`GitRefInfo`] containing information about branches on the repo.
+        converts (`List[GitRefInfo]`):
+            A list of [`GitRefInfo`] containing information about "convert" refs on the repo.
+            Converts are refs used (internally) to push preprocessed data in Dataset repos.
+        tags (`List[GitRefInfo]`):
+            A list of [`GitRefInfo`] containing information about tags on the repo.
+        pull_requests (`List[GitRefInfo]`, *optional*):
+            A list of [`GitRefInfo`] containing information about pull requests on the repo.
+            Only returned if `include_prs=True` is set.
+    """
+
+    branches: List[GitRefInfo]
+    converts: List[GitRefInfo]
+    tags: List[GitRefInfo]
+    pull_requests: Optional[List[GitRefInfo]]
+
+
+@dataclass
+class GitCommitInfo:
+    """
+    Contains information about a git commit for a repo on the Hub. Check out [`list_repo_commits`] for more details.
+
+    Attributes:
+        commit_id (`str`):
+            OID of the commit (e.g. `"e7da7f221d5bf496a48136c0cd264e630fe9fcc8"`)
+        authors (`List[str]`):
+            List of authors of the commit.
+        created_at (`datetime`):
+            Datetime when the commit was created.
+        title (`str`):
+            Title of the commit. This is a free-text value entered by the authors.
+        message (`str`):
+            Description of the commit. This is a free-text value entered by the authors.
+        formatted_title (`str`):
+            Title of the commit formatted as HTML. Only returned if `formatted=True` is set.
+        formatted_message (`str`):
+            Description of the commit formatted as HTML. Only returned if `formatted=True` is set.
+    """
+
+    commit_id: str
+
+    authors: List[str]
+    created_at: datetime
+    title: str
+    message: str
+
+    formatted_title: Optional[str]
+    formatted_message: Optional[str]
+
+
+@dataclass
+class UserLikes:
+    """
+    Contains information about a user likes on the Hub.
+
+    Attributes:
+        user (`str`):
+            Name of the user for which we fetched the likes.
+        total (`int`):
+            Total number of likes.
+        datasets (`List[str]`):
+            List of datasets liked by the user (as repo_ids).
+        models (`List[str]`):
+            List of models liked by the user (as repo_ids).
+        spaces (`List[str]`):
+            List of spaces liked by the user (as repo_ids).
+    """
+
+    # Metadata
+    user: str
+    total: int
+
+    # User likes
+    datasets: List[str]
+    models: List[str]
+    spaces: List[str]
+
+
+@dataclass
+class User:
+    """
+    Contains information about a user on the Hub.
+
+    Attributes:
+        avatar_url (`str`):
+            URL of the user's avatar.
+        username (`str`):
+            Name of the user on the Hub (unique).
+        fullname (`str`):
+            User's full name.
+    """
+
+    # Metadata
+    avatar_url: str
+    username: str
+    fullname: str
+
+
+def future_compatible(fn: CallableT) -> CallableT:
+    """Wrap a method of `HfApi` to handle `run_as_future=True`.
+
+    A method flagged as "future_compatible" will be called in a thread if `run_as_future=True` and return a
+    `concurrent.futures.Future` instance. Otherwise, it will be called normally and return the result.
+    """
+    sig = inspect.signature(fn)
+    args_params = list(sig.parameters)[1:]  # remove "self" from list
+
+    @wraps(fn)
+    def _inner(self, *args, **kwargs):
+        # Get `run_as_future` value if provided (default to False)
+        if "run_as_future" in kwargs:
+            run_as_future = kwargs["run_as_future"]
+            kwargs["run_as_future"] = False  # avoid recursion error
+        else:
+            run_as_future = False
+            for param, value in zip(args_params, args):
+                if param == "run_as_future":
+                    run_as_future = value
+                    break
+
+        # Call the function in a thread if `run_as_future=True`
+        if run_as_future:
+            return self.run_as_future(fn, self, *args, **kwargs)
+
+        # Otherwise, call the function normally
+        return fn(self, *args, **kwargs)
+
+    _inner.is_future_compatible = True  # type: ignore
+    return _inner  # type: ignore
+
+
+class HfApi:
+    def __init__(
+        self,
+        endpoint: Optional[str] = None,
+        token: Optional[str] = None,
+        library_name: Optional[str] = None,
+        library_version: Optional[str] = None,
+        user_agent: Union[Dict, str, None] = None,
+    ) -> None:
+        """Create a HF client to interact with the Hub via HTTP.
+
+        The client is initialized with some high-level settings used in all requests
+        made to the Hub (HF endpoint, authentication, user agents...). Using the `HfApi`
+        client is preferred but not mandatory as all of its public methods are exposed
+        directly at the root of `huggingface_hub`.
+
+        Args:
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if
+                not provided.
+            library_name (`str`, *optional*):
+                The name of the library that is making the HTTP request. Will be added to
+                the user-agent header. Example: `"transformers"`.
+            library_version (`str`, *optional*):
+                The version of the library that is making the HTTP request. Will be added
+                to the user-agent header. Example: `"4.24.0"`.
+            user_agent (`str`, `dict`, *optional*):
+                The user agent info in the form of a dictionary or a single string. It will
+                be completed with information about the installed packages.
+        """
+        self.endpoint = endpoint if endpoint is not None else ENDPOINT
+        self.token = token
+        self.library_name = library_name
+        self.library_version = library_version
+        self.user_agent = user_agent
+        self._thread_pool: Optional[ThreadPoolExecutor] = None
+
+    def run_as_future(self, fn: Callable[..., R], *args, **kwargs) -> Future[R]:
+        """
+        Run a method in the background and return a Future instance.
+
+        The main goal is to run methods without blocking the main thread (e.g. to push data during a training).
+        Background jobs are queued to preserve order but are not ran in parallel. If you need to speed-up your scripts
+        by parallelizing lots of call to the API, you must setup and use your own [ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#threadpoolexecutor).
+
+        Note: Most-used methods like [`upload_file`], [`upload_folder`] and [`create_commit`] have a `run_as_future: bool`
+        argument to directly call them in the background. This is equivalent to calling `api.run_as_future(...)` on them
+        but less verbose.
+
+        Args:
+            fn (`Callable`):
+                The method to run in the background.
+            *args, **kwargs:
+                Arguments with which the method will be called.
+
+        Return:
+            `Future`: a [Future](https://docs.python.org/3/library/concurrent.futures.html#future-objects) instance to
+            get the result of the task.
+
+        Example:
+            ```py
+            >>> from huggingface_hub import HfApi
+            >>> api = HfApi()
+            >>> future = api.run_as_future(api.whoami) # instant
+            >>> future.done()
+            False
+            >>> future.result() # wait until complete and return result
+            (...)
+            >>> future.done()
+            True
+            ```
+        """
+        if self._thread_pool is None:
+            self._thread_pool = ThreadPoolExecutor(max_workers=1)
+        self._thread_pool
+        return self._thread_pool.submit(fn, *args, **kwargs)
+
+    @validate_hf_hub_args
+    def whoami(self, token: Optional[str] = None) -> Dict:
+        """
+        Call HF API to know "whoami".
+
+        Args:
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if
+                not provided.
+        """
+        r = get_session().get(
+            f"{self.endpoint}/api/whoami-v2",
+            headers=self._build_hf_headers(
+                # If `token` is provided and not `None`, it will be used by default.
+                # Otherwise, the token must be retrieved from cache or env variable.
+                token=(token or self.token or True),
+            ),
+        )
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as e:
+            raise HTTPError(
+                "Invalid user token. If you didn't pass a user token, make sure you "
+                "are properly logged in by executing `huggingface-cli login`, and "
+                "if you did pass a user token, double-check it's correct.",
+                request=e.request,
+                response=e.response,
+            ) from e
+        return r.json()
+
+    def get_token_permission(self, token: Optional[str] = None) -> Literal["read", "write", None]:
+        """
+        Check if a given `token` is valid and return its permissions.
+
+        For more details about tokens, please refer to https://huggingface.co/docs/hub/security-tokens#what-are-user-access-tokens.
+
+        Args:
+            token (`str`, *optional*):
+                The token to check for validity. Defaults to the one saved locally.
+
+        Returns:
+            `Literal["read", "write", None]`: Permission granted by the token ("read" or "write"). Returns `None` if no
+            token passed or token is invalid.
+        """
+        try:
+            return self.whoami(token=token)["auth"]["accessToken"]["role"]
+        except (LocalTokenNotFoundError, HTTPError):
+            return None
+
+    def get_model_tags(self) -> Dict:
+        """
+        List all valid model tags as a nested namespace object
+        """
+        path = f"{self.endpoint}/api/models-tags-by-type"
+        r = get_session().get(path)
+        hf_raise_for_status(r)
+        return r.json()
+
+    def get_dataset_tags(self) -> Dict:
+        """
+        List all valid dataset tags as a nested namespace object.
+        """
+        path = f"{self.endpoint}/api/datasets-tags-by-type"
+        r = get_session().get(path)
+        hf_raise_for_status(r)
+        return r.json()
+
+    @validate_hf_hub_args
+    def list_models(
+        self,
+        *,
+        filter: Union[ModelFilter, str, Iterable[str], None] = None,
+        author: Optional[str] = None,
+        search: Optional[str] = None,
+        emissions_thresholds: Optional[Tuple[float, float]] = None,
+        sort: Union[Literal["last_modified"], str, None] = None,
+        direction: Optional[Literal[-1]] = None,
+        limit: Optional[int] = None,
+        full: Optional[bool] = None,
+        cardData: bool = False,
+        fetch_config: bool = False,
+        token: Optional[Union[bool, str]] = None,
+    ) -> Iterable[ModelInfo]:
+        """
+        List models hosted on the Huggingface Hub, given some filters.
+
+        Args:
+            filter ([`ModelFilter`] or `str` or `Iterable`, *optional*):
+                A string or [`ModelFilter`] which can be used to identify models
+                on the Hub.
+            author (`str`, *optional*):
+                A string which identify the author (user or organization) of the
+                returned models
+            search (`str`, *optional*):
+                A string that will be contained in the returned model ids.
+            emissions_thresholds (`Tuple`, *optional*):
+                A tuple of two ints or floats representing a minimum and maximum
+                carbon footprint to filter the resulting models with in grams.
+            sort (`Literal["last_modified"]` or `str`, *optional*):
+                The key with which to sort the resulting models. Possible values
+                are the properties of the [`huggingface_hub.hf_api.ModelInfo`] class.
+            direction (`Literal[-1]` or `int`, *optional*):
+                Direction in which to sort. The value `-1` sorts by descending
+                order while all other values sort by ascending order.
+            limit (`int`, *optional*):
+                The limit on the number of models fetched. Leaving this option
+                to `None` fetches all models.
+            full (`bool`, *optional*):
+                Whether to fetch all model data, including the `last_modified`,
+                the `sha`, the files and the `tags`. This is set to `True` by
+                default when using a filter.
+            cardData (`bool`, *optional*):
+                Whether to grab the metadata for the model as well. Can contain
+                useful information such as carbon emissions, metrics, and
+                datasets trained on.
+            fetch_config (`bool`, *optional*):
+                Whether to fetch the model configs as well. This is not included
+                in `full` due to its size.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            `Iterable[ModelInfo]`: an iterable of [`huggingface_hub.hf_api.ModelInfo`] objects.
+
+        Example usage with the `filter` argument:
+
+        ```python
+        >>> from huggingface_hub import HfApi
+
+        >>> api = HfApi()
+
+        >>> # List all models
+        >>> api.list_models()
+
+        >>> # List only the text classification models
+        >>> api.list_models(filter="text-classification")
+        >>> # Using the `ModelFilter`
+        >>> filt = ModelFilter(task="text-classification")
+
+
+        >>> # List only models from the AllenNLP library
+        >>> api.list_models(filter="allennlp")
+        ```
+
+        Example usage with the `search` argument:
+
+        ```python
+        >>> from huggingface_hub import HfApi
+
+        >>> api = HfApi()
+
+        >>> # List all models with "bert" in their name
+        >>> api.list_models(search="bert")
+
+        >>> # List all models with "bert" in their name made by google
+        >>> api.list_models(search="bert", author="google")
+        ```
+        """
+        if emissions_thresholds is not None and cardData is None:
+            raise ValueError("`emissions_thresholds` were passed without setting `cardData=True`.")
+
+        path = f"{self.endpoint}/api/models"
+        headers = self._build_hf_headers(token=token)
+        params = {}
+        if filter is not None:
+            if isinstance(filter, ModelFilter):
+                params = self._unpack_model_filter(filter)
+            else:
+                params.update({"filter": filter})
+            params.update({"full": True})
+        if author is not None:
+            params.update({"author": author})
+        if search is not None:
+            params.update({"search": search})
+        if sort is not None:
+            params.update({"sort": "lastModified" if sort == "last_modified" else sort})
+        if direction is not None:
+            params.update({"direction": direction})
+        if limit is not None:
+            params.update({"limit": limit})
+        if full is not None:
+            if full:
+                params.update({"full": True})
+            elif "full" in params:
+                del params["full"]
+        if fetch_config:
+            params.update({"config": True})
+        if cardData:
+            params.update({"cardData": True})
+
+        # `items` is a generator
+        items = paginate(path, params=params, headers=headers)
+        if limit is not None:
+            items = islice(items, limit)  # Do not iterate over all pages
+        for item in items:
+            if "siblings" not in item:
+                item["siblings"] = None
+            model_info = ModelInfo(**item)
+            if emissions_thresholds is None or _is_emission_within_treshold(model_info, *emissions_thresholds):
+                yield model_info
+
+    def _unpack_model_filter(self, model_filter: ModelFilter):
+        """
+        Unpacks a [`ModelFilter`] into something readable for `list_models`
+        """
+        model_str = ""
+
+        # Handling author
+        if model_filter.author is not None:
+            model_str = f"{model_filter.author}/"
+
+        # Handling model_name
+        if model_filter.model_name is not None:
+            model_str += model_filter.model_name
+
+        filter_list: List[str] = []
+
+        # Handling tasks
+        if model_filter.task is not None:
+            filter_list.extend([model_filter.task] if isinstance(model_filter.task, str) else model_filter.task)
+
+        # Handling dataset
+        if model_filter.trained_dataset is not None:
+            if not isinstance(model_filter.trained_dataset, (list, tuple)):
+                model_filter.trained_dataset = [model_filter.trained_dataset]
+            for dataset in model_filter.trained_dataset:
+                if "dataset:" not in dataset:
+                    dataset = f"dataset:{dataset}"
+                filter_list.append(dataset)
+
+        # Handling library
+        if model_filter.library:
+            filter_list.extend(
+                [model_filter.library] if isinstance(model_filter.library, str) else model_filter.library
+            )
+
+        # Handling tags
+        if model_filter.tags:
+            filter_list.extend([model_filter.tags] if isinstance(model_filter.tags, str) else model_filter.tags)
+
+        query_dict: Dict[str, Any] = {}
+        if model_str is not None:
+            query_dict["search"] = model_str
+        if isinstance(model_filter.language, list):
+            filter_list.extend(model_filter.language)
+        elif isinstance(model_filter.language, str):
+            filter_list.append(model_filter.language)
+        query_dict["filter"] = tuple(filter_list)
+        return query_dict
+
+    @validate_hf_hub_args
+    def list_datasets(
+        self,
+        *,
+        filter: Union[DatasetFilter, str, Iterable[str], None] = None,
+        author: Optional[str] = None,
+        search: Optional[str] = None,
+        sort: Union[Literal["last_modified"], str, None] = None,
+        direction: Optional[Literal[-1]] = None,
+        limit: Optional[int] = None,
+        full: Optional[bool] = None,
+        token: Optional[str] = None,
+    ) -> Iterable[DatasetInfo]:
+        """
+        List datasets hosted on the Huggingface Hub, given some filters.
+
+        Args:
+            filter ([`DatasetFilter`] or `str` or `Iterable`, *optional*):
+                A string or [`DatasetFilter`] which can be used to identify
+                datasets on the hub.
+            author (`str`, *optional*):
+                A string which identify the author of the returned datasets.
+            search (`str`, *optional*):
+                A string that will be contained in the returned datasets.
+            sort (`Literal["last_modified"]` or `str`, *optional*):
+                The key with which to sort the resulting datasets. Possible
+                values are the properties of the [`huggingface_hub.hf_api.DatasetInfo`] class.
+            direction (`Literal[-1]` or `int`, *optional*):
+                Direction in which to sort. The value `-1` sorts by descending
+                order while all other values sort by ascending order.
+            limit (`int`, *optional*):
+                The limit on the number of datasets fetched. Leaving this option
+                to `None` fetches all datasets.
+            full (`bool`, *optional*):
+                Whether to fetch all dataset data, including the `last_modified`,
+                the `card_data` and  the files. Can contain useful information such as the
+                PapersWithCode ID.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            `Iterable[DatasetInfo]`: an iterable of [`huggingface_hub.hf_api.DatasetInfo`] objects.
+
+        Example usage with the `filter` argument:
+
+        ```python
+        >>> from huggingface_hub import HfApi
+
+        >>> api = HfApi()
+
+        >>> # List all datasets
+        >>> api.list_datasets()
+
+
+        >>> # List only the text classification datasets
+        >>> api.list_datasets(filter="task_categories:text-classification")
+        >>> # Using the `DatasetFilter`
+        >>> filt = DatasetFilter(task_categories="text-classification")
+
+
+        >>> # List only the datasets in russian for language modeling
+        >>> api.list_datasets(
+        ...     filter=("language:ru", "task_ids:language-modeling")
+        ... )
+        >>> # Using the `DatasetFilter`
+        >>> filt = DatasetFilter(language="ru", task_ids="language-modeling")
+
+        >>> api.list_datasets(filter=filt)
+        ```
+
+        Example usage with the `search` argument:
+
+        ```python
+        >>> from huggingface_hub import HfApi
+
+        >>> api = HfApi()
+
+        >>> # List all datasets with "text" in their name
+        >>> api.list_datasets(search="text")
+
+        >>> # List all datasets with "text" in their name made by google
+        >>> api.list_datasets(search="text", author="google")
+        ```
+        """
+        path = f"{self.endpoint}/api/datasets"
+        headers = self._build_hf_headers(token=token)
+        params = {}
+        if filter is not None:
+            if isinstance(filter, DatasetFilter):
+                params = self._unpack_dataset_filter(filter)
+            else:
+                params.update({"filter": filter})
+        if author is not None:
+            params.update({"author": author})
+        if search is not None:
+            params.update({"search": search})
+        if sort is not None:
+            params.update({"sort": "lastModified" if sort == "last_modified" else sort})
+        if direction is not None:
+            params.update({"direction": direction})
+        if limit is not None:
+            params.update({"limit": limit})
+        if full:
+            params.update({"full": True})
+
+        items = paginate(path, params=params, headers=headers)
+        if limit is not None:
+            items = islice(items, limit)  # Do not iterate over all pages
+        for item in items:
+            if "siblings" not in item:
+                item["siblings"] = None
+            yield DatasetInfo(**item)
+
+    def _unpack_dataset_filter(self, dataset_filter: DatasetFilter):
+        """
+        Unpacks a [`DatasetFilter`] into something readable for `list_datasets`
+        """
+        dataset_str = ""
+
+        # Handling author
+        if dataset_filter.author is not None:
+            dataset_str = f"{dataset_filter.author}/"
+
+        # Handling dataset_name
+        if dataset_filter.dataset_name is not None:
+            dataset_str += dataset_filter.dataset_name
+
+        filter_list = []
+        data_attributes = [
+            "benchmark",
+            "language_creators",
+            "language",
+            "multilinguality",
+            "size_categories",
+            "task_categories",
+            "task_ids",
+        ]
+
+        for attr in data_attributes:
+            curr_attr = getattr(dataset_filter, attr)
+            if curr_attr is not None:
+                if not isinstance(curr_attr, (list, tuple)):
+                    curr_attr = [curr_attr]
+                for data in curr_attr:
+                    if f"{attr}:" not in data:
+                        data = f"{attr}:{data}"
+                    filter_list.append(data)
+
+        query_dict: Dict[str, Any] = {}
+        if dataset_str is not None:
+            query_dict["search"] = dataset_str
+        query_dict["filter"] = tuple(filter_list)
+        return query_dict
+
+    def list_metrics(self) -> List[MetricInfo]:
+        """
+        Get the public list of all the metrics on huggingface.co
+
+        Returns:
+            `List[MetricInfo]`: a list of [`MetricInfo`] objects which.
+        """
+        path = f"{self.endpoint}/api/metrics"
+        r = get_session().get(path)
+        hf_raise_for_status(r)
+        d = r.json()
+        return [MetricInfo(**x) for x in d]
+
+    @validate_hf_hub_args
+    def list_spaces(
+        self,
+        *,
+        filter: Union[str, Iterable[str], None] = None,
+        author: Optional[str] = None,
+        search: Optional[str] = None,
+        sort: Union[Literal["last_modified"], str, None] = None,
+        direction: Optional[Literal[-1]] = None,
+        limit: Optional[int] = None,
+        datasets: Union[str, Iterable[str], None] = None,
+        models: Union[str, Iterable[str], None] = None,
+        linked: bool = False,
+        full: Optional[bool] = None,
+        token: Optional[str] = None,
+    ) -> Iterable[SpaceInfo]:
+        """
+        List spaces hosted on the Huggingface Hub, given some filters.
+
+        Args:
+            filter (`str` or `Iterable`, *optional*):
+                A string tag or list of tags that can be used to identify Spaces on the Hub.
+            author (`str`, *optional*):
+                A string which identify the author of the returned Spaces.
+            search (`str`, *optional*):
+                A string that will be contained in the returned Spaces.
+            sort (`Literal["last_modified"]` or `str`, *optional*):
+                The key with which to sort the resulting Spaces. Possible
+                values are the properties of the [`huggingface_hub.hf_api.SpaceInfo`]` class.
+            direction (`Literal[-1]` or `int`, *optional*):
+                Direction in which to sort. The value `-1` sorts by descending
+                order while all other values sort by ascending order.
+            limit (`int`, *optional*):
+                The limit on the number of Spaces fetched. Leaving this option
+                to `None` fetches all Spaces.
+            datasets (`str` or `Iterable`, *optional*):
+                Whether to return Spaces that make use of a dataset.
+                The name of a specific dataset can be passed as a string.
+            models (`str` or `Iterable`, *optional*):
+                Whether to return Spaces that make use of a model.
+                The name of a specific model can be passed as a string.
+            linked (`bool`, *optional*):
+                Whether to return Spaces that make use of either a model or a dataset.
+            full (`bool`, *optional*):
+                Whether to fetch all Spaces data, including the `last_modified`, `siblings`
+                and `card_data` fields.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            `Iterable[SpaceInfo]`: an iterable of [`huggingface_hub.hf_api.SpaceInfo`] objects.
+        """
+        path = f"{self.endpoint}/api/spaces"
+        headers = self._build_hf_headers(token=token)
+        params: Dict[str, Any] = {}
+        if filter is not None:
+            params.update({"filter": filter})
+        if author is not None:
+            params.update({"author": author})
+        if search is not None:
+            params.update({"search": search})
+        if sort is not None:
+            params.update({"sort": "lastModified" if sort == "last_modified" else sort})
+        if direction is not None:
+            params.update({"direction": direction})
+        if limit is not None:
+            params.update({"limit": limit})
+        if full:
+            params.update({"full": True})
+        if linked:
+            params.update({"linked": True})
+        if datasets is not None:
+            params.update({"datasets": datasets})
+        if models is not None:
+            params.update({"models": models})
+
+        items = paginate(path, params=params, headers=headers)
+        if limit is not None:
+            items = islice(items, limit)  # Do not iterate over all pages
+        for item in items:
+            if "siblings" not in item:
+                item["siblings"] = None
+            yield SpaceInfo(**item)
+
+    @validate_hf_hub_args
+    def like(
+        self,
+        repo_id: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> None:
+        """
+        Like a given repo on the Hub (e.g. set as favorite).
+
+        See also [`unlike`] and [`list_liked_repos`].
+
+        Args:
+            repo_id (`str`):
+                The repository to like. Example: `"user/my-cool-model"`.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if liking a dataset or space, `None` or
+                `"model"` if liking a model. Default is `None`.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private
+                but not authenticated or repo does not exist.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import like, list_liked_repos, unlike
+        >>> like("gpt2")
+        >>> "gpt2" in list_liked_repos().models
+        True
+        >>> unlike("gpt2")
+        >>> "gpt2" in list_liked_repos().models
+        False
+        ```
+        """
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        response = get_session().post(
+            url=f"{self.endpoint}/api/{repo_type}s/{repo_id}/like",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+    @validate_hf_hub_args
+    def unlike(
+        self,
+        repo_id: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> None:
+        """
+        Unlike a given repo on the Hub (e.g. remove from favorite list).
+
+        See also [`like`] and [`list_liked_repos`].
+
+        Args:
+            repo_id (`str`):
+                The repository to unlike. Example: `"user/my-cool-model"`.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if unliking a dataset or space, `None` or
+                `"model"` if unliking a model. Default is `None`.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private
+                but not authenticated or repo does not exist.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import like, list_liked_repos, unlike
+        >>> like("gpt2")
+        >>> "gpt2" in list_liked_repos().models
+        True
+        >>> unlike("gpt2")
+        >>> "gpt2" in list_liked_repos().models
+        False
+        ```
+        """
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        response = get_session().delete(
+            url=f"{self.endpoint}/api/{repo_type}s/{repo_id}/like", headers=self._build_hf_headers(token=token)
+        )
+        hf_raise_for_status(response)
+
+    @validate_hf_hub_args
+    def list_liked_repos(
+        self,
+        user: Optional[str] = None,
+        *,
+        token: Optional[str] = None,
+    ) -> UserLikes:
+        """
+        List all public repos liked by a user on huggingface.co.
+
+        This list is public so token is optional. If `user` is not passed, it defaults to
+        the logged in user.
+
+        See also [`like`] and [`unlike`].
+
+        Args:
+            user (`str`, *optional*):
+                Name of the user for which you want to fetch the likes.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                Used only if `user` is not passed to implicitly determine the current
+                user name.
+
+        Returns:
+            [`UserLikes`]: object containing the user name and 3 lists of repo ids (1 for
+            models, 1 for datasets and 1 for Spaces).
+
+        Raises:
+            [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+                If `user` is not passed and no token found (either from argument or from machine).
+
+        Example:
+        ```python
+        >>> from huggingface_hub import list_liked_repos
+
+        >>> likes = list_liked_repos("julien-c")
+
+        >>> likes.user
+        "julien-c"
+
+        >>> likes.models
+        ["osanseviero/streamlit_1.15", "Xhaheen/ChatGPT_HF", ...]
+        ```
+        """
+        # User is either provided explicitly or retrieved from current token.
+        if user is None:
+            me = self.whoami(token=token)
+            if me["type"] == "user":
+                user = me["name"]
+            else:
+                raise ValueError(
+                    "Cannot list liked repos. You must provide a 'user' as input or be logged in as a user."
+                )
+
+        path = f"{self.endpoint}/api/users/{user}/likes"
+        headers = self._build_hf_headers(token=token)
+
+        likes = list(paginate(path, params={}, headers=headers))
+        # Looping over a list of items similar to:
+        #   {
+        #       'createdAt': '2021-09-09T21:53:27.000Z',
+        #       'repo': {
+        #           'name': 'PaddlePaddle/PaddleOCR',
+        #           'type': 'space'
+        #        }
+        #   }
+        # Let's loop 3 times over the received list. Less efficient but more straightforward to read.
+        return UserLikes(
+            user=user,
+            total=len(likes),
+            models=[like["repo"]["name"] for like in likes if like["repo"]["type"] == "model"],
+            datasets=[like["repo"]["name"] for like in likes if like["repo"]["type"] == "dataset"],
+            spaces=[like["repo"]["name"] for like in likes if like["repo"]["type"] == "space"],
+        )
+
+    @validate_hf_hub_args
+    def list_repo_likers(
+        self,
+        repo_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> List[User]:
+        """
+        List all users who liked a given repo on the hugging Face Hub.
+
+        See also [`like`] and [`list_liked_repos`].
+
+        Args:
+            repo_id (`str`):
+                The repository to retrieve . Example: `"user/my-cool-model"`.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+
+        Returns:
+            `List[User]`: a list of [`User`] objects.
+        """
+
+        # Construct the API endpoint
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        path = f"{self.endpoint}/api/{repo_type}s/{repo_id}/likers"
+        headers = self._build_hf_headers(token=token)
+
+        # Make the request
+        response = get_session().get(path, headers=headers)
+        hf_raise_for_status(response)
+
+        # Parse the results into User objects
+        likers_data = response.json()
+        return [
+            User(
+                username=user_data["user"],
+                fullname=user_data["fullname"],
+                avatar_url=user_data["avatarUrl"],
+            )
+            for user_data in likers_data
+        ]
+
+    @validate_hf_hub_args
+    def model_info(
+        self,
+        repo_id: str,
+        *,
+        revision: Optional[str] = None,
+        timeout: Optional[float] = None,
+        securityStatus: Optional[bool] = None,
+        files_metadata: bool = False,
+        token: Optional[Union[bool, str]] = None,
+    ) -> ModelInfo:
+        """
+        Get info on one specific model on huggingface.co
+
+        Model can be private if you pass an acceptable token or are logged in.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            revision (`str`, *optional*):
+                The revision of the model repository from which to get the
+                information.
+            timeout (`float`, *optional*):
+                Whether to set a timeout for the request to the Hub.
+            securityStatus (`bool`, *optional*):
+                Whether to retrieve the security status from the model
+                repository as well.
+            files_metadata (`bool`, *optional*):
+                Whether or not to retrieve metadata for files in the repository
+                (size, LFS metadata, etc). Defaults to `False`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            [`huggingface_hub.hf_api.ModelInfo`]: The model repository information.
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+            - [`~utils.RevisionNotFoundError`]
+              If the revision to download from cannot be found.
+
+        </Tip>
+        """
+        headers = self._build_hf_headers(token=token)
+        path = (
+            f"{self.endpoint}/api/models/{repo_id}"
+            if revision is None
+            else (f"{self.endpoint}/api/models/{repo_id}/revision/{quote(revision, safe='')}")
+        )
+        params = {}
+        if securityStatus:
+            params["securityStatus"] = True
+        if files_metadata:
+            params["blobs"] = True
+        r = get_session().get(path, headers=headers, timeout=timeout, params=params)
+        hf_raise_for_status(r)
+        data = r.json()
+        return ModelInfo(**data)
+
+    @validate_hf_hub_args
+    def dataset_info(
+        self,
+        repo_id: str,
+        *,
+        revision: Optional[str] = None,
+        timeout: Optional[float] = None,
+        files_metadata: bool = False,
+        token: Optional[Union[bool, str]] = None,
+    ) -> DatasetInfo:
+        """
+        Get info on one specific dataset on huggingface.co.
+
+        Dataset can be private if you pass an acceptable token.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            revision (`str`, *optional*):
+                The revision of the dataset repository from which to get the
+                information.
+            timeout (`float`, *optional*):
+                Whether to set a timeout for the request to the Hub.
+            files_metadata (`bool`, *optional*):
+                Whether or not to retrieve metadata for files in the repository
+                (size, LFS metadata, etc). Defaults to `False`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            [`hf_api.DatasetInfo`]: The dataset repository information.
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+            - [`~utils.RevisionNotFoundError`]
+              If the revision to download from cannot be found.
+
+        </Tip>
+        """
+        headers = self._build_hf_headers(token=token)
+        path = (
+            f"{self.endpoint}/api/datasets/{repo_id}"
+            if revision is None
+            else (f"{self.endpoint}/api/datasets/{repo_id}/revision/{quote(revision, safe='')}")
+        )
+        params = {}
+        if files_metadata:
+            params["blobs"] = True
+
+        r = get_session().get(path, headers=headers, timeout=timeout, params=params)
+        hf_raise_for_status(r)
+        data = r.json()
+        return DatasetInfo(**data)
+
+    @validate_hf_hub_args
+    def space_info(
+        self,
+        repo_id: str,
+        *,
+        revision: Optional[str] = None,
+        timeout: Optional[float] = None,
+        files_metadata: bool = False,
+        token: Optional[Union[bool, str]] = None,
+    ) -> SpaceInfo:
+        """
+        Get info on one specific Space on huggingface.co.
+
+        Space can be private if you pass an acceptable token.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            revision (`str`, *optional*):
+                The revision of the space repository from which to get the
+                information.
+            timeout (`float`, *optional*):
+                Whether to set a timeout for the request to the Hub.
+            files_metadata (`bool`, *optional*):
+                Whether or not to retrieve metadata for files in the repository
+                (size, LFS metadata, etc). Defaults to `False`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            [`~hf_api.SpaceInfo`]: The space repository information.
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+            - [`~utils.RevisionNotFoundError`]
+              If the revision to download from cannot be found.
+
+        </Tip>
+        """
+        headers = self._build_hf_headers(token=token)
+        path = (
+            f"{self.endpoint}/api/spaces/{repo_id}"
+            if revision is None
+            else (f"{self.endpoint}/api/spaces/{repo_id}/revision/{quote(revision, safe='')}")
+        )
+        params = {}
+        if files_metadata:
+            params["blobs"] = True
+
+        r = get_session().get(path, headers=headers, timeout=timeout, params=params)
+        hf_raise_for_status(r)
+        data = r.json()
+        return SpaceInfo(**data)
+
+    @validate_hf_hub_args
+    def repo_info(
+        self,
+        repo_id: str,
+        *,
+        revision: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        timeout: Optional[float] = None,
+        files_metadata: bool = False,
+        token: Optional[Union[bool, str]] = None,
+    ) -> Union[ModelInfo, DatasetInfo, SpaceInfo]:
+        """
+        Get the info object for a given repo of a given type.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            revision (`str`, *optional*):
+                The revision of the repository from which to get the
+                information.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if getting repository info from a dataset or a space,
+                `None` or `"model"` if getting repository info from a model. Default is `None`.
+            timeout (`float`, *optional*):
+                Whether to set a timeout for the request to the Hub.
+            files_metadata (`bool`, *optional*):
+                Whether or not to retrieve metadata for files in the repository
+                (size, LFS metadata, etc). Defaults to `False`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            `Union[SpaceInfo, DatasetInfo, ModelInfo]`: The repository information, as a
+            [`huggingface_hub.hf_api.DatasetInfo`], [`huggingface_hub.hf_api.ModelInfo`]
+            or [`huggingface_hub.hf_api.SpaceInfo`] object.
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+            - [`~utils.RevisionNotFoundError`]
+              If the revision to download from cannot be found.
+
+        </Tip>
+        """
+        if repo_type is None or repo_type == "model":
+            method = self.model_info
+        elif repo_type == "dataset":
+            method = self.dataset_info  # type: ignore
+        elif repo_type == "space":
+            method = self.space_info  # type: ignore
+        else:
+            raise ValueError("Unsupported repo type.")
+        return method(
+            repo_id,
+            revision=revision,
+            token=token,
+            timeout=timeout,
+            files_metadata=files_metadata,
+        )
+
+    @validate_hf_hub_args
+    def repo_exists(
+        self,
+        repo_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> bool:
+        """
+        Checks if a repository exists on the Hugging Face Hub.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if getting repository info from a dataset or a space,
+                `None` or `"model"` if getting repository info from a model. Default is `None`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            True if the repository exists, False otherwise.
+
+        <Tip>
+
+        Examples:
+            ```py
+            >>> from huggingface_hub import repo_exists
+            >>> repo_exists("huggingface/transformers")
+            True
+            >>> repo_exists("huggingface/not-a-repo")
+            False
+            ```
+
+        </Tip>
+        """
+        try:
+            self.repo_info(repo_id=repo_id, repo_type=repo_type, token=token)
+            return True
+        except GatedRepoError:
+            return True  # we don't have access but it exists
+        except RepositoryNotFoundError:
+            return False
+
+    @validate_hf_hub_args
+    def file_exists(
+        self,
+        repo_id: str,
+        filename: str,
+        *,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> bool:
+        """
+        Checks if a file exists in a repository on the Hugging Face Hub.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            filename (`str`):
+                The name of the file to check, for example:
+                `"config.json"`
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if getting repository info from a dataset or a space,
+                `None` or `"model"` if getting repository info from a model. Default is `None`.
+            revision (`str`, *optional*):
+                The revision of the repository from which to get the information. Defaults to `"main"` branch.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            True if the file exists, False otherwise.
+
+        <Tip>
+
+        Examples:
+            ```py
+            >>> from huggingface_hub import file_exists
+            >>> file_exists("bigcode/starcoder", "config.json")
+            True
+            >>> file_exists("bigcode/starcoder", "not-a-file")
+            False
+            >>> file_exists("bigcode/not-a-repo", "config.json")
+            False
+            ```
+
+        </Tip>
+        """
+        url = hf_hub_url(
+            repo_id=repo_id, repo_type=repo_type, revision=revision, filename=filename, endpoint=self.endpoint
+        )
+        try:
+            if token is None:
+                token = self.token
+            get_hf_file_metadata(url, token=token)
+            return True
+        except GatedRepoError:  # raise specifically on gated repo
+            raise
+        except (RepositoryNotFoundError, EntryNotFoundError, RevisionNotFoundError):
+            return False
+
+    @validate_hf_hub_args
+    @_deprecate_method(version="0.23", message="Use `list_repo_tree` and `get_paths_info` instead.")
+    def list_files_info(
+        self,
+        repo_id: str,
+        paths: Union[List[str], str, None] = None,
+        *,
+        expand: bool = False,
+        revision: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        token: Optional[Union[bool, str]] = None,
+    ) -> Iterable[RepoFile]:
+        """
+        List files on a repo and get information about them.
+
+        Takes as input a list of paths. Those paths can be either files or folders. Two server endpoints are called:
+        1. POST "/paths-info" to get information about the provided paths. Called once.
+        2. GET  "/tree?recursive=True" to paginate over the input folders. Called only if a folder path is provided as
+           input. Will be called multiple times to follow pagination.
+        If no path is provided as input, step 1. is ignored and all files from the repo are listed.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated by a `/`.
+            paths (`Union[List[str], str, None]`, *optional*):
+                The paths to get information about. Paths to files are directly resolved. Paths to folders are resolved
+                recursively which means that information is returned about all files in the folder and its subfolders.
+                If `None`, all files are returned (the default). If a path do not exist, it is ignored without raising
+                an exception.
+            expand (`bool`, *optional*, defaults to `False`):
+                Whether to fetch more information about the files (e.g. last commit and security scan results). This
+                operation is more expensive for the server so only 50 results are returned per page (instead of 1000).
+                As pagination is implemented in `huggingface_hub`, this is transparent for you except for the time it
+                takes to get the results.
+            revision (`str`, *optional*):
+                The revision of the repository from which to get the information. Defaults to `"main"` branch.
+            repo_type (`str`, *optional*):
+                The type of the repository from which to get the information (`"model"`, `"dataset"` or `"space"`.
+                Defaults to `"model"`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token). If `None` or `True` and
+                machine is logged in (through `huggingface-cli login` or [`~huggingface_hub.login`]), token will be
+                retrieved from the cache. If `False`, token is not sent in the request header.
+
+        Returns:
+            `Iterable[RepoFile]`:
+                The information about the files, as an iterable of [`RepoFile`] objects. The order of the files is
+                not guaranteed.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private but not authenticated or repo
+                does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If revision is not found (error 404) on the repo.
+
+        Examples:
+
+            Get information about files on a repo.
+            ```py
+            >>> from huggingface_hub import list_files_info
+            >>> files_info = list_files_info("lysandre/arxiv-nlp", ["README.md", "config.json"])
+            >>> files_info
+            <generator object HfApi.list_files_info at 0x7f93b848e730>
+            >>> list(files_info)
+            [
+                RepoFile(path='README.md', size=391, blob_id='43bd404b159de6fba7c2f4d3264347668d43af25', lfs=None, last_commit=None, security=None),
+                RepoFile(path='config.json', size=554, blob_id='2f9618c3a19b9a61add74f70bfb121335aeef666', lfs=None, last_commit=None, security=None)
+            ]
+            ```
+
+            Get even more information about files on a repo (last commit and security scan results)
+            ```py
+            >>> from huggingface_hub import list_files_info
+            >>> files_info = list_files_info("prompthero/openjourney-v4", expand=True)
+            >>> list(files_info)
+            [
+                RepoFile(
+                    path='safety_checker/pytorch_model.bin',
+                    size=1216064769,
+                    blob_id='c8835557a0d3af583cb06c7c154b7e54a069c41d',
+                    lfs={
+                        'size': 1216064769,
+                        'sha256': '16d28f2b37109f222cdc33620fdd262102ac32112be0352a7f77e9614b35a394',
+                        'pointer_size': 135
+                    },
+                    last_commit={
+                        'oid': '47b62b20b20e06b9de610e840282b7e6c3d51190',
+                        'title': 'Upload diffusers weights (#48)',
+                        'date': datetime.datetime(2023, 3, 21, 10, 5, 27, tzinfo=datetime.timezone.utc)
+                    },
+                    security={
+                        'safe': True,
+                        'av_scan': {
+                            'virusFound': False,
+                            'virusNames': None
+                        },
+                        'pickle_import_scan': {
+                            'highestSafetyLevel': 'innocuous',
+                            'imports': [
+                                {'module': 'torch', 'name': 'FloatStorage', 'safety': 'innocuous'},
+                                {'module': 'collections', 'name': 'OrderedDict', 'safety': 'innocuous'},
+                                {'module': 'torch', 'name': 'LongStorage', 'safety': 'innocuous'},
+                                {'module': 'torch._utils', 'name': '_rebuild_tensor_v2', 'safety': 'innocuous'}
+                            ]
+                        }
+                    }
+                ),
+                RepoFile(
+                    path='scheduler/scheduler_config.json',
+                    size=465,
+                    blob_id='70d55e3e9679f41cbc66222831b38d5abce683dd',
+                    lfs=None,
+                    last_commit={
+                        'oid': '47b62b20b20e06b9de610e840282b7e6c3d51190',
+                        'title': 'Upload diffusers weights (#48)',
+                        'date': datetime.datetime(2023, 3, 21, 10, 5, 27, tzinfo=datetime.timezone.utc)},
+                        security={
+                            'safe': True,
+                            'av_scan': {
+                                'virusFound': False,
+                                'virusNames': None
+                            },
+                            'pickle_import_scan': None
+                        }
+                ),
+                ...
+            ]
+            ```
+
+            List LFS files from the "vae/" folder in "stabilityai/stable-diffusion-2" repository.
+
+            ```py
+            >>> from huggingface_hub import list_files_info
+            >>> [info.path for info in list_files_info("stabilityai/stable-diffusion-2", "vae") if info.lfs is not None]
+            ['vae/diffusion_pytorch_model.bin', 'vae/diffusion_pytorch_model.safetensors']
+            ```
+
+            List all files on a repo.
+            ```py
+            >>> from huggingface_hub import list_files_info
+            >>> [info.path for info in list_files_info("glue", repo_type="dataset")]
+            ['.gitattributes', 'README.md', 'dataset_infos.json', 'glue.py']
+            ```
+        """
+        repo_type = repo_type or REPO_TYPE_MODEL
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
+        headers = self._build_hf_headers(token=token)
+
+        folder_paths = []
+        if paths is None:
+            # `paths` is not provided => list all files from the repo
+            folder_paths.append("")
+        elif paths == []:
+            # corner case: server would return a 400 error if `paths` is an empty list. Let's return early.
+            return
+        else:
+            # `paths` is provided => get info about those
+            response = get_session().post(
+                f"{self.endpoint}/api/{repo_type}s/{repo_id}/paths-info/{revision}",
+                data={
+                    "paths": paths if isinstance(paths, list) else [paths],
+                    "expand": expand,
+                },
+                headers=headers,
+            )
+            hf_raise_for_status(response)
+            paths_info = response.json()
+
+            # List top-level files first
+            for path_info in paths_info:
+                if path_info["type"] == "file":
+                    yield RepoFile(**path_info)
+                else:
+                    folder_paths.append(path_info["path"])
+
+        # List files in subdirectories
+        for path in folder_paths:
+            encoded_path = "/" + quote(path, safe="") if path else ""
+            tree_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/tree/{revision}{encoded_path}"
+            for subpath_info in paginate(path=tree_url, headers=headers, params={"recursive": True, "expand": expand}):
+                if subpath_info["type"] == "file":
+                    yield RepoFile(**subpath_info)
+
+    @validate_hf_hub_args
+    def list_repo_files(
+        self,
+        repo_id: str,
+        *,
+        revision: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        token: Optional[Union[bool, str]] = None,
+    ) -> List[str]:
+        """
+        Get the list of files in a given repo.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated by a `/`.
+            revision (`str`, *optional*):
+                The revision of the model repository from which to get the information.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or space, `None` or `"model"` if uploading to
+                a model. Default is `None`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token). If `None` or `True` and
+                machine is logged in (through `huggingface-cli login` or [`~huggingface_hub.login`]), token will be
+                retrieved from the cache. If `False`, token is not sent in the request header.
+
+        Returns:
+            `List[str]`: the list of files in a given repository.
+        """
+        return [
+            f.rfilename
+            for f in self.list_repo_tree(
+                repo_id=repo_id, recursive=True, revision=revision, repo_type=repo_type, token=token
+            )
+            if isinstance(f, RepoFile)
+        ]
+
+    @validate_hf_hub_args
+    def list_repo_tree(
+        self,
+        repo_id: str,
+        path_in_repo: Optional[str] = None,
+        *,
+        recursive: bool = False,
+        expand: bool = False,
+        revision: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        token: Optional[Union[bool, str]] = None,
+    ) -> Iterable[Union[RepoFile, RepoFolder]]:
+        """
+        List a repo tree's files and folders and get information about them.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated by a `/`.
+            path_in_repo (`str`, *optional*):
+                Relative path of the tree (folder) in the repo, for example:
+                `"checkpoints/1fec34a/results"`. Will default to the root tree (folder) of the repository.
+            recursive (`bool`, *optional*, defaults to `False`):
+                Whether to list tree's files and folders recursively.
+            expand (`bool`, *optional*, defaults to `False`):
+                Whether to fetch more information about the tree's files and folders (e.g. last commit and files' security scan results). This
+                operation is more expensive for the server so only 50 results are returned per page (instead of 1000).
+                As pagination is implemented in `huggingface_hub`, this is transparent for you except for the time it
+                takes to get the results.
+            revision (`str`, *optional*):
+                The revision of the repository from which to get the tree. Defaults to `"main"` branch.
+            repo_type (`str`, *optional*):
+                The type of the repository from which to get the tree (`"model"`, `"dataset"` or `"space"`.
+                Defaults to `"model"`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token). If `None` or `True` and
+                machine is logged in (through `huggingface-cli login` or [`~huggingface_hub.login`]), token will be
+                retrieved from the cache. If `False`, token is not sent in the request header.
+
+        Returns:
+            `Iterable[Union[RepoFile, RepoFolder]]`:
+                The information about the tree's files and folders, as an iterable of [`RepoFile`] and [`RepoFolder`] objects. The order of the files and folders is
+                not guaranteed.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private but not authenticated or repo
+                does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If revision is not found (error 404) on the repo.
+            [`~utils.EntryNotFoundError`]:
+                If the tree (folder) does not exist (error 404) on the repo.
+
+        Examples:
+
+            Get information about a repo's tree.
+            ```py
+            >>> from huggingface_hub import list_repo_tree
+            >>> repo_tree = list_repo_tree("lysandre/arxiv-nlp")
+            >>> repo_tree
+            <generator object HfApi.list_repo_tree at 0x7fa4088e1ac0>
+            >>> list(repo_tree)
+            [
+                RepoFile(path='.gitattributes', size=391, blob_id='ae8c63daedbd4206d7d40126955d4e6ab1c80f8f', lfs=None, last_commit=None, security=None),
+                RepoFile(path='README.md', size=391, blob_id='43bd404b159de6fba7c2f4d3264347668d43af25', lfs=None, last_commit=None, security=None),
+                RepoFile(path='config.json', size=554, blob_id='2f9618c3a19b9a61add74f70bfb121335aeef666', lfs=None, last_commit=None, security=None),
+                RepoFile(
+                    path='flax_model.msgpack', size=497764107, blob_id='8095a62ccb4d806da7666fcda07467e2d150218e',
+                    lfs={'size': 497764107, 'sha256': 'd88b0d6a6ff9c3f8151f9d3228f57092aaea997f09af009eefd7373a77b5abb9', 'pointer_size': 134}, last_commit=None, security=None
+                ),
+                RepoFile(path='merges.txt', size=456318, blob_id='226b0752cac7789c48f0cb3ec53eda48b7be36cc', lfs=None, last_commit=None, security=None),
+                RepoFile(
+                    path='pytorch_model.bin', size=548123560, blob_id='64eaa9c526867e404b68f2c5d66fd78e27026523',
+                    lfs={'size': 548123560, 'sha256': '9be78edb5b928eba33aa88f431551348f7466ba9f5ef3daf1d552398722a5436', 'pointer_size': 134}, last_commit=None, security=None
+                ),
+                RepoFile(path='vocab.json', size=898669, blob_id='b00361fece0387ca34b4b8b8539ed830d644dbeb', lfs=None, last_commit=None, security=None)]
+            ]
+            ```
+
+            Get even more information about a repo's tree (last commit and files' security scan results)
+            ```py
+            >>> from huggingface_hub import list_repo_tree
+            >>> repo_tree = list_repo_tree("prompthero/openjourney-v4", expand=True)
+            >>> list(repo_tree)
+            [
+                RepoFolder(
+                    path='feature_extractor',
+                    tree_id='aa536c4ea18073388b5b0bc791057a7296a00398',
+                    last_commit={
+                        'oid': '47b62b20b20e06b9de610e840282b7e6c3d51190',
+                        'title': 'Upload diffusers weights (#48)',
+                        'date': datetime.datetime(2023, 3, 21, 9, 5, 27, tzinfo=datetime.timezone.utc)
+                    }
+                ),
+                RepoFolder(
+                    path='safety_checker',
+                    tree_id='65aef9d787e5557373fdf714d6c34d4fcdd70440',
+                    last_commit={
+                        'oid': '47b62b20b20e06b9de610e840282b7e6c3d51190',
+                        'title': 'Upload diffusers weights (#48)',
+                        'date': datetime.datetime(2023, 3, 21, 9, 5, 27, tzinfo=datetime.timezone.utc)
+                    }
+                ),
+                RepoFile(
+                    path='model_index.json',
+                    size=582,
+                    blob_id='d3d7c1e8c3e78eeb1640b8e2041ee256e24c9ee1',
+                    lfs=None,
+                    last_commit={
+                        'oid': 'b195ed2d503f3eb29637050a886d77bd81d35f0e',
+                        'title': 'Fix deprecation warning by changing `CLIPFeatureExtractor` to `CLIPImageProcessor`. (#54)',
+                        'date': datetime.datetime(2023, 5, 15, 21, 41, 59, tzinfo=datetime.timezone.utc)
+                    },
+                    security={
+                        'safe': True,
+                        'av_scan': {'virusFound': False, 'virusNames': None},
+                        'pickle_import_scan': None
+                    }
+                )
+                ...
+            ]
+            ```
+        """
+        repo_type = repo_type or REPO_TYPE_MODEL
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
+        headers = self._build_hf_headers(token=token)
+
+        encoded_path_in_repo = "/" + quote(path_in_repo, safe="") if path_in_repo else ""
+        tree_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/tree/{revision}{encoded_path_in_repo}"
+        for path_info in paginate(path=tree_url, headers=headers, params={"recursive": recursive, "expand": expand}):
+            yield (RepoFile(**path_info) if path_info["type"] == "file" else RepoFolder(**path_info))
+
+    @validate_hf_hub_args
+    def list_repo_refs(
+        self,
+        repo_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        include_pull_requests: bool = False,
+        token: Optional[Union[bool, str]] = None,
+    ) -> GitRefs:
+        """
+        Get the list of refs of a given repo (both tags and branches).
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if listing refs from a dataset or a Space,
+                `None` or `"model"` if listing from a model. Default is `None`.
+            include_pull_requests (`bool`, *optional*):
+                Whether to include refs from pull requests in the list. Defaults to `False`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+        >>> api.list_repo_refs("gpt2")
+        GitRefs(branches=[GitRefInfo(name='main', ref='refs/heads/main', target_commit='e7da7f221d5bf496a48136c0cd264e630fe9fcc8')], converts=[], tags=[])
+
+        >>> api.list_repo_refs("bigcode/the-stack", repo_type='dataset')
+        GitRefs(
+            branches=[
+                GitRefInfo(name='main', ref='refs/heads/main', target_commit='18edc1591d9ce72aa82f56c4431b3c969b210ae3'),
+                GitRefInfo(name='v1.1.a1', ref='refs/heads/v1.1.a1', target_commit='f9826b862d1567f3822d3d25649b0d6d22ace714')
+            ],
+            converts=[],
+            tags=[
+                GitRefInfo(name='v1.0', ref='refs/tags/v1.0', target_commit='c37a8cd1e382064d8aced5e05543c5f7753834da')
+            ]
+        )
+        ```
+
+        Returns:
+            [`GitRefs`]: object containing all information about branches and tags for a
+            repo on the Hub.
+        """
+        repo_type = repo_type or REPO_TYPE_MODEL
+        response = get_session().get(
+            f"{self.endpoint}/api/{repo_type}s/{repo_id}/refs",
+            headers=self._build_hf_headers(token=token),
+            params={"include_prs": 1} if include_pull_requests else {},
+        )
+        hf_raise_for_status(response)
+        data = response.json()
+
+        def _format_as_git_ref_info(item: Dict) -> GitRefInfo:
+            return GitRefInfo(name=item["name"], ref=item["ref"], target_commit=item["targetCommit"])
+
+        return GitRefs(
+            branches=[_format_as_git_ref_info(item) for item in data["branches"]],
+            converts=[_format_as_git_ref_info(item) for item in data["converts"]],
+            tags=[_format_as_git_ref_info(item) for item in data["tags"]],
+            pull_requests=[_format_as_git_ref_info(item) for item in data["pullRequests"]]
+            if include_pull_requests
+            else None,
+        )
+
+    @validate_hf_hub_args
+    def list_repo_commits(
+        self,
+        repo_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        token: Optional[Union[bool, str]] = None,
+        revision: Optional[str] = None,
+        formatted: bool = False,
+    ) -> List[GitCommitInfo]:
+        """
+        Get the list of commits of a given revision for a repo on the Hub.
+
+        Commits are sorted by date (last commit first).
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated by a `/`.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if listing commits from a dataset or a Space, `None` or `"model"` if
+                listing from a model. Default is `None`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            formatted (`bool`):
+                Whether to return the HTML-formatted title and description of the commits. Defaults to False.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+
+        # Commits are sorted by date (last commit first)
+        >>> initial_commit = api.list_repo_commits("gpt2")[-1]
+
+        # Initial commit is always a system commit containing the `.gitattributes` file.
+        >>> initial_commit
+        GitCommitInfo(
+            commit_id='9b865efde13a30c13e0a33e536cf3e4a5a9d71d8',
+            authors=['system'],
+            created_at=datetime.datetime(2019, 2, 18, 10, 36, 15, tzinfo=datetime.timezone.utc),
+            title='initial commit',
+            message='',
+            formatted_title=None,
+            formatted_message=None
+        )
+
+        # Create an empty branch by deriving from initial commit
+        >>> api.create_branch("gpt2", "new_empty_branch", revision=initial_commit.commit_id)
+        ```
+
+        Returns:
+            List[[`GitCommitInfo`]]: list of objects containing information about the commits for a repo on the Hub.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private but not authenticated or repo
+                does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If revision is not found (error 404) on the repo.
+        """
+        repo_type = repo_type or REPO_TYPE_MODEL
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
+
+        # Paginate over results and return the list of commits.
+        return [
+            GitCommitInfo(
+                commit_id=item["id"],
+                authors=[author["user"] for author in item["authors"]],
+                created_at=parse_datetime(item["date"]),
+                title=item["title"],
+                message=item["message"],
+                formatted_title=item.get("formatted", {}).get("title"),
+                formatted_message=item.get("formatted", {}).get("message"),
+            )
+            for item in paginate(
+                f"{self.endpoint}/api/{repo_type}s/{repo_id}/commits/{revision}",
+                headers=self._build_hf_headers(token=token),
+                params={"expand[]": "formatted"} if formatted else {},
+            )
+        ]
+
+    @validate_hf_hub_args
+    def get_paths_info(
+        self,
+        repo_id: str,
+        paths: Union[List[str], str],
+        *,
+        expand: bool = False,
+        revision: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        token: Optional[Union[bool, str]] = None,
+    ) -> List[Union[RepoFile, RepoFolder]]:
+        """
+        Get information about a repo's paths.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated by a `/`.
+            paths (`Union[List[str], str]`, *optional*):
+                The paths to get information about. If a path do not exist, it is ignored without raising
+                an exception.
+            expand (`bool`, *optional*, defaults to `False`):
+                Whether to fetch more information about the paths (e.g. last commit and files' security scan results). This
+                operation is more expensive for the server so only 50 results are returned per page (instead of 1000).
+                As pagination is implemented in `huggingface_hub`, this is transparent for you except for the time it
+                takes to get the results.
+            revision (`str`, *optional*):
+                The revision of the repository from which to get the information. Defaults to `"main"` branch.
+            repo_type (`str`, *optional*):
+                The type of the repository from which to get the information (`"model"`, `"dataset"` or `"space"`.
+                Defaults to `"model"`.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token). If `None` or `True` and
+                machine is logged in (through `huggingface-cli login` or [`~huggingface_hub.login`]), token will be
+                retrieved from the cache. If `False`, token is not sent in the request header.
+
+        Returns:
+            `List[Union[RepoFile, RepoFolder]]`:
+                The information about the paths, as a list of [`RepoFile`] and [`RepoFolder`] objects.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private but not authenticated or repo
+                does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If revision is not found (error 404) on the repo.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import get_paths_info
+        >>> paths_info = get_paths_info("allenai/c4", ["README.md", "en"], repo_type="dataset")
+        >>> paths_info
+        [
+            RepoFile(path='README.md', size=2379, blob_id='f84cb4c97182890fc1dbdeaf1a6a468fd27b4fff', lfs=None, last_commit=None, security=None),
+            RepoFolder(path='en', tree_id='dc943c4c40f53d02b31ced1defa7e5f438d5862e', last_commit=None)
+        ]
+        ```
+        """
+        repo_type = repo_type or REPO_TYPE_MODEL
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
+        headers = self._build_hf_headers(token=token)
+
+        response = get_session().post(
+            f"{self.endpoint}/api/{repo_type}s/{repo_id}/paths-info/{revision}",
+            data={
+                "paths": paths if isinstance(paths, list) else [paths],
+                "expand": expand,
+            },
+            headers=headers,
+        )
+        hf_raise_for_status(response)
+        paths_info = response.json()
+        return [
+            RepoFile(**path_info) if path_info["type"] == "file" else RepoFolder(**path_info)
+            for path_info in paths_info
+        ]
+
+    @validate_hf_hub_args
+    def super_squash_history(
+        self,
+        repo_id: str,
+        *,
+        branch: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> None:
+        """Squash commit history on a branch for a repo on the Hub.
+
+        Squashing the repo history is useful when you know you'll make hundreds of commits and you don't want to
+        clutter the history. Squashing commits can only be performed from the head of a branch.
+
+        <Tip warning={true}>
+
+        Once squashed, the commit history cannot be retrieved. This is a non-revertible operation.
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        Once the history of a branch has been squashed, it is not possible to merge it back into another branch since
+        their history will have diverged.
+
+        </Tip>
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated by a `/`.
+            branch (`str`, *optional*):
+                The branch to squash. Defaults to the head of the `"main"` branch.
+            commit_message (`str`, *optional*):
+                The commit message to use for the squashed commit.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if listing commits from a dataset or a Space, `None` or `"model"` if
+                listing from a model. Default is `None`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token). If the machine is logged in
+                (through `huggingface-cli login` or [`~huggingface_hub.login`]), token can be automatically retrieved
+                from the cache.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private but not authenticated or repo
+                does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If the branch to squash cannot be found.
+            [`~utils.BadRequestError`]:
+                If invalid reference for a branch. You cannot squash history on tags.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+
+        # Create repo
+        >>> repo_id = api.create_repo("test-squash").repo_id
+
+        # Make a lot of commits.
+        >>> api.upload_file(repo_id=repo_id, path_in_repo="file.txt", path_or_fileobj=b"content")
+        >>> api.upload_file(repo_id=repo_id, path_in_repo="lfs.bin", path_or_fileobj=b"content")
+        >>> api.upload_file(repo_id=repo_id, path_in_repo="file.txt", path_or_fileobj=b"another_content")
+
+        # Squash history
+        >>> api.super_squash_history(repo_id=repo_id)
+        ```
+        """
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        if repo_type not in REPO_TYPES:
+            raise ValueError("Invalid repo type")
+        if branch is None:
+            branch = DEFAULT_REVISION
+
+        # Prepare request
+        url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/super-squash/{branch}"
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+        commit_message = commit_message or f"Super-squash branch '{branch}' using huggingface_hub"
+
+        # Super-squash
+        response = get_session().post(url=url, headers=headers, json={"message": commit_message})
+        hf_raise_for_status(response)
+
+    @validate_hf_hub_args
+    def create_repo(
+        self,
+        repo_id: str,
+        *,
+        token: Optional[str] = None,
+        private: bool = False,
+        repo_type: Optional[str] = None,
+        exist_ok: bool = False,
+        space_sdk: Optional[str] = None,
+        space_hardware: Optional[SpaceHardware] = None,
+        space_storage: Optional[SpaceStorage] = None,
+        space_sleep_time: Optional[int] = None,
+        space_secrets: Optional[List[Dict[str, str]]] = None,
+        space_variables: Optional[List[Dict[str, str]]] = None,
+    ) -> RepoUrl:
+        """Create an empty repo on the HuggingFace Hub.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+            private (`bool`, *optional*, defaults to `False`):
+                Whether the model repo should be private.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            exist_ok (`bool`, *optional*, defaults to `False`):
+                If `True`, do not raise an error if repo already exists.
+            space_sdk (`str`, *optional*):
+                Choice of SDK to use if repo_type is "space". Can be "streamlit", "gradio", "docker", or "static".
+            space_hardware (`SpaceHardware` or `str`, *optional*):
+                Choice of Hardware if repo_type is "space". See [`SpaceHardware`] for a complete list.
+            space_storage (`SpaceStorage` or `str`, *optional*):
+                Choice of persistent storage tier. Example: `"small"`. See [`SpaceStorage`] for a complete list.
+            space_sleep_time (`int`, *optional*):
+                Number of seconds of inactivity to wait before a Space is put to sleep. Set to `-1` if you don't want
+                your Space to sleep (default behavior for upgraded hardware). For free hardware, you can't configure
+                the sleep time (value is fixed to 48 hours of inactivity).
+                See https://huggingface.co/docs/hub/spaces-gpus#sleep-time for more details.
+            space_secrets (`List[Dict[str, str]]`, *optional*):
+                A list of secret keys to set in your Space. Each item is in the form `{"key": ..., "value": ..., "description": ...}` where description is optional.
+                For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets.
+            space_variables (`List[Dict[str, str]]`, *optional*):
+                A list of public environment variables to set in your Space. Each item is in the form `{"key": ..., "value": ..., "description": ...}` where description is optional.
+                For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets-and-environment-variables.
+
+        Returns:
+            [`RepoUrl`]: URL to the newly created repo. Value is a subclass of `str` containing
+            attributes like `endpoint`, `repo_type` and `repo_id`.
+        """
+        organization, name = repo_id.split("/") if "/" in repo_id else (None, repo_id)
+
+        path = f"{self.endpoint}/api/repos/create"
+
+        if repo_type not in REPO_TYPES:
+            raise ValueError("Invalid repo type")
+
+        json: Dict[str, Any] = {"name": name, "organization": organization, "private": private}
+        if repo_type is not None:
+            json["type"] = repo_type
+        if repo_type == "space":
+            if space_sdk is None:
+                raise ValueError(
+                    "No space_sdk provided. `create_repo` expects space_sdk to be one"
+                    f" of {SPACES_SDK_TYPES} when repo_type is 'space'`"
+                )
+            if space_sdk not in SPACES_SDK_TYPES:
+                raise ValueError(f"Invalid space_sdk. Please choose one of {SPACES_SDK_TYPES}.")
+            json["sdk"] = space_sdk
+
+        if space_sdk is not None and repo_type != "space":
+            warnings.warn("Ignoring provided space_sdk because repo_type is not 'space'.")
+
+        function_args = [
+            "space_hardware",
+            "space_storage",
+            "space_sleep_time",
+            "space_secrets",
+            "space_variables",
+        ]
+        json_keys = ["hardware", "storageTier", "sleepTimeSeconds", "secrets", "variables"]
+        values = [space_hardware, space_storage, space_sleep_time, space_secrets, space_variables]
+
+        if repo_type == "space":
+            json.update({k: v for k, v in zip(json_keys, values) if v is not None})
+        else:
+            provided_space_args = [key for key, value in zip(function_args, values) if value is not None]
+
+            if provided_space_args:
+                warnings.warn(f"Ignoring provided {', '.join(provided_space_args)} because repo_type is not 'space'.")
+
+        if getattr(self, "_lfsmultipartthresh", None):
+            # Testing purposes only.
+            # See https://github.com/huggingface/huggingface_hub/pull/733/files#r820604472
+            json["lfsmultipartthresh"] = self._lfsmultipartthresh  # type: ignore
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+
+        while True:
+            r = get_session().post(path, headers=headers, json=json)
+            if r.status_code == 409 and "Cannot create repo: another conflicting operation is in progress" in r.text:
+                # Since https://github.com/huggingface/moon-landing/pull/7272 (private repo), it is not possible to
+                # concurrently create repos on the Hub for a same user. This is rarely an issue, except when running
+                # tests. To avoid any inconvenience, we retry to create the repo for this specific error.
+                # NOTE: This could have being fixed directly in the tests but adding it here should fixed CIs for all
+                # dependent libraries.
+                # NOTE: If a fix is implemented server-side, we should be able to remove this retry mechanism.
+                logger.debug("Create repo failed due to a concurrency issue. Retrying...")
+                continue
+            break
+
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as err:
+            if exist_ok and err.response.status_code == 409:
+                # Repo already exists and `exist_ok=True`
+                pass
+            elif exist_ok and err.response.status_code == 403:
+                # No write permission on the namespace but repo might already exist
+                try:
+                    self.repo_info(repo_id=repo_id, repo_type=repo_type, token=token)
+                    if repo_type is None or repo_type == REPO_TYPE_MODEL:
+                        return RepoUrl(f"{self.endpoint}/{repo_id}")
+                    return RepoUrl(f"{self.endpoint}/{repo_type}/{repo_id}")
+                except HfHubHTTPError:
+                    raise
+            else:
+                raise
+
+        d = r.json()
+        return RepoUrl(d["url"], endpoint=self.endpoint)
+
+    @validate_hf_hub_args
+    def delete_repo(
+        self,
+        repo_id: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        missing_ok: bool = False,
+    ) -> None:
+        """
+        Delete a repo from the HuggingFace Hub. CAUTION: this is irreversible.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model.
+            missing_ok (`bool`, *optional*, defaults to `False`):
+                If `True`, do not raise an error if repo does not exist.
+
+        Raises:
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to delete from cannot be found and `missing_ok` is set to False (default).
+        """
+        organization, name = repo_id.split("/") if "/" in repo_id else (None, repo_id)
+
+        path = f"{self.endpoint}/api/repos/delete"
+
+        if repo_type not in REPO_TYPES:
+            raise ValueError("Invalid repo type")
+
+        json = {"name": name, "organization": organization}
+        if repo_type is not None:
+            json["type"] = repo_type
+
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+        r = get_session().delete(path, headers=headers, json=json)
+        try:
+            hf_raise_for_status(r)
+        except RepositoryNotFoundError:
+            if not missing_ok:
+                raise
+
+    @validate_hf_hub_args
+    def update_repo_visibility(
+        self,
+        repo_id: str,
+        private: bool = False,
+        *,
+        token: Optional[str] = None,
+        organization: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> Dict[str, bool]:
+        """Update the visibility setting of a repository.
+
+        Args:
+            repo_id (`str`, *optional*):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            private (`bool`, *optional*, defaults to `False`):
+                Whether the model repo should be private.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+
+        Returns:
+            The HTTP response in json.
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        if repo_type not in REPO_TYPES:
+            raise ValueError("Invalid repo type")
+
+        organization, name = repo_id.split("/") if "/" in repo_id else (None, repo_id)
+
+        if organization is None:
+            namespace = self.whoami(token)["name"]
+        else:
+            namespace = organization
+
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL  # default repo type
+
+        r = get_session().put(
+            url=f"{self.endpoint}/api/{repo_type}s/{namespace}/{name}/settings",
+            headers=self._build_hf_headers(token=token, is_write_action=True),
+            json={"private": private},
+        )
+        hf_raise_for_status(r)
+        return r.json()
+
+    def move_repo(
+        self,
+        from_id: str,
+        to_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ):
+        """
+        Moving a repository from namespace1/repo_name1 to namespace2/repo_name2
+
+        Note there are certain limitations. For more information about moving
+        repositories, please see
+        https://hf.co/docs/hub/repositories-settings#renaming-or-transferring-a-repo.
+
+        Args:
+            from_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`. Original repository identifier.
+            to_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`. Final repository identifier.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        if len(from_id.split("/")) != 2:
+            raise ValueError(f"Invalid repo_id: {from_id}. It should have a namespace (:namespace:/:repo_name:)")
+
+        if len(to_id.split("/")) != 2:
+            raise ValueError(f"Invalid repo_id: {to_id}. It should have a namespace (:namespace:/:repo_name:)")
+
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL  # Hub won't accept `None`.
+
+        json = {"fromRepo": from_id, "toRepo": to_id, "type": repo_type}
+
+        path = f"{self.endpoint}/api/repos/move"
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+        r = get_session().post(path, headers=headers, json=json)
+        try:
+            hf_raise_for_status(r)
+        except HfHubHTTPError as e:
+            e.append_to_message(
+                "\nFor additional documentation please see"
+                " https://hf.co/docs/hub/repositories-settings#renaming-or-transferring-a-repo."
+            )
+            raise
+
+    @overload
+    def create_commit(  # type: ignore
+        self,
+        repo_id: str,
+        operations: Iterable[CommitOperation],
+        *,
+        commit_message: str,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        num_threads: int = 5,
+        parent_commit: Optional[str] = None,
+        run_as_future: Literal[False] = ...,
+    ) -> CommitInfo:
+        ...
+
+    @overload
+    def create_commit(
+        self,
+        repo_id: str,
+        operations: Iterable[CommitOperation],
+        *,
+        commit_message: str,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        num_threads: int = 5,
+        parent_commit: Optional[str] = None,
+        run_as_future: Literal[True] = ...,
+    ) -> Future[CommitInfo]:
+        ...
+
+    @validate_hf_hub_args
+    @future_compatible
+    def create_commit(
+        self,
+        repo_id: str,
+        operations: Iterable[CommitOperation],
+        *,
+        commit_message: str,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        num_threads: int = 5,
+        parent_commit: Optional[str] = None,
+        run_as_future: bool = False,
+    ) -> Union[CommitInfo, Future[CommitInfo]]:
+        """
+        Creates a commit in the given repo, deleting & uploading files as needed.
+
+        <Tip warning={true}>
+
+        The input list of `CommitOperation` will be mutated during the commit process. Do not reuse the same objects
+        for multiple commits.
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        `create_commit` assumes that the repo already exists on the Hub. If you get a
+        Client error 404, please make sure you are authenticated and that `repo_id` and
+        `repo_type` are set correctly. If repo does not exist, create it first using
+        [`~hf_api.create_repo`].
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        `create_commit` is limited to 25k LFS files and a 1GB payload for regular files.
+
+        </Tip>
+
+        Args:
+            repo_id (`str`):
+                The repository in which the commit will be created, for example:
+                `"username/custom_transformers"`
+
+            operations (`Iterable` of [`~hf_api.CommitOperation`]):
+                An iterable of operations to include in the commit, either:
+
+                    - [`~hf_api.CommitOperationAdd`] to upload a file
+                    - [`~hf_api.CommitOperationDelete`] to delete a file
+                    - [`~hf_api.CommitOperationCopy`] to copy a file
+
+                Operation objects will be mutated to include information relative to the upload. Do not reuse the
+                same objects for multiple commits.
+
+            commit_message (`str`):
+                The summary (first line) of the commit that will be created.
+
+            commit_description (`str`, *optional*):
+                The description of the commit that will be created
+
+            token (`str`, *optional*):
+                Authentication token, obtained with `HfApi.login` method. Will
+                default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+
+            create_pr (`boolean`, *optional*):
+                Whether or not to create a Pull Request with that commit. Defaults to `False`.
+                If `revision` is not set, PR is opened against the `"main"` branch. If
+                `revision` is set and is a branch, PR is opened against this branch. If
+                `revision` is set and is not a branch name (example: a commit oid), an
+                `RevisionNotFoundError` is returned by the server.
+
+            num_threads (`int`, *optional*):
+                Number of concurrent threads for uploading files. Defaults to 5.
+                Setting it to 2 means at most 2 files will be uploaded concurrently.
+
+            parent_commit (`str`, *optional*):
+                The OID / SHA of the parent commit, as a hexadecimal string.
+                Shorthands (7 first characters) are also supported. If specified and `create_pr` is `False`,
+                the commit will fail if `revision` does not point to `parent_commit`. If specified and `create_pr`
+                is `True`, the pull request will be created from `parent_commit`. Specifying `parent_commit`
+                ensures the repo has not changed before committing the changes, and can be especially useful
+                if the repo is updated / committed to concurrently.
+            run_as_future (`bool`, *optional*):
+                Whether or not to run this method in the background. Background jobs are run sequentially without
+                blocking the main thread. Passing `run_as_future=True` will return a [Future](https://docs.python.org/3/library/concurrent.futures.html#future-objects)
+                object. Defaults to `False`.
+
+        Returns:
+            [`CommitInfo`] or `Future`:
+                Instance of [`CommitInfo`] containing information about the newly created commit (commit hash, commit
+                url, pr url, commit message,...). If `run_as_future=True` is passed, returns a Future object which will
+                contain the result when executed.
+
+        Raises:
+            [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+                If commit message is empty.
+            [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+                If parent commit is not a valid commit OID.
+            [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+                If the Hub API returns an HTTP 400 error (bad request)
+            [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+                If `create_pr` is `True` and revision is neither `None` nor `"main"`.
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private
+                but not authenticated or repo does not exist.
+        """
+        if parent_commit is not None and not REGEX_COMMIT_OID.fullmatch(parent_commit):
+            raise ValueError(
+                f"`parent_commit` is not a valid commit OID. It must match the following regex: {REGEX_COMMIT_OID}"
+            )
+
+        if commit_message is None or len(commit_message) == 0:
+            raise ValueError("`commit_message` can't be empty, please pass a value.")
+
+        commit_description = commit_description if commit_description is not None else ""
+        repo_type = repo_type if repo_type is not None else REPO_TYPE_MODEL
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        unquoted_revision = revision or DEFAULT_REVISION
+        revision = quote(unquoted_revision, safe="")
+        create_pr = create_pr if create_pr is not None else False
+
+        operations = list(operations)
+        additions = [op for op in operations if isinstance(op, CommitOperationAdd)]
+        copies = [op for op in operations if isinstance(op, CommitOperationCopy)]
+        nb_additions = len(additions)
+        nb_copies = len(copies)
+        nb_deletions = len(operations) - nb_additions - nb_copies
+
+        for addition in additions:
+            if addition._is_committed:
+                raise ValueError(
+                    f"CommitOperationAdd {addition} has already being committed and cannot be reused. Please create a"
+                    " new CommitOperationAdd object if you want to create a new commit."
+                )
+
+        logger.debug(
+            f"About to commit to the hub: {len(additions)} addition(s), {len(copies)} copie(s) and"
+            f" {nb_deletions} deletion(s)."
+        )
+
+        # If updating twice the same file or update then delete a file in a single commit
+        _warn_on_overwriting_operations(operations)
+
+        self.preupload_lfs_files(
+            repo_id=repo_id,
+            additions=additions,
+            token=token,
+            repo_type=repo_type,
+            revision=unquoted_revision,  # first-class methods take unquoted revision
+            create_pr=create_pr,
+            num_threads=num_threads,
+            free_memory=False,  # do not remove `CommitOperationAdd.path_or_fileobj` on LFS files for "normal" users
+        )
+        files_to_copy = _fetch_lfs_files_to_copy(
+            copies=copies,
+            repo_type=repo_type,
+            repo_id=repo_id,
+            token=token or self.token,
+            revision=revision,
+            endpoint=self.endpoint,
+        )
+        commit_payload = _prepare_commit_payload(
+            operations=operations,
+            files_to_copy=files_to_copy,
+            commit_message=commit_message,
+            commit_description=commit_description,
+            parent_commit=parent_commit,
+        )
+        commit_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/commit/{revision}"
+
+        def _payload_as_ndjson() -> Iterable[bytes]:
+            for item in commit_payload:
+                yield json.dumps(item).encode()
+                yield b"\n"
+
+        headers = {
+            # See https://github.com/huggingface/huggingface_hub/issues/1085#issuecomment-1265208073
+            "Content-Type": "application/x-ndjson",
+            **self._build_hf_headers(token=token, is_write_action=True),
+        }
+        data = b"".join(_payload_as_ndjson())
+        params = {"create_pr": "1"} if create_pr else None
+
+        try:
+            commit_resp = get_session().post(url=commit_url, headers=headers, data=data, params=params)
+            hf_raise_for_status(commit_resp, endpoint_name="commit")
+        except RepositoryNotFoundError as e:
+            e.append_to_message(_CREATE_COMMIT_NO_REPO_ERROR_MESSAGE)
+            raise
+        except EntryNotFoundError as e:
+            if nb_deletions > 0 and "A file with this name doesn't exist" in str(e):
+                e.append_to_message(
+                    "\nMake sure to differentiate file and folder paths in delete"
+                    " operations with a trailing '/' or using `is_folder=True/False`."
+                )
+            raise
+
+        # Mark additions as committed (cannot be reused in another commit)
+        for addition in additions:
+            addition._is_committed = True
+
+        commit_data = commit_resp.json()
+        return CommitInfo(
+            commit_url=commit_data["commitUrl"],
+            commit_message=commit_message,
+            commit_description=commit_description,
+            oid=commit_data["commitOid"],
+            pr_url=commit_data["pullRequestUrl"] if create_pr else None,
+        )
+
+    @experimental
+    @validate_hf_hub_args
+    def create_commits_on_pr(
+        self,
+        *,
+        repo_id: str,
+        addition_commits: List[List[CommitOperationAdd]],
+        deletion_commits: List[List[CommitOperationDelete]],
+        commit_message: str,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        merge_pr: bool = True,
+        num_threads: int = 5,  # TODO: use to multithread uploads
+        verbose: bool = False,
+    ) -> str:
+        """Push changes to the Hub in multiple commits.
+
+        Commits are pushed to a draft PR branch. If the upload fails or gets interrupted, it can be resumed. Progress
+        is tracked in the PR description. At the end of the process, the PR is set as open and the title is updated to
+        match the initial commit message. If `merge_pr=True` is passed, the PR is merged automatically.
+
+        All deletion commits are pushed first, followed by the addition commits. The order of the commits is not
+        guaranteed as we might implement parallel commits in the future. Be sure that your are not updating several
+        times the same file.
+
+        <Tip warning={true}>
+
+        `create_commits_on_pr` is experimental.  Its API and behavior is subject to change in the future without prior notice.
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        `create_commits_on_pr` assumes that the repo already exists on the Hub. If you get a Client error 404, please
+        make sure you are authenticated and that `repo_id` and `repo_type` are set correctly. If repo does not exist,
+        create it first using [`~hf_api.create_repo`].
+
+        </Tip>
+
+        Args:
+            repo_id (`str`):
+                The repository in which the commits will be pushed. Example: `"username/my-cool-model"`.
+
+            addition_commits (`List` of `List` of [`~hf_api.CommitOperationAdd`]):
+                A list containing lists of [`~hf_api.CommitOperationAdd`]. Each sublist will result in a commit on the
+                PR.
+
+            deletion_commits
+                A list containing lists of [`~hf_api.CommitOperationDelete`]. Each sublist will result in a commit on
+                the PR. Deletion commits are pushed before addition commits.
+
+            commit_message (`str`):
+                The summary (first line) of the commit that will be created. Will also be the title of the PR.
+
+            commit_description (`str`, *optional*):
+                The description of the commit that will be created. The description will be added to the PR.
+
+            token (`str`, *optional*):
+                Authentication token, obtained with `HfApi.login` method. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or space, `None` or `"model"` if uploading to
+                a model. Default is `None`.
+
+            merge_pr (`bool`):
+                If set to `True`, the Pull Request is merged at the end of the process. Defaults to `True`.
+
+            num_threads (`int`, *optional*):
+                Number of concurrent threads for uploading files. Defaults to 5.
+
+            verbose (`bool`):
+                If set to `True`, process will run on verbose mode i.e. print information about the ongoing tasks.
+                Defaults to `False`.
+
+        Returns:
+            `str`: URL to the created PR.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import HfApi, plan_multi_commits
+        >>> addition_commits, deletion_commits = plan_multi_commits(
+        ...     operations=[
+        ...          CommitOperationAdd(...),
+        ...          CommitOperationAdd(...),
+        ...          CommitOperationDelete(...),
+        ...          CommitOperationDelete(...),
+        ...          CommitOperationAdd(...),
+        ...     ],
+        ... )
+        >>> HfApi().create_commits_on_pr(
+        ...     repo_id="my-cool-model",
+        ...     addition_commits=addition_commits,
+        ...     deletion_commits=deletion_commits,
+        ...     (...)
+        ...     verbose=True,
+        ... )
+        ```
+
+        Raises:
+            [`MultiCommitException`]:
+                If an unexpected issue occur in the process: empty commits, unexpected commits in a PR, unexpected PR
+                description, etc.
+        """
+        logger = logging.get_logger(__name__ + ".create_commits_on_pr")
+        if verbose:
+            logger.setLevel("INFO")
+
+        # 1. Get strategy ID
+        logger.info(
+            f"Will create {len(deletion_commits)} deletion commit(s) and {len(addition_commits)} addition commit(s),"
+            f" totalling {sum(len(ops) for ops in addition_commits+deletion_commits)} atomic operations."
+        )
+        strategy = MultiCommitStrategy(
+            addition_commits=[MultiCommitStep(operations=operations) for operations in addition_commits],  # type: ignore
+            deletion_commits=[MultiCommitStep(operations=operations) for operations in deletion_commits],  # type: ignore
+        )
+        logger.info(f"Multi-commits strategy with ID {strategy.id}.")
+
+        # 2. Get or create a PR with this strategy ID
+        for discussion in self.get_repo_discussions(repo_id=repo_id, repo_type=repo_type, token=token):
+            # search for a draft PR with strategy ID
+            if discussion.is_pull_request and discussion.status == "draft" and strategy.id in discussion.title:
+                pr = self.get_discussion_details(
+                    repo_id=repo_id, discussion_num=discussion.num, repo_type=repo_type, token=token
+                )
+                logger.info(f"PR already exists: {pr.url}. Will resume process where it stopped.")
+                break
+        else:
+            # did not find a PR matching the strategy ID
+            pr = multi_commit_create_pull_request(
+                self,
+                repo_id=repo_id,
+                commit_message=commit_message,
+                commit_description=commit_description,
+                strategy=strategy,
+                token=token,
+                repo_type=repo_type,
+            )
+            logger.info(f"New PR created: {pr.url}")
+
+        # 3. Parse PR description to check consistency with strategy (e.g. same commits are scheduled)
+        for event in pr.events:
+            if isinstance(event, DiscussionComment):
+                pr_comment = event
+                break
+        else:
+            raise MultiCommitException(f"PR #{pr.num} must have at least 1 comment")
+
+        description_commits = multi_commit_parse_pr_description(pr_comment.content)
+        if len(description_commits) != len(strategy.all_steps):
+            raise MultiCommitException(
+                f"Corrupted multi-commit PR #{pr.num}: got {len(description_commits)} steps in"
+                f" description but {len(strategy.all_steps)} in strategy."
+            )
+        for step_id in strategy.all_steps:
+            if step_id not in description_commits:
+                raise MultiCommitException(
+                    f"Corrupted multi-commit PR #{pr.num}: expected step {step_id} but didn't find"
+                    f" it (have {', '.join(description_commits)})."
+                )
+
+        # 4. Retrieve commit history (and check consistency)
+        commits_on_main_branch = {
+            commit.commit_id
+            for commit in self.list_repo_commits(
+                repo_id=repo_id, repo_type=repo_type, token=token, revision=DEFAULT_REVISION
+            )
+        }
+        pr_commits = [
+            commit
+            for commit in self.list_repo_commits(
+                repo_id=repo_id, repo_type=repo_type, token=token, revision=pr.git_reference
+            )
+            if commit.commit_id not in commits_on_main_branch
+        ]
+        if len(pr_commits) > 0:
+            logger.info(f"Found {len(pr_commits)} existing commits on the PR.")
+
+        # At this point `pr_commits` is a list of commits pushed to the PR. We expect all of these commits (if any) to have
+        # a step_id as title. We raise exception if an unexpected commit has been pushed.
+        if len(pr_commits) > len(strategy.all_steps):
+            raise MultiCommitException(
+                f"Corrupted multi-commit PR #{pr.num}: scheduled {len(strategy.all_steps)} steps but"
+                f" {len(pr_commits)} commits have already been pushed to the PR."
+            )
+
+        # Check which steps are already completed
+        remaining_additions = {step.id: step for step in strategy.addition_commits}
+        remaining_deletions = {step.id: step for step in strategy.deletion_commits}
+        for commit in pr_commits:
+            if commit.title in remaining_additions:
+                step = remaining_additions.pop(commit.title)
+                step.completed = True
+            elif commit.title in remaining_deletions:
+                step = remaining_deletions.pop(commit.title)
+                step.completed = True
+
+        if len(remaining_deletions) > 0 and len(remaining_additions) < len(strategy.addition_commits):
+            raise MultiCommitException(
+                f"Corrupted multi-commit PR #{pr.num}: some addition commits have already been pushed to the PR but"
+                " deletion commits are not all completed yet."
+            )
+        nb_remaining = len(remaining_deletions) + len(remaining_additions)
+        if len(pr_commits) > 0:
+            logger.info(
+                f"{nb_remaining} commits remaining ({len(remaining_deletions)} deletion commits and"
+                f" {len(remaining_additions)} addition commits)"
+            )
+
+        # 5. Push remaining commits to the PR + update description
+        # TODO: multi-thread this
+        for step in list(remaining_deletions.values()) + list(remaining_additions.values()):
+            # Push new commit
+            self.create_commit(
+                repo_id=repo_id,
+                repo_type=repo_type,
+                token=token,
+                commit_message=step.id,
+                revision=pr.git_reference,
+                num_threads=num_threads,
+                operations=step.operations,
+                create_pr=False,
+            )
+            step.completed = True
+            nb_remaining -= 1
+            logger.info(f"  step {step.id} completed (still {nb_remaining} to go).")
+
+            # Update PR description
+            self.edit_discussion_comment(
+                repo_id=repo_id,
+                repo_type=repo_type,
+                token=token,
+                discussion_num=pr.num,
+                comment_id=pr_comment.id,
+                new_content=multi_commit_generate_comment(
+                    commit_message=commit_message, commit_description=commit_description, strategy=strategy
+                ),
+            )
+        logger.info("All commits have been pushed.")
+
+        # 6. Update PR (and merge)
+        self.rename_discussion(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            token=token,
+            discussion_num=pr.num,
+            new_title=commit_message,
+        )
+        self.change_discussion_status(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            token=token,
+            discussion_num=pr.num,
+            new_status="open",
+            comment=MULTI_COMMIT_PR_COMPLETION_COMMENT_TEMPLATE,
+        )
+        logger.info("PR is now open for reviews.")
+
+        if merge_pr:  # User don't want a PR => merge it
+            try:
+                self.merge_pull_request(
+                    repo_id=repo_id,
+                    repo_type=repo_type,
+                    token=token,
+                    discussion_num=pr.num,
+                    comment=MULTI_COMMIT_PR_CLOSING_COMMENT_TEMPLATE,
+                )
+                logger.info("PR has been automatically merged (`merge_pr=True` was passed).")
+            except BadRequestError as error:
+                if error.server_message is not None and "no associated changes" in error.server_message:
+                    # PR cannot be merged as no changes are associated. We close the PR without merging with a comment to
+                    # explain.
+                    self.change_discussion_status(
+                        repo_id=repo_id,
+                        repo_type=repo_type,
+                        token=token,
+                        discussion_num=pr.num,
+                        comment=MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_NO_CHANGES_TEMPLATE,
+                        new_status="closed",
+                    )
+                    logger.warning("Couldn't merge the PR: no associated changes.")
+                else:
+                    # PR cannot be merged for another reason (conflicting files for example). We comment the PR to explain
+                    # and re-raise the exception.
+                    self.comment_discussion(
+                        repo_id=repo_id,
+                        repo_type=repo_type,
+                        token=token,
+                        discussion_num=pr.num,
+                        comment=MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_BAD_REQUEST_TEMPLATE.format(
+                            error_message=error.server_message
+                        ),
+                    )
+                    raise MultiCommitException(
+                        f"Couldn't merge Pull Request in multi-commit: {error.server_message}"
+                    ) from error
+
+        return pr.url
+
+    def preupload_lfs_files(
+        self,
+        repo_id: str,
+        additions: Iterable[CommitOperationAdd],
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        num_threads: int = 5,
+        free_memory: bool = True,
+        gitignore_content: Optional[str] = None,
+    ):
+        """Pre-upload LFS files to S3 in preparation on a future commit.
+
+        This method is useful if you are generating the files to upload on-the-fly and you don't want to store them
+        in memory before uploading them all at once.
+
+        <Tip warning={true}>
+
+        This is a power-user method. You shouldn't need to call it directly to make a normal commit.
+        Use [`create_commit`] directly instead.
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        Commit operations will be mutated during the process. In particular, the attached `path_or_fileobj` will be
+        removed after the upload to save memory (and replaced by an empty `bytes` object). Do not reuse the same
+        objects except to pass them to [`create_commit`]. If you don't want to remove the attached content from the
+        commit operation object, pass `free_memory=False`.
+
+        </Tip>
+
+        Args:
+            repo_id (`str`):
+                The repository in which you will commit the files, for example: `"username/custom_transformers"`.
+
+            operations (`Iterable` of [`CommitOperationAdd`]):
+                The list of files to upload. Warning: the objects in this list will be mutated to include information
+                relative to the upload. Do not reuse the same objects for multiple commits.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                The type of repository to upload to (e.g. `"model"` -default-, `"dataset"` or `"space"`).
+
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+
+            create_pr (`boolean`, *optional*):
+                Whether or not you plan to create a Pull Request with that commit. Defaults to `False`.
+
+            num_threads (`int`, *optional*):
+                Number of concurrent threads for uploading files. Defaults to 5.
+                Setting it to 2 means at most 2 files will be uploaded concurrently.
+
+            gitignore_content (`str`, *optional*):
+                The content of the `.gitignore` file to know which files should be ignored. The order of priority
+                is to first check if `gitignore_content` is passed, then check if the `.gitignore` file is present
+                in the list of files to commit and finally default to the `.gitignore` file already hosted on the Hub
+                (if any).
+
+        Example:
+        ```py
+        >>> from huggingface_hub import CommitOperationAdd, preupload_lfs_files, create_commit, create_repo
+
+        >>> repo_id = create_repo("test_preupload").repo_id
+
+        # Generate and preupload LFS files one by one
+        >>> operations = [] # List of all `CommitOperationAdd` objects that will be generated
+        >>> for i in range(5):
+        ...     content = ... # generate binary content
+        ...     addition = CommitOperationAdd(path_in_repo=f"shard_{i}_of_5.bin", path_or_fileobj=content)
+        ...     preupload_lfs_files(repo_id, additions=[addition]) # upload + free memory
+        ...     operations.append(addition)
+
+        # Create commit
+        >>> create_commit(repo_id, operations=operations, commit_message="Commit all shards")
+        ```
+        """
+        repo_type = repo_type if repo_type is not None else REPO_TYPE_MODEL
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
+        create_pr = create_pr if create_pr is not None else False
+
+        # Check if a `gitignore` file is being committed to the Hub.
+        additions = list(additions)
+        if gitignore_content is None:
+            for addition in additions:
+                if addition.path_in_repo == ".gitignore":
+                    with addition.as_file() as f:
+                        gitignore_content = f.read().decode()
+                        break
+
+        # Filter out already uploaded files
+        new_additions = [addition for addition in additions if not addition._is_uploaded]
+
+        # Check which new files are LFS
+        try:
+            _fetch_upload_modes(
+                additions=new_additions,
+                repo_type=repo_type,
+                repo_id=repo_id,
+                token=token or self.token,
+                revision=revision,
+                endpoint=self.endpoint,
+                create_pr=create_pr or False,
+                gitignore_content=gitignore_content,
+            )
+        except RepositoryNotFoundError as e:
+            e.append_to_message(_CREATE_COMMIT_NO_REPO_ERROR_MESSAGE)
+            raise
+
+        # Filter out regular files
+        new_lfs_additions = [addition for addition in new_additions if addition._upload_mode == "lfs"]
+
+        # Filter out files listed in .gitignore
+        new_lfs_additions_to_upload = []
+        for addition in new_lfs_additions:
+            if addition._should_ignore:
+                logger.debug(f"Skipping upload for LFS file '{addition.path_in_repo}' (ignored by gitignore file).")
+            else:
+                new_lfs_additions_to_upload.append(addition)
+        if len(new_lfs_additions) != len(new_lfs_additions_to_upload):
+            logger.info(
+                f"Skipped upload for {len(new_lfs_additions) - len(new_lfs_additions_to_upload)} LFS file(s) "
+                "(ignored by gitignore file)."
+            )
+
+        # Upload new LFS files
+        _upload_lfs_files(
+            additions=new_lfs_additions_to_upload,
+            repo_type=repo_type,
+            repo_id=repo_id,
+            token=token or self.token,
+            endpoint=self.endpoint,
+            num_threads=num_threads,
+            # If `create_pr`, we don't want to check user permission on the revision as users with read permission
+            # should still be able to create PRs even if they don't have write permission on the target branch of the
+            # PR (i.e. `revision`).
+            revision=revision if not create_pr else None,
+        )
+        for addition in new_lfs_additions_to_upload:
+            addition._is_uploaded = True
+            if free_memory:
+                addition.path_or_fileobj = b""
+
+    @overload
+    def upload_file(  # type: ignore
+        self,
+        *,
+        path_or_fileobj: Union[str, Path, bytes, BinaryIO],
+        path_in_repo: str,
+        repo_id: str,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        run_as_future: Literal[False] = ...,
+    ) -> CommitInfo:
+        ...
+
+    @overload
+    def upload_file(
+        self,
+        *,
+        path_or_fileobj: Union[str, Path, bytes, BinaryIO],
+        path_in_repo: str,
+        repo_id: str,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        run_as_future: Literal[True] = ...,
+    ) -> Future[CommitInfo]:
+        ...
+
+    @validate_hf_hub_args
+    @future_compatible
+    def upload_file(
+        self,
+        *,
+        path_or_fileobj: Union[str, Path, bytes, BinaryIO],
+        path_in_repo: str,
+        repo_id: str,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        run_as_future: bool = False,
+    ) -> Union[CommitInfo, Future[CommitInfo]]:
+        """
+        Upload a local file (up to 50 GB) to the given repo. The upload is done
+        through a HTTP post request, and doesn't require git or git-lfs to be
+        installed.
+
+        Args:
+            path_or_fileobj (`str`, `Path`, `bytes`, or `IO`):
+                Path to a file on the local machine or binary data stream /
+                fileobj / buffer.
+            path_in_repo (`str`):
+                Relative filepath in the repo, for example:
+                `"checkpoints/1fec34a/weights.bin"`
+            repo_id (`str`):
+                The repository to which the file will be uploaded, for example:
+                `"username/custom_transformers"`
+            token (`str`, *optional*):
+                Authentication token, obtained with `HfApi.login` method. Will
+                default to the stored token.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            commit_message (`str`, *optional*):
+                The summary / title / first line of the generated commit
+            commit_description (`str` *optional*)
+                The description of the generated commit
+            create_pr (`boolean`, *optional*):
+                Whether or not to create a Pull Request with that commit. Defaults to `False`.
+                If `revision` is not set, PR is opened against the `"main"` branch. If
+                `revision` is set and is a branch, PR is opened against this branch. If
+                `revision` is set and is not a branch name (example: a commit oid), an
+                `RevisionNotFoundError` is returned by the server.
+            parent_commit (`str`, *optional*):
+                The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+                If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+                If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+                Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+                especially useful if the repo is updated / committed to concurrently.
+            run_as_future (`bool`, *optional*):
+                Whether or not to run this method in the background. Background jobs are run sequentially without
+                blocking the main thread. Passing `run_as_future=True` will return a [Future](https://docs.python.org/3/library/concurrent.futures.html#future-objects)
+                object. Defaults to `False`.
+
+
+        Returns:
+            [`CommitInfo`] or `Future`:
+                Instance of [`CommitInfo`] containing information about the newly created commit (commit hash, commit
+                url, pr url, commit message,...). If `run_as_future=True` is passed, returns a Future object which will
+                contain the result when executed.
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+            - [`~utils.RevisionNotFoundError`]
+              If the revision to download from cannot be found.
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        `upload_file` assumes that the repo already exists on the Hub. If you get a
+        Client error 404, please make sure you are authenticated and that `repo_id` and
+        `repo_type` are set correctly. If repo does not exist, create it first using
+        [`~hf_api.create_repo`].
+
+        </Tip>
+
+        Example:
+
+        ```python
+        >>> from huggingface_hub import upload_file
+
+        >>> with open("./local/filepath", "rb") as fobj:
+        ...     upload_file(
+        ...         path_or_fileobj=fileobj,
+        ...         path_in_repo="remote/file/path.h5",
+        ...         repo_id="username/my-dataset",
+        ...         repo_type="dataset",
+        ...         token="my_token",
+        ...     )
+        "https://huggingface.co/datasets/username/my-dataset/blob/main/remote/file/path.h5"
+
+        >>> upload_file(
+        ...     path_or_fileobj=".\\\\local\\\\file\\\\path",
+        ...     path_in_repo="remote/file/path.h5",
+        ...     repo_id="username/my-model",
+        ...     token="my_token",
+        ... )
+        "https://huggingface.co/username/my-model/blob/main/remote/file/path.h5"
+
+        >>> upload_file(
+        ...     path_or_fileobj=".\\\\local\\\\file\\\\path",
+        ...     path_in_repo="remote/file/path.h5",
+        ...     repo_id="username/my-model",
+        ...     token="my_token",
+        ...     create_pr=True,
+        ... )
+        "https://huggingface.co/username/my-model/blob/refs%2Fpr%2F1/remote/file/path.h5"
+        ```
+        """
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+
+        commit_message = (
+            commit_message if commit_message is not None else f"Upload {path_in_repo} with huggingface_hub"
+        )
+        operation = CommitOperationAdd(
+            path_or_fileobj=path_or_fileobj,
+            path_in_repo=path_in_repo,
+        )
+
+        commit_info = self.create_commit(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            operations=[operation],
+            commit_message=commit_message,
+            commit_description=commit_description,
+            token=token,
+            revision=revision,
+            create_pr=create_pr,
+            parent_commit=parent_commit,
+        )
+
+        if commit_info.pr_url is not None:
+            revision = quote(_parse_revision_from_pr_url(commit_info.pr_url), safe="")
+        if repo_type in REPO_TYPES_URL_PREFIXES:
+            repo_id = REPO_TYPES_URL_PREFIXES[repo_type] + repo_id
+        revision = revision if revision is not None else DEFAULT_REVISION
+
+        return CommitInfo(
+            commit_url=commit_info.commit_url,
+            commit_message=commit_info.commit_message,
+            commit_description=commit_info.commit_description,
+            oid=commit_info.oid,
+            pr_url=commit_info.pr_url,
+            # Similar to `hf_hub_url` but it's "blob" instead of "resolve"
+            # TODO: remove this in v1.0
+            _url=f"{self.endpoint}/{repo_id}/blob/{revision}/{path_in_repo}",
+        )
+
+    @overload
+    def upload_folder(  # type: ignore
+        self,
+        *,
+        repo_id: str,
+        folder_path: Union[str, Path],
+        path_in_repo: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        delete_patterns: Optional[Union[List[str], str]] = None,
+        multi_commits: Literal[False] = ...,
+        multi_commits_verbose: bool = False,
+        run_as_future: Literal[False] = ...,
+    ) -> CommitInfo:
+        ...
+
+    @overload
+    def upload_folder(  # type: ignore
+        self,
+        *,
+        repo_id: str,
+        folder_path: Union[str, Path],
+        path_in_repo: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        delete_patterns: Optional[Union[List[str], str]] = None,
+        multi_commits: Literal[True] = ...,
+        multi_commits_verbose: bool = False,
+        run_as_future: Literal[False] = ...,
+    ) -> str:  # Only the PR url in multi-commits mode
+        ...
+
+    @overload
+    def upload_folder(  # type: ignore
+        self,
+        *,
+        repo_id: str,
+        folder_path: Union[str, Path],
+        path_in_repo: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        delete_patterns: Optional[Union[List[str], str]] = None,
+        multi_commits: Literal[False] = ...,
+        multi_commits_verbose: bool = False,
+        run_as_future: Literal[True] = ...,
+    ) -> Future[CommitInfo]:
+        ...
+
+    @overload
+    def upload_folder(
+        self,
+        *,
+        repo_id: str,
+        folder_path: Union[str, Path],
+        path_in_repo: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        delete_patterns: Optional[Union[List[str], str]] = None,
+        multi_commits: Literal[True] = ...,
+        multi_commits_verbose: bool = False,
+        run_as_future: Literal[True] = ...,
+    ) -> Future[str]:  # Only the PR url in multi-commits mode
+        ...
+
+    @validate_hf_hub_args
+    @future_compatible
+    def upload_folder(
+        self,
+        *,
+        repo_id: str,
+        folder_path: Union[str, Path],
+        path_in_repo: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        delete_patterns: Optional[Union[List[str], str]] = None,
+        multi_commits: bool = False,
+        multi_commits_verbose: bool = False,
+        run_as_future: bool = False,
+    ) -> Union[CommitInfo, str, Future[CommitInfo], Future[str]]:
+        """
+        Upload a local folder to the given repo. The upload is done through a HTTP requests, and doesn't require git or
+        git-lfs to be installed.
+
+        The structure of the folder will be preserved. Files with the same name already present in the repository will
+        be overwritten. Others will be left untouched.
+
+        Use the `allow_patterns` and `ignore_patterns` arguments to specify which files to upload. These parameters
+        accept either a single pattern or a list of patterns. Patterns are Standard Wildcards (globbing patterns) as
+        documented [here](https://tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm). If both `allow_patterns` and
+        `ignore_patterns` are provided, both constraints apply. By default, all files from the folder are uploaded.
+
+        Use the `delete_patterns` argument to specify remote files you want to delete. Input type is the same as for
+        `allow_patterns` (see above). If `path_in_repo` is also provided, the patterns are matched against paths
+        relative to this folder. For example, `upload_folder(..., path_in_repo="experiment", delete_patterns="logs/*")`
+        will delete any remote file under `./experiment/logs/`. Note that the `.gitattributes` file will not be deleted
+        even if it matches the patterns.
+
+        Any `.git/` folder present in any subdirectory will be ignored. However, please be aware that the `.gitignore`
+        file is not taken into account.
+
+        Uses `HfApi.create_commit` under the hood.
+
+        Args:
+            repo_id (`str`):
+                The repository to which the file will be uploaded, for example:
+                `"username/custom_transformers"`
+            folder_path (`str` or `Path`):
+                Path to the folder to upload on the local file system
+            path_in_repo (`str`, *optional*):
+                Relative path of the directory in the repo, for example:
+                `"checkpoints/1fec34a/results"`. Will default to the root folder of the repository.
+            token (`str`, *optional*):
+                Authentication token, obtained with `HfApi.login` method. Will
+                default to the stored token.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            commit_message (`str`, *optional*):
+                The summary / title / first line of the generated commit. Defaults to:
+                `f"Upload {path_in_repo} with huggingface_hub"`
+            commit_description (`str` *optional*):
+                The description of the generated commit
+            create_pr (`boolean`, *optional*):
+                Whether or not to create a Pull Request with that commit. Defaults to `False`. If `revision` is not
+                set, PR is opened against the `"main"` branch. If `revision` is set and is a branch, PR is opened
+                against this branch. If `revision` is set and is not a branch name (example: a commit oid), an
+                `RevisionNotFoundError` is returned by the server. If both `multi_commits` and `create_pr` are True,
+                the PR created in the multi-commit process is kept opened.
+            parent_commit (`str`, *optional*):
+                The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+                If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+                If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+                Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+                especially useful if the repo is updated / committed to concurrently.
+            allow_patterns (`List[str]` or `str`, *optional*):
+                If provided, only files matching at least one pattern are uploaded.
+            ignore_patterns (`List[str]` or `str`, *optional*):
+                If provided, files matching any of the patterns are not uploaded.
+            delete_patterns (`List[str]` or `str`, *optional*):
+                If provided, remote files matching any of the patterns will be deleted from the repo while committing
+                new files. This is useful if you don't know which files have already been uploaded.
+                Note: to avoid discrepancies the `.gitattributes` file is not deleted even if it matches the pattern.
+            multi_commits (`bool`):
+                If True, changes are pushed to a PR using a multi-commit process. Defaults to `False`.
+            multi_commits_verbose (`bool`):
+                If True and `multi_commits` is used, more information will be displayed to the user.
+            run_as_future (`bool`, *optional*):
+                Whether or not to run this method in the background. Background jobs are run sequentially without
+                blocking the main thread. Passing `run_as_future=True` will return a [Future](https://docs.python.org/3/library/concurrent.futures.html#future-objects)
+                object. Defaults to `False`.
+
+        Returns:
+            [`CommitInfo`] or `Future`:
+                Instance of [`CommitInfo`] containing information about the newly created commit (commit hash, commit
+                url, pr url, commit message,...). If `run_as_future=True` is passed, returns a Future object which will
+                contain the result when executed.
+            [`str`] or `Future`:
+                If `multi_commits=True`, returns the url of the PR created to push the changes. If `run_as_future=True`
+                is passed, returns a Future object which will contain the result when executed.
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+            if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            if some parameter value is invalid
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        `upload_folder` assumes that the repo already exists on the Hub. If you get a Client error 404, please make
+        sure you are authenticated and that `repo_id` and `repo_type` are set correctly. If repo does not exist, create
+        it first using [`~hf_api.create_repo`].
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        `multi_commits` is experimental. Its API and behavior is subject to change in the future without prior notice.
+
+        </Tip>
+
+        Example:
+
+        ```python
+        # Upload checkpoints folder except the log files
+        >>> upload_folder(
+        ...     folder_path="local/checkpoints",
+        ...     path_in_repo="remote/experiment/checkpoints",
+        ...     repo_id="username/my-dataset",
+        ...     repo_type="datasets",
+        ...     token="my_token",
+        ...     ignore_patterns="**/logs/*.txt",
+        ... )
+        # "https://huggingface.co/datasets/username/my-dataset/tree/main/remote/experiment/checkpoints"
+
+        # Upload checkpoints folder including logs while deleting existing logs from the repo
+        # Useful if you don't know exactly which log files have already being pushed
+        >>> upload_folder(
+        ...     folder_path="local/checkpoints",
+        ...     path_in_repo="remote/experiment/checkpoints",
+        ...     repo_id="username/my-dataset",
+        ...     repo_type="datasets",
+        ...     token="my_token",
+        ...     delete_patterns="**/logs/*.txt",
+        ... )
+        "https://huggingface.co/datasets/username/my-dataset/tree/main/remote/experiment/checkpoints"
+
+        # Upload checkpoints folder while creating a PR
+        >>> upload_folder(
+        ...     folder_path="local/checkpoints",
+        ...     path_in_repo="remote/experiment/checkpoints",
+        ...     repo_id="username/my-dataset",
+        ...     repo_type="datasets",
+        ...     token="my_token",
+        ...     create_pr=True,
+        ... )
+        "https://huggingface.co/datasets/username/my-dataset/tree/refs%2Fpr%2F1/remote/experiment/checkpoints"
+
+        ```
+        """
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+
+        if multi_commits:
+            if revision is not None and revision != DEFAULT_REVISION:
+                raise ValueError("Cannot use `multi_commit` to commit changes other than the main branch.")
+
+        # By default, upload folder to the root directory in repo.
+        if path_in_repo is None:
+            path_in_repo = ""
+
+        # Do not upload .git folder
+        if ignore_patterns is None:
+            ignore_patterns = []
+        elif isinstance(ignore_patterns, str):
+            ignore_patterns = [ignore_patterns]
+        ignore_patterns += IGNORE_GIT_FOLDER_PATTERNS
+
+        delete_operations = self._prepare_upload_folder_deletions(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=DEFAULT_REVISION if create_pr else revision,
+            token=token,
+            path_in_repo=path_in_repo,
+            delete_patterns=delete_patterns,
+        )
+        add_operations = _prepare_upload_folder_additions(
+            folder_path,
+            path_in_repo,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+        )
+
+        # Optimize operations: if some files will be overwritten, we don't need to delete them first
+        if len(add_operations) > 0:
+            added_paths = set(op.path_in_repo for op in add_operations)
+            delete_operations = [
+                delete_op for delete_op in delete_operations if delete_op.path_in_repo not in added_paths
+            ]
+        commit_operations = delete_operations + add_operations
+
+        commit_message = commit_message or "Upload folder using huggingface_hub"
+        if multi_commits:
+            addition_commits, deletion_commits = plan_multi_commits(operations=commit_operations)
+            pr_url = self.create_commits_on_pr(
+                repo_id=repo_id,
+                repo_type=repo_type,
+                addition_commits=addition_commits,
+                deletion_commits=deletion_commits,
+                commit_message=commit_message,
+                commit_description=commit_description,
+                token=token,
+                merge_pr=not create_pr,
+                verbose=multi_commits_verbose,
+            )
+            # Defining a CommitInfo object is not really relevant in this case
+            # Let's return early with pr_url only (as string).
+            return pr_url
+
+        commit_info = self.create_commit(
+            repo_type=repo_type,
+            repo_id=repo_id,
+            operations=commit_operations,
+            commit_message=commit_message,
+            commit_description=commit_description,
+            token=token,
+            revision=revision,
+            create_pr=create_pr,
+            parent_commit=parent_commit,
+        )
+
+        # Create url to uploaded folder (for legacy return value)
+        if create_pr and commit_info.pr_url is not None:
+            revision = quote(_parse_revision_from_pr_url(commit_info.pr_url), safe="")
+        if repo_type in REPO_TYPES_URL_PREFIXES:
+            repo_id = REPO_TYPES_URL_PREFIXES[repo_type] + repo_id
+        revision = revision if revision is not None else DEFAULT_REVISION
+
+        return CommitInfo(
+            commit_url=commit_info.commit_url,
+            commit_message=commit_info.commit_message,
+            commit_description=commit_info.commit_description,
+            oid=commit_info.oid,
+            pr_url=commit_info.pr_url,
+            # Similar to `hf_hub_url` but it's "tree" instead of "resolve"
+            # TODO: remove this in v1.0
+            _url=f"{self.endpoint}/{repo_id}/tree/{revision}/{path_in_repo}",
+        )
+
+    @validate_hf_hub_args
+    def delete_file(
+        self,
+        path_in_repo: str,
+        repo_id: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+    ) -> CommitInfo:
+        """
+        Deletes a file in the given repo.
+
+        Args:
+            path_in_repo (`str`):
+                Relative filepath in the repo, for example:
+                `"checkpoints/1fec34a/weights.bin"`
+            repo_id (`str`):
+                The repository from which the file will be deleted, for example:
+                `"username/custom_transformers"`
+            token (`str`, *optional*):
+                Authentication token, obtained with `HfApi.login` method. Will
+                default to the stored token.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if the file is in a dataset or
+                space, `None` or `"model"` if in a model. Default is `None`.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            commit_message (`str`, *optional*):
+                The summary / title / first line of the generated commit. Defaults to
+                `f"Delete {path_in_repo} with huggingface_hub"`.
+            commit_description (`str` *optional*)
+                The description of the generated commit
+            create_pr (`boolean`, *optional*):
+                Whether or not to create a Pull Request with that commit. Defaults to `False`.
+                If `revision` is not set, PR is opened against the `"main"` branch. If
+                `revision` is set and is a branch, PR is opened against this branch. If
+                `revision` is set and is not a branch name (example: a commit oid), an
+                `RevisionNotFoundError` is returned by the server.
+            parent_commit (`str`, *optional*):
+                The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+                If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+                If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+                Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+                especially useful if the repo is updated / committed to concurrently.
+
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+            - [`~utils.RevisionNotFoundError`]
+              If the revision to download from cannot be found.
+            - [`~utils.EntryNotFoundError`]
+              If the file to download cannot be found.
+
+        </Tip>
+
+        """
+        commit_message = (
+            commit_message if commit_message is not None else f"Delete {path_in_repo} with huggingface_hub"
+        )
+
+        operations = [CommitOperationDelete(path_in_repo=path_in_repo)]
+
+        return self.create_commit(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            token=token,
+            operations=operations,
+            revision=revision,
+            commit_message=commit_message,
+            commit_description=commit_description,
+            create_pr=create_pr,
+            parent_commit=parent_commit,
+        )
+
+    @validate_hf_hub_args
+    def delete_folder(
+        self,
+        path_in_repo: str,
+        repo_id: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+    ) -> CommitInfo:
+        """
+        Deletes a folder in the given repo.
+
+        Simple wrapper around [`create_commit`] method.
+
+        Args:
+            path_in_repo (`str`):
+                Relative folder path in the repo, for example: `"checkpoints/1fec34a"`.
+            repo_id (`str`):
+                The repository from which the folder will be deleted, for example:
+                `"username/custom_transformers"`
+            token (`str`, *optional*):
+                Authentication token, obtained with `HfApi.login` method. Will default
+                to the stored token.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if the folder is in a dataset or
+                space, `None` or `"model"` if in a model. Default is `None`.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            commit_message (`str`, *optional*):
+                The summary / title / first line of the generated commit. Defaults to
+                `f"Delete folder {path_in_repo} with huggingface_hub"`.
+            commit_description (`str` *optional*)
+                The description of the generated commit.
+            create_pr (`boolean`, *optional*):
+                Whether or not to create a Pull Request with that commit. Defaults to `False`.
+                If `revision` is not set, PR is opened against the `"main"` branch. If
+                `revision` is set and is a branch, PR is opened against this branch. If
+                `revision` is set and is not a branch name (example: a commit oid), an
+                `RevisionNotFoundError` is returned by the server.
+            parent_commit (`str`, *optional*):
+                The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+                If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+                If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+                Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+                especially useful if the repo is updated / committed to concurrently.
+        """
+        return self.create_commit(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            token=token,
+            operations=[CommitOperationDelete(path_in_repo=path_in_repo, is_folder=True)],
+            revision=revision,
+            commit_message=(
+                commit_message if commit_message is not None else f"Delete folder {path_in_repo} with huggingface_hub"
+            ),
+            commit_description=commit_description,
+            create_pr=create_pr,
+            parent_commit=parent_commit,
+        )
+
+    @validate_hf_hub_args
+    def get_hf_file_metadata(
+        self,
+        *,
+        url: str,
+        token: Union[bool, str, None] = None,
+        proxies: Optional[Dict] = None,
+        timeout: Optional[float] = DEFAULT_REQUEST_TIMEOUT,
+    ) -> HfFileMetadata:
+        """Fetch metadata of a file versioned on the Hub for a given url.
+
+        Args:
+            url (`str`):
+                File url, for example returned by [`hf_hub_url`].
+            token (`str` or `bool`, *optional*):
+                A token to be used for the download.
+                    - If `True`, the token is read from the HuggingFace config
+                    folder.
+                    - If `False` or `None`, no token is provided.
+                    - If a string, it's used as the authentication token.
+            proxies (`dict`, *optional*):
+                Dictionary mapping protocol to the URL of the proxy passed to `requests.request`.
+            timeout (`float`, *optional*, defaults to 10):
+                How many seconds to wait for the server to send metadata before giving up.
+
+        Returns:
+            A [`HfFileMetadata`] object containing metadata such as location, etag, size and commit_hash.
+        """
+        if token is None:
+            # Cannot do `token = token or self.token` as token can be `False`.
+            token = self.token
+
+        return get_hf_file_metadata(
+            url=url,
+            token=token,
+            proxies=proxies,
+            timeout=timeout,
+            library_name=self.library_name,
+            library_version=self.library_version,
+            user_agent=self.user_agent,
+        )
+
+    @validate_hf_hub_args
+    def hf_hub_download(
+        self,
+        repo_id: str,
+        filename: str,
+        *,
+        subfolder: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        cache_dir: Union[str, Path, None] = None,
+        local_dir: Union[str, Path, None] = None,
+        local_dir_use_symlinks: Union[bool, Literal["auto"]] = "auto",
+        force_download: bool = False,
+        force_filename: Optional[str] = None,
+        proxies: Optional[Dict] = None,
+        etag_timeout: float = DEFAULT_ETAG_TIMEOUT,
+        resume_download: bool = False,
+        token: Optional[Union[str, bool]] = None,
+        local_files_only: bool = False,
+        legacy_cache_layout: bool = False,
+    ) -> str:
+        """Download a given file if it's not already present in the local cache.
+
+        The new cache file layout looks like this:
+        - The cache directory contains one subfolder per repo_id (namespaced by repo type)
+        - inside each repo folder:
+            - refs is a list of the latest known revision => commit_hash pairs
+            - blobs contains the actual file blobs (identified by their git-sha or sha256, depending on
+            whether they're LFS files or not)
+            - snapshots contains one subfolder per commit, each "commit" contains the subset of the files
+            that have been resolved at that particular commit. Each filename is a symlink to the blob
+            at that particular commit.
+
+        If `local_dir` is provided, the file structure from the repo will be replicated in this location. You can configure
+        how you want to move those files:
+        - If `local_dir_use_symlinks="auto"` (default), files are downloaded and stored in the cache directory as blob
+            files. Small files (<5MB) are duplicated in `local_dir` while a symlink is created for bigger files. The goal
+            is to be able to manually edit and save small files without corrupting the cache while saving disk space for
+            binary files. The 5MB threshold can be configured with the `HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD`
+            environment variable.
+        - If `local_dir_use_symlinks=True`, files are downloaded, stored in the cache directory and symlinked in `local_dir`.
+            This is optimal in term of disk usage but files must not be manually edited.
+        - If `local_dir_use_symlinks=False` and the blob files exist in the cache directory, they are duplicated in the
+            local dir. This means disk usage is not optimized.
+        - Finally, if `local_dir_use_symlinks=False` and the blob files do not exist in the cache directory, then the
+            files are downloaded and directly placed under `local_dir`. This means if you need to download them again later,
+            they will be re-downloaded entirely.
+
+        ```
+        [  96]  .
+        └── [ 160]  models--julien-c--EsperBERTo-small
+            ├── [ 160]  blobs
+            │   ├── [321M]  403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+            │   ├── [ 398]  7cb18dc9bafbfcf74629a4b760af1b160957a83e
+            │   └── [1.4K]  d7edf6bd2a681fb0175f7735299831ee1b22b812
+            ├── [  96]  refs
+            │   └── [  40]  main
+            └── [ 128]  snapshots
+                ├── [ 128]  2439f60ef33a0d46d85da5001d52aeda5b00ce9f
+                │   ├── [  52]  README.md -> ../../blobs/d7edf6bd2a681fb0175f7735299831ee1b22b812
+                │   └── [  76]  pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+                └── [ 128]  bbc77c8132af1cc5cf678da3f1ddf2de43606d48
+                    ├── [  52]  README.md -> ../../blobs/7cb18dc9bafbfcf74629a4b760af1b160957a83e
+                    └── [  76]  pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+        ```
+
+        Args:
+            repo_id (`str`):
+                A user or an organization name and a repo name separated by a `/`.
+            filename (`str`):
+                The name of the file in the repo.
+            subfolder (`str`, *optional*):
+                An optional value corresponding to a folder inside the model repo.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if downloading from a dataset or space,
+                `None` or `"model"` if downloading from a model. Default is `None`.
+            revision (`str`, *optional*):
+                An optional Git revision id which can be a branch name, a tag, or a
+                commit hash.
+            cache_dir (`str`, `Path`, *optional*):
+                Path to the folder where cached files are stored.
+            local_dir (`str` or `Path`, *optional*):
+                If provided, the downloaded file will be placed under this directory, either as a symlink (default) or
+                a regular file (see description for more details).
+            local_dir_use_symlinks (`"auto"` or `bool`, defaults to `"auto"`):
+                To be used with `local_dir`. If set to "auto", the cache directory will be used and the file will be either
+                duplicated or symlinked to the local directory depending on its size. It set to `True`, a symlink will be
+                created, no matter the file size. If set to `False`, the file will either be duplicated from cache (if
+                already exists) or downloaded from the Hub and not cached. See description for more details.
+            force_download (`bool`, *optional*, defaults to `False`):
+                Whether the file should be downloaded even if it already exists in
+                the local cache.
+            proxies (`dict`, *optional*):
+                Dictionary mapping protocol to the URL of the proxy passed to
+                `requests.request`.
+            etag_timeout (`float`, *optional*, defaults to `10`):
+                When fetching ETag, how many seconds to wait for the server to send
+                data before giving up which is passed to `requests.request`.
+            resume_download (`bool`, *optional*, defaults to `False`):
+                If `True`, resume a previously interrupted download.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+            local_files_only (`bool`, *optional*, defaults to `False`):
+                If `True`, avoid downloading the file and return the path to the
+                local cached file if it exists.
+            legacy_cache_layout (`bool`, *optional*, defaults to `False`):
+                If `True`, uses the legacy file cache layout i.e. just call [`hf_hub_url`]
+                then `cached_download`. This is deprecated as the new cache layout is
+                more powerful.
+
+        Returns:
+            Local path (string) of file or if networking is off, last version of
+            file cached on disk.
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            if `token=True` and the token cannot be found.
+            - [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError)
+            if ETag cannot be determined.
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+            If the repository to download from cannot be found. This may be because it doesn't exist,
+            or because it is set to `private` and you do not have access.
+            - [`~utils.RevisionNotFoundError`]
+            If the revision to download from cannot be found.
+            - [`~utils.EntryNotFoundError`]
+            If the file to download cannot be found.
+            - [`~utils.LocalEntryNotFoundError`]
+            If network is disabled or unavailable and file is not found in cache.
+
+        </Tip>
+        """
+        from .file_download import hf_hub_download
+
+        if token is None:
+            # Cannot do `token = token or self.token` as token can be `False`.
+            token = self.token
+
+        return hf_hub_download(
+            repo_id=repo_id,
+            filename=filename,
+            subfolder=subfolder,
+            repo_type=repo_type,
+            revision=revision,
+            endpoint=self.endpoint,
+            library_name=self.library_name,
+            library_version=self.library_version,
+            cache_dir=cache_dir,
+            local_dir=local_dir,
+            local_dir_use_symlinks=local_dir_use_symlinks,
+            user_agent=self.user_agent,
+            force_download=force_download,
+            force_filename=force_filename,
+            proxies=proxies,
+            etag_timeout=etag_timeout,
+            resume_download=resume_download,
+            token=token,
+            local_files_only=local_files_only,
+            legacy_cache_layout=legacy_cache_layout,
+        )
+
+    @validate_hf_hub_args
+    def snapshot_download(
+        self,
+        repo_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        cache_dir: Union[str, Path, None] = None,
+        local_dir: Union[str, Path, None] = None,
+        local_dir_use_symlinks: Union[bool, Literal["auto"]] = "auto",
+        proxies: Optional[Dict] = None,
+        etag_timeout: float = DEFAULT_ETAG_TIMEOUT,
+        resume_download: bool = False,
+        force_download: bool = False,
+        token: Optional[Union[str, bool]] = None,
+        local_files_only: bool = False,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        max_workers: int = 8,
+        tqdm_class: Optional[base_tqdm] = None,
+    ) -> str:
+        """Download repo files.
+
+        Download a whole snapshot of a repo's files at the specified revision. This is useful when you want all files from
+        a repo, because you don't know which ones you will need a priori. All files are nested inside a folder in order
+        to keep their actual filename relative to that folder. You can also filter which files to download using
+        `allow_patterns` and `ignore_patterns`.
+
+        If `local_dir` is provided, the file structure from the repo will be replicated in this location. You can configure
+        how you want to move those files:
+        - If `local_dir_use_symlinks="auto"` (default), files are downloaded and stored in the cache directory as blob
+            files. Small files (<5MB) are duplicated in `local_dir` while a symlink is created for bigger files. The goal
+            is to be able to manually edit and save small files without corrupting the cache while saving disk space for
+            binary files. The 5MB threshold can be configured with the `HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD`
+            environment variable.
+        - If `local_dir_use_symlinks=True`, files are downloaded, stored in the cache directory and symlinked in `local_dir`.
+            This is optimal in term of disk usage but files must not be manually edited.
+        - If `local_dir_use_symlinks=False` and the blob files exist in the cache directory, they are duplicated in the
+            local dir. This means disk usage is not optimized.
+        - Finally, if `local_dir_use_symlinks=False` and the blob files do not exist in the cache directory, then the
+            files are downloaded and directly placed under `local_dir`. This means if you need to download them again later,
+            they will be re-downloaded entirely.
+
+        An alternative would be to clone the repo but this requires git and git-lfs to be installed and properly
+        configured. It is also not possible to filter which files to download when cloning a repository using git.
+
+        Args:
+            repo_id (`str`):
+                A user or an organization name and a repo name separated by a `/`.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if downloading from a dataset or space,
+                `None` or `"model"` if downloading from a model. Default is `None`.
+            revision (`str`, *optional*):
+                An optional Git revision id which can be a branch name, a tag, or a
+                commit hash.
+            cache_dir (`str`, `Path`, *optional*):
+                Path to the folder where cached files are stored.
+            local_dir (`str` or `Path`, *optional*):
+                If provided, the downloaded files will be placed under this directory, either as symlinks (default) or
+                regular files (see description for more details).
+            local_dir_use_symlinks (`"auto"` or `bool`, defaults to `"auto"`):
+                To be used with `local_dir`. If set to "auto", the cache directory will be used and the file will be either
+                duplicated or symlinked to the local directory depending on its size. It set to `True`, a symlink will be
+                created, no matter the file size. If set to `False`, the file will either be duplicated from cache (if
+                already exists) or downloaded from the Hub and not cached. See description for more details.
+            proxies (`dict`, *optional*):
+                Dictionary mapping protocol to the URL of the proxy passed to
+                `requests.request`.
+            etag_timeout (`float`, *optional*, defaults to `10`):
+                When fetching ETag, how many seconds to wait for the server to send
+                data before giving up which is passed to `requests.request`.
+            resume_download (`bool`, *optional*, defaults to `False):
+                If `True`, resume a previously interrupted download.
+            force_download (`bool`, *optional*, defaults to `False`):
+                Whether the file should be downloaded even if it already exists in the local cache.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+            local_files_only (`bool`, *optional*, defaults to `False`):
+                If `True`, avoid downloading the file and return the path to the
+                local cached file if it exists.
+            allow_patterns (`List[str]` or `str`, *optional*):
+                If provided, only files matching at least one pattern are downloaded.
+            ignore_patterns (`List[str]` or `str`, *optional*):
+                If provided, files matching any of the patterns are not downloaded.
+            max_workers (`int`, *optional*):
+                Number of concurrent threads to download files (1 thread = 1 file download).
+                Defaults to 8.
+            tqdm_class (`tqdm`, *optional*):
+                If provided, overwrites the default behavior for the progress bar. Passed
+                argument must inherit from `tqdm.auto.tqdm` or at least mimic its behavior.
+                Note that the `tqdm_class` is not passed to each individual download.
+                Defaults to the custom HF progress bar that can be disabled by setting
+                `HF_HUB_DISABLE_PROGRESS_BARS` environment variable.
+
+        Returns:
+            Local folder path (string) of repo snapshot
+
+        <Tip>
+
+        Raises the following errors:
+
+        - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+        if `token=True` and the token cannot be found.
+        - [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError) if
+        ETag cannot be determined.
+        - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+        if some parameter value is invalid
+
+        </Tip>
+        """
+        from ._snapshot_download import snapshot_download
+
+        if token is None:
+            # Cannot do `token = token or self.token` as token can be `False`.
+            token = self.token
+
+        return snapshot_download(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            endpoint=self.endpoint,
+            cache_dir=cache_dir,
+            local_dir=local_dir,
+            local_dir_use_symlinks=local_dir_use_symlinks,
+            library_name=self.library_name,
+            library_version=self.library_version,
+            user_agent=self.user_agent,
+            proxies=proxies,
+            etag_timeout=etag_timeout,
+            resume_download=resume_download,
+            force_download=force_download,
+            token=token,
+            local_files_only=local_files_only,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            max_workers=max_workers,
+            tqdm_class=tqdm_class,
+        )
+
+    def get_safetensors_metadata(
+        self,
+        repo_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> SafetensorsRepoMetadata:
+        """
+        Parse metadata for a safetensors repo on the Hub.
+
+        We first check if the repo has a single safetensors file or a sharded safetensors repo. If it's a single
+        safetensors file, we parse the metadata from this file. If it's a sharded safetensors repo, we parse the
+        metadata from the index file and then parse the metadata from each shard.
+
+        To parse metadata from a single safetensors file, use [`get_safetensors_metadata`].
+
+        For more details regarding the safetensors format, check out https://huggingface.co/docs/safetensors/index#format.
+
+        Args:
+            repo_id (`str`):
+                A user or an organization name and a repo name separated by a `/`.
+            filename (`str`):
+                The name of the file in the repo.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if the file is in a dataset or space, `None` or `"model"` if in a
+                model. Default is `None`.
+            revision (`str`, *optional*):
+                The git revision to fetch the file from. Can be a branch name, a tag, or a commit hash. Defaults to the
+                head of the `"main"` branch.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token). If `None` or `True` and
+                machine is logged in (through `huggingface-cli login` or [`~huggingface_hub.login`]), token will be
+                retrieved from the cache. If `False`, token is not sent in the request header.
+
+        Returns:
+            [`SafetensorsRepoMetadata`]: information related to safetensors repo.
+
+        Raises:
+            - [`NotASafetensorsRepoError`]: if the repo is not a safetensors repo i.e. doesn't have either a
+              `model.safetensors` or a `model.safetensors.index.json` file.
+            - [`SafetensorsParsingError`]: if a safetensors file header couldn't be parsed correctly.
+
+        Example:
+            ```py
+            # Parse repo with single weights file
+            >>> metadata = get_safetensors_metadata("bigscience/bloomz-560m")
+            >>> metadata
+            SafetensorsRepoMetadata(
+                metadata=None,
+                sharded=False,
+                weight_map={'h.0.input_layernorm.bias': 'model.safetensors', ...},
+                files_metadata={'model.safetensors': SafetensorsFileMetadata(...)}
+            )
+            >>> metadata.files_metadata["model.safetensors"].metadata
+            {'format': 'pt'}
+
+            # Parse repo with sharded model
+            >>> metadata = get_safetensors_metadata("bigscience/bloom")
+            Parse safetensors files: 100%|██████████████████████████████████████████| 72/72 [00:12<00:00,  5.78it/s]
+            >>> metadata
+            SafetensorsRepoMetadata(metadata={'total_size': 352494542848}, sharded=True, weight_map={...}, files_metadata={...})
+            >>> len(metadata.files_metadata)
+            72  # All safetensors files have been fetched
+
+            # Parse repo with sharded model
+            >>> get_safetensors_metadata("runwayml/stable-diffusion-v1-5")
+            NotASafetensorsRepoError: 'runwayml/stable-diffusion-v1-5' is not a safetensors repo. Couldn't find 'model.safetensors.index.json' or 'model.safetensors' files.
+            ```
+        """
+        if self.file_exists(  # Single safetensors file => non-sharded model
+            repo_id=repo_id, filename=SAFETENSORS_SINGLE_FILE, repo_type=repo_type, revision=revision, token=token
+        ):
+            file_metadata = self.parse_safetensors_file_metadata(
+                repo_id=repo_id, filename=SAFETENSORS_SINGLE_FILE, repo_type=repo_type, revision=revision, token=token
+            )
+            return SafetensorsRepoMetadata(
+                metadata=None,
+                sharded=False,
+                weight_map={tensor_name: SAFETENSORS_SINGLE_FILE for tensor_name in file_metadata.tensors.keys()},
+                files_metadata={SAFETENSORS_SINGLE_FILE: file_metadata},
+            )
+        elif self.file_exists(  # Multiple safetensors files => sharded with index
+            repo_id=repo_id, filename=SAFETENSORS_INDEX_FILE, repo_type=repo_type, revision=revision, token=token
+        ):
+            # Fetch index
+            index_file = self.hf_hub_download(
+                repo_id=repo_id, filename=SAFETENSORS_INDEX_FILE, repo_type=repo_type, revision=revision, token=token
+            )
+            with open(index_file) as f:
+                index = json.load(f)
+
+            weight_map = index.get("weight_map", {})
+
+            # Fetch metadata per shard
+            files_metadata = {}
+
+            def _parse(filename: str) -> None:
+                files_metadata[filename] = self.parse_safetensors_file_metadata(
+                    repo_id=repo_id, filename=filename, repo_type=repo_type, revision=revision, token=token
+                )
+
+            thread_map(
+                _parse,
+                set(weight_map.values()),
+                desc="Parse safetensors files",
+                tqdm_class=hf_tqdm,
+            )
+
+            return SafetensorsRepoMetadata(
+                metadata=index.get("metadata", None),
+                sharded=True,
+                weight_map=weight_map,
+                files_metadata=files_metadata,
+            )
+        else:
+            # Not a safetensors repo
+            raise NotASafetensorsRepoError(
+                f"'{repo_id}' is not a safetensors repo. Couldn't find '{SAFETENSORS_INDEX_FILE}' or '{SAFETENSORS_SINGLE_FILE}' files."
+            )
+
+    def parse_safetensors_file_metadata(
+        self,
+        repo_id: str,
+        filename: str,
+        *,
+        repo_type: Optional[str] = None,
+        revision: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> SafetensorsFileMetadata:
+        """
+        Parse metadata from a safetensors file on the Hub.
+
+        To parse metadata from all safetensors files in a repo at once, use [`get_safetensors_metadata`].
+
+        For more details regarding the safetensors format, check out https://huggingface.co/docs/safetensors/index#format.
+
+        Args:
+            repo_id (`str`):
+                A user or an organization name and a repo name separated by a `/`.
+            filename (`str`):
+                The name of the file in the repo.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if the file is in a dataset or space, `None` or `"model"` if in a
+                model. Default is `None`.
+            revision (`str`, *optional*):
+                The git revision to fetch the file from. Can be a branch name, a tag, or a commit hash. Defaults to the
+                head of the `"main"` branch.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token). If `None` or `True` and
+                machine is logged in (through `huggingface-cli login` or [`~huggingface_hub.login`]), token will be
+                retrieved from the cache. If `False`, token is not sent in the request header.
+
+        Returns:
+            [`SafetensorsFileMetadata`]: information related to a safetensors file.
+
+        Raises:
+            - [`NotASafetensorsRepoError`]: if the repo is not a safetensors repo i.e. doesn't have either a
+              `model.safetensors` or a `model.safetensors.index.json` file.
+            - [`SafetensorsParsingError`]: if a safetensors file header couldn't be parsed correctly.
+        """
+        url = hf_hub_url(
+            repo_id=repo_id, filename=filename, repo_type=repo_type, revision=revision, endpoint=self.endpoint
+        )
+        _headers = self._build_hf_headers(token=token)
+
+        # 1. Fetch first 100kb
+        # Empirically, 97% of safetensors files have a metadata size < 100kb (over the top 1000 models on the Hub).
+        # We assume fetching 100kb is faster than making 2 GET requests. Therefore we always fetch the first 100kb to
+        # avoid the 2nd GET in most cases.
+        # See https://github.com/huggingface/huggingface_hub/pull/1855#discussion_r1404286419.
+        response = get_session().get(url, headers={**_headers, "range": "bytes=0-100000"})
+        hf_raise_for_status(response)
+
+        # 2. Parse metadata size
+        metadata_size = struct.unpack("<Q", response.content[:8])[0]
+        if metadata_size > SAFETENSORS_MAX_HEADER_LENGTH:
+            raise SafetensorsParsingError(
+                f"Failed to parse safetensors header for '{filename}' (repo '{repo_id}', revision "
+                f"'{revision or DEFAULT_REVISION}'): safetensors header is too big. Maximum supported size is "
+                f"{SAFETENSORS_MAX_HEADER_LENGTH} bytes (got {metadata_size})."
+            )
+
+        # 3.a. Get metadata from payload
+        if metadata_size <= 100000:
+            metadata_as_bytes = response.content[8 : 8 + metadata_size]
+        else:  # 3.b. Request full metadata
+            response = get_session().get(url, headers={**_headers, "range": f"bytes=8-{metadata_size+7}"})
+            hf_raise_for_status(response)
+            metadata_as_bytes = response.content
+
+        # 4. Parse json header
+        try:
+            metadata_as_dict = json.loads(metadata_as_bytes.decode(errors="ignore"))
+        except json.JSONDecodeError as e:
+            raise SafetensorsParsingError(
+                f"Failed to parse safetensors header for '{filename}' (repo '{repo_id}', revision "
+                f"'{revision or DEFAULT_REVISION}'): header is not json-encoded string. Please make sure this is a "
+                "correctly formatted safetensors file."
+            ) from e
+
+        try:
+            return SafetensorsFileMetadata(
+                metadata=metadata_as_dict.get("__metadata__", {}),
+                tensors={
+                    key: TensorInfo(
+                        dtype=tensor["dtype"],
+                        shape=tensor["shape"],
+                        data_offsets=tuple(tensor["data_offsets"]),  # type: ignore
+                    )
+                    for key, tensor in metadata_as_dict.items()
+                    if key != "__metadata__"
+                },
+            )
+        except (KeyError, IndexError) as e:
+            raise SafetensorsParsingError(
+                f"Failed to parse safetensors header for '{filename}' (repo '{repo_id}', revision "
+                f"'{revision or DEFAULT_REVISION}'): header format not recognized. Please make sure this is a correctly"
+                " formatted safetensors file."
+            ) from e
+
+    @validate_hf_hub_args
+    def create_branch(
+        self,
+        repo_id: str,
+        *,
+        branch: str,
+        revision: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        exist_ok: bool = False,
+    ) -> None:
+        """
+        Create a new branch for a repo on the Hub, starting from the specified revision (defaults to `main`).
+        To find a revision suiting your needs, you can use [`list_repo_refs`] or [`list_repo_commits`].
+
+        Args:
+            repo_id (`str`):
+                The repository in which the branch will be created.
+                Example: `"user/my-cool-model"`.
+
+            branch (`str`):
+                The name of the branch to create.
+
+            revision (`str`, *optional*):
+                The git revision to create the branch from. It can be a branch name or
+                the OID/SHA of a commit, as a hexadecimal string. Defaults to the head
+                of the `"main"` branch.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if creating a branch on a dataset or
+                space, `None` or `"model"` if tagging a model. Default is `None`.
+
+            exist_ok (`bool`, *optional*, defaults to `False`):
+                If `True`, do not raise an error if branch already exists.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private
+                but not authenticated or repo does not exist.
+            [`~utils.BadRequestError`]:
+                If invalid reference for a branch. Ex: `refs/pr/5` or 'refs/foo/bar'.
+            [`~utils.HfHubHTTPError`]:
+                If the branch already exists on the repo (error 409) and `exist_ok` is
+                set to `False`.
+        """
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        branch = quote(branch, safe="")
+
+        # Prepare request
+        branch_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/branch/{branch}"
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+        payload = {}
+        if revision is not None:
+            payload["startingPoint"] = revision
+
+        # Create branch
+        response = get_session().post(url=branch_url, headers=headers, json=payload)
+        try:
+            hf_raise_for_status(response)
+        except HfHubHTTPError as e:
+            if not (e.response.status_code == 409 and exist_ok):
+                raise
+
+    @validate_hf_hub_args
+    def delete_branch(
+        self,
+        repo_id: str,
+        *,
+        branch: str,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a branch from a repo on the Hub.
+
+        Args:
+            repo_id (`str`):
+                The repository in which a branch will be deleted.
+                Example: `"user/my-cool-model"`.
+
+            branch (`str`):
+                The name of the branch to delete.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if creating a branch on a dataset or
+                space, `None` or `"model"` if tagging a model. Default is `None`.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private
+                but not authenticated or repo does not exist.
+            [`~utils.HfHubHTTPError`]:
+                If trying to delete a protected branch. Ex: `main` cannot be deleted.
+            [`~utils.HfHubHTTPError`]:
+                If trying to delete a branch that does not exist.
+
+        """
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        branch = quote(branch, safe="")
+
+        # Prepare request
+        branch_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/branch/{branch}"
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+
+        # Delete branch
+        response = get_session().delete(url=branch_url, headers=headers)
+        hf_raise_for_status(response)
+
+    @validate_hf_hub_args
+    def create_tag(
+        self,
+        repo_id: str,
+        *,
+        tag: str,
+        tag_message: Optional[str] = None,
+        revision: Optional[str] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        exist_ok: bool = False,
+    ) -> None:
+        """
+        Tag a given commit of a repo on the Hub.
+
+        Args:
+            repo_id (`str`):
+                The repository in which a commit will be tagged.
+                Example: `"user/my-cool-model"`.
+
+            tag (`str`):
+                The name of the tag to create.
+
+            tag_message (`str`, *optional*):
+                The description of the tag to create.
+
+            revision (`str`, *optional*):
+                The git revision to tag. It can be a branch name or the OID/SHA of a
+                commit, as a hexadecimal string. Shorthands (7 first characters) are
+                also supported. Defaults to the head of the `"main"` branch.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if tagging a dataset or
+                space, `None` or `"model"` if tagging a model. Default is
+                `None`.
+
+            exist_ok (`bool`, *optional*, defaults to `False`):
+                If `True`, do not raise an error if tag already exists.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private
+                but not authenticated or repo does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If revision is not found (error 404) on the repo.
+            [`~utils.HfHubHTTPError`]:
+                If the branch already exists on the repo (error 409) and `exist_ok` is
+                set to `False`.
+        """
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
+
+        # Prepare request
+        tag_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/tag/{revision}"
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+        payload = {"tag": tag}
+        if tag_message is not None:
+            payload["message"] = tag_message
+
+        # Tag
+        response = get_session().post(url=tag_url, headers=headers, json=payload)
+        try:
+            hf_raise_for_status(response)
+        except HfHubHTTPError as e:
+            if not (e.response.status_code == 409 and exist_ok):
+                raise
+
+    @validate_hf_hub_args
+    def delete_tag(
+        self,
+        repo_id: str,
+        *,
+        tag: str,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a tag from a repo on the Hub.
+
+        Args:
+            repo_id (`str`):
+                The repository in which a tag will be deleted.
+                Example: `"user/my-cool-model"`.
+
+            tag (`str`):
+                The name of the tag to delete.
+
+            token (`str`, *optional*):
+                Authentication token. Will default to the stored token.
+
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if tagging a dataset or space, `None` or
+                `"model"` if tagging a model. Default is `None`.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private
+                but not authenticated or repo does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If tag is not found.
+        """
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        tag = quote(tag, safe="")
+
+        # Prepare request
+        tag_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/tag/{tag}"
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+
+        # Un-tag
+        response = get_session().delete(url=tag_url, headers=headers)
+        hf_raise_for_status(response)
+
+    @validate_hf_hub_args
+    def get_full_repo_name(
+        self,
+        model_id: str,
+        *,
+        organization: Optional[str] = None,
+        token: Optional[Union[bool, str]] = None,
+    ):
+        """
+        Returns the repository name for a given model ID and optional
+        organization.
+
+        Args:
+            model_id (`str`):
+                The name of the model.
+            organization (`str`, *optional*):
+                If passed, the repository name will be in the organization
+                namespace instead of the user namespace.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+
+        Returns:
+            `str`: The repository name in the user's namespace
+            ({username}/{model_id}) if no organization is passed, and under the
+            organization namespace ({organization}/{model_id}) otherwise.
+        """
+        if organization is None:
+            if "/" in model_id:
+                username = model_id.split("/")[0]
+            else:
+                username = self.whoami(token=token)["name"]  # type: ignore
+            return f"{username}/{model_id}"
+        else:
+            return f"{organization}/{model_id}"
+
+    @validate_hf_hub_args
+    def get_repo_discussions(
+        self,
+        repo_id: str,
+        *,
+        author: Optional[str] = None,
+        discussion_type: Optional[DiscussionTypeFilter] = None,
+        discussion_status: Optional[DiscussionStatusFilter] = None,
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> Iterator[Discussion]:
+        """
+        Fetches Discussions and Pull Requests for the given repo.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            author (`str`, *optional*):
+                Pass a value to filter by discussion author. `None` means no filter.
+                Default is `None`.
+            discussion_type (`str`, *optional*):
+                Set to `"pull_request"` to fetch only pull requests, `"discussion"`
+                to fetch only discussions. Set to `"all"` or `None` to fetch both.
+                Default is `None`.
+            discussion_status (`str`, *optional*):
+                Set to `"open"` (respectively `"closed"`) to fetch only open
+                (respectively closed) discussions. Set to `"all"` or `None`
+                to fetch both.
+                Default is `None`.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if fetching from a dataset or
+                space, `None` or `"model"` if fetching from a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            `Iterator[Discussion]`: An iterator of [`Discussion`] objects.
+
+        Example:
+            Collecting all discussions of a repo in a list:
+
+            ```python
+            >>> from huggingface_hub import get_repo_discussions
+            >>> discussions_list = list(get_repo_discussions(repo_id="bert-base-uncased"))
+            ```
+
+            Iterating over discussions of a repo:
+
+            ```python
+            >>> from huggingface_hub import get_repo_discussions
+            >>> for discussion in get_repo_discussions(repo_id="bert-base-uncased"):
+            ...     print(discussion.num, discussion.title)
+            ```
+        """
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        if discussion_type is not None and discussion_type not in DISCUSSION_TYPES:
+            raise ValueError(f"Invalid discussion_type, must be one of {DISCUSSION_TYPES}")
+        if discussion_status is not None and discussion_status not in DISCUSSION_STATUS:
+            raise ValueError(f"Invalid discussion_status, must be one of {DISCUSSION_STATUS}")
+
+        headers = self._build_hf_headers(token=token)
+        query_dict: Dict[str, str] = {}
+        if discussion_type is not None:
+            query_dict["type"] = discussion_type
+        if discussion_status is not None:
+            query_dict["status"] = discussion_status
+        if author is not None:
+            query_dict["author"] = author
+
+        def _fetch_discussion_page(page_index: int):
+            query_string = urlencode({**query_dict, "page_index": page_index})
+            path = f"{self.endpoint}/api/{repo_type}s/{repo_id}/discussions?{query_string}"
+            resp = get_session().get(path, headers=headers)
+            hf_raise_for_status(resp)
+            paginated_discussions = resp.json()
+            total = paginated_discussions["count"]
+            start = paginated_discussions["start"]
+            discussions = paginated_discussions["discussions"]
+            has_next = (start + len(discussions)) < total
+            return discussions, has_next
+
+        has_next, page_index = True, 0
+
+        while has_next:
+            discussions, has_next = _fetch_discussion_page(page_index=page_index)
+            for discussion in discussions:
+                yield Discussion(
+                    title=discussion["title"],
+                    num=discussion["num"],
+                    author=discussion.get("author", {}).get("name", "deleted"),
+                    created_at=parse_datetime(discussion["createdAt"]),
+                    status=discussion["status"],
+                    repo_id=discussion["repo"]["name"],
+                    repo_type=discussion["repo"]["type"],
+                    is_pull_request=discussion["isPullRequest"],
+                    endpoint=self.endpoint,
+                )
+            page_index = page_index + 1
+
+    @validate_hf_hub_args
+    def get_discussion_details(
+        self,
+        repo_id: str,
+        discussion_num: int,
+        *,
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> DiscussionWithDetails:
+        """Fetches a Discussion's / Pull Request 's details from the Hub.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            discussion_num (`int`):
+                The number of the Discussion or Pull Request . Must be a strictly positive integer.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        Returns: [`DiscussionWithDetails`]
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        if not isinstance(discussion_num, int) or discussion_num <= 0:
+            raise ValueError("Invalid discussion_num, must be a positive integer")
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+
+        path = f"{self.endpoint}/api/{repo_type}s/{repo_id}/discussions/{discussion_num}"
+        headers = self._build_hf_headers(token=token)
+        resp = get_session().get(path, params={"diff": "1"}, headers=headers)
+        hf_raise_for_status(resp)
+
+        discussion_details = resp.json()
+        is_pull_request = discussion_details["isPullRequest"]
+
+        target_branch = discussion_details["changes"]["base"] if is_pull_request else None
+        conflicting_files = discussion_details["filesWithConflicts"] if is_pull_request else None
+        merge_commit_oid = discussion_details["changes"].get("mergeCommitId", None) if is_pull_request else None
+
+        return DiscussionWithDetails(
+            title=discussion_details["title"],
+            num=discussion_details["num"],
+            author=discussion_details.get("author", {}).get("name", "deleted"),
+            created_at=parse_datetime(discussion_details["createdAt"]),
+            status=discussion_details["status"],
+            repo_id=discussion_details["repo"]["name"],
+            repo_type=discussion_details["repo"]["type"],
+            is_pull_request=discussion_details["isPullRequest"],
+            events=[deserialize_event(evt) for evt in discussion_details["events"]],
+            conflicting_files=conflicting_files,
+            target_branch=target_branch,
+            merge_commit_oid=merge_commit_oid,
+            diff=discussion_details.get("diff"),
+            endpoint=self.endpoint,
+        )
+
+    @validate_hf_hub_args
+    def create_discussion(
+        self,
+        repo_id: str,
+        title: str,
+        *,
+        token: Optional[str] = None,
+        description: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        pull_request: bool = False,
+    ) -> DiscussionWithDetails:
+        """Creates a Discussion or Pull Request.
+
+        Pull Requests created programmatically will be in `"draft"` status.
+
+        Creating a Pull Request with changes can also be done at once with [`HfApi.create_commit`].
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            title (`str`):
+                The title of the discussion. It can be up to 200 characters long,
+                and must be at least 3 characters long. Leading and trailing whitespaces
+                will be stripped.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+            description (`str`, *optional*):
+                An optional description for the Pull Request.
+                Defaults to `"Discussion opened with the huggingface_hub Python library"`
+            pull_request (`bool`, *optional*):
+                Whether to create a Pull Request or discussion. If `True`, creates a Pull Request.
+                If `False`, creates a discussion. Defaults to `False`.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+
+        Returns: [`DiscussionWithDetails`]
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>"""
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+
+        if description is not None:
+            description = description.strip()
+        description = (
+            description
+            if description
+            else (
+                f"{'Pull Request' if pull_request else 'Discussion'} opened with the"
+                " [huggingface_hub Python"
+                " library](https://huggingface.co/docs/huggingface_hub)"
+            )
+        )
+
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+        resp = get_session().post(
+            f"{self.endpoint}/api/{repo_type}s/{repo_id}/discussions",
+            json={
+                "title": title.strip(),
+                "description": description,
+                "pullRequest": pull_request,
+            },
+            headers=headers,
+        )
+        hf_raise_for_status(resp)
+        num = resp.json()["num"]
+        return self.get_discussion_details(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_num=num,
+            token=token,
+        )
+
+    @validate_hf_hub_args
+    def create_pull_request(
+        self,
+        repo_id: str,
+        title: str,
+        *,
+        token: Optional[str] = None,
+        description: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> DiscussionWithDetails:
+        """Creates a Pull Request . Pull Requests created programmatically will be in `"draft"` status.
+
+        Creating a Pull Request with changes can also be done at once with [`HfApi.create_commit`];
+
+        This is a wrapper around [`HfApi.create_discussion`].
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            title (`str`):
+                The title of the discussion. It can be up to 200 characters long,
+                and must be at least 3 characters long. Leading and trailing whitespaces
+                will be stripped.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+            description (`str`, *optional*):
+                An optional description for the Pull Request.
+                Defaults to `"Discussion opened with the huggingface_hub Python library"`
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+
+        Returns: [`DiscussionWithDetails`]
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>"""
+        return self.create_discussion(
+            repo_id=repo_id,
+            title=title,
+            token=token,
+            description=description,
+            repo_type=repo_type,
+            pull_request=True,
+        )
+
+    def _post_discussion_changes(
+        self,
+        *,
+        repo_id: str,
+        discussion_num: int,
+        resource: str,
+        body: Optional[dict] = None,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> requests.Response:
+        """Internal utility to POST changes to a Discussion or Pull Request"""
+        if not isinstance(discussion_num, int) or discussion_num <= 0:
+            raise ValueError("Invalid discussion_num, must be a positive integer")
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+        repo_id = f"{repo_type}s/{repo_id}"
+
+        path = f"{self.endpoint}/api/{repo_id}/discussions/{discussion_num}/{resource}"
+
+        headers = self._build_hf_headers(token=token, is_write_action=True)
+        resp = requests.post(path, headers=headers, json=body)
+        hf_raise_for_status(resp)
+        return resp
+
+    @validate_hf_hub_args
+    def comment_discussion(
+        self,
+        repo_id: str,
+        discussion_num: int,
+        comment: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> DiscussionComment:
+        """Creates a new comment on the given Discussion.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            discussion_num (`int`):
+                The number of the Discussion or Pull Request . Must be a strictly positive integer.
+            comment (`str`):
+                The content of the comment to create. Comments support markdown formatting.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        Returns:
+            [`DiscussionComment`]: the newly created comment
+
+
+        Examples:
+            ```python
+
+            >>> comment = \"\"\"
+            ... Hello @otheruser!
+            ...
+            ... # This is a title
+            ...
+            ... **This is bold**, *this is italic* and ~this is strikethrough~
+            ... And [this](http://url) is a link
+            ... \"\"\"
+
+            >>> HfApi().comment_discussion(
+            ...     repo_id="username/repo_name",
+            ...     discussion_num=34
+            ...     comment=comment
+            ... )
+            # DiscussionComment(id='deadbeef0000000', type='comment', ...)
+
+            ```
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        resp = self._post_discussion_changes(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_num=discussion_num,
+            token=token,
+            resource="comment",
+            body={"comment": comment},
+        )
+        return deserialize_event(resp.json()["newMessage"])  # type: ignore
+
+    @validate_hf_hub_args
+    def rename_discussion(
+        self,
+        repo_id: str,
+        discussion_num: int,
+        new_title: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> DiscussionTitleChange:
+        """Renames a Discussion.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            discussion_num (`int`):
+                The number of the Discussion or Pull Request . Must be a strictly positive integer.
+            new_title (`str`):
+                The new title for the discussion
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        Returns:
+            [`DiscussionTitleChange`]: the title change event
+
+
+        Examples:
+            ```python
+            >>> new_title = "New title, fixing a typo"
+            >>> HfApi().rename_discussion(
+            ...     repo_id="username/repo_name",
+            ...     discussion_num=34
+            ...     new_title=new_title
+            ... )
+            # DiscussionTitleChange(id='deadbeef0000000', type='title-change', ...)
+
+            ```
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        resp = self._post_discussion_changes(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_num=discussion_num,
+            token=token,
+            resource="title",
+            body={"title": new_title},
+        )
+        return deserialize_event(resp.json()["newTitle"])  # type: ignore
+
+    @validate_hf_hub_args
+    def change_discussion_status(
+        self,
+        repo_id: str,
+        discussion_num: int,
+        new_status: Literal["open", "closed"],
+        *,
+        token: Optional[str] = None,
+        comment: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> DiscussionStatusChange:
+        """Closes or re-opens a Discussion or Pull Request.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            discussion_num (`int`):
+                The number of the Discussion or Pull Request . Must be a strictly positive integer.
+            new_status (`str`):
+                The new status for the discussion, either `"open"` or `"closed"`.
+            comment (`str`, *optional*):
+                An optional comment to post with the status change.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        Returns:
+            [`DiscussionStatusChange`]: the status change event
+
+
+        Examples:
+            ```python
+            >>> new_title = "New title, fixing a typo"
+            >>> HfApi().rename_discussion(
+            ...     repo_id="username/repo_name",
+            ...     discussion_num=34
+            ...     new_title=new_title
+            ... )
+            # DiscussionStatusChange(id='deadbeef0000000', type='status-change', ...)
+
+            ```
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        if new_status not in ["open", "closed"]:
+            raise ValueError("Invalid status, valid statuses are: 'open' and 'closed'")
+        body: Dict[str, str] = {"status": new_status}
+        if comment and comment.strip():
+            body["comment"] = comment.strip()
+        resp = self._post_discussion_changes(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_num=discussion_num,
+            token=token,
+            resource="status",
+            body=body,
+        )
+        return deserialize_event(resp.json()["newStatus"])  # type: ignore
+
+    @validate_hf_hub_args
+    def merge_pull_request(
+        self,
+        repo_id: str,
+        discussion_num: int,
+        *,
+        token: Optional[str] = None,
+        comment: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ):
+        """Merges a Pull Request.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            discussion_num (`int`):
+                The number of the Discussion or Pull Request . Must be a strictly positive integer.
+            comment (`str`, *optional*):
+                An optional comment to post with the status change.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        Returns:
+            [`DiscussionStatusChange`]: the status change event
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        self._post_discussion_changes(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_num=discussion_num,
+            token=token,
+            resource="merge",
+            body={"comment": comment.strip()} if comment and comment.strip() else None,
+        )
+
+    @validate_hf_hub_args
+    def edit_discussion_comment(
+        self,
+        repo_id: str,
+        discussion_num: int,
+        comment_id: str,
+        new_content: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> DiscussionComment:
+        """Edits a comment on a Discussion / Pull Request.
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            discussion_num (`int`):
+                The number of the Discussion or Pull Request . Must be a strictly positive integer.
+            comment_id (`str`):
+                The ID of the comment to edit.
+            new_content (`str`):
+                The new content of the comment. Comments support markdown formatting.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        Returns:
+            [`DiscussionComment`]: the edited comment
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        resp = self._post_discussion_changes(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_num=discussion_num,
+            token=token,
+            resource=f"comment/{comment_id.lower()}/edit",
+            body={"content": new_content},
+        )
+        return deserialize_event(resp.json()["updatedComment"])  # type: ignore
+
+    @validate_hf_hub_args
+    def hide_discussion_comment(
+        self,
+        repo_id: str,
+        discussion_num: int,
+        comment_id: str,
+        *,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+    ) -> DiscussionComment:
+        """Hides a comment on a Discussion / Pull Request.
+
+        <Tip warning={true}>
+        Hidden comments' content cannot be retrieved anymore. Hiding a comment is irreversible.
+        </Tip>
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated
+                by a `/`.
+            discussion_num (`int`):
+                The number of the Discussion or Pull Request . Must be a strictly positive integer.
+            comment_id (`str`):
+                The ID of the comment to edit.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if uploading to a dataset or
+                space, `None` or `"model"` if uploading to a model. Default is
+                `None`.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token)
+
+        Returns:
+            [`DiscussionComment`]: the hidden comment
+
+        <Tip>
+
+        Raises the following errors:
+
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if some parameter value is invalid
+            - [`~utils.RepositoryNotFoundError`]
+              If the repository to download from cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        </Tip>
+        """
+        warnings.warn(
+            "Hidden comments' content cannot be retrieved anymore. Hiding a comment is irreversible.",
+            UserWarning,
+        )
+        resp = self._post_discussion_changes(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            discussion_num=discussion_num,
+            token=token,
+            resource=f"comment/{comment_id.lower()}/hide",
+        )
+        return deserialize_event(resp.json()["updatedComment"])  # type: ignore
+
+    @validate_hf_hub_args
+    def add_space_secret(
+        self, repo_id: str, key: str, value: str, *, description: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        """Adds or updates a secret in a Space.
+
+        Secrets allow to set secret keys or tokens to a Space without hardcoding them.
+        For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets.
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to update. Example: `"bigcode/in-the-stack"`.
+            key (`str`):
+                Secret key. Example: `"GITHUB_API_KEY"`
+            value (`str`):
+                Secret value. Example: `"your_github_api_key"`.
+            description (`str`, *optional*):
+                Secret description. Example: `"Github API key to access the Github API"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        """
+        payload = {"key": key, "value": value}
+        if description is not None:
+            payload["description"] = description
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{repo_id}/secrets",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(r)
+
+    @validate_hf_hub_args
+    def delete_space_secret(self, repo_id: str, key: str, *, token: Optional[str] = None) -> None:
+        """Deletes a secret from a Space.
+
+        Secrets allow to set secret keys or tokens to a Space without hardcoding them.
+        For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets.
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to update. Example: `"bigcode/in-the-stack"`.
+            key (`str`):
+                Secret key. Example: `"GITHUB_API_KEY"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        """
+        r = get_session().delete(
+            f"{self.endpoint}/api/spaces/{repo_id}/secrets",
+            headers=self._build_hf_headers(token=token),
+            json={"key": key},
+        )
+        hf_raise_for_status(r)
+
+    @validate_hf_hub_args
+    def get_space_variables(self, repo_id: str, *, token: Optional[str] = None) -> Dict[str, SpaceVariable]:
+        """Gets all variables from a Space.
+
+        Variables allow to set environment variables to a Space without hardcoding them.
+        For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets-and-environment-variables
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to query. Example: `"bigcode/in-the-stack"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        """
+        r = get_session().get(
+            f"{self.endpoint}/api/spaces/{repo_id}/variables",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(r)
+        return {k: SpaceVariable(k, v) for k, v in r.json().items()}
+
+    @validate_hf_hub_args
+    def add_space_variable(
+        self, repo_id: str, key: str, value: str, *, description: Optional[str] = None, token: Optional[str] = None
+    ) -> Dict[str, SpaceVariable]:
+        """Adds or updates a variable in a Space.
+
+        Variables allow to set environment variables to a Space without hardcoding them.
+        For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets-and-environment-variables
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to update. Example: `"bigcode/in-the-stack"`.
+            key (`str`):
+                Variable key. Example: `"MODEL_REPO_ID"`
+            value (`str`):
+                Variable value. Example: `"the_model_repo_id"`.
+            description (`str`):
+                Description of the variable. Example: `"Model Repo ID of the implemented model"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        """
+        payload = {"key": key, "value": value}
+        if description is not None:
+            payload["description"] = description
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{repo_id}/variables",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(r)
+        return {k: SpaceVariable(k, v) for k, v in r.json().items()}
+
+    @validate_hf_hub_args
+    def delete_space_variable(
+        self, repo_id: str, key: str, *, token: Optional[str] = None
+    ) -> Dict[str, SpaceVariable]:
+        """Deletes a variable from a Space.
+
+        Variables allow to set environment variables to a Space without hardcoding them.
+        For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets-and-environment-variables
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to update. Example: `"bigcode/in-the-stack"`.
+            key (`str`):
+                Variable key. Example: `"MODEL_REPO_ID"`
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        """
+        r = get_session().delete(
+            f"{self.endpoint}/api/spaces/{repo_id}/variables",
+            headers=self._build_hf_headers(token=token),
+            json={"key": key},
+        )
+        hf_raise_for_status(r)
+        return {k: SpaceVariable(k, v) for k, v in r.json().items()}
+
+    @validate_hf_hub_args
+    def get_space_runtime(self, repo_id: str, *, token: Optional[str] = None) -> SpaceRuntime:
+        """Gets runtime information about a Space.
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to update. Example: `"bigcode/in-the-stack"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if
+                not provided.
+        Returns:
+            [`SpaceRuntime`]: Runtime information about a Space including Space stage and hardware.
+        """
+        r = get_session().get(
+            f"{self.endpoint}/api/spaces/{repo_id}/runtime", headers=self._build_hf_headers(token=token)
+        )
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    @validate_hf_hub_args
+    def request_space_hardware(
+        self,
+        repo_id: str,
+        hardware: SpaceHardware,
+        *,
+        token: Optional[str] = None,
+        sleep_time: Optional[int] = None,
+    ) -> SpaceRuntime:
+        """Request new hardware for a Space.
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to update. Example: `"bigcode/in-the-stack"`.
+            hardware (`str` or [`SpaceHardware`]):
+                Hardware on which to run the Space. Example: `"t4-medium"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+            sleep_time (`int`, *optional*):
+                Number of seconds of inactivity to wait before a Space is put to sleep. Set to `-1` if you don't want
+                your Space to sleep (default behavior for upgraded hardware). For free hardware, you can't configure
+                the sleep time (value is fixed to 48 hours of inactivity).
+                See https://huggingface.co/docs/hub/spaces-gpus#sleep-time for more details.
+        Returns:
+            [`SpaceRuntime`]: Runtime information about a Space including Space stage and hardware.
+
+        <Tip>
+
+        It is also possible to request hardware directly when creating the Space repo! See [`create_repo`] for details.
+
+        </Tip>
+        """
+        if sleep_time is not None and hardware == SpaceHardware.CPU_BASIC:
+            warnings.warn(
+                "If your Space runs on the default 'cpu-basic' hardware, it will go to sleep if inactive for more"
+                " than 48 hours. This value is not configurable. If you don't want your Space to deactivate or if"
+                " you want to set a custom sleep time, you need to upgrade to a paid Hardware.",
+                UserWarning,
+            )
+        payload: Dict[str, Any] = {"flavor": hardware}
+        if sleep_time is not None:
+            payload["sleepTimeSeconds"] = sleep_time
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{repo_id}/hardware",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    @validate_hf_hub_args
+    def set_space_sleep_time(self, repo_id: str, sleep_time: int, *, token: Optional[str] = None) -> SpaceRuntime:
+        """Set a custom sleep time for a Space running on upgraded hardware..
+
+        Your Space will go to sleep after X seconds of inactivity. You are not billed when your Space is in "sleep"
+        mode. If a new visitor lands on your Space, it will "wake it up". Only upgraded hardware can have a
+        configurable sleep time. To know more about the sleep stage, please refer to
+        https://huggingface.co/docs/hub/spaces-gpus#sleep-time.
+
+        Args:
+            repo_id (`str`):
+                ID of the repo to update. Example: `"bigcode/in-the-stack"`.
+            sleep_time (`int`, *optional*):
+                Number of seconds of inactivity to wait before a Space is put to sleep. Set to `-1` if you don't want
+                your Space to pause (default behavior for upgraded hardware). For free hardware, you can't configure
+                the sleep time (value is fixed to 48 hours of inactivity).
+                See https://huggingface.co/docs/hub/spaces-gpus#sleep-time for more details.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        Returns:
+            [`SpaceRuntime`]: Runtime information about a Space including Space stage and hardware.
+
+        <Tip>
+
+        It is also possible to set a custom sleep time when requesting hardware with [`request_space_hardware`].
+
+        </Tip>
+        """
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{repo_id}/sleeptime",
+            headers=self._build_hf_headers(token=token),
+            json={"seconds": sleep_time},
+        )
+        hf_raise_for_status(r)
+        runtime = SpaceRuntime(r.json())
+
+        hardware = runtime.requested_hardware or runtime.hardware
+        if hardware == SpaceHardware.CPU_BASIC:
+            warnings.warn(
+                "If your Space runs on the default 'cpu-basic' hardware, it will go to sleep if inactive for more"
+                " than 48 hours. This value is not configurable. If you don't want your Space to deactivate or if"
+                " you want to set a custom sleep time, you need to upgrade to a paid Hardware.",
+                UserWarning,
+            )
+        return runtime
+
+    @validate_hf_hub_args
+    def pause_space(self, repo_id: str, *, token: Optional[str] = None) -> SpaceRuntime:
+        """Pause your Space.
+
+        A paused Space stops executing until manually restarted by its owner. This is different from the sleeping
+        state in which free Spaces go after 48h of inactivity. Paused time is not billed to your account, no matter the
+        hardware you've selected. To restart your Space, use [`restart_space`] and go to your Space settings page.
+
+        For more details, please visit [the docs](https://huggingface.co/docs/hub/spaces-gpus#pause).
+
+        Args:
+            repo_id (`str`):
+                ID of the Space to pause. Example: `"Salesforce/BLIP2"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Returns:
+            [`SpaceRuntime`]: Runtime information about your Space including `stage=PAUSED` and requested hardware.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If your Space is not found (error 404). Most probably wrong repo_id or your space is private but you
+                are not authenticated.
+            [`~utils.HfHubHTTPError`]:
+                403 Forbidden: only the owner of a Space can pause it. If you want to manage a Space that you don't
+                own, either ask the owner by opening a Discussion or duplicate the Space.
+            [`~utils.BadRequestError`]:
+                If your Space is a static Space. Static Spaces are always running and never billed. If you want to hide
+                a static Space, you can set it to private.
+        """
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{repo_id}/pause", headers=self._build_hf_headers(token=token)
+        )
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    @validate_hf_hub_args
+    def restart_space(
+        self, repo_id: str, *, token: Optional[str] = None, factory_reboot: bool = False
+    ) -> SpaceRuntime:
+        """Restart your Space.
+
+        This is the only way to programmatically restart a Space if you've put it on Pause (see [`pause_space`]). You
+        must be the owner of the Space to restart it. If you are using an upgraded hardware, your account will be
+        billed as soon as the Space is restarted. You can trigger a restart no matter the current state of a Space.
+
+        For more details, please visit [the docs](https://huggingface.co/docs/hub/spaces-gpus#pause).
+
+        Args:
+            repo_id (`str`):
+                ID of the Space to restart. Example: `"Salesforce/BLIP2"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+            factory_reboot (`bool`, *optional*):
+                If `True`, the Space will be rebuilt from scratch without caching any requirements.
+
+        Returns:
+            [`SpaceRuntime`]: Runtime information about your Space.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If your Space is not found (error 404). Most probably wrong repo_id or your space is private but you
+                are not authenticated.
+            [`~utils.HfHubHTTPError`]:
+                403 Forbidden: only the owner of a Space can restart it. If you want to restart a Space that you don't
+                own, either ask the owner by opening a Discussion or duplicate the Space.
+            [`~utils.BadRequestError`]:
+                If your Space is a static Space. Static Spaces are always running and never billed. If you want to hide
+                a static Space, you can set it to private.
+        """
+        params = {}
+        if factory_reboot:
+            params["factory"] = "true"
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{repo_id}/restart", headers=self._build_hf_headers(token=token), params=params
+        )
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    @validate_hf_hub_args
+    def duplicate_space(
+        self,
+        from_id: str,
+        to_id: Optional[str] = None,
+        *,
+        private: Optional[bool] = None,
+        token: Optional[str] = None,
+        exist_ok: bool = False,
+        hardware: Optional[SpaceHardware] = None,
+        storage: Optional[SpaceStorage] = None,
+        sleep_time: Optional[int] = None,
+        secrets: Optional[List[Dict[str, str]]] = None,
+        variables: Optional[List[Dict[str, str]]] = None,
+    ) -> RepoUrl:
+        """Duplicate a Space.
+
+        Programmatically duplicate a Space. The new Space will be created in your account and will be in the same state
+        as the original Space (running or paused). You can duplicate a Space no matter the current state of a Space.
+
+        Args:
+            from_id (`str`):
+                ID of the Space to duplicate. Example: `"pharma/CLIP-Interrogator"`.
+            to_id (`str`, *optional*):
+                ID of the new Space. Example: `"dog/CLIP-Interrogator"`. If not provided, the new Space will have the same
+                name as the original Space, but in your account.
+            private (`bool`, *optional*):
+                Whether the new Space should be private or not. Defaults to the same privacy as the original Space.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+            exist_ok (`bool`, *optional*, defaults to `False`):
+                If `True`, do not raise an error if repo already exists.
+            hardware (`SpaceHardware` or `str`, *optional*):
+                Choice of Hardware. Example: `"t4-medium"`. See [`SpaceHardware`] for a complete list.
+            storage (`SpaceStorage` or `str`, *optional*):
+                Choice of persistent storage tier. Example: `"small"`. See [`SpaceStorage`] for a complete list.
+            sleep_time (`int`, *optional*):
+                Number of seconds of inactivity to wait before a Space is put to sleep. Set to `-1` if you don't want
+                your Space to sleep (default behavior for upgraded hardware). For free hardware, you can't configure
+                the sleep time (value is fixed to 48 hours of inactivity).
+                See https://huggingface.co/docs/hub/spaces-gpus#sleep-time for more details.
+            secrets (`List[Dict[str, str]]`, *optional*):
+                A list of secret keys to set in your Space. Each item is in the form `{"key": ..., "value": ..., "description": ...}` where description is optional.
+                For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets.
+            variables (`List[Dict[str, str]]`, *optional*):
+                A list of public environment variables to set in your Space. Each item is in the form `{"key": ..., "value": ..., "description": ...}` where description is optional.
+                For more details, see https://huggingface.co/docs/hub/spaces-overview#managing-secrets-and-environment-variables.
+
+        Returns:
+            [`RepoUrl`]: URL to the newly created repo. Value is a subclass of `str` containing
+            attributes like `endpoint`, `repo_type` and `repo_id`.
+
+        Raises:
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`~utils.RepositoryNotFoundError`]
+              If one of `from_id` or `to_id` cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import duplicate_space
+
+        # Duplicate a Space to your account
+        >>> duplicate_space("multimodalart/dreambooth-training")
+        RepoUrl('https://huggingface.co/spaces/nateraw/dreambooth-training',...)
+
+        # Can set custom destination id and visibility flag.
+        >>> duplicate_space("multimodalart/dreambooth-training", to_id="my-dreambooth", private=True)
+        RepoUrl('https://huggingface.co/spaces/nateraw/my-dreambooth',...)
+        ```
+        """
+        # Parse to_id if provided
+        parsed_to_id = RepoUrl(to_id) if to_id is not None else None
+
+        # Infer target repo_id
+        to_namespace = (  # set namespace manually or default to username
+            parsed_to_id.namespace
+            if parsed_to_id is not None and parsed_to_id.namespace is not None
+            else self.whoami(token)["name"]
+        )
+        to_repo_name = parsed_to_id.repo_name if to_id is not None else RepoUrl(from_id).repo_name  # type: ignore
+
+        # repository must be a valid repo_id (namespace/repo_name).
+        payload: Dict[str, Any] = {"repository": f"{to_namespace}/{to_repo_name}"}
+
+        keys = ["private", "hardware", "storageTier", "sleepTimeSeconds", "secrets", "variables"]
+        values = [private, hardware, storage, sleep_time, secrets, variables]
+        payload.update({k: v for k, v in zip(keys, values) if v is not None})
+
+        if sleep_time is not None and hardware == SpaceHardware.CPU_BASIC:
+            warnings.warn(
+                "If your Space runs on the default 'cpu-basic' hardware, it will go to sleep if inactive for more"
+                " than 48 hours. This value is not configurable. If you don't want your Space to deactivate or if"
+                " you want to set a custom sleep time, you need to upgrade to a paid Hardware.",
+                UserWarning,
+            )
+
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{from_id}/duplicate",
+            headers=self._build_hf_headers(token=token, is_write_action=True),
+            json=payload,
+        )
+
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as err:
+            if exist_ok and err.response.status_code == 409:
+                # Repo already exists and `exist_ok=True`
+                pass
+            else:
+                raise
+
+        return RepoUrl(r.json()["url"], endpoint=self.endpoint)
+
+    @validate_hf_hub_args
+    def request_space_storage(
+        self,
+        repo_id: str,
+        storage: SpaceStorage,
+        *,
+        token: Optional[str] = None,
+    ) -> SpaceRuntime:
+        """Request persistent storage for a Space.
+
+        Args:
+            repo_id (`str`):
+                ID of the Space to update. Example: `"HuggingFaceH4/open_llm_leaderboard"`.
+            storage (`str` or [`SpaceStorage`]):
+               Storage tier. Either 'small', 'medium', or 'large'.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        Returns:
+            [`SpaceRuntime`]: Runtime information about a Space including Space stage and hardware.
+
+        <Tip>
+
+        It is not possible to decrease persistent storage after its granted. To do so, you must delete it
+        via [`delete_space_storage`].
+
+        </Tip>
+        """
+        payload: Dict[str, SpaceStorage] = {"tier": storage}
+        r = get_session().post(
+            f"{self.endpoint}/api/spaces/{repo_id}/storage",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    @validate_hf_hub_args
+    def delete_space_storage(
+        self,
+        repo_id: str,
+        *,
+        token: Optional[str] = None,
+    ) -> SpaceRuntime:
+        """Delete persistent storage for a Space.
+
+        Args:
+            repo_id (`str`):
+                ID of the Space to update. Example: `"HuggingFaceH4/open_llm_leaderboard"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+        Returns:
+            [`SpaceRuntime`]: Runtime information about a Space including Space stage and hardware.
+        Raises:
+            [`BadRequestError`]
+                If space has no persistent storage.
+
+        """
+        r = get_session().delete(
+            f"{self.endpoint}/api/spaces/{repo_id}/storage",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    #######################
+    # Inference Endpoints #
+    #######################
+
+    def list_inference_endpoints(
+        self, namespace: Optional[str] = None, *, token: Optional[str] = None
+    ) -> List[InferenceEndpoint]:
+        """Lists all inference endpoints for the given namespace.
+
+        Args:
+            namespace (`str`, *optional*):
+                The namespace to list endpoints for. Defaults to the current user. Set to `"*"` to list all endpoints
+                from all namespaces (i.e. personal namespace and all orgs the user belongs to).
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            List[`InferenceEndpoint`]: A list of all inference endpoints for the given namespace.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+        >>> api.list_inference_endpoints()
+        [InferenceEndpoint(name='my-endpoint', ...), ...]
+        ```
+        """
+        # Special case: list all endpoints for all namespaces the user has access to
+        if namespace == "*":
+            user = self.whoami(token=token)
+
+            # List personal endpoints first
+            endpoints: List[InferenceEndpoint] = list_inference_endpoints(namespace=self._get_namespace(token=token))
+
+            # Then list endpoints for all orgs the user belongs to and ignore 401 errors (no billing or no access)
+            for org in user.get("orgs", []):
+                try:
+                    endpoints += list_inference_endpoints(namespace=org["name"], token=token)
+                except HfHubHTTPError as error:
+                    if error.response.status_code == 401:  # Either no billing or user don't have access)
+                        logger.debug("Cannot list Inference Endpoints for org '%s': %s", org["name"], error)
+                    pass
+
+            return endpoints
+
+        # Normal case: list endpoints for a specific namespace
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().get(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return [
+            InferenceEndpoint.from_raw(endpoint, namespace=namespace, token=token)
+            for endpoint in response.json()["items"]
+        ]
+
+    def create_inference_endpoint(
+        self,
+        name: str,
+        *,
+        repository: str,
+        framework: str,
+        accelerator: str,
+        instance_size: str,
+        instance_type: str,
+        region: str,
+        vendor: str,
+        account_id: Optional[str] = None,
+        min_replica: int = 0,
+        max_replica: int = 1,
+        revision: Optional[str] = None,
+        task: Optional[str] = None,
+        custom_image: Optional[Dict] = None,
+        type: InferenceEndpointType = InferenceEndpointType.PROTECTED,
+        namespace: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> InferenceEndpoint:
+        """Create a new Inference Endpoint.
+
+        Args:
+            name (`str`):
+                The unique name for the new Inference Endpoint.
+            repository (`str`):
+                The name of the model repository associated with the Inference Endpoint (e.g. `"gpt2"`).
+            framework (`str`):
+                The machine learning framework used for the model (e.g. `"custom"`).
+            accelerator (`str`):
+                The hardware accelerator to be used for inference (e.g. `"cpu"`).
+            instance_size (`str`):
+                The size or type of the instance to be used for hosting the model (e.g. `"large"`).
+            instance_type (`str`):
+                The cloud instance type where the Inference Endpoint will be deployed (e.g. `"c6i"`).
+            region (`str`):
+                The cloud region in which the Inference Endpoint will be created (e.g. `"us-east-1"`).
+            vendor (`str`):
+                The cloud provider or vendor where the Inference Endpoint will be hosted (e.g. `"aws"`).
+            account_id (`str`, *optional*):
+                The account ID used to link a VPC to a private Inference Endpoint (if applicable).
+            min_replica (`int`, *optional*):
+                The minimum number of replicas (instances) to keep running for the Inference Endpoint. Defaults to 0.
+            max_replica (`int`, *optional*):
+                The maximum number of replicas (instances) to scale to for the Inference Endpoint. Defaults to 1.
+            revision (`str`, *optional*):
+                The specific model revision to deploy on the Inference Endpoint (e.g. `"6c0e6080953db56375760c0471a8c5f2929baf11"`).
+            task (`str`, *optional*):
+                The task on which to deploy the model (e.g. `"text-classification"`).
+            custom_image (`Dict`, *optional*):
+                A custom Docker image to use for the Inference Endpoint. This is useful if you want to deploy an
+                Inference Endpoint running on the `text-generation-inference` (TGI) framework (see examples).
+            type ([`InferenceEndpointType]`, *optional*):
+                The type of the Inference Endpoint, which can be `"protected"` (default), `"public"` or `"private"`.
+            namespace (`str`, *optional*):
+                The namespace where the Inference Endpoint will be created. Defaults to the current user's namespace.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+            Returns:
+                [`InferenceEndpoint`]: information about the updated Inference Endpoint.
+
+            Example:
+            ```python
+            >>> from huggingface_hub import HfApi
+            >>> api = HfApi()
+            >>> create_inference_endpoint(
+            ...     "my-endpoint-name",
+            ...     repository="gpt2",
+            ...     framework="pytorch",
+            ...     task="text-generation",
+            ...     accelerator="cpu",
+            ...     vendor="aws",
+            ...     region="us-east-1",
+            ...     type="protected",
+            ...     instance_size="medium",
+            ...     instance_type="c6i",
+            ... )
+            >>> endpoint
+            InferenceEndpoint(name='my-endpoint-name', status="pending",...)
+
+            # Run inference on the endpoint
+            >>> endpoint.client.text_generation(...)
+            "..."
+            ```
+
+            ```python
+            # Start an Inference Endpoint running Zephyr-7b-beta on TGI
+            >>> from huggingface_hub import HfApi
+            >>> api = HfApi()
+            >>> create_inference_endpoint(
+            ...     "aws-zephyr-7b-beta-0486",
+            ...     repository="HuggingFaceH4/zephyr-7b-beta",
+            ...     framework="pytorch",
+            ...     task="text-generation",
+            ...     accelerator="gpu",
+            ...     vendor="aws",
+            ...     region="us-east-1",
+            ...     type="protected",
+            ...     instance_size="medium",
+            ...     instance_type="g5.2xlarge",
+            ...     custom_image={
+            ...         "health_route": "/health",
+            ...         "env": {
+            ...             "MAX_BATCH_PREFILL_TOKENS": "2048",
+            ...             "MAX_INPUT_LENGTH": "1024",
+            ...             "MAX_TOTAL_TOKENS": "1512",
+            ...             "MODEL_ID": "/repository"
+            ...         },
+            ...         "url": "ghcr.io/huggingface/text-generation-inference:1.1.0",
+            ...     },
+            ... )
+
+            ```
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        image = {"custom": custom_image} if custom_image is not None else {"huggingface": {}}
+        payload: Dict = {
+            "accountId": account_id,
+            "compute": {
+                "accelerator": accelerator,
+                "instanceSize": instance_size,
+                "instanceType": instance_type,
+                "scaling": {
+                    "maxReplica": max_replica,
+                    "minReplica": min_replica,
+                },
+            },
+            "model": {
+                "framework": framework,
+                "repository": repository,
+                "revision": revision,
+                "task": task,
+                "image": image,
+            },
+            "name": name,
+            "provider": {
+                "region": region,
+                "vendor": vendor,
+            },
+            "type": type,
+        }
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def get_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Get information about an Inference Endpoint.
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to retrieve information about.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the requested Inference Endpoint.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+        >>> endpoint = api.get_inference_endpoint("my-text-to-image")
+        >>> endpoint
+        InferenceEndpoint(name='my-text-to-image', ...)
+
+        # Get status
+        >>> endpoint.status
+        'running'
+        >>> endpoint.url
+        'https://my-text-to-image.region.vendor.endpoints.huggingface.cloud'
+
+        # Run inference
+        >>> endpoint.client.text_to_image(...)
+        ```
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().get(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def update_inference_endpoint(
+        self,
+        name: str,
+        *,
+        # Compute update
+        accelerator: Optional[str] = None,
+        instance_size: Optional[str] = None,
+        instance_type: Optional[str] = None,
+        min_replica: Optional[int] = None,
+        max_replica: Optional[int] = None,
+        # Model update
+        repository: Optional[str] = None,
+        framework: Optional[str] = None,
+        revision: Optional[str] = None,
+        task: Optional[str] = None,
+        # Other
+        namespace: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> InferenceEndpoint:
+        """Update an Inference Endpoint.
+
+        This method allows the update of either the compute configuration, the deployed model, or both. All arguments are
+        optional but at least one must be provided.
+
+        For convenience, you can also update an Inference Endpoint using [`InferenceEndpoint.update`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to update.
+
+            accelerator (`str`, *optional*):
+                The hardware accelerator to be used for inference (e.g. `"cpu"`).
+            instance_size (`str`, *optional*):
+                The size or type of the instance to be used for hosting the model (e.g. `"large"`).
+            instance_type (`str`, *optional*):
+                The cloud instance type where the Inference Endpoint will be deployed (e.g. `"c6i"`).
+            min_replica (`int`, *optional*):
+                The minimum number of replicas (instances) to keep running for the Inference Endpoint.
+            max_replica (`int`, *optional*):
+                The maximum number of replicas (instances) to scale to for the Inference Endpoint.
+
+            repository (`str`, *optional*):
+                The name of the model repository associated with the Inference Endpoint (e.g. `"gpt2"`).
+            framework (`str`, *optional*):
+                The machine learning framework used for the model (e.g. `"custom"`).
+            revision (`str`, *optional*):
+                The specific model revision to deploy on the Inference Endpoint (e.g. `"6c0e6080953db56375760c0471a8c5f2929baf11"`).
+            task (`str`, *optional*):
+                The task on which to deploy the model (e.g. `"text-classification"`).
+
+            namespace (`str`, *optional*):
+                The namespace where the Inference Endpoint will be updated. Defaults to the current user's namespace.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the updated Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        payload: Dict = {}
+        if any(value is not None for value in (accelerator, instance_size, instance_type, min_replica, max_replica)):
+            payload["compute"] = {
+                "accelerator": accelerator,
+                "instanceSize": instance_size,
+                "instanceType": instance_type,
+                "scaling": {
+                    "maxReplica": max_replica,
+                    "minReplica": min_replica,
+                },
+            }
+        if any(value is not None for value in (repository, framework, revision, task)):
+            payload["model"] = {
+                "framework": framework,
+                "repository": repository,
+                "revision": revision,
+                "task": task,
+                "image": {"huggingface": {}},
+            }
+
+        response = get_session().put(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def delete_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        """Delete an Inference Endpoint.
+
+        This operation is not reversible. If you don't want to be charged for an Inference Endpoint, it is preferable
+        to pause it with [`pause_inference_endpoint`] or scale it to zero with [`scale_to_zero_inference_endpoint`].
+
+        For convenience, you can also delete an Inference Endpoint using [`InferenceEndpoint.delete`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to delete.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+        """
+        namespace = namespace or self._get_namespace(token=token)
+        response = get_session().delete(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+    def pause_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Pause an Inference Endpoint.
+
+        A paused Inference Endpoint will not be charged. It can be resumed at any time using [`resume_inference_endpoint`].
+        This is different than scaling the Inference Endpoint to zero with [`scale_to_zero_inference_endpoint`], which
+        would be automatically restarted when a request is made to it.
+
+        For convenience, you can also pause an Inference Endpoint using [`pause_inference_endpoint`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to pause.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the paused Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}/pause",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def resume_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Resume an Inference Endpoint.
+
+        For convenience, you can also resume an Inference Endpoint using [`InferenceEndpoint.resume`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to resume.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the resumed Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}/resume",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def scale_to_zero_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Scale Inference Endpoint to zero.
+
+        An Inference Endpoint scaled to zero will not be charged. It will be resume on the next request to it, with a
+        cold start delay. This is different than pausing the Inference Endpoint with [`pause_inference_endpoint`], which
+        would require a manual resume with [`resume_inference_endpoint`].
+
+        For convenience, you can also scale an Inference Endpoint to zero using [`InferenceEndpoint.scale_to_zero`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to scale to zero.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the scaled-to-zero Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}/scale-to-zero",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def _get_namespace(self, token: Optional[str] = None) -> str:
+        """Get the default namespace for the current user."""
+        me = self.whoami(token=token)
+        if me["type"] == "user":
+            return me["name"]
+        else:
+            raise ValueError(
+                "Cannot determine default namespace. You must provide a 'namespace' as input or be logged in as a"
+                " user."
+            )
+
+    ########################
+    # Collection Endpoints #
+    ########################
+    @validate_hf_hub_args
+    def list_collections(
+        self,
+        *,
+        owner: Union[List[str], str, None] = None,
+        item: Union[List[str], str, None] = None,
+        sort: Optional[Literal["lastModified", "trending", "upvotes"]] = None,
+        limit: Optional[int] = None,
+        token: Optional[Union[bool, str]] = None,
+    ) -> Iterable[Collection]:
+        """List collections on the Huggingface Hub, given some filters.
+
+        <Tip warning={true}>
+
+        When listing collections, the item list per collection is truncated to 4 items maximum. To retrieve all items
+        from a collection, you must use [`get_collection`].
+
+        </Tip>
+
+        Args:
+            owner (`List[str]` or `str`, *optional*):
+                Filter by owner's username.
+            item (`List[str]` or `str`, *optional*):
+                Filter collections containing a particular items. Example: `"models/teknium/OpenHermes-2.5-Mistral-7B"`, `"datasets/squad"` or `"papers/2311.12983"`.
+            sort (`Literal["lastModified", "trending", "upvotes"]`, *optional*):
+                Sort collections by last modified, trending or upvotes.
+            limit (`int`, *optional*):
+                Maximum number of collections to be returned.
+            token (`bool` or `str`, *optional*):
+                An authentication token (see https://huggingface.co/settings/token).
+
+        Returns:
+            `Iterable[Collection]`: an iterable of [`Collection`] objects.
+        """
+        # Construct the API endpoint
+        path = f"{self.endpoint}/api/collections"
+        headers = self._build_hf_headers(token=token)
+        params: Dict = {}
+        if owner is not None:
+            params.update({"owner": owner})
+        if item is not None:
+            params.update({"item": item})
+        if sort is not None:
+            params.update({"sort": sort})
+        if limit is not None:
+            params.update({"limit": limit})
+
+        # Paginate over the results until limit is reached
+        items = paginate(path, headers=headers, params=params)
+        if limit is not None:
+            items = islice(items, limit)  # Do not iterate over all pages
+
+        # Parse as Collection and return
+        for position, collection_data in enumerate(items):
+            yield Collection(position=position, **collection_data)
+
+    def get_collection(self, collection_slug: str, *, token: Optional[str] = None) -> Collection:
+        """Gets information about a Collection on the Hub.
+
+        Args:
+            collection_slug (`str`):
+                Slug of the collection of the Hub. Example: `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Returns: [`Collection`]
+
+        Example:
+
+        ```py
+        >>> from huggingface_hub import get_collection
+        >>> collection = get_collection("TheBloke/recent-models-64f9a55bb3115b4f513ec026")
+        >>> collection.title
+        'Recent models'
+        >>> len(collection.items)
+        37
+        >>> collection.items[0]
+        CollectionItem(
+            item_object_id='651446103cd773a050bf64c2',
+            item_id='TheBloke/U-Amethyst-20B-AWQ',
+            item_type='model',
+            position=88,
+            note=None
+        )
+        ```
+        """
+        r = get_session().get(
+            f"{self.endpoint}/api/collections/{collection_slug}", headers=self._build_hf_headers(token=token)
+        )
+        hf_raise_for_status(r)
+        return Collection(**{**r.json(), "endpoint": self.endpoint})
+
+    def create_collection(
+        self,
+        title: str,
+        *,
+        namespace: Optional[str] = None,
+        description: Optional[str] = None,
+        private: bool = False,
+        exists_ok: bool = False,
+        token: Optional[str] = None,
+    ) -> Collection:
+        """Create a new Collection on the Hub.
+
+        Args:
+            title (`str`):
+                Title of the collection to create. Example: `"Recent models"`.
+            namespace (`str`, *optional*):
+                Namespace of the collection to create (username or org). Will default to the owner name.
+            description (`str`, *optional*):
+                Description of the collection to create.
+            private (`bool`, *optional*):
+                Whether the collection should be private or not. Defaults to `False` (i.e. public collection).
+            exists_ok (`bool`, *optional*):
+                If `True`, do not raise an error if collection already exists.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Returns: [`Collection`]
+
+        Example:
+
+        ```py
+        >>> from huggingface_hub import create_collection
+        >>> collection = create_collection(
+        ...     title="ICCV 2023",
+        ...     description="Portfolio of models, papers and demos I presented at ICCV 2023",
+        ... )
+        >>> collection.slug
+        "username/iccv-2023-64f9a55bb3115b4f513ec026"
+        ```
+        """
+        if namespace is None:
+            namespace = self.whoami(token)["name"]
+
+        payload = {
+            "title": title,
+            "namespace": namespace,
+            "private": private,
+        }
+        if description is not None:
+            payload["description"] = description
+
+        r = get_session().post(
+            f"{self.endpoint}/api/collections", headers=self._build_hf_headers(token=token), json=payload
+        )
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as err:
+            if exists_ok and err.response.status_code == 409:
+                # Collection already exists and `exists_ok=True`
+                slug = r.json()["slug"]
+                return self.get_collection(slug, token=token)
+            else:
+                raise
+        return Collection(**{**r.json(), "endpoint": self.endpoint})
+
+    def update_collection_metadata(
+        self,
+        collection_slug: str,
+        *,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        position: Optional[int] = None,
+        private: Optional[bool] = None,
+        theme: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> Collection:
+        """Update metadata of a collection on the Hub.
+
+        All arguments are optional. Only provided metadata will be updated.
+
+        Args:
+            collection_slug (`str`):
+                Slug of the collection to update. Example: `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
+            title (`str`):
+                Title of the collection to update.
+            description (`str`, *optional*):
+                Description of the collection to update.
+            position (`int`, *optional*):
+                New position of the collection in the list of collections of the user.
+            private (`bool`, *optional*):
+                Whether the collection should be private or not.
+            theme (`str`, *optional*):
+                Theme of the collection on the Hub.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Returns: [`Collection`]
+
+        Example:
+
+        ```py
+        >>> from huggingface_hub import update_collection_metadata
+        >>> collection = update_collection_metadata(
+        ...     collection_slug="username/iccv-2023-64f9a55bb3115b4f513ec026",
+        ...     title="ICCV Oct. 2023"
+        ...     description="Portfolio of models, datasets, papers and demos I presented at ICCV Oct. 2023",
+        ...     private=False,
+        ...     theme="pink",
+        ... )
+        >>> collection.slug
+        "username/iccv-oct-2023-64f9a55bb3115b4f513ec026"
+        # ^collection slug got updated but not the trailing ID
+        ```
+        """
+        payload = {
+            "position": position,
+            "private": private,
+            "theme": theme,
+            "title": title,
+            "description": description,
+        }
+        r = get_session().patch(
+            f"{self.endpoint}/api/collections/{collection_slug}",
+            headers=self._build_hf_headers(token=token),
+            # Only send not-none values to the API
+            json={key: value for key, value in payload.items() if value is not None},
+        )
+        hf_raise_for_status(r)
+        return Collection(**{**r.json()["data"], "endpoint": self.endpoint})
+
+    def delete_collection(
+        self, collection_slug: str, *, missing_ok: bool = False, token: Optional[str] = None
+    ) -> None:
+        """Delete a collection on the Hub.
+
+        Args:
+            collection_slug (`str`):
+                Slug of the collection to delete. Example: `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
+            missing_ok (`bool`, *optional*):
+                If `True`, do not raise an error if collection doesn't exists.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Example:
+
+        ```py
+        >>> from huggingface_hub import delete_collection
+        >>> collection = delete_collection("username/useless-collection-64f9a55bb3115b4f513ec026", missing_ok=True)
+        ```
+
+        <Tip warning={true}>
+
+        This is a non-revertible action. A deleted collection cannot be restored.
+
+        </Tip>
+        """
+        r = get_session().delete(
+            f"{self.endpoint}/api/collections/{collection_slug}", headers=self._build_hf_headers(token=token)
+        )
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as err:
+            if missing_ok and err.response.status_code == 404:
+                # Collection doesn't exists and `missing_ok=True`
+                return
+            else:
+                raise
+
+    def add_collection_item(
+        self,
+        collection_slug: str,
+        item_id: str,
+        item_type: CollectionItemType_T,
+        *,
+        note: Optional[str] = None,
+        exists_ok: bool = False,
+        token: Optional[str] = None,
+    ) -> Collection:
+        """Add an item to a collection on the Hub.
+
+        Args:
+            collection_slug (`str`):
+                Slug of the collection to update. Example: `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
+            item_id (`str`):
+                ID of the item to add to the collection. It can be the ID of a repo on the Hub (e.g. `"facebook/bart-large-mnli"`)
+                or a paper id (e.g. `"2307.09288"`).
+            item_type (`str`):
+                Type of the item to add. Can be one of `"model"`, `"dataset"`, `"space"` or `"paper"`.
+            note (`str`, *optional*):
+                A note to attach to the item in the collection. The maximum size for a note is 500 characters.
+            exists_ok (`bool`, *optional*):
+                If `True`, do not raise an error if item already exists.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Returns: [`Collection`]
+
+        Example:
+
+        ```py
+        >>> from huggingface_hub import add_collection_item
+        >>> collection = add_collection_item(
+        ...     collection_slug="davanstrien/climate-64f99dc2a5067f6b65531bab",
+        ...     item_id="pierre-loic/climate-news-articles",
+        ...     item_type="dataset"
+        ... )
+        >>> collection.items[-1].item_id
+        "pierre-loic/climate-news-articles"
+        # ^item got added to the collection on last position
+
+        # Add item with a note
+        >>> add_collection_item(
+        ...     collection_slug="davanstrien/climate-64f99dc2a5067f6b65531bab",
+        ...     item_id="datasets/climate_fever",
+        ...     item_type="dataset"
+        ...     note="This dataset adopts the FEVER methodology that consists of 1,535 real-world claims regarding climate-change collected on the internet."
+        ... )
+        (...)
+        ```
+        """
+        payload: Dict[str, Any] = {"item": {"id": item_id, "type": item_type}}
+        if note is not None:
+            payload["note"] = note
+        r = get_session().post(
+            f"{self.endpoint}/api/collections/{collection_slug}/items",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as err:
+            if exists_ok and err.response.status_code == 409:
+                # Item already exists and `exists_ok=True`
+                return self.get_collection(collection_slug, token=token)
+            else:
+                raise
+        return Collection(**{**r.json(), "endpoint": self.endpoint})
+
+    def update_collection_item(
+        self,
+        collection_slug: str,
+        item_object_id: str,
+        *,
+        note: Optional[str] = None,
+        position: Optional[int] = None,
+        token: Optional[str] = None,
+    ) -> None:
+        """Update an item in a collection.
+
+        Args:
+            collection_slug (`str`):
+                Slug of the collection to update. Example: `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
+            item_object_id (`str`):
+                ID of the item in the collection. This is not the id of the item on the Hub (repo_id or paper id).
+                It must be retrieved from a [`CollectionItem`] object. Example: `collection.items[0].item_object_id`.
+            note (`str`, *optional*):
+                A note to attach to the item in the collection. The maximum size for a note is 500 characters.
+            position (`int`, *optional*):
+                New position of the item in the collection.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Example:
+
+        ```py
+        >>> from huggingface_hub import get_collection, update_collection_item
+
+        # Get collection first
+        >>> collection = get_collection("TheBloke/recent-models-64f9a55bb3115b4f513ec026")
+
+        # Update item based on its ID (add note + update position)
+        >>> update_collection_item(
+        ...     collection_slug="TheBloke/recent-models-64f9a55bb3115b4f513ec026",
+        ...     item_object_id=collection.items[-1].item_object_id,
+        ...     note="Newly updated model!"
+        ...     position=0,
+        ... )
+        ```
+        """
+        payload = {"position": position, "note": note}
+        r = get_session().patch(
+            f"{self.endpoint}/api/collections/{collection_slug}/items/{item_object_id}",
+            headers=self._build_hf_headers(token=token),
+            # Only send not-none values to the API
+            json={key: value for key, value in payload.items() if value is not None},
+        )
+        hf_raise_for_status(r)
+
+    def delete_collection_item(
+        self,
+        collection_slug: str,
+        item_object_id: str,
+        *,
+        missing_ok: bool = False,
+        token: Optional[str] = None,
+    ) -> None:
+        """Delete an item from a collection.
+
+        Args:
+            collection_slug (`str`):
+                Slug of the collection to update. Example: `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
+            item_object_id (`str`):
+                ID of the item in the collection. This is not the id of the item on the Hub (repo_id or paper id).
+                It must be retrieved from a [`CollectionItem`] object. Example: `collection.items[0]._id`.
+            missing_ok (`bool`, *optional*):
+                If `True`, do not raise an error if item doesn't exists.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Example:
+
+        ```py
+        >>> from huggingface_hub import get_collection, delete_collection_item
+
+        # Get collection first
+        >>> collection = get_collection("TheBloke/recent-models-64f9a55bb3115b4f513ec026")
+
+        # Delete item based on its ID
+        >>> delete_collection_item(
+        ...     collection_slug="TheBloke/recent-models-64f9a55bb3115b4f513ec026",
+        ...     item_object_id=collection.items[-1].item_object_id,
+        ... )
+        ```
+        """
+        r = get_session().delete(
+            f"{self.endpoint}/api/collections/{collection_slug}/items/{item_object_id}",
+            headers=self._build_hf_headers(token=token),
+        )
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as err:
+            if missing_ok and err.response.status_code == 404:
+                # Item already deleted and `missing_ok=True`
+                return
+            else:
+                raise
+
+    ##########################
+    # Manage access requests #
+    ##########################
+
+    @validate_hf_hub_args
+    def list_pending_access_requests(
+        self, repo_id: str, *, repo_type: Optional[str] = None, token: Optional[str] = None
+    ) -> List[AccessRequest]:
+        """
+        Get pending access requests for a given gated repo.
+
+        A pending request means the user has requested access to the repo but the request has not been processed yet.
+        If the approval mode is automatic, this list should be empty. Pending requests can be accepted or rejected
+        using [`accept_access_request`] and [`reject_access_request`].
+
+        For more info about gated repos, see https://huggingface.co/docs/hub/models-gated.
+
+        Args:
+            repo_id (`str`):
+                The id of the repo to get access requests for.
+            repo_type (`str`, *optional*):
+                The type of the repo to get access requests for. Must be one of `model`, `dataset` or `space`.
+                Defaults to `model`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+
+        Returns:
+            `List[AccessRequest]`: A list of [`AccessRequest`] objects. Each time contains a `username`, `email`,
+            `status` and `timestamp` attribute. If the gated repo has a custom form, the `fields` attribute will
+            be populated with user's answers.
+
+        Raises:
+            `HTTPError`:
+                HTTP 400 if the repo is not gated.
+            `HTTPError`:
+                HTTP 403 if you only have read-only access to the repo. This can be the case if you don't have `write`
+                or `admin` role in the organization the repo belongs to or if you passed a `read` token.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import list_pending_access_requests, accept_access_request
+
+        # List pending requests
+        >>> requests = list_pending_access_requests("meta-llama/Llama-2-7b")
+        >>> len(requests)
+        411
+        >>> requests[0]
+        [
+            AccessRequest(
+                username='clem',
+                fullname='Clem 🤗',
+                email='***',
+                timestamp=datetime.datetime(2023, 11, 23, 18, 4, 53, 828000, tzinfo=datetime.timezone.utc),
+                status='pending',
+                fields=None,
+            ),
+            ...
+        ]
+
+        # Accept Clem's request
+        >>> accept_access_request("meta-llama/Llama-2-7b", "clem")
+        ```
+        """
+        return self._list_access_requests(repo_id, "pending", repo_type=repo_type, token=token)
+
+    @validate_hf_hub_args
+    def list_accepted_access_requests(
+        self, repo_id: str, *, repo_type: Optional[str] = None, token: Optional[str] = None
+    ) -> List[AccessRequest]:
+        """
+        Get accepted access requests for a given gated repo.
+
+        An accepted request means the user has requested access to the repo and the request has been accepted. The user
+        can download any file of the repo. If the approval mode is automatic, this list should contains by default all
+        requests. Accepted requests can be cancelled or rejected at any time using [`cancel_access_request`] and
+        [`reject_access_request`]. A cancelled request will go back to the pending list while a rejected request will
+        go to the rejected list. In both cases, the user will lose access to the repo.
+
+        For more info about gated repos, see https://huggingface.co/docs/hub/models-gated.
+
+        Args:
+            repo_id (`str`):
+                The id of the repo to get access requests for.
+            repo_type (`str`, *optional*):
+                The type of the repo to get access requests for. Must be one of `model`, `dataset` or `space`.
+                Defaults to `model`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+
+        Returns:
+            `List[AccessRequest]`: A list of [`AccessRequest`] objects. Each time contains a `username`, `email`,
+            `status` and `timestamp` attribute. If the gated repo has a custom form, the `fields` attribute will
+            be populated with user's answers.
+
+        Raises:
+            `HTTPError`:
+                HTTP 400 if the repo is not gated.
+            `HTTPError`:
+                HTTP 403 if you only have read-only access to the repo. This can be the case if you don't have `write`
+                or `admin` role in the organization the repo belongs to or if you passed a `read` token.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import list_accepted_access_requests
+
+        >>> requests = list_accepted_access_requests("meta-llama/Llama-2-7b")
+        >>> len(requests)
+        411
+        >>> requests[0]
+        [
+            AccessRequest(
+                username='clem',
+                fullname='Clem 🤗',
+                email='***',
+                timestamp=datetime.datetime(2023, 11, 23, 18, 4, 53, 828000, tzinfo=datetime.timezone.utc),
+                status='accepted',
+                fields=None,
+            ),
+            ...
+        ]
+        ```
+        """
+        return self._list_access_requests(repo_id, "accepted", repo_type=repo_type, token=token)
+
+    @validate_hf_hub_args
+    def list_rejected_access_requests(
+        self, repo_id: str, *, repo_type: Optional[str] = None, token: Optional[str] = None
+    ) -> List[AccessRequest]:
+        """
+        Get rejected access requests for a given gated repo.
+
+        A rejected request means the user has requested access to the repo and the request has been explicitly rejected
+        by a repo owner (either you or another user from your organization). The user cannot download any file of the
+        repo. Rejected requests can be accepted or cancelled at any time using [`accept_access_request`] and
+        [`cancel_access_request`]. A cancelled request will go back to the pending list while an accepted request will
+        go to the accepted list.
+
+        For more info about gated repos, see https://huggingface.co/docs/hub/models-gated.
+
+        Args:
+            repo_id (`str`):
+                The id of the repo to get access requests for.
+            repo_type (`str`, *optional*):
+                The type of the repo to get access requests for. Must be one of `model`, `dataset` or `space`.
+                Defaults to `model`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+
+        Returns:
+            `List[AccessRequest]`: A list of [`AccessRequest`] objects. Each time contains a `username`, `email`,
+            `status` and `timestamp` attribute. If the gated repo has a custom form, the `fields` attribute will
+            be populated with user's answers.
+
+        Raises:
+            `HTTPError`:
+                HTTP 400 if the repo is not gated.
+            `HTTPError`:
+                HTTP 403 if you only have read-only access to the repo. This can be the case if you don't have `write`
+                or `admin` role in the organization the repo belongs to or if you passed a `read` token.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import list_rejected_access_requests
+
+        >>> requests = list_rejected_access_requests("meta-llama/Llama-2-7b")
+        >>> len(requests)
+        411
+        >>> requests[0]
+        [
+            AccessRequest(
+                username='clem',
+                fullname='Clem 🤗',
+                email='***',
+                timestamp=datetime.datetime(2023, 11, 23, 18, 4, 53, 828000, tzinfo=datetime.timezone.utc),
+                status='rejected',
+                fields=None,
+            ),
+            ...
+        ]
+        ```
+        """
+        return self._list_access_requests(repo_id, "rejected", repo_type=repo_type, token=token)
+
+    def _list_access_requests(
+        self,
+        repo_id: str,
+        status: Literal["accepted", "rejected", "pending"],
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> List[AccessRequest]:
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+
+        response = get_session().get(
+            f"{ENDPOINT}/api/{repo_type}s/{repo_id}/user-access-request/{status}",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+        return [
+            AccessRequest(
+                username=request["user"]["user"],
+                fullname=request["user"]["fullname"],
+                email=request["user"]["email"],
+                status=request["status"],
+                timestamp=parse_datetime(request["timestamp"]),
+                fields=request.get("fields"),  # only if custom fields in form
+            )
+            for request in response.json()
+        ]
+
+    @validate_hf_hub_args
+    def cancel_access_request(
+        self, repo_id: str, user: str, *, repo_type: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        """
+        Cancel an access request from a user for a given gated repo.
+
+        A cancelled request will go back to the pending list and the user will lose access to the repo.
+
+        For more info about gated repos, see https://huggingface.co/docs/hub/models-gated.
+
+        Args:
+            repo_id (`str`):
+                The id of the repo to cancel access request for.
+            user (`str`):
+                The username of the user which access request should be cancelled.
+            repo_type (`str`, *optional*):
+                The type of the repo to cancel access request for. Must be one of `model`, `dataset` or `space`.
+                Defaults to `model`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+
+        Raises:
+            `HTTPError`:
+                HTTP 400 if the repo is not gated.
+            `HTTPError`:
+                HTTP 403 if you only have read-only access to the repo. This can be the case if you don't have `write`
+                or `admin` role in the organization the repo belongs to or if you passed a `read` token.
+            `HTTPError`:
+                HTTP 404 if the user does not exist on the Hub.
+            `HTTPError`:
+                HTTP 404 if the user access request cannot be found.
+            `HTTPError`:
+                HTTP 404 if the user access request is already in the pending list.
+        """
+        self._handle_access_request(repo_id, user, "pending", repo_type=repo_type, token=token)
+
+    @validate_hf_hub_args
+    def accept_access_request(
+        self, repo_id: str, user: str, *, repo_type: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        """
+        Accept an access request from a user for a given gated repo.
+
+        Once the request is accepted, the user will be able to download any file of the repo and access the community
+        tab. If the approval mode is automatic, you don't have to accept requests manually. An accepted request can be
+        cancelled or rejected at any time using [`cancel_access_request`] and [`reject_access_request`].
+
+        For more info about gated repos, see https://huggingface.co/docs/hub/models-gated.
+
+        Args:
+            repo_id (`str`):
+                The id of the repo to accept access request for.
+            user (`str`):
+                The username of the user which access request should be accepted.
+            repo_type (`str`, *optional*):
+                The type of the repo to accept access request for. Must be one of `model`, `dataset` or `space`.
+                Defaults to `model`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+
+        Raises:
+            `HTTPError`:
+                HTTP 400 if the repo is not gated.
+            `HTTPError`:
+                HTTP 403 if you only have read-only access to the repo. This can be the case if you don't have `write`
+                or `admin` role in the organization the repo belongs to or if you passed a `read` token.
+            `HTTPError`:
+                HTTP 404 if the user does not exist on the Hub.
+            `HTTPError`:
+                HTTP 404 if the user access request cannot be found.
+            `HTTPError`:
+                HTTP 404 if the user access request is already in the accepted list.
+        """
+        self._handle_access_request(repo_id, user, "accepted", repo_type=repo_type, token=token)
+
+    @validate_hf_hub_args
+    def reject_access_request(
+        self, repo_id: str, user: str, *, repo_type: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        """
+        Reject an access request from a user for a given gated repo.
+
+        A rejected request will go to the rejected list. The user cannot download any file of the repo. Rejected
+        requests can be accepted or cancelled at any time using [`accept_access_request`] and [`cancel_access_request`].
+        A cancelled request will go back to the pending list while an accepted request will go to the accepted list.
+
+        For more info about gated repos, see https://huggingface.co/docs/hub/models-gated.
+
+        Args:
+            repo_id (`str`):
+                The id of the repo to reject access request for.
+            user (`str`):
+                The username of the user which access request should be rejected.
+            repo_type (`str`, *optional*):
+                The type of the repo to reject access request for. Must be one of `model`, `dataset` or `space`.
+                Defaults to `model`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+
+        Raises:
+            `HTTPError`:
+                HTTP 400 if the repo is not gated.
+            `HTTPError`:
+                HTTP 403 if you only have read-only access to the repo. This can be the case if you don't have `write`
+                or `admin` role in the organization the repo belongs to or if you passed a `read` token.
+            `HTTPError`:
+                HTTP 404 if the user does not exist on the Hub.
+            `HTTPError`:
+                HTTP 404 if the user access request cannot be found.
+            `HTTPError`:
+                HTTP 404 if the user access request is already in the rejected list.
+        """
+        self._handle_access_request(repo_id, user, "rejected", repo_type=repo_type, token=token)
+
+    @validate_hf_hub_args
+    def _handle_access_request(
+        self,
+        repo_id: str,
+        user: str,
+        status: Literal["accepted", "rejected", "pending"],
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> None:
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+
+        response = get_session().post(
+            f"{ENDPOINT}/api/{repo_type}s/{repo_id}/user-access-request/handle",
+            headers=self._build_hf_headers(token=token),
+            json={"user": user, "status": status},
+        )
+        hf_raise_for_status(response)
+
+    @validate_hf_hub_args
+    def grant_access(
+        self, repo_id: str, user: str, *, repo_type: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        """
+        Grant access to a user for a given gated repo.
+
+        Granting access don't require for the user to send an access request by themselves. The user is automatically
+        added to the accepted list meaning they can download the files You can revoke the granted access at any time
+        using [`cancel_access_request`] or [`reject_access_request`].
+
+        For more info about gated repos, see https://huggingface.co/docs/hub/models-gated.
+
+        Args:
+            repo_id (`str`):
+                The id of the repo to grant access to.
+            user (`str`):
+                The username of the user to grant access.
+            repo_type (`str`, *optional*):
+                The type of the repo to grant access to. Must be one of `model`, `dataset` or `space`.
+                Defaults to `model`.
+            token (`str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+
+        Raises:
+            `HTTPError`:
+                HTTP 400 if the repo is not gated.
+            `HTTPError`:
+                HTTP 400 if the user already has access to the repo.
+            `HTTPError`:
+                HTTP 403 if you only have read-only access to the repo. This can be the case if you don't have `write`
+                or `admin` role in the organization the repo belongs to or if you passed a `read` token.
+            `HTTPError`:
+                HTTP 404 if the user does not exist on the Hub.
+        """
+        if repo_type not in REPO_TYPES:
+            raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
+        if repo_type is None:
+            repo_type = REPO_TYPE_MODEL
+
+        response = get_session().post(
+            f"{ENDPOINT}/api/models/{repo_id}/user-access-request/grant",
+            headers=self._build_hf_headers(token=token),
+            json={"user": user},
+        )
+        hf_raise_for_status(response)
+        return response.json()
+
+    #############
+    # Internals #
+    #############
+
+    def _build_hf_headers(
+        self,
+        token: Optional[Union[bool, str]] = None,
+        is_write_action: bool = False,
+        library_name: Optional[str] = None,
+        library_version: Optional[str] = None,
+        user_agent: Union[Dict, str, None] = None,
+    ) -> Dict[str, str]:
+        """
+        Alias for [`build_hf_headers`] that uses the token from [`HfApi`] client
+        when `token` is not provided.
+        """
+        if token is None:
+            # Cannot do `token = token or self.token` as token can be `False`.
+            token = self.token
+        return build_hf_headers(
+            token=token,
+            is_write_action=is_write_action,
+            library_name=library_name or self.library_name,
+            library_version=library_version or self.library_version,
+            user_agent=user_agent or self.user_agent,
+        )
+
+    def _prepare_upload_folder_deletions(
+        self,
+        repo_id: str,
+        repo_type: Optional[str],
+        revision: Optional[str],
+        token: Optional[str],
+        path_in_repo: str,
+        delete_patterns: Optional[Union[List[str], str]],
+    ) -> List[CommitOperationDelete]:
+        """Generate the list of Delete operations for a commit to delete files from a repo.
+
+        List remote files and match them against the `delete_patterns` constraints. Returns a list of [`CommitOperationDelete`]
+        with the matching items.
+
+        Note: `.gitattributes` file is essential to make a repo work properly on the Hub. This file will always be
+              kept even if it matches the `delete_patterns` constraints.
+        """
+        if delete_patterns is None:
+            # If no delete patterns, no need to list and filter remote files
+            return []
+
+        # List remote files
+        filenames = self.list_repo_files(repo_id=repo_id, revision=revision, repo_type=repo_type, token=token)
+
+        # Compute relative path in repo
+        if path_in_repo:
+            path_in_repo = path_in_repo.strip("/") + "/"  # harmonize
+            relpath_to_abspath = {
+                file[len(path_in_repo) :]: file for file in filenames if file.startswith(path_in_repo)
+            }
+        else:
+            relpath_to_abspath = {file: file for file in filenames}
+
+        # Apply filter on relative paths and return
+        return [
+            CommitOperationDelete(path_in_repo=relpath_to_abspath[relpath], is_folder=False)
+            for relpath in filter_repo_objects(relpath_to_abspath.keys(), allow_patterns=delete_patterns)
+            if relpath_to_abspath[relpath] != ".gitattributes"
+        ]
+
+
+def _prepare_upload_folder_additions(
+    folder_path: Union[str, Path],
+    path_in_repo: str,
+    allow_patterns: Optional[Union[List[str], str]] = None,
+    ignore_patterns: Optional[Union[List[str], str]] = None,
+) -> List[CommitOperationAdd]:
+    """Generate the list of Add operations for a commit to upload a folder.
+
+    Files not matching the `allow_patterns` (allowlist) and `ignore_patterns` (denylist)
+    constraints are discarded.
+    """
+    folder_path = Path(folder_path).expanduser().resolve()
+    if not folder_path.is_dir():
+        raise ValueError(f"Provided path: '{folder_path}' is not a directory")
+
+    # List files from folder
+    relpath_to_abspath = {
+        path.relative_to(folder_path).as_posix(): path
+        for path in sorted(folder_path.glob("**/*"))  # sorted to be deterministic
+        if path.is_file()
+    }
+
+    # Filter files and return
+    # Patterns are applied on the path relative to `folder_path`. `path_in_repo` is prefixed after the filtering.
+    prefix = f"{path_in_repo.strip('/')}/" if path_in_repo else ""
+    return [
+        CommitOperationAdd(
+            path_or_fileobj=relpath_to_abspath[relpath],  # absolute path on disk
+            path_in_repo=prefix + relpath,  # "absolute" path in repo
+        )
+        for relpath in filter_repo_objects(
+            relpath_to_abspath.keys(), allow_patterns=allow_patterns, ignore_patterns=ignore_patterns
+        )
+    ]
+
+
+def _parse_revision_from_pr_url(pr_url: str) -> str:
+    """Safely parse revision number from a PR url.
+
+    Example:
+    ```py
+    >>> _parse_revision_from_pr_url("https://huggingface.co/bigscience/bloom/discussions/2")
+    "refs/pr/2"
+    ```
+    """
+    re_match = re.match(_REGEX_DISCUSSION_URL, pr_url)
+    if re_match is None:
+        raise RuntimeError(f"Unexpected response from the hub, expected a Pull Request URL but got: '{pr_url}'")
+    return f"refs/pr/{re_match[1]}"
+
+
+api = HfApi()
+
+whoami = api.whoami
+get_token_permission = api.get_token_permission
+
+list_models = api.list_models
+model_info = api.model_info
+
+list_datasets = api.list_datasets
+dataset_info = api.dataset_info
+
+list_spaces = api.list_spaces
+space_info = api.space_info
+
+repo_exists = api.repo_exists
+file_exists = api.file_exists
+repo_info = api.repo_info
+list_repo_files = api.list_repo_files
+list_repo_refs = api.list_repo_refs
+list_repo_commits = api.list_repo_commits
+list_files_info = api.list_files_info
+list_repo_tree = api.list_repo_tree
+get_paths_info = api.get_paths_info
+
+list_metrics = api.list_metrics
+
+get_model_tags = api.get_model_tags
+get_dataset_tags = api.get_dataset_tags
+
+create_commit = api.create_commit
+create_repo = api.create_repo
+delete_repo = api.delete_repo
+update_repo_visibility = api.update_repo_visibility
+super_squash_history = api.super_squash_history
+move_repo = api.move_repo
+upload_file = api.upload_file
+upload_folder = api.upload_folder
+delete_file = api.delete_file
+delete_folder = api.delete_folder
+create_commits_on_pr = api.create_commits_on_pr
+preupload_lfs_files = api.preupload_lfs_files
+create_branch = api.create_branch
+delete_branch = api.delete_branch
+create_tag = api.create_tag
+delete_tag = api.delete_tag
+get_full_repo_name = api.get_full_repo_name
+
+# Safetensors helpers
+get_safetensors_metadata = api.get_safetensors_metadata
+parse_safetensors_file_metadata = api.parse_safetensors_file_metadata
+
+# Background jobs
+run_as_future = api.run_as_future
+
+# Activity API
+list_liked_repos = api.list_liked_repos
+list_repo_likers = api.list_repo_likers
+like = api.like
+unlike = api.unlike
+
+# Community API
+get_discussion_details = api.get_discussion_details
+get_repo_discussions = api.get_repo_discussions
+create_discussion = api.create_discussion
+create_pull_request = api.create_pull_request
+change_discussion_status = api.change_discussion_status
+comment_discussion = api.comment_discussion
+edit_discussion_comment = api.edit_discussion_comment
+rename_discussion = api.rename_discussion
+merge_pull_request = api.merge_pull_request
+
+# Space API
+add_space_secret = api.add_space_secret
+delete_space_secret = api.delete_space_secret
+get_space_variables = api.get_space_variables
+add_space_variable = api.add_space_variable
+delete_space_variable = api.delete_space_variable
+get_space_runtime = api.get_space_runtime
+request_space_hardware = api.request_space_hardware
+set_space_sleep_time = api.set_space_sleep_time
+pause_space = api.pause_space
+restart_space = api.restart_space
+duplicate_space = api.duplicate_space
+request_space_storage = api.request_space_storage
+delete_space_storage = api.delete_space_storage
+
+# Inference Endpoint API
+list_inference_endpoints = api.list_inference_endpoints
+create_inference_endpoint = api.create_inference_endpoint
+get_inference_endpoint = api.get_inference_endpoint
+update_inference_endpoint = api.update_inference_endpoint
+delete_inference_endpoint = api.delete_inference_endpoint
+pause_inference_endpoint = api.pause_inference_endpoint
+resume_inference_endpoint = api.resume_inference_endpoint
+scale_to_zero_inference_endpoint = api.scale_to_zero_inference_endpoint
+
+# Collections API
+get_collection = api.get_collection
+list_collections = api.list_collections
+create_collection = api.create_collection
+update_collection_metadata = api.update_collection_metadata
+delete_collection = api.delete_collection
+add_collection_item = api.add_collection_item
+update_collection_item = api.update_collection_item
+delete_collection_item = api.delete_collection_item
+delete_collection_item = api.delete_collection_item
+
+# Access requests API
+list_pending_access_requests = api.list_pending_access_requests
+list_accepted_access_requests = api.list_accepted_access_requests
+list_rejected_access_requests = api.list_rejected_access_requests
+cancel_access_request = api.cancel_access_request
+accept_access_request = api.accept_access_request
+reject_access_request = api.reject_access_request
+grant_access = api.grant_access
diff --git a/lib/python3.11/site-packages/huggingface_hub/hf_file_system.py b/lib/python3.11/site-packages/huggingface_hub/hf_file_system.py
new file mode 100644
index 0000000000000000000000000000000000000000..89c07fb945db5868b884d3952ee2eda31ad03d32
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/hf_file_system.py
@@ -0,0 +1,670 @@
+import copy
+import os
+import re
+import tempfile
+from collections import deque
+from dataclasses import dataclass, field
+from datetime import datetime
+from itertools import chain
+from typing import Any, Dict, List, NoReturn, Optional, Tuple, Union
+from urllib.parse import quote, unquote
+
+import fsspec
+
+from ._commit_api import CommitOperationCopy, CommitOperationDelete
+from .constants import DEFAULT_REVISION, ENDPOINT, REPO_TYPE_MODEL, REPO_TYPES_MAPPING, REPO_TYPES_URL_PREFIXES
+from .file_download import hf_hub_url
+from .hf_api import HfApi, LastCommitInfo, RepoFile
+from .utils import (
+    EntryNotFoundError,
+    HFValidationError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+    hf_raise_for_status,
+    http_backoff,
+)
+
+
+# Regex used to match special revisions with "/" in them (see #1710)
+SPECIAL_REFS_REVISION_REGEX = re.compile(
+    r"""
+    (^refs\/convert\/\w+)     # `refs/convert/parquet` revisions
+    |
+    (^refs\/pr\/\d+)          # PR revisions
+    """,
+    re.VERBOSE,
+)
+
+
+@dataclass
+class HfFileSystemResolvedPath:
+    """Data structure containing information about a resolved Hugging Face file system path."""
+
+    repo_type: str
+    repo_id: str
+    revision: str
+    path_in_repo: str
+    # The part placed after '@' in the initial path. It can be a quoted or unquoted refs revision.
+    # Used to reconstruct the unresolved path to return to the user.
+    _raw_revision: Optional[str] = field(default=None, repr=False)
+
+    def unresolve(self) -> str:
+        repo_path = REPO_TYPES_URL_PREFIXES.get(self.repo_type, "") + self.repo_id
+        if self._raw_revision:
+            return f"{repo_path}@{self._raw_revision}/{self.path_in_repo}".rstrip("/")
+        elif self.revision != DEFAULT_REVISION:
+            return f"{repo_path}@{safe_revision(self.revision)}/{self.path_in_repo}".rstrip("/")
+        else:
+            return f"{repo_path}/{self.path_in_repo}".rstrip("/")
+
+
+class HfFileSystem(fsspec.AbstractFileSystem):
+    """
+    Access a remote Hugging Face Hub repository as if were a local file system.
+
+    Args:
+        token (`str`, *optional*):
+            Authentication token, obtained with [`HfApi.login`] method. Will default to the stored token.
+
+    Usage:
+
+    ```python
+    >>> from huggingface_hub import HfFileSystem
+
+    >>> fs = HfFileSystem()
+
+    >>> # List files
+    >>> fs.glob("my-username/my-model/*.bin")
+    ['my-username/my-model/pytorch_model.bin']
+    >>> fs.ls("datasets/my-username/my-dataset", detail=False)
+    ['datasets/my-username/my-dataset/.gitattributes', 'datasets/my-username/my-dataset/README.md', 'datasets/my-username/my-dataset/data.json']
+
+    >>> # Read/write files
+    >>> with fs.open("my-username/my-model/pytorch_model.bin") as f:
+    ...     data = f.read()
+    >>> with fs.open("my-username/my-model/pytorch_model.bin", "wb") as f:
+    ...     f.write(data)
+    ```
+    """
+
+    root_marker = ""
+    protocol = "hf"
+
+    def __init__(
+        self,
+        *args,
+        endpoint: Optional[str] = None,
+        token: Optional[str] = None,
+        **storage_options,
+    ):
+        super().__init__(*args, **storage_options)
+        self.endpoint = endpoint or ENDPOINT
+        self.token = token
+        self._api = HfApi(endpoint=endpoint, token=token)
+        # Maps (repo_type, repo_id, revision) to a 2-tuple with:
+        #  * the 1st element indicating whether the repositoy and the revision exist
+        #  * the 2nd element being the exception raised if the repository or revision doesn't exist
+        self._repo_and_revision_exists_cache: Dict[
+            Tuple[str, str, Optional[str]], Tuple[bool, Optional[Exception]]
+        ] = {}
+
+    def _repo_and_revision_exist(
+        self, repo_type: str, repo_id: str, revision: Optional[str]
+    ) -> Tuple[bool, Optional[Exception]]:
+        if (repo_type, repo_id, revision) not in self._repo_and_revision_exists_cache:
+            try:
+                self._api.repo_info(repo_id, revision=revision, repo_type=repo_type)
+            except (RepositoryNotFoundError, HFValidationError) as e:
+                self._repo_and_revision_exists_cache[(repo_type, repo_id, revision)] = False, e
+                self._repo_and_revision_exists_cache[(repo_type, repo_id, None)] = False, e
+            except RevisionNotFoundError as e:
+                self._repo_and_revision_exists_cache[(repo_type, repo_id, revision)] = False, e
+                self._repo_and_revision_exists_cache[(repo_type, repo_id, None)] = True, None
+            else:
+                self._repo_and_revision_exists_cache[(repo_type, repo_id, revision)] = True, None
+                self._repo_and_revision_exists_cache[(repo_type, repo_id, None)] = True, None
+        return self._repo_and_revision_exists_cache[(repo_type, repo_id, revision)]
+
+    def resolve_path(self, path: str, revision: Optional[str] = None) -> HfFileSystemResolvedPath:
+        def _align_revision_in_path_with_revision(
+            revision_in_path: Optional[str], revision: Optional[str]
+        ) -> Optional[str]:
+            if revision is not None:
+                if revision_in_path is not None and revision_in_path != revision:
+                    raise ValueError(
+                        f'Revision specified in path ("{revision_in_path}") and in `revision` argument ("{revision}")'
+                        " are not the same."
+                    )
+            else:
+                revision = revision_in_path
+            return revision
+
+        path = self._strip_protocol(path)
+        if not path:
+            # can't list repositories at root
+            raise NotImplementedError("Access to repositories lists is not implemented.")
+        elif path.split("/")[0] + "/" in REPO_TYPES_URL_PREFIXES.values():
+            if "/" not in path:
+                # can't list repositories at the repository type level
+                raise NotImplementedError("Access to repositories lists is not implemented.")
+            repo_type, path = path.split("/", 1)
+            repo_type = REPO_TYPES_MAPPING[repo_type]
+        else:
+            repo_type = REPO_TYPE_MODEL
+        if path.count("/") > 0:
+            if "@" in path:
+                repo_id, revision_in_path = path.split("@", 1)
+                if "/" in revision_in_path:
+                    match = SPECIAL_REFS_REVISION_REGEX.search(revision_in_path)
+                    if match is not None and revision in (None, match.group()):
+                        # Handle `refs/convert/parquet` and PR revisions separately
+                        path_in_repo = SPECIAL_REFS_REVISION_REGEX.sub("", revision_in_path).lstrip("/")
+                        revision_in_path = match.group()
+                    else:
+                        revision_in_path, path_in_repo = revision_in_path.split("/", 1)
+                else:
+                    path_in_repo = ""
+                revision = _align_revision_in_path_with_revision(unquote(revision_in_path), revision)
+                repo_and_revision_exist, err = self._repo_and_revision_exist(repo_type, repo_id, revision)
+                if not repo_and_revision_exist:
+                    _raise_file_not_found(path, err)
+            else:
+                revision_in_path = None
+                repo_id_with_namespace = "/".join(path.split("/")[:2])
+                path_in_repo_with_namespace = "/".join(path.split("/")[2:])
+                repo_id_without_namespace = path.split("/")[0]
+                path_in_repo_without_namespace = "/".join(path.split("/")[1:])
+                repo_id = repo_id_with_namespace
+                path_in_repo = path_in_repo_with_namespace
+                repo_and_revision_exist, err = self._repo_and_revision_exist(repo_type, repo_id, revision)
+                if not repo_and_revision_exist:
+                    if isinstance(err, (RepositoryNotFoundError, HFValidationError)):
+                        repo_id = repo_id_without_namespace
+                        path_in_repo = path_in_repo_without_namespace
+                        repo_and_revision_exist, _ = self._repo_and_revision_exist(repo_type, repo_id, revision)
+                        if not repo_and_revision_exist:
+                            _raise_file_not_found(path, err)
+                    else:
+                        _raise_file_not_found(path, err)
+        else:
+            repo_id = path
+            path_in_repo = ""
+            if "@" in path:
+                repo_id, revision_in_path = path.split("@", 1)
+                revision = _align_revision_in_path_with_revision(unquote(revision_in_path), revision)
+            else:
+                revision_in_path = None
+            repo_and_revision_exist, _ = self._repo_and_revision_exist(repo_type, repo_id, revision)
+            if not repo_and_revision_exist:
+                raise NotImplementedError("Access to repositories lists is not implemented.")
+
+        revision = revision if revision is not None else DEFAULT_REVISION
+        return HfFileSystemResolvedPath(repo_type, repo_id, revision, path_in_repo, _raw_revision=revision_in_path)
+
+    def invalidate_cache(self, path: Optional[str] = None) -> None:
+        if not path:
+            self.dircache.clear()
+            self._repo_and_revision_exists_cache.clear()
+        else:
+            path = self.resolve_path(path).unresolve()
+            while path:
+                self.dircache.pop(path, None)
+                path = self._parent(path)
+
+    def _open(
+        self,
+        path: str,
+        mode: str = "rb",
+        revision: Optional[str] = None,
+        **kwargs,
+    ) -> "HfFileSystemFile":
+        if "a" in mode:
+            raise NotImplementedError("Appending to remote files is not yet supported.")
+        return HfFileSystemFile(self, path, mode=mode, revision=revision, **kwargs)
+
+    def _rm(self, path: str, revision: Optional[str] = None, **kwargs) -> None:
+        resolved_path = self.resolve_path(path, revision=revision)
+        self._api.delete_file(
+            path_in_repo=resolved_path.path_in_repo,
+            repo_id=resolved_path.repo_id,
+            token=self.token,
+            repo_type=resolved_path.repo_type,
+            revision=resolved_path.revision,
+            commit_message=kwargs.get("commit_message"),
+            commit_description=kwargs.get("commit_description"),
+        )
+        self.invalidate_cache(path=resolved_path.unresolve())
+
+    def rm(
+        self,
+        path: str,
+        recursive: bool = False,
+        maxdepth: Optional[int] = None,
+        revision: Optional[str] = None,
+        **kwargs,
+    ) -> None:
+        resolved_path = self.resolve_path(path, revision=revision)
+        root_path = REPO_TYPES_URL_PREFIXES.get(resolved_path.repo_type, "") + resolved_path.repo_id
+        paths = self.expand_path(path, recursive=recursive, maxdepth=maxdepth, revision=revision)
+        paths_in_repo = [path[len(root_path) + 1 :] for path in paths if not self.isdir(path)]
+        operations = [CommitOperationDelete(path_in_repo=path_in_repo) for path_in_repo in paths_in_repo]
+        commit_message = f"Delete {path} "
+        commit_message += "recursively " if recursive else ""
+        commit_message += f"up to depth {maxdepth} " if maxdepth is not None else ""
+        # TODO: use `commit_description` to list all the deleted paths?
+        self._api.create_commit(
+            repo_id=resolved_path.repo_id,
+            repo_type=resolved_path.repo_type,
+            token=self.token,
+            operations=operations,
+            revision=resolved_path.revision,
+            commit_message=kwargs.get("commit_message", commit_message),
+            commit_description=kwargs.get("commit_description"),
+        )
+        self.invalidate_cache(path=resolved_path.unresolve())
+
+    def ls(
+        self, path: str, detail: bool = True, refresh: bool = False, revision: Optional[str] = None, **kwargs
+    ) -> List[Union[str, Dict[str, Any]]]:
+        """List the contents of a directory."""
+        resolved_path = self.resolve_path(path, revision=revision)
+        path = resolved_path.unresolve()
+        kwargs = {"expand_info": detail, **kwargs}
+        try:
+            out = self._ls_tree(path, refresh=refresh, revision=revision, **kwargs)
+        except EntryNotFoundError:
+            # Path could be a file
+            if not resolved_path.path_in_repo:
+                _raise_file_not_found(path, None)
+            out = self._ls_tree(self._parent(path), refresh=refresh, revision=revision, **kwargs)
+            out = [o for o in out if o["name"] == path]
+            if len(out) == 0:
+                _raise_file_not_found(path, None)
+        return out if detail else [o["name"] for o in out]
+
+    def _ls_tree(
+        self,
+        path: str,
+        recursive: bool = False,
+        refresh: bool = False,
+        revision: Optional[str] = None,
+        expand_info: bool = True,
+    ):
+        resolved_path = self.resolve_path(path, revision=revision)
+        path = resolved_path.unresolve()
+        root_path = HfFileSystemResolvedPath(
+            resolved_path.repo_type,
+            resolved_path.repo_id,
+            resolved_path.revision,
+            path_in_repo="",
+            _raw_revision=resolved_path._raw_revision,
+        ).unresolve()
+
+        out = []
+        if path in self.dircache and not refresh:
+            cached_path_infos = self.dircache[path]
+            out.extend(cached_path_infos)
+            dirs_not_in_dircache = []
+            if recursive:
+                # Use BFS to traverse the cache and build the "recursive "output
+                # (The Hub uses a so-called "tree first" strategy for the tree endpoint but we sort the output to follow the spec so the result is (eventually) the same)
+                dirs_to_visit = deque(
+                    [path_info for path_info in cached_path_infos if path_info["type"] == "directory"]
+                )
+                while dirs_to_visit:
+                    dir_info = dirs_to_visit.popleft()
+                    if dir_info["name"] not in self.dircache:
+                        dirs_not_in_dircache.append(dir_info["name"])
+                    else:
+                        cached_path_infos = self.dircache[dir_info["name"]]
+                        out.extend(cached_path_infos)
+                        dirs_to_visit.extend(
+                            [path_info for path_info in cached_path_infos if path_info["type"] == "directory"]
+                        )
+
+            dirs_not_expanded = []
+            if expand_info:
+                # Check if there are directories with non-expanded entries
+                dirs_not_expanded = [self._parent(o["name"]) for o in out if o["last_commit"] is None]
+
+            if (recursive and dirs_not_in_dircache) or (expand_info and dirs_not_expanded):
+                # If the dircache is incomplete, find the common path of the missing and non-expanded entries
+                # and extend the output with the result of `_ls_tree(common_path, recursive=True)`
+                common_prefix = os.path.commonprefix(dirs_not_in_dircache + dirs_not_expanded)
+                # Get the parent directory if the common prefix itself is not a directory
+                common_path = (
+                    common_prefix.rstrip("/")
+                    if common_prefix.endswith("/")
+                    or common_prefix == root_path
+                    or common_prefix in chain(dirs_not_in_dircache, dirs_not_expanded)
+                    else self._parent(common_prefix)
+                )
+                out = [o for o in out if not o["name"].startswith(common_path + "/")]
+                for cached_path in self.dircache:
+                    if cached_path.startswith(common_path + "/"):
+                        self.dircache.pop(cached_path, None)
+                self.dircache.pop(common_path, None)
+                out.extend(
+                    self._ls_tree(
+                        common_path,
+                        recursive=recursive,
+                        refresh=True,
+                        revision=revision,
+                        expand_info=expand_info,
+                    )
+                )
+        else:
+            tree = self._api.list_repo_tree(
+                resolved_path.repo_id,
+                resolved_path.path_in_repo,
+                recursive=recursive,
+                expand=expand_info,
+                revision=resolved_path.revision,
+                repo_type=resolved_path.repo_type,
+            )
+            for path_info in tree:
+                if isinstance(path_info, RepoFile):
+                    cache_path_info = {
+                        "name": root_path + "/" + path_info.path,
+                        "size": path_info.size,
+                        "type": "file",
+                        "blob_id": path_info.blob_id,
+                        "lfs": path_info.lfs,
+                        "last_commit": path_info.last_commit,
+                        "security": path_info.security,
+                    }
+                else:
+                    cache_path_info = {
+                        "name": root_path + "/" + path_info.path,
+                        "size": 0,
+                        "type": "directory",
+                        "tree_id": path_info.tree_id,
+                        "last_commit": path_info.last_commit,
+                    }
+                parent_path = self._parent(cache_path_info["name"])
+                self.dircache.setdefault(parent_path, []).append(cache_path_info)
+                out.append(cache_path_info)
+        return copy.deepcopy(out)  # copy to not let users modify the dircache
+
+    def glob(self, path, **kwargs):
+        # Set expand_info=False by default to get a x10 speed boost
+        kwargs = {"expand_info": kwargs.get("detail", False), **kwargs}
+        path = self.resolve_path(path, revision=kwargs.get("revision")).unresolve()
+        return super().glob(path, **kwargs)
+
+    def find(
+        self,
+        path: str,
+        maxdepth: Optional[int] = None,
+        withdirs: bool = False,
+        detail: bool = False,
+        refresh: bool = False,
+        revision: Optional[str] = None,
+        **kwargs,
+    ) -> Union[List[str], Dict[str, Dict[str, Any]]]:
+        if maxdepth:
+            return super().find(
+                path, maxdepth=maxdepth, withdirs=withdirs, detail=detail, refresh=refresh, revision=revision, **kwargs
+            )
+        resolved_path = self.resolve_path(path, revision=revision)
+        path = resolved_path.unresolve()
+        kwargs = {"expand_info": detail, **kwargs}
+        try:
+            out = self._ls_tree(path, recursive=True, refresh=refresh, revision=resolved_path.revision, **kwargs)
+        except EntryNotFoundError:
+            # Path could be a file
+            if self.info(path, revision=revision, **kwargs)["type"] == "file":
+                out = {path: {}}
+            else:
+                out = {}
+        else:
+            if not withdirs:
+                out = [o for o in out if o["type"] != "directory"]
+            else:
+                # If `withdirs=True`, include the directory itself to be consistent with the spec
+                path_info = self.info(path, revision=resolved_path.revision, **kwargs)
+                out = [path_info] + out if path_info["type"] == "directory" else out
+            out = {o["name"]: o for o in out}
+        names = sorted(out)
+        if not detail:
+            return names
+        else:
+            return {name: out[name] for name in names}
+
+    def cp_file(self, path1: str, path2: str, revision: Optional[str] = None, **kwargs) -> None:
+        resolved_path1 = self.resolve_path(path1, revision=revision)
+        resolved_path2 = self.resolve_path(path2, revision=revision)
+
+        same_repo = (
+            resolved_path1.repo_type == resolved_path2.repo_type and resolved_path1.repo_id == resolved_path2.repo_id
+        )
+
+        if same_repo and self.info(path1, revision=resolved_path1.revision)["lfs"] is not None:
+            commit_message = f"Copy {path1} to {path2}"
+            self._api.create_commit(
+                repo_id=resolved_path1.repo_id,
+                repo_type=resolved_path1.repo_type,
+                revision=resolved_path2.revision,
+                commit_message=kwargs.get("commit_message", commit_message),
+                commit_description=kwargs.get("commit_description", ""),
+                operations=[
+                    CommitOperationCopy(
+                        src_path_in_repo=resolved_path1.path_in_repo,
+                        path_in_repo=resolved_path2.path_in_repo,
+                        src_revision=resolved_path1.revision,
+                    )
+                ],
+            )
+        else:
+            with self.open(path1, "rb", revision=resolved_path1.revision) as f:
+                content = f.read()
+            commit_message = f"Copy {path1} to {path2}"
+            self._api.upload_file(
+                path_or_fileobj=content,
+                path_in_repo=resolved_path2.path_in_repo,
+                repo_id=resolved_path2.repo_id,
+                token=self.token,
+                repo_type=resolved_path2.repo_type,
+                revision=resolved_path2.revision,
+                commit_message=kwargs.get("commit_message", commit_message),
+                commit_description=kwargs.get("commit_description"),
+            )
+        self.invalidate_cache(path=resolved_path1.unresolve())
+        self.invalidate_cache(path=resolved_path2.unresolve())
+
+    def modified(self, path: str, **kwargs) -> datetime:
+        info = self.info(path, **kwargs)
+        return info["last_commit"]["date"]
+
+    def info(self, path: str, refresh: bool = False, revision: Optional[str] = None, **kwargs) -> Dict[str, Any]:
+        resolved_path = self.resolve_path(path, revision=revision)
+        path = resolved_path.unresolve()
+        expand_info = kwargs.get(
+            "expand_info", True
+        )  # don't expose it as a parameter in the public API to follow the spec
+        if not resolved_path.path_in_repo:
+            # Path is the root directory
+            out = {
+                "name": path,
+                "size": 0,
+                "type": "directory",
+            }
+            if expand_info:
+                last_commit = self._api.list_repo_commits(
+                    resolved_path.repo_id, repo_type=resolved_path.repo_type, revision=resolved_path.revision
+                )[-1]
+                out = {
+                    **out,
+                    "tree_id": None,  # TODO: tree_id of the root directory?
+                    "last_commit": LastCommitInfo(
+                        oid=last_commit.commit_id, title=last_commit.title, date=last_commit.created_at
+                    ),
+                }
+        else:
+            out = None
+            parent_path = self._parent(path)
+            if parent_path in self.dircache:
+                # Check if the path is in the cache
+                out1 = [o for o in self.dircache[parent_path] if o["name"] == path]
+                if not out1:
+                    _raise_file_not_found(path, None)
+                out = out1[0]
+            if refresh or out is None or (expand_info and out and out["last_commit"] is None):
+                paths_info = self._api.get_paths_info(
+                    resolved_path.repo_id,
+                    resolved_path.path_in_repo,
+                    expand=expand_info,
+                    revision=resolved_path.revision,
+                    repo_type=resolved_path.repo_type,
+                )
+                if not paths_info:
+                    _raise_file_not_found(path, None)
+                path_info = paths_info[0]
+                root_path = HfFileSystemResolvedPath(
+                    resolved_path.repo_type,
+                    resolved_path.repo_id,
+                    resolved_path.revision,
+                    path_in_repo="",
+                    _raw_revision=resolved_path._raw_revision,
+                ).unresolve()
+                if isinstance(path_info, RepoFile):
+                    out = {
+                        "name": root_path + "/" + path_info.path,
+                        "size": path_info.size,
+                        "type": "file",
+                        "blob_id": path_info.blob_id,
+                        "lfs": path_info.lfs,
+                        "last_commit": path_info.last_commit,
+                        "security": path_info.security,
+                    }
+                else:
+                    out = {
+                        "name": root_path + "/" + path_info.path,
+                        "size": 0,
+                        "type": "directory",
+                        "tree_id": path_info.tree_id,
+                        "last_commit": path_info.last_commit,
+                    }
+                if not expand_info:
+                    out = {k: out[k] for k in ["name", "size", "type"]}
+        assert out is not None
+        return copy.deepcopy(out)  # copy to not let users modify the dircache
+
+    def exists(self, path, **kwargs):
+        """Is there a file at the given path"""
+        try:
+            self.info(path, expand_info=False, **kwargs)
+            return True
+        except:  # noqa: E722
+            # any exception allowed bar FileNotFoundError?
+            return False
+
+    def isdir(self, path):
+        """Is this entry directory-like?"""
+        try:
+            return self.info(path, expand_info=False)["type"] == "directory"
+        except OSError:
+            return False
+
+    def isfile(self, path):
+        """Is this entry file-like?"""
+        try:
+            return self.info(path, expand_info=False)["type"] == "file"
+        except:  # noqa: E722
+            return False
+
+    @property
+    def transaction(self):
+        """A context within which files are committed together upon exit
+
+        Requires the file class to implement `.commit()` and `.discard()`
+        for the normal and exception cases.
+        """
+        # Taken from https://github.com/fsspec/filesystem_spec/blob/3fbb6fee33b46cccb015607630843dea049d3243/fsspec/spec.py#L231
+        # See https://github.com/huggingface/huggingface_hub/issues/1733
+        raise NotImplementedError("Transactional commits are not supported.")
+
+    def start_transaction(self):
+        """Begin write transaction for deferring files, non-context version"""
+        # Taken from https://github.com/fsspec/filesystem_spec/blob/3fbb6fee33b46cccb015607630843dea049d3243/fsspec/spec.py#L241
+        # See https://github.com/huggingface/huggingface_hub/issues/1733
+        raise NotImplementedError("Transactional commits are not supported.")
+
+
+class HfFileSystemFile(fsspec.spec.AbstractBufferedFile):
+    def __init__(self, fs: HfFileSystem, path: str, revision: Optional[str] = None, **kwargs):
+        super().__init__(fs, path, **kwargs)
+        self.fs: HfFileSystem
+
+        try:
+            self.resolved_path = fs.resolve_path(path, revision=revision)
+        except FileNotFoundError as e:
+            if "w" in kwargs.get("mode", ""):
+                raise FileNotFoundError(
+                    f"{e}.\nMake sure the repository and revision exist before writing data."
+                ) from e
+
+    def __del__(self):
+        if not hasattr(self, "resolved_path"):
+            # Means that the constructor failed. Nothing to do.
+            return
+        return super().__del__()
+
+    def _fetch_range(self, start: int, end: int) -> bytes:
+        headers = {
+            "range": f"bytes={start}-{end - 1}",
+            **self.fs._api._build_hf_headers(),
+        }
+        url = hf_hub_url(
+            repo_id=self.resolved_path.repo_id,
+            revision=self.resolved_path.revision,
+            filename=self.resolved_path.path_in_repo,
+            repo_type=self.resolved_path.repo_type,
+            endpoint=self.fs.endpoint,
+        )
+        r = http_backoff("GET", url, headers=headers)
+        hf_raise_for_status(r)
+        return r.content
+
+    def _initiate_upload(self) -> None:
+        self.temp_file = tempfile.NamedTemporaryFile(prefix="hffs-", delete=False)
+
+    def _upload_chunk(self, final: bool = False) -> None:
+        self.buffer.seek(0)
+        block = self.buffer.read()
+        self.temp_file.write(block)
+        if final:
+            self.temp_file.close()
+            self.fs._api.upload_file(
+                path_or_fileobj=self.temp_file.name,
+                path_in_repo=self.resolved_path.path_in_repo,
+                repo_id=self.resolved_path.repo_id,
+                token=self.fs.token,
+                repo_type=self.resolved_path.repo_type,
+                revision=self.resolved_path.revision,
+                commit_message=self.kwargs.get("commit_message"),
+                commit_description=self.kwargs.get("commit_description"),
+            )
+            os.remove(self.temp_file.name)
+            self.fs.invalidate_cache(
+                path=self.resolved_path.unresolve(),
+            )
+
+
+def safe_revision(revision: str) -> str:
+    return revision if SPECIAL_REFS_REVISION_REGEX.match(revision) else safe_quote(revision)
+
+
+def safe_quote(s: str) -> str:
+    return quote(s, safe="")
+
+
+def _raise_file_not_found(path: str, err: Optional[Exception]) -> NoReturn:
+    msg = path
+    if isinstance(err, RepositoryNotFoundError):
+        msg = f"{path} (repository not found)"
+    elif isinstance(err, RevisionNotFoundError):
+        msg = f"{path} (revision not found)"
+    elif isinstance(err, HFValidationError):
+        msg = f"{path} (invalid repository id)"
+    raise FileNotFoundError(msg) from err
diff --git a/lib/python3.11/site-packages/huggingface_hub/hub_mixin.py b/lib/python3.11/site-packages/huggingface_hub/hub_mixin.py
new file mode 100644
index 0000000000000000000000000000000000000000..b78ae332fa5108b29d4e17202fbb0a0633faef90
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/hub_mixin.py
@@ -0,0 +1,368 @@
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Type, TypeVar, Union
+
+from .constants import CONFIG_NAME, PYTORCH_WEIGHTS_NAME
+from .file_download import hf_hub_download, is_torch_available
+from .hf_api import HfApi
+from .utils import HfHubHTTPError, SoftTemporaryDirectory, logging, validate_hf_hub_args
+
+
+if is_torch_available():
+    import torch  # type: ignore
+
+logger = logging.get_logger(__name__)
+
+# Generic variable that is either ModelHubMixin or a subclass thereof
+T = TypeVar("T", bound="ModelHubMixin")
+
+
+class ModelHubMixin:
+    """
+    A generic mixin to integrate ANY machine learning framework with the Hub.
+
+    To integrate your framework, your model class must inherit from this class. Custom logic for saving/loading models
+    have to be overwritten in  [`_from_pretrained`] and [`_save_pretrained`]. [`PyTorchModelHubMixin`] is a good example
+    of mixin integration with the Hub. Check out our [integration guide](../guides/integrations) for more instructions.
+    """
+
+    def save_pretrained(
+        self,
+        save_directory: Union[str, Path],
+        *,
+        config: Optional[dict] = None,
+        repo_id: Optional[str] = None,
+        push_to_hub: bool = False,
+        **kwargs,
+    ) -> Optional[str]:
+        """
+        Save weights in local directory.
+
+        Args:
+            save_directory (`str` or `Path`):
+                Path to directory in which the model weights and configuration will be saved.
+            config (`dict`, *optional*):
+                Model configuration specified as a key/value dictionary.
+            push_to_hub (`bool`, *optional*, defaults to `False`):
+                Whether or not to push your model to the Huggingface Hub after saving it.
+            repo_id (`str`, *optional*):
+                ID of your repository on the Hub. Used only if `push_to_hub=True`. Will default to the folder name if
+                not provided.
+            kwargs:
+                Additional key word arguments passed along to the [`~ModelHubMixin.push_to_hub`] method.
+        """
+        save_directory = Path(save_directory)
+        save_directory.mkdir(parents=True, exist_ok=True)
+
+        # saving model weights/files
+        self._save_pretrained(save_directory)
+
+        # saving config
+        if isinstance(config, dict):
+            (save_directory / CONFIG_NAME).write_text(json.dumps(config))
+
+        if push_to_hub:
+            kwargs = kwargs.copy()  # soft-copy to avoid mutating input
+            if config is not None:  # kwarg for `push_to_hub`
+                kwargs["config"] = config
+            if repo_id is None:
+                repo_id = save_directory.name  # Defaults to `save_directory` name
+            return self.push_to_hub(repo_id=repo_id, **kwargs)
+        return None
+
+    def _save_pretrained(self, save_directory: Path) -> None:
+        """
+        Overwrite this method in subclass to define how to save your model.
+        Check out our [integration guide](../guides/integrations) for instructions.
+
+        Args:
+            save_directory (`str` or `Path`):
+                Path to directory in which the model weights and configuration will be saved.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @validate_hf_hub_args
+    def from_pretrained(
+        cls: Type[T],
+        pretrained_model_name_or_path: Union[str, Path],
+        *,
+        force_download: bool = False,
+        resume_download: bool = False,
+        proxies: Optional[Dict] = None,
+        token: Optional[Union[str, bool]] = None,
+        cache_dir: Optional[Union[str, Path]] = None,
+        local_files_only: bool = False,
+        revision: Optional[str] = None,
+        **model_kwargs,
+    ) -> T:
+        """
+        Download a model from the Huggingface Hub and instantiate it.
+
+        Args:
+            pretrained_model_name_or_path (`str`, `Path`):
+                - Either the `model_id` (string) of a model hosted on the Hub, e.g. `bigscience/bloom`.
+                - Or a path to a `directory` containing model weights saved using
+                    [`~transformers.PreTrainedModel.save_pretrained`], e.g., `../path/to/my_model_directory/`.
+            revision (`str`, *optional*):
+                Revision of the model on the Hub. Can be a branch name, a git tag or any commit id.
+                Defaults to the latest commit on `main` branch.
+            force_download (`bool`, *optional*, defaults to `False`):
+                Whether to force (re-)downloading the model weights and configuration files from the Hub, overriding
+                the existing cache.
+            resume_download (`bool`, *optional*, defaults to `False`):
+                Whether to delete incompletely received files. Will attempt to resume the download if such a file exists.
+            proxies (`Dict[str, str]`, *optional*):
+                A dictionary of proxy servers to use by protocol or endpoint, e.g., `{'http': 'foo.bar:3128',
+                'http://hostname': 'foo.bar:4012'}`. The proxies are used on every request.
+            token (`str` or `bool`, *optional*):
+                The token to use as HTTP bearer authorization for remote files. By default, it will use the token
+                cached when running `huggingface-cli login`.
+            cache_dir (`str`, `Path`, *optional*):
+                Path to the folder where cached files are stored.
+            local_files_only (`bool`, *optional*, defaults to `False`):
+                If `True`, avoid downloading the file and return the path to the local cached file if it exists.
+            model_kwargs (`Dict`, *optional*):
+                Additional kwargs to pass to the model during initialization.
+        """
+        model_id = pretrained_model_name_or_path
+        config_file: Optional[str] = None
+        if os.path.isdir(model_id):
+            if CONFIG_NAME in os.listdir(model_id):
+                config_file = os.path.join(model_id, CONFIG_NAME)
+            else:
+                logger.warning(f"{CONFIG_NAME} not found in {Path(model_id).resolve()}")
+        elif isinstance(model_id, str):
+            try:
+                config_file = hf_hub_download(
+                    repo_id=str(model_id),
+                    filename=CONFIG_NAME,
+                    revision=revision,
+                    cache_dir=cache_dir,
+                    force_download=force_download,
+                    proxies=proxies,
+                    resume_download=resume_download,
+                    token=token,
+                    local_files_only=local_files_only,
+                )
+            except HfHubHTTPError:
+                logger.info(f"{CONFIG_NAME} not found in HuggingFace Hub.")
+
+        if config_file is not None:
+            with open(config_file, "r", encoding="utf-8") as f:
+                config = json.load(f)
+            model_kwargs.update({"config": config})
+
+        return cls._from_pretrained(
+            model_id=str(model_id),
+            revision=revision,
+            cache_dir=cache_dir,
+            force_download=force_download,
+            proxies=proxies,
+            resume_download=resume_download,
+            local_files_only=local_files_only,
+            token=token,
+            **model_kwargs,
+        )
+
+    @classmethod
+    def _from_pretrained(
+        cls: Type[T],
+        *,
+        model_id: str,
+        revision: Optional[str],
+        cache_dir: Optional[Union[str, Path]],
+        force_download: bool,
+        proxies: Optional[Dict],
+        resume_download: bool,
+        local_files_only: bool,
+        token: Optional[Union[str, bool]],
+        **model_kwargs,
+    ) -> T:
+        """Overwrite this method in subclass to define how to load your model from pretrained.
+
+        Use [`hf_hub_download`] or [`snapshot_download`] to download files from the Hub before loading them. Most
+        args taken as input can be directly passed to those 2 methods. If needed, you can add more arguments to this
+        method using "model_kwargs". For example [`PyTorchModelHubMixin._from_pretrained`] takes as input a `map_location`
+        parameter to set on which device the model should be loaded.
+
+        Check out our [integration guide](../guides/integrations) for more instructions.
+
+        Args:
+            model_id (`str`):
+                ID of the model to load from the Huggingface Hub (e.g. `bigscience/bloom`).
+            revision (`str`, *optional*):
+                Revision of the model on the Hub. Can be a branch name, a git tag or any commit id. Defaults to the
+                latest commit on `main` branch.
+            force_download (`bool`, *optional*, defaults to `False`):
+                Whether to force (re-)downloading the model weights and configuration files from the Hub, overriding
+                the existing cache.
+            resume_download (`bool`, *optional*, defaults to `False`):
+                Whether to delete incompletely received files. Will attempt to resume the download if such a file exists.
+            proxies (`Dict[str, str]`, *optional*):
+                A dictionary of proxy servers to use by protocol or endpoint (e.g., `{'http': 'foo.bar:3128',
+                'http://hostname': 'foo.bar:4012'}`).
+            token (`str` or `bool`, *optional*):
+                The token to use as HTTP bearer authorization for remote files. By default, it will use the token
+                cached when running `huggingface-cli login`.
+            cache_dir (`str`, `Path`, *optional*):
+                Path to the folder where cached files are stored.
+            local_files_only (`bool`, *optional*, defaults to `False`):
+                If `True`, avoid downloading the file and return the path to the local cached file if it exists.
+            model_kwargs:
+                Additional keyword arguments passed along to the [`~ModelHubMixin._from_pretrained`] method.
+        """
+        raise NotImplementedError
+
+    @validate_hf_hub_args
+    def push_to_hub(
+        self,
+        repo_id: str,
+        *,
+        config: Optional[dict] = None,
+        commit_message: str = "Push model using huggingface_hub.",
+        private: bool = False,
+        api_endpoint: Optional[str] = None,
+        token: Optional[str] = None,
+        branch: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        allow_patterns: Optional[Union[List[str], str]] = None,
+        ignore_patterns: Optional[Union[List[str], str]] = None,
+        delete_patterns: Optional[Union[List[str], str]] = None,
+    ) -> str:
+        """
+        Upload model checkpoint to the Hub.
+
+        Use `allow_patterns` and `ignore_patterns` to precisely filter which files should be pushed to the hub. Use
+        `delete_patterns` to delete existing remote files in the same commit. See [`upload_folder`] reference for more
+        details.
+
+
+        Args:
+            repo_id (`str`):
+                ID of the repository to push to (example: `"username/my-model"`).
+            config (`dict`, *optional*):
+                Configuration object to be saved alongside the model weights.
+            commit_message (`str`, *optional*):
+                Message to commit while pushing.
+            private (`bool`, *optional*, defaults to `False`):
+                Whether the repository created should be private.
+            api_endpoint (`str`, *optional*):
+                The API endpoint to use when pushing the model to the hub.
+            token (`str`, *optional*):
+                The token to use as HTTP bearer authorization for remote files. By default, it will use the token
+                cached when running `huggingface-cli login`.
+            branch (`str`, *optional*):
+                The git branch on which to push the model. This defaults to `"main"`.
+            create_pr (`boolean`, *optional*):
+                Whether or not to create a Pull Request from `branch` with that commit. Defaults to `False`.
+            allow_patterns (`List[str]` or `str`, *optional*):
+                If provided, only files matching at least one pattern are pushed.
+            ignore_patterns (`List[str]` or `str`, *optional*):
+                If provided, files matching any of the patterns are not pushed.
+            delete_patterns (`List[str]` or `str`, *optional*):
+                If provided, remote files matching any of the patterns will be deleted from the repo.
+
+        Returns:
+            The url of the commit of your model in the given repository.
+        """
+        api = HfApi(endpoint=api_endpoint, token=token)
+        repo_id = api.create_repo(repo_id=repo_id, private=private, exist_ok=True).repo_id
+
+        # Push the files to the repo in a single commit
+        with SoftTemporaryDirectory() as tmp:
+            saved_path = Path(tmp) / repo_id
+            self.save_pretrained(saved_path, config=config)
+            return api.upload_folder(
+                repo_id=repo_id,
+                repo_type="model",
+                folder_path=saved_path,
+                commit_message=commit_message,
+                revision=branch,
+                create_pr=create_pr,
+                allow_patterns=allow_patterns,
+                ignore_patterns=ignore_patterns,
+                delete_patterns=delete_patterns,
+            )
+
+
+class PyTorchModelHubMixin(ModelHubMixin):
+    """
+    Implementation of [`ModelHubMixin`] to provide model Hub upload/download capabilities to PyTorch models. The model
+    is set in evaluation mode by default using `model.eval()` (dropout modules are deactivated). To train the model,
+    you should first set it back in training mode with `model.train()`.
+
+    Example:
+
+    ```python
+    >>> import torch
+    >>> import torch.nn as nn
+    >>> from huggingface_hub import PyTorchModelHubMixin
+
+
+    >>> class MyModel(nn.Module, PyTorchModelHubMixin):
+    ...     def __init__(self):
+    ...         super().__init__()
+    ...         self.param = nn.Parameter(torch.rand(3, 4))
+    ...         self.linear = nn.Linear(4, 5)
+
+    ...     def forward(self, x):
+    ...         return self.linear(x + self.param)
+    >>> model = MyModel()
+
+    # Save model weights to local directory
+    >>> model.save_pretrained("my-awesome-model")
+
+    # Push model weights to the Hub
+    >>> model.push_to_hub("my-awesome-model")
+
+    # Download and initialize weights from the Hub
+    >>> model = MyModel.from_pretrained("username/my-awesome-model")
+    ```
+    """
+
+    def _save_pretrained(self, save_directory: Path) -> None:
+        """Save weights from a Pytorch model to a local directory."""
+        model_to_save = self.module if hasattr(self, "module") else self  # type: ignore
+        torch.save(model_to_save.state_dict(), save_directory / PYTORCH_WEIGHTS_NAME)
+
+    @classmethod
+    def _from_pretrained(
+        cls,
+        *,
+        model_id: str,
+        revision: Optional[str],
+        cache_dir: Optional[Union[str, Path]],
+        force_download: bool,
+        proxies: Optional[Dict],
+        resume_download: bool,
+        local_files_only: bool,
+        token: Union[str, bool, None],
+        map_location: str = "cpu",
+        strict: bool = False,
+        **model_kwargs,
+    ):
+        """Load Pytorch pretrained weights and return the loaded model."""
+        if os.path.isdir(model_id):
+            print("Loading weights from local directory")
+            model_file = os.path.join(model_id, PYTORCH_WEIGHTS_NAME)
+        else:
+            model_file = hf_hub_download(
+                repo_id=model_id,
+                filename=PYTORCH_WEIGHTS_NAME,
+                revision=revision,
+                cache_dir=cache_dir,
+                force_download=force_download,
+                proxies=proxies,
+                resume_download=resume_download,
+                token=token,
+                local_files_only=local_files_only,
+            )
+        model = cls(**model_kwargs)
+
+        state_dict = torch.load(model_file, map_location=torch.device(map_location))
+        model.load_state_dict(state_dict, strict=strict)  # type: ignore
+        model.eval()  # type: ignore
+
+        return model
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/__init__.py b/lib/python3.11/site-packages/huggingface_hub/inference/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..045b27d56b346b1b0e75d0da5effb01a6fffbfeb
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb97ce6544ec49b18ecc3c9c84283941c71868e5
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_client.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_common.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_common.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a9d956f151c42beab3126acf3de8d237060eed6
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_common.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_text_generation.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_text_generation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e14fb772dda5290ee102d622085f67627391cadb
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_text_generation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_types.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_types.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06972e23e23918b1faedba77eaa666d9246e8f90
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/inference/__pycache__/_types.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_client.py b/lib/python3.11/site-packages/huggingface_hub/inference/_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a76f5ad152d6866dde3f88053816d98fda4901b
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/inference/_client.py
@@ -0,0 +1,1990 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Related resources:
+#    https://huggingface.co/tasks
+#    https://huggingface.co/docs/huggingface.js/inference/README
+#    https://github.com/huggingface/huggingface.js/tree/main/packages/inference/src
+#    https://github.com/huggingface/text-generation-inference/tree/main/clients/python
+#    https://github.com/huggingface/text-generation-inference/blob/main/clients/python/text_generation/client.py
+#    https://huggingface.slack.com/archives/C03E4DQ9LAJ/p1680169099087869
+#    https://github.com/huggingface/unity-api#tasks
+#
+# Some TODO:
+# - validate inputs/options/parameters? with Pydantic for instance? or only optionally?
+# - add all tasks
+#
+# NOTE: the philosophy of this client is "let's make it as easy as possible to use it, even if less optimized". Some
+# examples of how it translates:
+# - Timeout / Server unavailable is handled by the client in a single "timeout" parameter.
+# - Files can be provided as bytes, file paths, or URLs and the client will try to "guess" the type.
+# - Images are parsed as PIL.Image for easier manipulation.
+# - Provides a "recommended model" for each task => suboptimal but user-wise quicker to get a first script running.
+# - Only the main parameters are publicly exposed. Power users can always read the docs for more options.
+import logging
+import time
+import warnings
+from dataclasses import asdict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Literal,
+    Optional,
+    Union,
+    overload,
+)
+
+from requests import HTTPError
+from requests.structures import CaseInsensitiveDict
+
+from huggingface_hub.constants import ALL_INFERENCE_API_FRAMEWORKS, INFERENCE_ENDPOINT, MAIN_INFERENCE_API_FRAMEWORKS
+from huggingface_hub.inference._common import (
+    TASKS_EXPECTING_IMAGES,
+    ContentT,
+    InferenceTimeoutError,
+    ModelStatus,
+    _b64_encode,
+    _b64_to_image,
+    _bytes_to_dict,
+    _bytes_to_image,
+    _bytes_to_list,
+    _fetch_recommended_models,
+    _import_numpy,
+    _is_tgi_server,
+    _open_as_binary,
+    _set_as_non_tgi,
+    _stream_text_generation_response,
+)
+from huggingface_hub.inference._text_generation import (
+    TextGenerationParameters,
+    TextGenerationRequest,
+    TextGenerationResponse,
+    TextGenerationStreamResponse,
+    raise_text_generation_error,
+)
+from huggingface_hub.inference._types import (
+    ClassificationOutput,
+    ConversationalOutput,
+    FillMaskOutput,
+    ImageSegmentationOutput,
+    ObjectDetectionOutput,
+    QuestionAnsweringOutput,
+    TableQuestionAnsweringOutput,
+    TokenClassificationOutput,
+)
+from huggingface_hub.utils import (
+    BadRequestError,
+    build_hf_headers,
+    get_session,
+    hf_raise_for_status,
+)
+
+
+if TYPE_CHECKING:
+    import numpy as np
+    from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+
+class InferenceClient:
+    """
+    Initialize a new Inference Client.
+
+    [`InferenceClient`] aims to provide a unified experience to perform inference. The client can be used
+    seamlessly with either the (free) Inference API or self-hosted Inference Endpoints.
+
+    Args:
+        model (`str`, `optional`):
+            The model to run inference with. Can be a model id hosted on the Hugging Face Hub, e.g. `bigcode/starcoder`
+            or a URL to a deployed Inference Endpoint. Defaults to None, in which case a recommended model is
+            automatically selected for the task.
+        token (`str`, *optional*):
+            Hugging Face token. Will default to the locally saved token. Pass `token=False` if you don't want to send
+            your token to the server.
+        timeout (`float`, `optional`):
+            The maximum number of seconds to wait for a response from the server. Loading a new model in Inference
+            API can take up to several minutes. Defaults to None, meaning it will loop until the server is available.
+        headers (`Dict[str, str]`, `optional`):
+            Additional headers to send to the server. By default only the authorization and user-agent headers are sent.
+            Values in this dictionary will override the default values.
+        cookies (`Dict[str, str]`, `optional`):
+            Additional cookies to send to the server.
+    """
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        token: Union[str, bool, None] = None,
+        timeout: Optional[float] = None,
+        headers: Optional[Dict[str, str]] = None,
+        cookies: Optional[Dict[str, str]] = None,
+    ) -> None:
+        self.model: Optional[str] = model
+        self.headers = CaseInsensitiveDict(build_hf_headers(token=token))  # contains 'authorization' + 'user-agent'
+        if headers is not None:
+            self.headers.update(headers)
+        self.cookies = cookies
+        self.timeout = timeout
+
+    def __repr__(self):
+        return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"
+
+    @overload
+    def post(  # type: ignore[misc]
+        self,
+        *,
+        json: Optional[Union[str, Dict, List]] = None,
+        data: Optional[ContentT] = None,
+        model: Optional[str] = None,
+        task: Optional[str] = None,
+        stream: Literal[False] = ...,
+    ) -> bytes:
+        pass
+
+    @overload
+    def post(
+        self,
+        *,
+        json: Optional[Union[str, Dict, List]] = None,
+        data: Optional[ContentT] = None,
+        model: Optional[str] = None,
+        task: Optional[str] = None,
+        stream: Literal[True] = ...,
+    ) -> Iterable[bytes]:
+        pass
+
+    def post(
+        self,
+        *,
+        json: Optional[Union[str, Dict, List]] = None,
+        data: Optional[ContentT] = None,
+        model: Optional[str] = None,
+        task: Optional[str] = None,
+        stream: bool = False,
+    ) -> Union[bytes, Iterable[bytes]]:
+        """
+        Make a POST request to the inference server.
+
+        Args:
+            json (`Union[str, Dict, List]`, *optional*):
+                The JSON data to send in the request body, specific to each task. Defaults to None.
+            data (`Union[str, Path, bytes, BinaryIO]`, *optional*):
+                The content to send in the request body, specific to each task.
+                It can be raw bytes, a pointer to an opened file, a local file path,
+                or a URL to an online resource (image, audio file,...). If both `json` and `data` are passed,
+                `data` will take precedence. At least `json` or `data` must be provided. Defaults to None.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. Will override the model defined at the instance level. Defaults to None.
+            task (`str`, *optional*):
+                The task to perform on the inference. All available tasks can be found
+                [here](https://huggingface.co/tasks). Used only to default to a recommended model if `model` is not
+                provided. At least `model` or `task` must be provided. Defaults to None.
+            stream (`bool`, *optional*):
+                Whether to iterate over streaming APIs.
+
+        Returns:
+            bytes: The raw bytes returned by the server.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+        """
+        url = self._resolve_url(model, task)
+
+        if data is not None and json is not None:
+            warnings.warn("Ignoring `json` as `data` is passed as binary.")
+
+        # Set Accept header if relevant
+        headers = self.headers.copy()
+        if task in TASKS_EXPECTING_IMAGES and "Accept" not in headers:
+            headers["Accept"] = "image/png"
+
+        t0 = time.time()
+        timeout = self.timeout
+        while True:
+            with _open_as_binary(data) as data_as_binary:
+                try:
+                    response = get_session().post(
+                        url,
+                        json=json,
+                        data=data_as_binary,
+                        headers=headers,
+                        cookies=self.cookies,
+                        timeout=self.timeout,
+                        stream=stream,
+                    )
+                except TimeoutError as error:
+                    # Convert any `TimeoutError` to a `InferenceTimeoutError`
+                    raise InferenceTimeoutError(f"Inference call timed out: {url}") from error  # type: ignore
+
+            try:
+                hf_raise_for_status(response)
+                return response.iter_lines() if stream else response.content
+            except HTTPError as error:
+                if error.response.status_code == 422 and task is not None:
+                    error.args = (
+                        f"{error.args[0]}\nMake sure '{task}' task is supported by the model.",
+                    ) + error.args[1:]
+                if error.response.status_code == 503:
+                    # If Model is unavailable, either raise a TimeoutError...
+                    if timeout is not None and time.time() - t0 > timeout:
+                        raise InferenceTimeoutError(
+                            f"Model not loaded on the server: {url}. Please retry with a higher timeout (current:"
+                            f" {self.timeout}).",
+                            request=error.request,
+                            response=error.response,
+                        ) from error
+                    # ...or wait 1s and retry
+                    logger.info(f"Waiting for model to be loaded on the server: {error}")
+                    time.sleep(1)
+                    if timeout is not None:
+                        timeout = max(self.timeout - (time.time() - t0), 1)  # type: ignore
+                    continue
+                raise
+
+    def audio_classification(
+        self,
+        audio: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ClassificationOutput]:
+        """
+        Perform audio classification on the provided audio content.
+
+        Args:
+            audio (Union[str, Path, bytes, BinaryIO]):
+                The audio content to classify. It can be raw audio bytes, a local audio file, or a URL pointing to an
+                audio file.
+            model (`str`, *optional*):
+                The model to use for audio classification. Can be a model ID hosted on the Hugging Face Hub
+                or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for
+                audio classification will be used.
+
+        Returns:
+            `List[Dict]`: The classification output containing the predicted label and its confidence.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.audio_classification("audio.flac")
+        [{'score': 0.4976358711719513, 'label': 'hap'}, {'score': 0.3677836060523987, 'label': 'neu'},...]
+        ```
+        """
+        response = self.post(data=audio, model=model, task="audio-classification")
+        return _bytes_to_list(response)
+
+    def automatic_speech_recognition(
+        self,
+        audio: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> str:
+        """
+        Perform automatic speech recognition (ASR or audio-to-text) on the given audio content.
+
+        Args:
+            audio (Union[str, Path, bytes, BinaryIO]):
+                The content to transcribe. It can be raw audio bytes, local audio file, or a URL to an audio file.
+            model (`str`, *optional*):
+                The model to use for ASR. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. If not provided, the default recommended model for ASR will be used.
+
+        Returns:
+            str: The transcribed text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.automatic_speech_recognition("hello_world.flac")
+        "hello world"
+        ```
+        """
+        response = self.post(data=audio, model=model, task="automatic-speech-recognition")
+        return _bytes_to_dict(response)["text"]
+
+    def conversational(
+        self,
+        text: str,
+        generated_responses: Optional[List[str]] = None,
+        past_user_inputs: Optional[List[str]] = None,
+        *,
+        parameters: Optional[Dict[str, Any]] = None,
+        model: Optional[str] = None,
+    ) -> ConversationalOutput:
+        """
+        Generate conversational responses based on the given input text (i.e. chat with the API).
+
+        Args:
+            text (`str`):
+                The last input from the user in the conversation.
+            generated_responses (`List[str]`, *optional*):
+                A list of strings corresponding to the earlier replies from the model. Defaults to None.
+            past_user_inputs (`List[str]`, *optional*):
+                A list of strings corresponding to the earlier replies from the user. Should be the same length as
+                `generated_responses`. Defaults to None.
+            parameters (`Dict[str, Any]`, *optional*):
+                Additional parameters for the conversational task. Defaults to None. For more details about the available
+                parameters, please refer to [this page](https://huggingface.co/docs/api-inference/detailed_parameters#conversational-task)
+            model (`str`, *optional*):
+                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
+                Defaults to None.
+
+        Returns:
+            `Dict`: The generated conversational output.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> output = client.conversational("Hi, who are you?")
+        >>> output
+        {'generated_text': 'I am the one who knocks.', 'conversation': {'generated_responses': ['I am the one who knocks.'], 'past_user_inputs': ['Hi, who are you?']}, 'warnings': ['Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.']}
+        >>> client.conversational(
+        ...     "Wow, that's scary!",
+        ...     generated_responses=output["conversation"]["generated_responses"],
+        ...     past_user_inputs=output["conversation"]["past_user_inputs"],
+        ... )
+        ```
+        """
+        payload: Dict[str, Any] = {"inputs": {"text": text}}
+        if generated_responses is not None:
+            payload["inputs"]["generated_responses"] = generated_responses
+        if past_user_inputs is not None:
+            payload["inputs"]["past_user_inputs"] = past_user_inputs
+        if parameters is not None:
+            payload["parameters"] = parameters
+        response = self.post(json=payload, model=model, task="conversational")
+        return _bytes_to_dict(response)  # type: ignore
+
+    def visual_question_answering(
+        self,
+        image: ContentT,
+        question: str,
+        *,
+        model: Optional[str] = None,
+    ) -> List[str]:
+        """
+        Answering open-ended questions based on an image.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image for the context. It can be raw bytes, an image file, or a URL to an online image.
+            question (`str`):
+                Question to be answered.
+            model (`str`, *optional*):
+                The model to use for the visual question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended visual question answering model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label and associated probability.
+
+        Raises:
+            `InferenceTimeoutError`:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.visual_question_answering(
+        ...     image="https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg",
+        ...     question="What is the animal doing?"
+        ... )
+        [{'score': 0.778609573841095, 'answer': 'laying down'},{'score': 0.6957435607910156, 'answer': 'sitting'}, ...]
+        ```
+        """
+        payload: Dict[str, Any] = {"question": question, "image": _b64_encode(image)}
+        response = self.post(json=payload, model=model, task="visual-question-answering")
+        return _bytes_to_list(response)
+
+    def document_question_answering(
+        self,
+        image: ContentT,
+        question: str,
+        *,
+        model: Optional[str] = None,
+    ) -> List[QuestionAnsweringOutput]:
+        """
+        Answer questions on document images.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image for the context. It can be raw bytes, an image file, or a URL to an online image.
+            question (`str`):
+                Question to be answered.
+            model (`str`, *optional*):
+                The model to use for the document question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended document question answering model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label, associated probability, word ids, and page number.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.document_question_answering(image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png", question="What is the invoice number?")
+        [{'score': 0.42515629529953003, 'answer': 'us-001', 'start': 16, 'end': 16}]
+        ```
+        """
+        payload: Dict[str, Any] = {"question": question, "image": _b64_encode(image)}
+        response = self.post(json=payload, model=model, task="document-question-answering")
+        return _bytes_to_list(response)
+
+    def feature_extraction(self, text: str, *, model: Optional[str] = None) -> "np.ndarray":
+        """
+        Generate embeddings for a given text.
+
+        Args:
+            text (`str`):
+                The text to embed.
+            model (`str`, *optional*):
+                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
+                Defaults to None.
+
+        Returns:
+            `np.ndarray`: The embedding representing the input text as a float32 numpy array.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.feature_extraction("Hi, who are you?")
+        array([[ 2.424802  ,  2.93384   ,  1.1750331 , ...,  1.240499, -0.13776633, -0.7889173 ],
+        [-0.42943227, -0.6364878 , -1.693462  , ...,  0.41978157, -2.4336355 ,  0.6162071 ],
+        ...,
+        [ 0.28552425, -0.928395  , -1.2077185 , ...,  0.76810825, -2.1069427 ,  0.6236161 ]], dtype=float32)
+        ```
+        """
+        response = self.post(json={"inputs": text}, model=model, task="feature-extraction")
+        np = _import_numpy()
+        return np.array(_bytes_to_dict(response), dtype="float32")
+
+    def fill_mask(self, text: str, *, model: Optional[str] = None) -> List[FillMaskOutput]:
+        """
+        Fill in a hole with a missing word (token to be precise).
+
+        Args:
+            text (`str`):
+                a string to be filled from, must contain the [MASK] token (check model card for exact name of the mask).
+            model (`str`, *optional*):
+                The model to use for the fill mask task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended fill mask model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of fill mask output dictionaries containing the predicted label, associated
+            probability, token reference, and completed text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.fill_mask("The goal of life is <mask>.")
+        [{'score': 0.06897063553333282,
+        'token': 11098,
+        'token_str': ' happiness',
+        'sequence': 'The goal of life is happiness.'},
+        {'score': 0.06554922461509705,
+        'token': 45075,
+        'token_str': ' immortality',
+        'sequence': 'The goal of life is immortality.'}]
+        ```
+        """
+        response = self.post(json={"inputs": text}, model=model, task="fill-mask")
+        return _bytes_to_list(response)
+
+    def image_classification(
+        self,
+        image: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ClassificationOutput]:
+        """
+        Perform image classification on the given image using the specified model.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The image to classify. It can be raw bytes, an image file, or a URL to an online image.
+            model (`str`, *optional*):
+                The model to use for image classification. Can be a model ID hosted on the Hugging Face Hub or a URL to a
+                deployed Inference Endpoint. If not provided, the default recommended model for image classification will be used.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label and associated probability.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
+        [{'score': 0.9779096841812134, 'label': 'Blenheim spaniel'}, ...]
+        ```
+        """
+        response = self.post(data=image, model=model, task="image-classification")
+        return _bytes_to_list(response)
+
+    def image_segmentation(
+        self,
+        image: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ImageSegmentationOutput]:
+        """
+        Perform image segmentation on the given image using the specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The image to segment. It can be raw bytes, an image file, or a URL to an online image.
+            model (`str`, *optional*):
+                The model to use for image segmentation. Can be a model ID hosted on the Hugging Face Hub or a URL to a
+                deployed Inference Endpoint. If not provided, the default recommended model for image segmentation will be used.
+
+        Returns:
+            `List[Dict]`: A list of dictionaries containing the segmented masks and associated attributes.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.image_segmentation("cat.jpg"):
+        [{'score': 0.989008, 'label': 'LABEL_184', 'mask': <PIL.PngImagePlugin.PngImageFile image mode=L size=400x300 at 0x7FDD2B129CC0>}, ...]
+        ```
+        """
+
+        # Segment
+        response = self.post(data=image, model=model, task="image-segmentation")
+        output = _bytes_to_dict(response)
+
+        # Parse masks as PIL Image
+        if not isinstance(output, list):
+            raise ValueError(f"Server output must be a list. Got {type(output)}: {str(output)[:200]}...")
+        for item in output:
+            item["mask"] = _b64_to_image(item["mask"])
+        return output
+
+    def image_to_image(
+        self,
+        image: ContentT,
+        prompt: Optional[str] = None,
+        *,
+        negative_prompt: Optional[str] = None,
+        height: Optional[int] = None,
+        width: Optional[int] = None,
+        num_inference_steps: Optional[int] = None,
+        guidance_scale: Optional[float] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> "Image":
+        """
+        Perform image-to-image translation using a specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image for translation. It can be raw bytes, an image file, or a URL to an online image.
+            prompt (`str`, *optional*):
+                The text prompt to guide the image generation.
+            negative_prompt (`str`, *optional*):
+                A negative prompt to guide the translation process.
+            height (`int`, *optional*):
+                The height in pixels of the generated image.
+            width (`int`, *optional*):
+                The width in pixels of the generated image.
+            num_inference_steps (`int`, *optional*):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, *optional*):
+                Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
+                usually at the expense of lower image quality.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `Image`: The translated image.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> image = client.image_to_image("cat.jpg", prompt="turn the cat into a tiger")
+        >>> image.save("tiger.jpg")
+        ```
+        """
+        parameters = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "height": height,
+            "width": width,
+            "num_inference_steps": num_inference_steps,
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        if all(parameter is None for parameter in parameters.values()):
+            # Either only an image to send => send as raw bytes
+            data = image
+            payload: Optional[Dict[str, Any]] = None
+        else:
+            # Or an image + some parameters => use base64 encoding
+            data = None
+            payload = {"inputs": _b64_encode(image)}
+            for key, value in parameters.items():
+                if value is not None:
+                    payload.setdefault("parameters", {})[key] = value
+
+        response = self.post(json=payload, data=data, model=model, task="image-to-image")
+        return _bytes_to_image(response)
+
+    def image_to_text(self, image: ContentT, *, model: Optional[str] = None) -> str:
+        """
+        Takes an input image and return text.
+
+        Models can have very different outputs depending on your use case (image captioning, optical character recognition
+        (OCR), Pix2Struct, etc). Please have a look to the model card to learn more about a model's specificities.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image to caption. It can be raw bytes, an image file, or a URL to an online image..
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `str`: The generated text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.image_to_text("cat.jpg")
+        'a cat standing in a grassy field '
+        >>> client.image_to_text("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
+        'a dog laying on the grass next to a flower pot '
+        ```
+        """
+        response = self.post(data=image, model=model, task="image-to-text")
+        return _bytes_to_dict(response)[0]["generated_text"]
+
+    def list_deployed_models(
+        self, frameworks: Union[None, str, Literal["all"], List[str]] = None
+    ) -> Dict[str, List[str]]:
+        """
+        List models currently deployed on the Inference API service.
+
+        This helper checks deployed models framework by framework. By default, it will check the 4 main frameworks that
+        are supported and account for 95% of the hosted models. However, if you want a complete list of models you can
+        specify `frameworks="all"` as input. Alternatively, if you know before-hand which framework you are interested
+        in, you can also restrict to search to this one (e.g. `frameworks="text-generation-inference"`). The more
+        frameworks are checked, the more time it will take.
+
+        <Tip>
+
+        This endpoint is mostly useful for discoverability. If you already know which model you want to use and want to
+        check its availability, you can directly use [`~InferenceClient.get_model_status`].
+
+        </Tip>
+
+        Args:
+            frameworks (`Literal["all"]` or `List[str]` or `str`, *optional*):
+                The frameworks to filter on. By default only a subset of the available frameworks are tested. If set to
+                "all", all available frameworks will be tested. It is also possible to provide a single framework or a
+                custom set of frameworks to check.
+
+        Returns:
+            `Dict[str, List[str]]`: A dictionary mapping task names to a sorted list of model IDs.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+
+        # Discover zero-shot-classification models currently deployed
+        >>> models = client.list_deployed_models()
+        >>> models["zero-shot-classification"]
+        ['Narsil/deberta-large-mnli-zero-cls', 'facebook/bart-large-mnli', ...]
+
+        # List from only 1 framework
+        >>> client.list_deployed_models("text-generation-inference")
+        {'text-generation': ['bigcode/starcoder', 'meta-llama/Llama-2-70b-chat-hf', ...], ...}
+        ```
+        """
+        # Resolve which frameworks to check
+        if frameworks is None:
+            frameworks = MAIN_INFERENCE_API_FRAMEWORKS
+        elif frameworks == "all":
+            frameworks = ALL_INFERENCE_API_FRAMEWORKS
+        elif isinstance(frameworks, str):
+            frameworks = [frameworks]
+        frameworks = list(set(frameworks))
+
+        # Fetch them iteratively
+        models_by_task: Dict[str, List[str]] = {}
+
+        def _unpack_response(framework: str, items: List[Dict]) -> None:
+            for model in items:
+                if framework == "sentence-transformers":
+                    # Model running with the `sentence-transformers` framework can work with both tasks even if not
+                    # branded as such in the API response
+                    models_by_task.setdefault("feature-extraction", []).append(model["model_id"])
+                    models_by_task.setdefault("sentence-similarity", []).append(model["model_id"])
+                else:
+                    models_by_task.setdefault(model["task"], []).append(model["model_id"])
+
+        for framework in frameworks:
+            response = get_session().get(f"{INFERENCE_ENDPOINT}/framework/{framework}", headers=self.headers)
+            hf_raise_for_status(response)
+            _unpack_response(framework, response.json())
+
+        # Sort alphabetically for discoverability and return
+        for task, models in models_by_task.items():
+            models_by_task[task] = sorted(set(models), key=lambda x: x.lower())
+        return models_by_task
+
+    def object_detection(
+        self,
+        image: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ObjectDetectionOutput]:
+        """
+        Perform object detection on the given image using the specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The image to detect objects on. It can be raw bytes, an image file, or a URL to an online image.
+            model (`str`, *optional*):
+                The model to use for object detection. Can be a model ID hosted on the Hugging Face Hub or a URL to a
+                deployed Inference Endpoint. If not provided, the default recommended model for object detection (DETR) will be used.
+
+        Returns:
+            `List[ObjectDetectionOutput]`: A list of dictionaries containing the bounding boxes and associated attributes.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+            `ValueError`:
+                If the request output is not a List.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.object_detection("people.jpg"):
+        [{"score":0.9486683011054993,"label":"person","box":{"xmin":59,"ymin":39,"xmax":420,"ymax":510}}, ... ]
+        ```
+        """
+        # detect objects
+        response = self.post(data=image, model=model, task="object-detection")
+        output = _bytes_to_dict(response)
+        if not isinstance(output, list):
+            raise ValueError(f"Server output must be a list. Got {type(output)}: {str(output)[:200]}...")
+        return output
+
+    def question_answering(
+        self, question: str, context: str, *, model: Optional[str] = None
+    ) -> QuestionAnsweringOutput:
+        """
+        Retrieve the answer to a question from a given text.
+
+        Args:
+            question (`str`):
+                Question to be answered.
+            context (`str`):
+                The context of the question.
+            model (`str`):
+                The model to use for the question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint.
+
+        Returns:
+            `Dict`: a dictionary of question answering output containing the score, start index, end index, and answer.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.question_answering(question="What's my name?", context="My name is Clara and I live in Berkeley.")
+        {'score': 0.9326562285423279, 'start': 11, 'end': 16, 'answer': 'Clara'}
+        ```
+        """
+
+        payload: Dict[str, Any] = {"question": question, "context": context}
+        response = self.post(
+            json=payload,
+            model=model,
+            task="question-answering",
+        )
+        return _bytes_to_dict(response)  # type: ignore
+
+    def sentence_similarity(
+        self, sentence: str, other_sentences: List[str], *, model: Optional[str] = None
+    ) -> List[float]:
+        """
+        Compute the semantic similarity between a sentence and a list of other sentences by comparing their embeddings.
+
+        Args:
+            sentence (`str`):
+                The main sentence to compare to others.
+            other_sentences (`List[str]`):
+                The list of sentences to compare to.
+            model (`str`, *optional*):
+                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[float]`: The embedding representing the input text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.sentence_similarity(
+        ...     "Machine learning is so easy.",
+        ...     other_sentences=[
+        ...         "Deep learning is so straightforward.",
+        ...         "This is so difficult, like rocket science.",
+        ...         "I can't believe how much I struggled with this.",
+        ...     ],
+        ... )
+        [0.7785726189613342, 0.45876261591911316, 0.2906220555305481]
+        ```
+        """
+        response = self.post(
+            json={"inputs": {"source_sentence": sentence, "sentences": other_sentences}},
+            model=model,
+            task="sentence-similarity",
+        )
+        return _bytes_to_list(response)
+
+    def summarization(
+        self,
+        text: str,
+        *,
+        parameters: Optional[Dict[str, Any]] = None,
+        model: Optional[str] = None,
+    ) -> str:
+        """
+        Generate a summary of a given text using a specified model.
+
+        Args:
+            text (`str`):
+                The input text to summarize.
+            parameters (`Dict[str, Any]`, *optional*):
+                Additional parameters for summarization. Check out this [page](https://huggingface.co/docs/api-inference/detailed_parameters#summarization-task)
+                for more details.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `str`: The generated summary text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.summarization("The Eiffel tower...")
+        'The Eiffel tower is one of the most famous landmarks in the world....'
+        ```
+        """
+        payload: Dict[str, Any] = {"inputs": text}
+        if parameters is not None:
+            payload["parameters"] = parameters
+        response = self.post(json=payload, model=model, task="summarization")
+        return _bytes_to_dict(response)[0]["summary_text"]
+
+    def table_question_answering(
+        self, table: Dict[str, Any], query: str, *, model: Optional[str] = None
+    ) -> TableQuestionAnsweringOutput:
+        """
+        Retrieve the answer to a question from information given in a table.
+
+        Args:
+            table (`str`):
+                A table of data represented as a dict of lists where entries are headers and the lists are all the
+                values, all lists must have the same size.
+            query (`str`):
+                The query in plain text that you want to ask the table.
+            model (`str`):
+                The model to use for the table-question-answering task. Can be a model ID hosted on the Hugging Face
+                Hub or a URL to a deployed Inference Endpoint.
+
+        Returns:
+            `Dict`: a dictionary of table question answering output containing the answer, coordinates, cells and the aggregator used.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> query = "How many stars does the transformers repository have?"
+        >>> table = {"Repository": ["Transformers", "Datasets", "Tokenizers"], "Stars": ["36542", "4512", "3934"]}
+        >>> client.table_question_answering(table, query, model="google/tapas-base-finetuned-wtq")
+        {'answer': 'AVERAGE > 36542', 'coordinates': [[0, 1]], 'cells': ['36542'], 'aggregator': 'AVERAGE'}
+        ```
+        """
+        response = self.post(
+            json={
+                "query": query,
+                "table": table,
+            },
+            model=model,
+            task="table-question-answering",
+        )
+        return _bytes_to_dict(response)  # type: ignore
+
+    def tabular_classification(self, table: Dict[str, Any], *, model: str) -> List[str]:
+        """
+        Classifying a target category (a group) based on a set of attributes.
+
+        Args:
+            table (`Dict[str, Any]`):
+                Set of attributes to classify.
+            model (`str`):
+                The model to use for the tabular-classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint.
+
+        Returns:
+            `List`: a list of labels, one per row in the initial table.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> table = {
+        ...     "fixed_acidity": ["7.4", "7.8", "10.3"],
+        ...     "volatile_acidity": ["0.7", "0.88", "0.32"],
+        ...     "citric_acid": ["0", "0", "0.45"],
+        ...     "residual_sugar": ["1.9", "2.6", "6.4"],
+        ...     "chlorides": ["0.076", "0.098", "0.073"],
+        ...     "free_sulfur_dioxide": ["11", "25", "5"],
+        ...     "total_sulfur_dioxide": ["34", "67", "13"],
+        ...     "density": ["0.9978", "0.9968", "0.9976"],
+        ...     "pH": ["3.51", "3.2", "3.23"],
+        ...     "sulphates": ["0.56", "0.68", "0.82"],
+        ...     "alcohol": ["9.4", "9.8", "12.6"],
+        ... }
+        >>> client.tabular_classification(table=table, model="julien-c/wine-quality")
+        ["5", "5", "5"]
+        ```
+        """
+        response = self.post(json={"table": table}, model=model, task="tabular-classification")
+        return _bytes_to_list(response)
+
+    def tabular_regression(self, table: Dict[str, Any], *, model: str) -> List[float]:
+        """
+        Predicting a numerical target value given a set of attributes/features in a table.
+
+        Args:
+            table (`Dict[str, Any]`):
+                Set of attributes stored in a table. The attributes used to predict the target can be both numerical and categorical.
+            model (`str`):
+                The model to use for the tabular-regression task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint.
+
+        Returns:
+            `List`: a list of predicted numerical target values.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> table = {
+        ...     "Height": ["11.52", "12.48", "12.3778"],
+        ...     "Length1": ["23.2", "24", "23.9"],
+        ...     "Length2": ["25.4", "26.3", "26.5"],
+        ...     "Length3": ["30", "31.2", "31.1"],
+        ...     "Species": ["Bream", "Bream", "Bream"],
+        ...     "Width": ["4.02", "4.3056", "4.6961"],
+        ... }
+        >>> client.tabular_regression(table, model="scikit-learn/Fish-Weight")
+        [110, 120, 130]
+        ```
+        """
+        response = self.post(json={"table": table}, model=model, task="tabular-regression")
+        return _bytes_to_list(response)
+
+    def text_classification(self, text: str, *, model: Optional[str] = None) -> List[ClassificationOutput]:
+        """
+        Perform text classification (e.g. sentiment-analysis) on the given text.
+
+        Args:
+            text (`str`):
+                A string to be classified.
+            model (`str`, *optional*):
+                The model to use for the text classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended text classification model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label and associated probability.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.text_classification("I like you")
+        [{'label': 'POSITIVE', 'score': 0.9998695850372314}, {'label': 'NEGATIVE', 'score': 0.0001304351753788069}]
+        ```
+        """
+        response = self.post(json={"inputs": text}, model=model, task="text-classification")
+        return _bytes_to_list(response)[0]
+
+    @overload
+    def text_generation(  # type: ignore
+        self,
+        prompt: str,
+        *,
+        details: Literal[False] = ...,
+        stream: Literal[False] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> str:
+        ...
+
+    @overload
+    def text_generation(  # type: ignore
+        self,
+        prompt: str,
+        *,
+        details: Literal[True] = ...,
+        stream: Literal[False] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> TextGenerationResponse:
+        ...
+
+    @overload
+    def text_generation(  # type: ignore
+        self,
+        prompt: str,
+        *,
+        details: Literal[False] = ...,
+        stream: Literal[True] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> Iterable[str]:
+        ...
+
+    @overload
+    def text_generation(
+        self,
+        prompt: str,
+        *,
+        details: Literal[True] = ...,
+        stream: Literal[True] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> Iterable[TextGenerationStreamResponse]:
+        ...
+
+    def text_generation(
+        self,
+        prompt: str,
+        *,
+        details: bool = False,
+        stream: bool = False,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+        decoder_input_details: bool = False,
+    ) -> Union[str, TextGenerationResponse, Iterable[str], Iterable[TextGenerationStreamResponse]]:
+        """
+        Given a prompt, generate the following text.
+
+        It is recommended to have Pydantic installed in order to get inputs validated. This is preferable as it allow
+        early failures.
+
+        API endpoint is supposed to run with the `text-generation-inference` backend (TGI). This backend is the
+        go-to solution to run large language models at scale. However, for some smaller models (e.g. "gpt2") the
+        default `transformers` + `api-inference` solution is still in use. Both approaches have very similar APIs, but
+        not exactly the same. This method is compatible with both approaches but some parameters are only available for
+        `text-generation-inference`. If some parameters are ignored, a warning message is triggered but the process
+        continues correctly.
+
+        To learn more about the TGI project, please refer to https://github.com/huggingface/text-generation-inference.
+
+        Args:
+            prompt (`str`):
+                Input text.
+            details (`bool`, *optional*):
+                By default, text_generation returns a string. Pass `details=True` if you want a detailed output (tokens,
+                probabilities, seed, finish reason, etc.). Only available for models running on with the
+                `text-generation-inference` backend.
+            stream (`bool`, *optional*):
+                By default, text_generation returns the full generated text. Pass `stream=True` if you want a stream of
+                tokens to be returned. Only available for models running on with the `text-generation-inference`
+                backend.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+            do_sample (`bool`):
+                Activate logits sampling
+            max_new_tokens (`int`):
+                Maximum number of generated tokens
+            best_of (`int`):
+                Generate best_of sequences and return the one if the highest token logprobs
+            repetition_penalty (`float`):
+                The parameter for repetition penalty. 1.0 means no penalty. See [this
+                paper](https://arxiv.org/pdf/1909.05858.pdf) for more details.
+            return_full_text (`bool`):
+                Whether to prepend the prompt to the generated text
+            seed (`int`):
+                Random sampling seed
+            stop_sequences (`List[str]`):
+                Stop generating tokens if a member of `stop_sequences` is generated
+            temperature (`float`):
+                The value used to module the logits distribution.
+            top_k (`int`):
+                The number of highest probability vocabulary tokens to keep for top-k-filtering.
+            top_p (`float`):
+                If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or
+                higher are kept for generation.
+            truncate (`int`):
+                Truncate inputs tokens to the given size
+            typical_p (`float`):
+                Typical Decoding mass
+                See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) for more information
+            watermark (`bool`):
+                Watermarking with [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226)
+            decoder_input_details (`bool`):
+                Return the decoder input token logprobs and ids. You must set `details=True` as well for it to be taken
+                into account. Defaults to `False`.
+
+        Returns:
+            `Union[str, TextGenerationResponse, Iterable[str], Iterable[TextGenerationStreamResponse]]`:
+            Generated text returned from the server:
+            - if `stream=False` and `details=False`, the generated text is returned as a `str` (default)
+            - if `stream=True` and `details=False`, the generated text is returned token by token as a `Iterable[str]`
+            - if `stream=False` and `details=True`, the generated text is returned with more details as a [`~huggingface_hub.inference._text_generation.TextGenerationResponse`]
+            - if `details=True` and `stream=True`, the generated text is returned token by token as a iterable of [`~huggingface_hub.inference._text_generation.TextGenerationStreamResponse`]
+
+        Raises:
+            `ValidationError`:
+                If input values are not valid. No HTTP call is made to the server.
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+
+        # Case 1: generate text
+        >>> client.text_generation("The huggingface_hub library is ", max_new_tokens=12)
+        '100% open source and built to be easy to use.'
+
+        # Case 2: iterate over the generated tokens. Useful for large generation.
+        >>> for token in client.text_generation("The huggingface_hub library is ", max_new_tokens=12, stream=True):
+        ...     print(token)
+        100
+        %
+        open
+        source
+        and
+        built
+        to
+        be
+        easy
+        to
+        use
+        .
+
+        # Case 3: get more details about the generation process.
+        >>> client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True)
+        TextGenerationResponse(
+            generated_text='100% open source and built to be easy to use.',
+            details=Details(
+                finish_reason=<FinishReason.Length: 'length'>,
+                generated_tokens=12,
+                seed=None,
+                prefill=[
+                    InputToken(id=487, text='The', logprob=None),
+                    InputToken(id=53789, text=' hugging', logprob=-13.171875),
+                    (...)
+                    InputToken(id=204, text=' ', logprob=-7.0390625)
+                ],
+                tokens=[
+                    Token(id=1425, text='100', logprob=-1.0175781, special=False),
+                    Token(id=16, text='%', logprob=-0.0463562, special=False),
+                    (...)
+                    Token(id=25, text='.', logprob=-0.5703125, special=False)
+                ],
+                best_of_sequences=None
+            )
+        )
+
+        # Case 4: iterate over the generated tokens with more details.
+        # Last object is more complete, containing the full generated text and the finish reason.
+        >>> for details in client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True, stream=True):
+        ...     print(details)
+        ...
+        TextGenerationStreamResponse(token=Token(id=1425, text='100', logprob=-1.0175781, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=16, text='%', logprob=-0.0463562, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=1314, text=' open', logprob=-1.3359375, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=3178, text=' source', logprob=-0.28100586, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=273, text=' and', logprob=-0.5961914, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=3426, text=' built', logprob=-1.9423828, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-1.4121094, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=314, text=' be', logprob=-1.5224609, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=1833, text=' easy', logprob=-2.1132812, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-0.08520508, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=745, text=' use', logprob=-0.39453125, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(
+            id=25,
+            text='.',
+            logprob=-0.5703125,
+            special=False),
+            generated_text='100% open source and built to be easy to use.',
+            details=StreamDetails(finish_reason=<FinishReason.Length: 'length'>, generated_tokens=12, seed=None)
+        )
+        ```
+        """
+        # NOTE: Text-generation integration is taken from the text-generation-inference project. It has more features
+        # like input/output validation (if Pydantic is installed). See `_text_generation.py` header for more details.
+
+        if decoder_input_details and not details:
+            warnings.warn(
+                "`decoder_input_details=True` has been passed to the server but `details=False` is set meaning that"
+                " the output from the server will be truncated."
+            )
+            decoder_input_details = False
+
+        # Validate parameters
+        parameters = TextGenerationParameters(
+            best_of=best_of,
+            details=details,
+            do_sample=do_sample,
+            max_new_tokens=max_new_tokens,
+            repetition_penalty=repetition_penalty,
+            return_full_text=return_full_text,
+            seed=seed,
+            stop=stop_sequences if stop_sequences is not None else [],
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p,
+            truncate=truncate,
+            typical_p=typical_p,
+            watermark=watermark,
+            decoder_input_details=decoder_input_details,
+        )
+        request = TextGenerationRequest(inputs=prompt, stream=stream, parameters=parameters)
+        payload = asdict(request)
+
+        # Remove some parameters if not a TGI server
+        if not _is_tgi_server(model):
+            ignored_parameters = []
+            for key in "watermark", "stop", "details", "decoder_input_details":
+                if payload["parameters"][key] is not None:
+                    ignored_parameters.append(key)
+                del payload["parameters"][key]
+            if len(ignored_parameters) > 0:
+                warnings.warn(
+                    "API endpoint/model for text-generation is not served via TGI. Ignoring parameters"
+                    f" {ignored_parameters}.",
+                    UserWarning,
+                )
+            if details:
+                warnings.warn(
+                    "API endpoint/model for text-generation is not served via TGI. Parameter `details=True` will"
+                    " be ignored meaning only the generated text will be returned.",
+                    UserWarning,
+                )
+                details = False
+            if stream:
+                raise ValueError(
+                    "API endpoint/model for text-generation is not served via TGI. Cannot return output as a stream."
+                    " Please pass `stream=False` as input."
+                )
+
+        # Handle errors separately for more precise error messages
+        try:
+            bytes_output = self.post(json=payload, model=model, task="text-generation", stream=stream)  # type: ignore
+        except HTTPError as e:
+            if isinstance(e, BadRequestError) and "The following `model_kwargs` are not used by the model" in str(e):
+                _set_as_non_tgi(model)
+                return self.text_generation(  # type: ignore
+                    prompt=prompt,
+                    details=details,
+                    stream=stream,
+                    model=model,
+                    do_sample=do_sample,
+                    max_new_tokens=max_new_tokens,
+                    best_of=best_of,
+                    repetition_penalty=repetition_penalty,
+                    return_full_text=return_full_text,
+                    seed=seed,
+                    stop_sequences=stop_sequences,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    truncate=truncate,
+                    typical_p=typical_p,
+                    watermark=watermark,
+                    decoder_input_details=decoder_input_details,
+                )
+            raise_text_generation_error(e)
+
+        # Parse output
+        if stream:
+            return _stream_text_generation_response(bytes_output, details)  # type: ignore
+
+        data = _bytes_to_dict(bytes_output)[0]
+        return TextGenerationResponse(**data) if details else data["generated_text"]
+
+    def text_to_image(
+        self,
+        prompt: str,
+        *,
+        negative_prompt: Optional[str] = None,
+        height: Optional[float] = None,
+        width: Optional[float] = None,
+        num_inference_steps: Optional[float] = None,
+        guidance_scale: Optional[float] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> "Image":
+        """
+        Generate an image based on a given text using a specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            prompt (`str`):
+                The prompt to generate an image from.
+            negative_prompt (`str`, *optional*):
+                An optional negative prompt for the image generation.
+            height (`float`, *optional*):
+                The height in pixels of the image to generate.
+            width (`float`, *optional*):
+                The width in pixels of the image to generate.
+            num_inference_steps (`int`, *optional*):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, *optional*):
+                Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
+                usually at the expense of lower image quality.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `Image`: The generated image.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+
+        >>> image = client.text_to_image("An astronaut riding a horse on the moon.")
+        >>> image.save("astronaut.png")
+
+        >>> image = client.text_to_image(
+        ...     "An astronaut riding a horse on the moon.",
+        ...     negative_prompt="low resolution, blurry",
+        ...     model="stabilityai/stable-diffusion-2-1",
+        ... )
+        >>> image.save("better_astronaut.png")
+        ```
+        """
+        payload = {"inputs": prompt}
+        parameters = {
+            "negative_prompt": negative_prompt,
+            "height": height,
+            "width": width,
+            "num_inference_steps": num_inference_steps,
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        for key, value in parameters.items():
+            if value is not None:
+                payload.setdefault("parameters", {})[key] = value  # type: ignore
+        response = self.post(json=payload, model=model, task="text-to-image")
+        return _bytes_to_image(response)
+
+    def text_to_speech(self, text: str, *, model: Optional[str] = None) -> bytes:
+        """
+        Synthesize an audio of a voice pronouncing a given text.
+
+        Args:
+            text (`str`):
+                The text to synthesize.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `bytes`: The generated audio.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from pathlib import Path
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+
+        >>> audio = client.text_to_speech("Hello world")
+        >>> Path("hello_world.flac").write_bytes(audio)
+        ```
+        """
+        return self.post(json={"inputs": text}, model=model, task="text-to-speech")
+
+    def token_classification(self, text: str, *, model: Optional[str] = None) -> List[TokenClassificationOutput]:
+        """
+        Perform token classification on the given text.
+        Usually used for sentence parsing, either grammatical, or Named Entity Recognition (NER) to understand keywords contained within text.
+
+        Args:
+            text (`str`):
+                A string to be classified.
+            model (`str`, *optional*):
+                The model to use for the token classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended token classification model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: List of token classification outputs containing the entity group, confidence score, word, start and end index.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.token_classification("My name is Sarah Jessica Parker but you can call me Jessica")
+        [{'entity_group': 'PER',
+        'score': 0.9971321225166321,
+        'word': 'Sarah Jessica Parker',
+        'start': 11,
+        'end': 31},
+        {'entity_group': 'PER',
+        'score': 0.9773476123809814,
+        'word': 'Jessica',
+        'start': 52,
+        'end': 59}]
+        ```
+        """
+        payload: Dict[str, Any] = {"inputs": text}
+        response = self.post(
+            json=payload,
+            model=model,
+            task="token-classification",
+        )
+        return _bytes_to_list(response)
+
+    def translation(
+        self, text: str, *, model: Optional[str] = None, src_lang: Optional[str] = None, tgt_lang: Optional[str] = None
+    ) -> str:
+        """
+        Convert text from one language to another.
+
+        Check out https://huggingface.co/tasks/translation for more information on how to choose the best model for
+        your specific use case. Source and target languages usually depend on the model.
+        However, it is possible to specify source and target languages for certain models. If you are working with one of these models,
+        you can use `src_lang` and `tgt_lang` arguments to pass the relevant information.
+        You can find this information in the model card.
+
+        Args:
+            text (`str`):
+                A string to be translated.
+            model (`str`, *optional*):
+                The model to use for the translation task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended translation model will be used.
+                Defaults to None.
+            src_lang (`str`, *optional*):
+                Source language of the translation task, i.e. input language. Cannot be passed without `tgt_lang`.
+            tgt_lang (`str`, *optional*):
+                Target language of the translation task, i.e. output language. Cannot be passed without `src_lang`.
+
+        Returns:
+            `str`: The generated translated text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+            `ValueError`:
+                If only one of the `src_lang` and `tgt_lang` arguments are provided.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.translation("My name is Wolfgang and I live in Berlin")
+        'Mein Name ist Wolfgang und ich lebe in Berlin.'
+        >>> client.translation("My name is Wolfgang and I live in Berlin", model="Helsinki-NLP/opus-mt-en-fr")
+        "Je m'appelle Wolfgang et je vis à Berlin."
+        ```
+
+        Specifying languages:
+        ```py
+        >>> client.translation("My name is Sarah Jessica Parker but you can call me Jessica", model="facebook/mbart-large-50-many-to-many-mmt", src_lang="en_XX", tgt_lang="fr_XX")
+        "Mon nom est Sarah Jessica Parker mais vous pouvez m\'appeler Jessica"
+        ```
+        """
+        # Throw error if only one of `src_lang` and `tgt_lang` was given
+        if src_lang is not None and tgt_lang is None:
+            raise ValueError("You cannot specify `src_lang` without specifying `tgt_lang`.")
+
+        if src_lang is None and tgt_lang is not None:
+            raise ValueError("You cannot specify `tgt_lang` without specifying `src_lang`.")
+
+        # If both `src_lang` and `tgt_lang` are given, pass them to the request body
+        payload: Dict = {"inputs": text}
+        if src_lang and tgt_lang:
+            payload["parameters"] = {"src_lang": src_lang, "tgt_lang": tgt_lang}
+        response = self.post(json=payload, model=model, task="translation")
+        return _bytes_to_dict(response)[0]["translation_text"]
+
+    def zero_shot_classification(
+        self, text: str, labels: List[str], *, multi_label: bool = False, model: Optional[str] = None
+    ) -> List[ClassificationOutput]:
+        """
+        Provide as input a text and a set of candidate labels to classify the input text.
+
+        Args:
+            text (`str`):
+                The input text to classify.
+            labels (`List[str]`):
+                List of string possible labels. There must be at least 2 labels.
+            multi_label (`bool`):
+                Boolean that is set to True if classes can overlap.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `List[Dict]`: List of classification outputs containing the predicted labels and their confidence.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> text = (
+        ...     "A new model offers an explanation for how the Galilean satellites formed around the solar system's"
+        ...     "largest world. Konstantin Batygin did not set out to solve one of the solar system's most puzzling"
+        ...     " mysteries when he went for a run up a hill in Nice, France."
+        ... )
+        >>> labels = ["space & cosmos", "scientific discovery", "microbiology", "robots", "archeology"]
+        >>> client.zero_shot_classification(text, labels)
+        [
+            {"label": "scientific discovery", "score": 0.7961668968200684},
+            {"label": "space & cosmos", "score": 0.18570658564567566},
+            {"label": "microbiology", "score": 0.00730885099619627},
+            {"label": "archeology", "score": 0.006258360575884581},
+            {"label": "robots", "score": 0.004559356719255447},
+        ]
+        >>> client.zero_shot_classification(text, labels, multi_label=True)
+        [
+            {"label": "scientific discovery", "score": 0.9829297661781311},
+            {"label": "space & cosmos", "score": 0.755190908908844},
+            {"label": "microbiology", "score": 0.0005462635890580714},
+            {"label": "archeology", "score": 0.00047131875180639327},
+            {"label": "robots", "score": 0.00030448526376858354},
+        ]
+        ```
+        """
+        # Raise ValueError if input is less than 2 labels
+        if len(labels) < 2:
+            raise ValueError("You must specify at least 2 classes to compare.")
+
+        response = self.post(
+            json={
+                "inputs": text,
+                "parameters": {
+                    "candidate_labels": ",".join(labels),
+                    "multi_label": multi_label,
+                },
+            },
+            model=model,
+            task="zero-shot-classification",
+        )
+        output = _bytes_to_dict(response)
+        return [{"label": label, "score": score} for label, score in zip(output["labels"], output["scores"])]
+
+    def zero_shot_image_classification(
+        self, image: ContentT, labels: List[str], *, model: Optional[str] = None
+    ) -> List[ClassificationOutput]:
+        """
+        Provide input image and text labels to predict text labels for the image.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image to caption. It can be raw bytes, an image file, or a URL to an online image.
+            labels (`List[str]`):
+                List of string possible labels. There must be at least 2 labels.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `List[Dict]`: List of classification outputs containing the predicted labels and their confidence.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `HTTPError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+
+        >>> client.zero_shot_image_classification(
+        ...     "https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg",
+        ...     labels=["dog", "cat", "horse"],
+        ... )
+        [{"label": "dog", "score": 0.956}, ...]
+        ```
+        """
+        # Raise ValueError if input is less than 2 labels
+        if len(labels) < 2:
+            raise ValueError("You must specify at least 2 classes to compare.")
+
+        response = self.post(
+            json={"image": _b64_encode(image), "parameters": {"candidate_labels": ",".join(labels)}},
+            model=model,
+            task="zero-shot-image-classification",
+        )
+        return _bytes_to_list(response)
+
+    def _resolve_url(self, model: Optional[str] = None, task: Optional[str] = None) -> str:
+        model = model or self.model
+
+        # If model is already a URL, ignore `task` and return directly
+        if model is not None and (model.startswith("http://") or model.startswith("https://")):
+            return model
+
+        # # If no model but task is set => fetch the recommended one for this task
+        if model is None:
+            if task is None:
+                raise ValueError(
+                    "You must specify at least a model (repo_id or URL) or a task, either when instantiating"
+                    " `InferenceClient` or when making a request."
+                )
+            model = self.get_recommended_model(task)
+            logger.info(
+                f"Using recommended model {model} for task {task}. Note that it is"
+                f" encouraged to explicitly set `model='{model}'` as the recommended"
+                " models list might get updated without prior notice."
+            )
+
+        # Compute InferenceAPI url
+        return (
+            # Feature-extraction and sentence-similarity are the only cases where we handle models with several tasks.
+            f"{INFERENCE_ENDPOINT}/pipeline/{task}/{model}"
+            if task in ("feature-extraction", "sentence-similarity")
+            # Otherwise, we use the default endpoint
+            else f"{INFERENCE_ENDPOINT}/models/{model}"
+        )
+
+    @staticmethod
+    def get_recommended_model(task: str) -> str:
+        """
+        Get the model Hugging Face recommends for the input task.
+
+        Args:
+            task (`str`):
+                The Hugging Face task to get which model Hugging Face recommends.
+                All available tasks can be found [here](https://huggingface.co/tasks).
+
+        Returns:
+            `str`: Name of the model recommended for the input task.
+
+        Raises:
+            `ValueError`: If Hugging Face has no recommendation for the input task.
+        """
+        model = _fetch_recommended_models().get(task)
+        if model is None:
+            raise ValueError(
+                f"Task {task} has no recommended model. Please specify a model"
+                " explicitly. Visit https://huggingface.co/tasks for more info."
+            )
+        return model
+
+    def get_model_status(self, model: Optional[str] = None) -> ModelStatus:
+        """
+        Get the status of a model hosted on the Inference API.
+
+        <Tip>
+
+        This endpoint is mostly useful when you already know which model you want to use and want to check its
+        availability. If you want to discover already deployed models, you should rather use [`~InferenceClient.list_deployed_models`].
+
+        </Tip>
+
+        Args:
+            model (`str`, *optional*):
+                Identifier of the model for witch the status gonna be checked. If model is not provided,
+                the model associated with this instance of [`InferenceClient`] will be used. Only InferenceAPI service can be checked so the
+                identifier cannot be a URL.
+
+
+        Returns:
+            [`ModelStatus`]: An instance of ModelStatus dataclass, containing information,
+                         about the state of the model: load, state, compute type and framework.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import InferenceClient
+        >>> client = InferenceClient()
+        >>> client.get_model_status("bigcode/starcoder")
+        ModelStatus(loaded=True, state='Loaded', compute_type='gpu', framework='text-generation-inference')
+        ```
+        """
+        model = model or self.model
+        if model is None:
+            raise ValueError("Model id not provided.")
+        if model.startswith("https://"):
+            raise NotImplementedError("Model status is only available for Inference API endpoints.")
+        url = f"{INFERENCE_ENDPOINT}/status/{model}"
+
+        response = get_session().get(url, headers=self.headers)
+        hf_raise_for_status(response)
+        response_data = response.json()
+
+        if "error" in response_data:
+            raise ValueError(response_data["error"])
+
+        return ModelStatus(
+            loaded=response_data["loaded"],
+            state=response_data["state"],
+            compute_type=response_data["compute_type"],
+            framework=response_data["framework"],
+        )
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_common.py b/lib/python3.11/site-packages/huggingface_hub/inference/_common.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e147a5c13bf1de0da8f1dd0f176334f4d2d2323
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/inference/_common.py
@@ -0,0 +1,327 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities used by both the sync and async inference clients."""
+import base64
+import io
+import json
+import logging
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterable,
+    BinaryIO,
+    ContextManager,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Literal,
+    Optional,
+    Set,
+    Union,
+    overload,
+)
+
+from requests import HTTPError
+
+from ..constants import ENDPOINT
+from ..utils import (
+    build_hf_headers,
+    get_session,
+    hf_raise_for_status,
+    is_aiohttp_available,
+    is_numpy_available,
+    is_pillow_available,
+)
+from ._text_generation import TextGenerationStreamResponse, _parse_text_generation_error
+
+
+if TYPE_CHECKING:
+    from aiohttp import ClientResponse, ClientSession
+    from PIL import Image
+
+# TYPES
+UrlT = str
+PathT = Union[str, Path]
+BinaryT = Union[bytes, BinaryIO]
+ContentT = Union[BinaryT, PathT, UrlT]
+
+# Use to set a Accept: image/png header
+TASKS_EXPECTING_IMAGES = {"text-to-image", "image-to-image"}
+
+logger = logging.getLogger(__name__)
+
+
+# Add dataclass for ModelStatus. We use this dataclass in get_model_status function.
+@dataclass
+class ModelStatus:
+    """
+    This Dataclass represents the the model status in the Hugging Face Inference API.
+
+    Args:
+        loaded (`bool`):
+            If the model is currently loaded into Hugging Face's InferenceAPI. Models
+            are loaded on-demand, leading to the user's first request taking longer.
+            If a model is loaded, you can be assured that it is in a healthy state.
+        state (`str`):
+            The current state of the model. This can be 'Loaded', 'Loadable', 'TooBig'.
+            If a model's state is 'Loadable', it's not too big and has a supported
+            backend. Loadable models are automatically loaded when the user first
+            requests inference on the endpoint. This means it is transparent for the
+            user to load a model, except that the first call takes longer to complete.
+        compute_type (`str`):
+            The type of compute resource the model is using or will use, such as 'gpu' or 'cpu'.
+        framework (`str`):
+            The name of the framework that the model was built with, such as 'transformers'
+            or 'text-generation-inference'.
+    """
+
+    loaded: bool
+    state: str
+    compute_type: str
+    framework: str
+
+
+class InferenceTimeoutError(HTTPError, TimeoutError):
+    """Error raised when a model is unavailable or the request times out."""
+
+
+## IMPORT UTILS
+
+
+def _import_aiohttp():
+    # Make sure `aiohttp` is installed on the machine.
+    if not is_aiohttp_available():
+        raise ImportError("Please install aiohttp to use `AsyncInferenceClient` (`pip install aiohttp`).")
+    import aiohttp
+
+    return aiohttp
+
+
+def _import_numpy():
+    """Make sure `numpy` is installed on the machine."""
+    if not is_numpy_available():
+        raise ImportError("Please install numpy to use deal with embeddings (`pip install numpy`).")
+    import numpy
+
+    return numpy
+
+
+def _import_pil_image():
+    """Make sure `PIL` is installed on the machine."""
+    if not is_pillow_available():
+        raise ImportError(
+            "Please install Pillow to use deal with images (`pip install Pillow`). If you don't want the image to be"
+            " post-processed, use `client.post(...)` and get the raw response from the server."
+        )
+    from PIL import Image
+
+    return Image
+
+
+## RECOMMENDED MODELS
+
+# Will be globally fetched only once (see '_fetch_recommended_models')
+_RECOMMENDED_MODELS: Optional[Dict[str, Optional[str]]] = None
+
+
+def _fetch_recommended_models() -> Dict[str, Optional[str]]:
+    global _RECOMMENDED_MODELS
+    if _RECOMMENDED_MODELS is None:
+        response = get_session().get(f"{ENDPOINT}/api/tasks", headers=build_hf_headers())
+        hf_raise_for_status(response)
+        _RECOMMENDED_MODELS = {
+            task: _first_or_none(details["widgetModels"]) for task, details in response.json().items()
+        }
+    return _RECOMMENDED_MODELS
+
+
+def _first_or_none(items: List[Any]) -> Optional[Any]:
+    try:
+        return items[0] or None
+    except IndexError:
+        return None
+
+
+## ENCODING / DECODING UTILS
+
+
+@overload
+def _open_as_binary(content: ContentT) -> ContextManager[BinaryT]:
+    ...  # means "if input is not None, output is not None"
+
+
+@overload
+def _open_as_binary(content: Literal[None]) -> ContextManager[Literal[None]]:
+    ...  # means "if input is None, output is None"
+
+
+@contextmanager  # type: ignore
+def _open_as_binary(content: Optional[ContentT]) -> Generator[Optional[BinaryT], None, None]:
+    """Open `content` as a binary file, either from a URL, a local path, or raw bytes.
+
+    Do nothing if `content` is None,
+
+    TODO: handle a PIL.Image as input
+    TODO: handle base64 as input
+    """
+    # If content is a string => must be either a URL or a path
+    if isinstance(content, str):
+        if content.startswith("https://") or content.startswith("http://"):
+            logger.debug(f"Downloading content from {content}")
+            yield get_session().get(content).content  # TODO: retrieve as stream and pipe to post request ?
+            return
+        content = Path(content)
+        if not content.exists():
+            raise FileNotFoundError(
+                f"File not found at {content}. If `data` is a string, it must either be a URL or a path to a local"
+                " file. To pass raw content, please encode it as bytes first."
+            )
+
+    # If content is a Path => open it
+    if isinstance(content, Path):
+        logger.debug(f"Opening content from {content}")
+        with content.open("rb") as f:
+            yield f
+    else:
+        # Otherwise: already a file-like object or None
+        yield content
+
+
+def _b64_encode(content: ContentT) -> str:
+    """Encode a raw file (image, audio) into base64. Can be byes, an opened file, a path or a URL."""
+    with _open_as_binary(content) as data:
+        data_as_bytes = data if isinstance(data, bytes) else data.read()
+        return base64.b64encode(data_as_bytes).decode()
+
+
+def _b64_to_image(encoded_image: str) -> "Image":
+    """Parse a base64-encoded string into a PIL Image."""
+    Image = _import_pil_image()
+    return Image.open(io.BytesIO(base64.b64decode(encoded_image)))
+
+
+def _bytes_to_list(content: bytes) -> List:
+    """Parse bytes from a Response object into a Python list.
+
+    Expects the response body to be JSON-encoded data.
+
+    NOTE: This is exactly the same implementation as `_bytes_to_dict` and will not complain if the returned data is a
+    dictionary. The only advantage of having both is to help the user (and mypy) understand what kind of data to expect.
+    """
+    return json.loads(content.decode())
+
+
+def _bytes_to_dict(content: bytes) -> Dict:
+    """Parse bytes from a Response object into a Python dictionary.
+
+    Expects the response body to be JSON-encoded data.
+
+    NOTE: This is exactly the same implementation as `_bytes_to_list` and will not complain if the returned data is a
+    list. The only advantage of having both is to help the user (and mypy) understand what kind of data to expect.
+    """
+    return json.loads(content.decode())
+
+
+def _bytes_to_image(content: bytes) -> "Image":
+    """Parse bytes from a Response object into a PIL Image.
+
+    Expects the response body to be raw bytes. To deal with b64 encoded images, use `_b64_to_image` instead.
+    """
+    Image = _import_pil_image()
+    return Image.open(io.BytesIO(content))
+
+
+## STREAMING UTILS
+
+
+def _stream_text_generation_response(
+    bytes_output_as_lines: Iterable[bytes], details: bool
+) -> Union[Iterable[str], Iterable[TextGenerationStreamResponse]]:
+    # Parse ServerSentEvents
+    for byte_payload in bytes_output_as_lines:
+        # Skip line
+        if byte_payload == b"\n":
+            continue
+
+        payload = byte_payload.decode("utf-8")
+
+        # Event data
+        if payload.startswith("data:"):
+            # Decode payload
+            json_payload = json.loads(payload.lstrip("data:").rstrip("/n"))
+            # Either an error as being returned
+            if json_payload.get("error") is not None:
+                raise _parse_text_generation_error(json_payload["error"], json_payload.get("error_type"))
+            # Or parse token payload
+            output = TextGenerationStreamResponse(**json_payload)
+            yield output.token.text if not details else output
+
+
+async def _async_stream_text_generation_response(
+    bytes_output_as_lines: AsyncIterable[bytes], details: bool
+) -> Union[AsyncIterable[str], AsyncIterable[TextGenerationStreamResponse]]:
+    # Parse ServerSentEvents
+    async for byte_payload in bytes_output_as_lines:
+        # Skip line
+        if byte_payload == b"\n":
+            continue
+
+        payload = byte_payload.decode("utf-8")
+
+        # Event data
+        if payload.startswith("data:"):
+            # Decode payload
+            json_payload = json.loads(payload.lstrip("data:").rstrip("/n"))
+            # Either an error as being returned
+            if json_payload.get("error") is not None:
+                raise _parse_text_generation_error(json_payload["error"], json_payload.get("error_type"))
+            # Or parse token payload
+            output = TextGenerationStreamResponse(**json_payload)
+            yield output.token.text if not details else output
+
+
+async def _async_yield_from(client: "ClientSession", response: "ClientResponse") -> AsyncIterable[bytes]:
+    async for byte_payload in response.content:
+        yield byte_payload
+    await client.close()
+
+
+# "TGI servers" are servers running with the `text-generation-inference` backend.
+# This backend is the go-to solution to run large language models at scale. However,
+# for some smaller models (e.g. "gpt2") the default `transformers` + `api-inference`
+# solution is still in use.
+#
+# Both approaches have very similar APIs, but not exactly the same. What we do first in
+# the `text_generation` method is to assume the model is served via TGI. If we realize
+# it's not the case (i.e. we receive an HTTP 400 Bad Request), we fallback to the
+# default API with a warning message. We remember for each model if it's a TGI server
+# or not using `_NON_TGI_SERVERS` global variable.
+#
+# For more details, see https://github.com/huggingface/text-generation-inference and
+# https://huggingface.co/docs/api-inference/detailed_parameters#text-generation-task.
+
+_NON_TGI_SERVERS: Set[Optional[str]] = set()
+
+
+def _set_as_non_tgi(model: Optional[str]) -> None:
+    _NON_TGI_SERVERS.add(model)
+
+
+def _is_tgi_server(model: Optional[str]) -> bool:
+    return model not in _NON_TGI_SERVERS
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__init__.py b/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..85d79abfe52b66529ed8fb6a5eefc071ae48660e
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..32232d932bd6ace7e8cd4b8b7f85f12e945cb9b1
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_generated/_async_client.py b/lib/python3.11/site-packages/huggingface_hub/inference/_generated/_async_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..67a6128b8161a075866619e7a4c225dfb31ae7c2
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/inference/_generated/_async_client.py
@@ -0,0 +1,2020 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# WARNING
+# This entire file has been adapted from the sync-client code in `src/huggingface_hub/inference/_client.py`.
+# Any change in InferenceClient will be automatically reflected in AsyncInferenceClient.
+# To re-generate the code, run `make style` or `python ./utils/generate_async_inference_client.py --update`.
+# WARNING
+import asyncio
+import logging
+import time
+import warnings
+from dataclasses import asdict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Union,
+    overload,
+)
+
+from requests.structures import CaseInsensitiveDict
+
+from huggingface_hub.constants import ALL_INFERENCE_API_FRAMEWORKS, INFERENCE_ENDPOINT, MAIN_INFERENCE_API_FRAMEWORKS
+from huggingface_hub.inference._common import (
+    TASKS_EXPECTING_IMAGES,
+    ContentT,
+    InferenceTimeoutError,
+    ModelStatus,
+    _async_stream_text_generation_response,
+    _b64_encode,
+    _b64_to_image,
+    _bytes_to_dict,
+    _bytes_to_image,
+    _bytes_to_list,
+    _fetch_recommended_models,
+    _import_numpy,
+    _is_tgi_server,
+    _open_as_binary,
+    _set_as_non_tgi,
+)
+from huggingface_hub.inference._text_generation import (
+    TextGenerationParameters,
+    TextGenerationRequest,
+    TextGenerationResponse,
+    TextGenerationStreamResponse,
+    raise_text_generation_error,
+)
+from huggingface_hub.inference._types import (
+    ClassificationOutput,
+    ConversationalOutput,
+    FillMaskOutput,
+    ImageSegmentationOutput,
+    ObjectDetectionOutput,
+    QuestionAnsweringOutput,
+    TableQuestionAnsweringOutput,
+    TokenClassificationOutput,
+)
+from huggingface_hub.utils import (
+    build_hf_headers,
+)
+
+from .._common import _async_yield_from, _import_aiohttp
+
+
+if TYPE_CHECKING:
+    import numpy as np
+    from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncInferenceClient:
+    """
+    Initialize a new Inference Client.
+
+    [`InferenceClient`] aims to provide a unified experience to perform inference. The client can be used
+    seamlessly with either the (free) Inference API or self-hosted Inference Endpoints.
+
+    Args:
+        model (`str`, `optional`):
+            The model to run inference with. Can be a model id hosted on the Hugging Face Hub, e.g. `bigcode/starcoder`
+            or a URL to a deployed Inference Endpoint. Defaults to None, in which case a recommended model is
+            automatically selected for the task.
+        token (`str`, *optional*):
+            Hugging Face token. Will default to the locally saved token. Pass `token=False` if you don't want to send
+            your token to the server.
+        timeout (`float`, `optional`):
+            The maximum number of seconds to wait for a response from the server. Loading a new model in Inference
+            API can take up to several minutes. Defaults to None, meaning it will loop until the server is available.
+        headers (`Dict[str, str]`, `optional`):
+            Additional headers to send to the server. By default only the authorization and user-agent headers are sent.
+            Values in this dictionary will override the default values.
+        cookies (`Dict[str, str]`, `optional`):
+            Additional cookies to send to the server.
+    """
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        token: Union[str, bool, None] = None,
+        timeout: Optional[float] = None,
+        headers: Optional[Dict[str, str]] = None,
+        cookies: Optional[Dict[str, str]] = None,
+    ) -> None:
+        self.model: Optional[str] = model
+        self.headers = CaseInsensitiveDict(build_hf_headers(token=token))  # contains 'authorization' + 'user-agent'
+        if headers is not None:
+            self.headers.update(headers)
+        self.cookies = cookies
+        self.timeout = timeout
+
+    def __repr__(self):
+        return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"
+
+    @overload
+    async def post(  # type: ignore[misc]
+        self,
+        *,
+        json: Optional[Union[str, Dict, List]] = None,
+        data: Optional[ContentT] = None,
+        model: Optional[str] = None,
+        task: Optional[str] = None,
+        stream: Literal[False] = ...,
+    ) -> bytes:
+        pass
+
+    @overload
+    async def post(
+        self,
+        *,
+        json: Optional[Union[str, Dict, List]] = None,
+        data: Optional[ContentT] = None,
+        model: Optional[str] = None,
+        task: Optional[str] = None,
+        stream: Literal[True] = ...,
+    ) -> AsyncIterable[bytes]:
+        pass
+
+    async def post(
+        self,
+        *,
+        json: Optional[Union[str, Dict, List]] = None,
+        data: Optional[ContentT] = None,
+        model: Optional[str] = None,
+        task: Optional[str] = None,
+        stream: bool = False,
+    ) -> Union[bytes, AsyncIterable[bytes]]:
+        """
+        Make a POST request to the inference server.
+
+        Args:
+            json (`Union[str, Dict, List]`, *optional*):
+                The JSON data to send in the request body, specific to each task. Defaults to None.
+            data (`Union[str, Path, bytes, BinaryIO]`, *optional*):
+                The content to send in the request body, specific to each task.
+                It can be raw bytes, a pointer to an opened file, a local file path,
+                or a URL to an online resource (image, audio file,...). If both `json` and `data` are passed,
+                `data` will take precedence. At least `json` or `data` must be provided. Defaults to None.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. Will override the model defined at the instance level. Defaults to None.
+            task (`str`, *optional*):
+                The task to perform on the inference. All available tasks can be found
+                [here](https://huggingface.co/tasks). Used only to default to a recommended model if `model` is not
+                provided. At least `model` or `task` must be provided. Defaults to None.
+            stream (`bool`, *optional*):
+                Whether to iterate over streaming APIs.
+
+        Returns:
+            bytes: The raw bytes returned by the server.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+        """
+
+        aiohttp = _import_aiohttp()
+
+        url = self._resolve_url(model, task)
+
+        if data is not None and json is not None:
+            warnings.warn("Ignoring `json` as `data` is passed as binary.")
+
+        # Set Accept header if relevant
+        headers = self.headers.copy()
+        if task in TASKS_EXPECTING_IMAGES and "Accept" not in headers:
+            headers["Accept"] = "image/png"
+
+        t0 = time.time()
+        timeout = self.timeout
+        while True:
+            with _open_as_binary(data) as data_as_binary:
+                # Do not use context manager as we don't want to close the connection immediately when returning
+                # a stream
+                client = aiohttp.ClientSession(
+                    headers=headers, cookies=self.cookies, timeout=aiohttp.ClientTimeout(self.timeout)
+                )
+
+                try:
+                    response = await client.post(url, json=json, data=data_as_binary)
+                    response_error_payload = None
+                    if response.status != 200:
+                        try:
+                            response_error_payload = await response.json()  # get payload before connection closed
+                        except Exception:
+                            pass
+                    response.raise_for_status()
+                    if stream:
+                        return _async_yield_from(client, response)
+                    else:
+                        content = await response.read()
+                        await client.close()
+                        return content
+                except asyncio.TimeoutError as error:
+                    await client.close()
+                    # Convert any `TimeoutError` to a `InferenceTimeoutError`
+                    raise InferenceTimeoutError(f"Inference call timed out: {url}") from error  # type: ignore
+                except aiohttp.ClientResponseError as error:
+                    error.response_error_payload = response_error_payload
+                    await client.close()
+                    if response.status == 422 and task is not None:
+                        error.message += f". Make sure '{task}' task is supported by the model."
+                    if response.status == 503:
+                        # If Model is unavailable, either raise a TimeoutError...
+                        if timeout is not None and time.time() - t0 > timeout:
+                            raise InferenceTimeoutError(
+                                f"Model not loaded on the server: {url}. Please retry with a higher timeout"
+                                f" (current: {self.timeout}).",
+                                request=error.request,
+                                response=error.response,
+                            ) from error
+                        # ...or wait 1s and retry
+                        logger.info(f"Waiting for model to be loaded on the server: {error}")
+                        time.sleep(1)
+                        if timeout is not None:
+                            timeout = max(self.timeout - (time.time() - t0), 1)  # type: ignore
+                        continue
+                    raise error
+
+    async def audio_classification(
+        self,
+        audio: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ClassificationOutput]:
+        """
+        Perform audio classification on the provided audio content.
+
+        Args:
+            audio (Union[str, Path, bytes, BinaryIO]):
+                The audio content to classify. It can be raw audio bytes, a local audio file, or a URL pointing to an
+                audio file.
+            model (`str`, *optional*):
+                The model to use for audio classification. Can be a model ID hosted on the Hugging Face Hub
+                or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for
+                audio classification will be used.
+
+        Returns:
+            `List[Dict]`: The classification output containing the predicted label and its confidence.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.audio_classification("audio.flac")
+        [{'score': 0.4976358711719513, 'label': 'hap'}, {'score': 0.3677836060523987, 'label': 'neu'},...]
+        ```
+        """
+        response = await self.post(data=audio, model=model, task="audio-classification")
+        return _bytes_to_list(response)
+
+    async def automatic_speech_recognition(
+        self,
+        audio: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> str:
+        """
+        Perform automatic speech recognition (ASR or audio-to-text) on the given audio content.
+
+        Args:
+            audio (Union[str, Path, bytes, BinaryIO]):
+                The content to transcribe. It can be raw audio bytes, local audio file, or a URL to an audio file.
+            model (`str`, *optional*):
+                The model to use for ASR. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. If not provided, the default recommended model for ASR will be used.
+
+        Returns:
+            str: The transcribed text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.automatic_speech_recognition("hello_world.flac")
+        "hello world"
+        ```
+        """
+        response = await self.post(data=audio, model=model, task="automatic-speech-recognition")
+        return _bytes_to_dict(response)["text"]
+
+    async def conversational(
+        self,
+        text: str,
+        generated_responses: Optional[List[str]] = None,
+        past_user_inputs: Optional[List[str]] = None,
+        *,
+        parameters: Optional[Dict[str, Any]] = None,
+        model: Optional[str] = None,
+    ) -> ConversationalOutput:
+        """
+        Generate conversational responses based on the given input text (i.e. chat with the API).
+
+        Args:
+            text (`str`):
+                The last input from the user in the conversation.
+            generated_responses (`List[str]`, *optional*):
+                A list of strings corresponding to the earlier replies from the model. Defaults to None.
+            past_user_inputs (`List[str]`, *optional*):
+                A list of strings corresponding to the earlier replies from the user. Should be the same length as
+                `generated_responses`. Defaults to None.
+            parameters (`Dict[str, Any]`, *optional*):
+                Additional parameters for the conversational task. Defaults to None. For more details about the available
+                parameters, please refer to [this page](https://huggingface.co/docs/api-inference/detailed_parameters#conversational-task)
+            model (`str`, *optional*):
+                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
+                Defaults to None.
+
+        Returns:
+            `Dict`: The generated conversational output.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> output = await client.conversational("Hi, who are you?")
+        >>> output
+        {'generated_text': 'I am the one who knocks.', 'conversation': {'generated_responses': ['I am the one who knocks.'], 'past_user_inputs': ['Hi, who are you?']}, 'warnings': ['Setting `pad_token_id` to `eos_token_id`:50256 async for open-end generation.']}
+        >>> await client.conversational(
+        ...     "Wow, that's scary!",
+        ...     generated_responses=output["conversation"]["generated_responses"],
+        ...     past_user_inputs=output["conversation"]["past_user_inputs"],
+        ... )
+        ```
+        """
+        payload: Dict[str, Any] = {"inputs": {"text": text}}
+        if generated_responses is not None:
+            payload["inputs"]["generated_responses"] = generated_responses
+        if past_user_inputs is not None:
+            payload["inputs"]["past_user_inputs"] = past_user_inputs
+        if parameters is not None:
+            payload["parameters"] = parameters
+        response = await self.post(json=payload, model=model, task="conversational")
+        return _bytes_to_dict(response)  # type: ignore
+
+    async def visual_question_answering(
+        self,
+        image: ContentT,
+        question: str,
+        *,
+        model: Optional[str] = None,
+    ) -> List[str]:
+        """
+        Answering open-ended questions based on an image.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image for the context. It can be raw bytes, an image file, or a URL to an online image.
+            question (`str`):
+                Question to be answered.
+            model (`str`, *optional*):
+                The model to use for the visual question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended visual question answering model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label and associated probability.
+
+        Raises:
+            `InferenceTimeoutError`:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.visual_question_answering(
+        ...     image="https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg",
+        ...     question="What is the animal doing?"
+        ... )
+        [{'score': 0.778609573841095, 'answer': 'laying down'},{'score': 0.6957435607910156, 'answer': 'sitting'}, ...]
+        ```
+        """
+        payload: Dict[str, Any] = {"question": question, "image": _b64_encode(image)}
+        response = await self.post(json=payload, model=model, task="visual-question-answering")
+        return _bytes_to_list(response)
+
+    async def document_question_answering(
+        self,
+        image: ContentT,
+        question: str,
+        *,
+        model: Optional[str] = None,
+    ) -> List[QuestionAnsweringOutput]:
+        """
+        Answer questions on document images.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image for the context. It can be raw bytes, an image file, or a URL to an online image.
+            question (`str`):
+                Question to be answered.
+            model (`str`, *optional*):
+                The model to use for the document question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended document question answering model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label, associated probability, word ids, and page number.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.document_question_answering(image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png", question="What is the invoice number?")
+        [{'score': 0.42515629529953003, 'answer': 'us-001', 'start': 16, 'end': 16}]
+        ```
+        """
+        payload: Dict[str, Any] = {"question": question, "image": _b64_encode(image)}
+        response = await self.post(json=payload, model=model, task="document-question-answering")
+        return _bytes_to_list(response)
+
+    async def feature_extraction(self, text: str, *, model: Optional[str] = None) -> "np.ndarray":
+        """
+        Generate embeddings for a given text.
+
+        Args:
+            text (`str`):
+                The text to embed.
+            model (`str`, *optional*):
+                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
+                Defaults to None.
+
+        Returns:
+            `np.ndarray`: The embedding representing the input text as a float32 numpy array.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.feature_extraction("Hi, who are you?")
+        array([[ 2.424802  ,  2.93384   ,  1.1750331 , ...,  1.240499, -0.13776633, -0.7889173 ],
+        [-0.42943227, -0.6364878 , -1.693462  , ...,  0.41978157, -2.4336355 ,  0.6162071 ],
+        ...,
+        [ 0.28552425, -0.928395  , -1.2077185 , ...,  0.76810825, -2.1069427 ,  0.6236161 ]], dtype=float32)
+        ```
+        """
+        response = await self.post(json={"inputs": text}, model=model, task="feature-extraction")
+        np = _import_numpy()
+        return np.array(_bytes_to_dict(response), dtype="float32")
+
+    async def fill_mask(self, text: str, *, model: Optional[str] = None) -> List[FillMaskOutput]:
+        """
+        Fill in a hole with a missing word (token to be precise).
+
+        Args:
+            text (`str`):
+                a string to be filled from, must contain the [MASK] token (check model card for exact name of the mask).
+            model (`str`, *optional*):
+                The model to use for the fill mask task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended fill mask model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of fill mask output dictionaries containing the predicted label, associated
+            probability, token reference, and completed text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.fill_mask("The goal of life is <mask>.")
+        [{'score': 0.06897063553333282,
+        'token': 11098,
+        'token_str': ' happiness',
+        'sequence': 'The goal of life is happiness.'},
+        {'score': 0.06554922461509705,
+        'token': 45075,
+        'token_str': ' immortality',
+        'sequence': 'The goal of life is immortality.'}]
+        ```
+        """
+        response = await self.post(json={"inputs": text}, model=model, task="fill-mask")
+        return _bytes_to_list(response)
+
+    async def image_classification(
+        self,
+        image: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ClassificationOutput]:
+        """
+        Perform image classification on the given image using the specified model.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The image to classify. It can be raw bytes, an image file, or a URL to an online image.
+            model (`str`, *optional*):
+                The model to use for image classification. Can be a model ID hosted on the Hugging Face Hub or a URL to a
+                deployed Inference Endpoint. If not provided, the default recommended model for image classification will be used.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label and associated probability.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
+        [{'score': 0.9779096841812134, 'label': 'Blenheim spaniel'}, ...]
+        ```
+        """
+        response = await self.post(data=image, model=model, task="image-classification")
+        return _bytes_to_list(response)
+
+    async def image_segmentation(
+        self,
+        image: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ImageSegmentationOutput]:
+        """
+        Perform image segmentation on the given image using the specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The image to segment. It can be raw bytes, an image file, or a URL to an online image.
+            model (`str`, *optional*):
+                The model to use for image segmentation. Can be a model ID hosted on the Hugging Face Hub or a URL to a
+                deployed Inference Endpoint. If not provided, the default recommended model for image segmentation will be used.
+
+        Returns:
+            `List[Dict]`: A list of dictionaries containing the segmented masks and associated attributes.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.image_segmentation("cat.jpg"):
+        [{'score': 0.989008, 'label': 'LABEL_184', 'mask': <PIL.PngImagePlugin.PngImageFile image mode=L size=400x300 at 0x7FDD2B129CC0>}, ...]
+        ```
+        """
+
+        # Segment
+        response = await self.post(data=image, model=model, task="image-segmentation")
+        output = _bytes_to_dict(response)
+
+        # Parse masks as PIL Image
+        if not isinstance(output, list):
+            raise ValueError(f"Server output must be a list. Got {type(output)}: {str(output)[:200]}...")
+        for item in output:
+            item["mask"] = _b64_to_image(item["mask"])
+        return output
+
+    async def image_to_image(
+        self,
+        image: ContentT,
+        prompt: Optional[str] = None,
+        *,
+        negative_prompt: Optional[str] = None,
+        height: Optional[int] = None,
+        width: Optional[int] = None,
+        num_inference_steps: Optional[int] = None,
+        guidance_scale: Optional[float] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> "Image":
+        """
+        Perform image-to-image translation using a specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image for translation. It can be raw bytes, an image file, or a URL to an online image.
+            prompt (`str`, *optional*):
+                The text prompt to guide the image generation.
+            negative_prompt (`str`, *optional*):
+                A negative prompt to guide the translation process.
+            height (`int`, *optional*):
+                The height in pixels of the generated image.
+            width (`int`, *optional*):
+                The width in pixels of the generated image.
+            num_inference_steps (`int`, *optional*):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, *optional*):
+                Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
+                usually at the expense of lower image quality.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `Image`: The translated image.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> image = await client.image_to_image("cat.jpg", prompt="turn the cat into a tiger")
+        >>> image.save("tiger.jpg")
+        ```
+        """
+        parameters = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "height": height,
+            "width": width,
+            "num_inference_steps": num_inference_steps,
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        if all(parameter is None for parameter in parameters.values()):
+            # Either only an image to send => send as raw bytes
+            data = image
+            payload: Optional[Dict[str, Any]] = None
+        else:
+            # Or an image + some parameters => use base64 encoding
+            data = None
+            payload = {"inputs": _b64_encode(image)}
+            for key, value in parameters.items():
+                if value is not None:
+                    payload.setdefault("parameters", {})[key] = value
+
+        response = await self.post(json=payload, data=data, model=model, task="image-to-image")
+        return _bytes_to_image(response)
+
+    async def image_to_text(self, image: ContentT, *, model: Optional[str] = None) -> str:
+        """
+        Takes an input image and return text.
+
+        Models can have very different outputs depending on your use case (image captioning, optical character recognition
+        (OCR), Pix2Struct, etc). Please have a look to the model card to learn more about a model's specificities.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image to caption. It can be raw bytes, an image file, or a URL to an online image..
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `str`: The generated text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.image_to_text("cat.jpg")
+        'a cat standing in a grassy field '
+        >>> await client.image_to_text("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
+        'a dog laying on the grass next to a flower pot '
+        ```
+        """
+        response = await self.post(data=image, model=model, task="image-to-text")
+        return _bytes_to_dict(response)[0]["generated_text"]
+
+    async def list_deployed_models(
+        self, frameworks: Union[None, str, Literal["all"], List[str]] = None
+    ) -> Dict[str, List[str]]:
+        """
+        List models currently deployed on the Inference API service.
+
+        This helper checks deployed models framework by framework. By default, it will check the 4 main frameworks that
+        are supported and account for 95% of the hosted models. However, if you want a complete list of models you can
+        specify `frameworks="all"` as input. Alternatively, if you know before-hand which framework you are interested
+        in, you can also restrict to search to this one (e.g. `frameworks="text-generation-inference"`). The more
+        frameworks are checked, the more time it will take.
+
+        <Tip>
+
+        This endpoint is mostly useful for discoverability. If you already know which model you want to use and want to
+        check its availability, you can directly use [`~InferenceClient.get_model_status`].
+
+        </Tip>
+
+        Args:
+            frameworks (`Literal["all"]` or `List[str]` or `str`, *optional*):
+                The frameworks to filter on. By default only a subset of the available frameworks are tested. If set to
+                "all", all available frameworks will be tested. It is also possible to provide a single framework or a
+                custom set of frameworks to check.
+
+        Returns:
+            `Dict[str, List[str]]`: A dictionary mapping task names to a sorted list of model IDs.
+
+        Example:
+        ```py
+        # Must be run in an async contextthon
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+
+        # Discover zero-shot-classification models currently deployed
+        >>> models = await client.list_deployed_models()
+        >>> models["zero-shot-classification"]
+        ['Narsil/deberta-large-mnli-zero-cls', 'facebook/bart-large-mnli', ...]
+
+        # List from only 1 framework
+        >>> await client.list_deployed_models("text-generation-inference")
+        {'text-generation': ['bigcode/starcoder', 'meta-llama/Llama-2-70b-chat-hf', ...], ...}
+        ```
+        """
+        # Resolve which frameworks to check
+        if frameworks is None:
+            frameworks = MAIN_INFERENCE_API_FRAMEWORKS
+        elif frameworks == "all":
+            frameworks = ALL_INFERENCE_API_FRAMEWORKS
+        elif isinstance(frameworks, str):
+            frameworks = [frameworks]
+        frameworks = list(set(frameworks))
+
+        # Fetch them iteratively
+        models_by_task: Dict[str, List[str]] = {}
+
+        def _unpack_response(framework: str, items: List[Dict]) -> None:
+            for model in items:
+                if framework == "sentence-transformers":
+                    # Model running with the `sentence-transformers` framework can work with both tasks even if not
+                    # branded as such in the API response
+                    models_by_task.setdefault("feature-extraction", []).append(model["model_id"])
+                    models_by_task.setdefault("sentence-similarity", []).append(model["model_id"])
+                else:
+                    models_by_task.setdefault(model["task"], []).append(model["model_id"])
+
+        async def _fetch_framework(framework: str) -> None:
+            async with _import_aiohttp().ClientSession(headers=self.headers) as client:
+                response = await client.get(f"{INFERENCE_ENDPOINT}/framework/{framework}")
+                response.raise_for_status()
+                _unpack_response(framework, await response.json())
+
+        import asyncio
+
+        await asyncio.gather(*[_fetch_framework(framework) for framework in frameworks])
+
+        # Sort alphabetically for discoverability and return
+        for task, models in models_by_task.items():
+            models_by_task[task] = sorted(set(models), key=lambda x: x.lower())
+        return models_by_task
+
+    async def object_detection(
+        self,
+        image: ContentT,
+        *,
+        model: Optional[str] = None,
+    ) -> List[ObjectDetectionOutput]:
+        """
+        Perform object detection on the given image using the specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The image to detect objects on. It can be raw bytes, an image file, or a URL to an online image.
+            model (`str`, *optional*):
+                The model to use for object detection. Can be a model ID hosted on the Hugging Face Hub or a URL to a
+                deployed Inference Endpoint. If not provided, the default recommended model for object detection (DETR) will be used.
+
+        Returns:
+            `List[ObjectDetectionOutput]`: A list of dictionaries containing the bounding boxes and associated attributes.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+            `ValueError`:
+                If the request output is not a List.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.object_detection("people.jpg"):
+        [{"score":0.9486683011054993,"label":"person","box":{"xmin":59,"ymin":39,"xmax":420,"ymax":510}}, ... ]
+        ```
+        """
+        # detect objects
+        response = await self.post(data=image, model=model, task="object-detection")
+        output = _bytes_to_dict(response)
+        if not isinstance(output, list):
+            raise ValueError(f"Server output must be a list. Got {type(output)}: {str(output)[:200]}...")
+        return output
+
+    async def question_answering(
+        self, question: str, context: str, *, model: Optional[str] = None
+    ) -> QuestionAnsweringOutput:
+        """
+        Retrieve the answer to a question from a given text.
+
+        Args:
+            question (`str`):
+                Question to be answered.
+            context (`str`):
+                The context of the question.
+            model (`str`):
+                The model to use for the question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint.
+
+        Returns:
+            `Dict`: a dictionary of question answering output containing the score, start index, end index, and answer.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.question_answering(question="What's my name?", context="My name is Clara and I live in Berkeley.")
+        {'score': 0.9326562285423279, 'start': 11, 'end': 16, 'answer': 'Clara'}
+        ```
+        """
+
+        payload: Dict[str, Any] = {"question": question, "context": context}
+        response = await self.post(
+            json=payload,
+            model=model,
+            task="question-answering",
+        )
+        return _bytes_to_dict(response)  # type: ignore
+
+    async def sentence_similarity(
+        self, sentence: str, other_sentences: List[str], *, model: Optional[str] = None
+    ) -> List[float]:
+        """
+        Compute the semantic similarity between a sentence and a list of other sentences by comparing their embeddings.
+
+        Args:
+            sentence (`str`):
+                The main sentence to compare to others.
+            other_sentences (`List[str]`):
+                The list of sentences to compare to.
+            model (`str`, *optional*):
+                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[float]`: The embedding representing the input text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.sentence_similarity(
+        ...     "Machine learning is so easy.",
+        ...     other_sentences=[
+        ...         "Deep learning is so straightforward.",
+        ...         "This is so difficult, like rocket science.",
+        ...         "I can't believe how much I struggled with this.",
+        ...     ],
+        ... )
+        [0.7785726189613342, 0.45876261591911316, 0.2906220555305481]
+        ```
+        """
+        response = await self.post(
+            json={"inputs": {"source_sentence": sentence, "sentences": other_sentences}},
+            model=model,
+            task="sentence-similarity",
+        )
+        return _bytes_to_list(response)
+
+    async def summarization(
+        self,
+        text: str,
+        *,
+        parameters: Optional[Dict[str, Any]] = None,
+        model: Optional[str] = None,
+    ) -> str:
+        """
+        Generate a summary of a given text using a specified model.
+
+        Args:
+            text (`str`):
+                The input text to summarize.
+            parameters (`Dict[str, Any]`, *optional*):
+                Additional parameters for summarization. Check out this [page](https://huggingface.co/docs/api-inference/detailed_parameters#summarization-task)
+                for more details.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `str`: The generated summary text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.summarization("The Eiffel tower...")
+        'The Eiffel tower is one of the most famous landmarks in the world....'
+        ```
+        """
+        payload: Dict[str, Any] = {"inputs": text}
+        if parameters is not None:
+            payload["parameters"] = parameters
+        response = await self.post(json=payload, model=model, task="summarization")
+        return _bytes_to_dict(response)[0]["summary_text"]
+
+    async def table_question_answering(
+        self, table: Dict[str, Any], query: str, *, model: Optional[str] = None
+    ) -> TableQuestionAnsweringOutput:
+        """
+        Retrieve the answer to a question from information given in a table.
+
+        Args:
+            table (`str`):
+                A table of data represented as a dict of lists where entries are headers and the lists are all the
+                values, all lists must have the same size.
+            query (`str`):
+                The query in plain text that you want to ask the table.
+            model (`str`):
+                The model to use for the table-question-answering task. Can be a model ID hosted on the Hugging Face
+                Hub or a URL to a deployed Inference Endpoint.
+
+        Returns:
+            `Dict`: a dictionary of table question answering output containing the answer, coordinates, cells and the aggregator used.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> query = "How many stars does the transformers repository have?"
+        >>> table = {"Repository": ["Transformers", "Datasets", "Tokenizers"], "Stars": ["36542", "4512", "3934"]}
+        >>> await client.table_question_answering(table, query, model="google/tapas-base-finetuned-wtq")
+        {'answer': 'AVERAGE > 36542', 'coordinates': [[0, 1]], 'cells': ['36542'], 'aggregator': 'AVERAGE'}
+        ```
+        """
+        response = await self.post(
+            json={
+                "query": query,
+                "table": table,
+            },
+            model=model,
+            task="table-question-answering",
+        )
+        return _bytes_to_dict(response)  # type: ignore
+
+    async def tabular_classification(self, table: Dict[str, Any], *, model: str) -> List[str]:
+        """
+        Classifying a target category (a group) based on a set of attributes.
+
+        Args:
+            table (`Dict[str, Any]`):
+                Set of attributes to classify.
+            model (`str`):
+                The model to use for the tabular-classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint.
+
+        Returns:
+            `List`: a list of labels, one per row in the initial table.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> table = {
+        ...     "fixed_acidity": ["7.4", "7.8", "10.3"],
+        ...     "volatile_acidity": ["0.7", "0.88", "0.32"],
+        ...     "citric_acid": ["0", "0", "0.45"],
+        ...     "residual_sugar": ["1.9", "2.6", "6.4"],
+        ...     "chlorides": ["0.076", "0.098", "0.073"],
+        ...     "free_sulfur_dioxide": ["11", "25", "5"],
+        ...     "total_sulfur_dioxide": ["34", "67", "13"],
+        ...     "density": ["0.9978", "0.9968", "0.9976"],
+        ...     "pH": ["3.51", "3.2", "3.23"],
+        ...     "sulphates": ["0.56", "0.68", "0.82"],
+        ...     "alcohol": ["9.4", "9.8", "12.6"],
+        ... }
+        >>> await client.tabular_classification(table=table, model="julien-c/wine-quality")
+        ["5", "5", "5"]
+        ```
+        """
+        response = await self.post(json={"table": table}, model=model, task="tabular-classification")
+        return _bytes_to_list(response)
+
+    async def tabular_regression(self, table: Dict[str, Any], *, model: str) -> List[float]:
+        """
+        Predicting a numerical target value given a set of attributes/features in a table.
+
+        Args:
+            table (`Dict[str, Any]`):
+                Set of attributes stored in a table. The attributes used to predict the target can be both numerical and categorical.
+            model (`str`):
+                The model to use for the tabular-regression task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint.
+
+        Returns:
+            `List`: a list of predicted numerical target values.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> table = {
+        ...     "Height": ["11.52", "12.48", "12.3778"],
+        ...     "Length1": ["23.2", "24", "23.9"],
+        ...     "Length2": ["25.4", "26.3", "26.5"],
+        ...     "Length3": ["30", "31.2", "31.1"],
+        ...     "Species": ["Bream", "Bream", "Bream"],
+        ...     "Width": ["4.02", "4.3056", "4.6961"],
+        ... }
+        >>> await client.tabular_regression(table, model="scikit-learn/Fish-Weight")
+        [110, 120, 130]
+        ```
+        """
+        response = await self.post(json={"table": table}, model=model, task="tabular-regression")
+        return _bytes_to_list(response)
+
+    async def text_classification(self, text: str, *, model: Optional[str] = None) -> List[ClassificationOutput]:
+        """
+        Perform text classification (e.g. sentiment-analysis) on the given text.
+
+        Args:
+            text (`str`):
+                A string to be classified.
+            model (`str`, *optional*):
+                The model to use for the text classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended text classification model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: a list of dictionaries containing the predicted label and associated probability.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.text_classification("I like you")
+        [{'label': 'POSITIVE', 'score': 0.9998695850372314}, {'label': 'NEGATIVE', 'score': 0.0001304351753788069}]
+        ```
+        """
+        response = await self.post(json={"inputs": text}, model=model, task="text-classification")
+        return _bytes_to_list(response)[0]
+
+    @overload
+    async def text_generation(  # type: ignore
+        self,
+        prompt: str,
+        *,
+        details: Literal[False] = ...,
+        stream: Literal[False] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> str:
+        ...
+
+    @overload
+    async def text_generation(  # type: ignore
+        self,
+        prompt: str,
+        *,
+        details: Literal[True] = ...,
+        stream: Literal[False] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> TextGenerationResponse:
+        ...
+
+    @overload
+    async def text_generation(  # type: ignore
+        self,
+        prompt: str,
+        *,
+        details: Literal[False] = ...,
+        stream: Literal[True] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> AsyncIterable[str]:
+        ...
+
+    @overload
+    async def text_generation(
+        self,
+        prompt: str,
+        *,
+        details: Literal[True] = ...,
+        stream: Literal[True] = ...,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+    ) -> AsyncIterable[TextGenerationStreamResponse]:
+        ...
+
+    async def text_generation(
+        self,
+        prompt: str,
+        *,
+        details: bool = False,
+        stream: bool = False,
+        model: Optional[str] = None,
+        do_sample: bool = False,
+        max_new_tokens: int = 20,
+        best_of: Optional[int] = None,
+        repetition_penalty: Optional[float] = None,
+        return_full_text: bool = False,
+        seed: Optional[int] = None,
+        stop_sequences: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        truncate: Optional[int] = None,
+        typical_p: Optional[float] = None,
+        watermark: bool = False,
+        decoder_input_details: bool = False,
+    ) -> Union[str, TextGenerationResponse, AsyncIterable[str], AsyncIterable[TextGenerationStreamResponse]]:
+        """
+        Given a prompt, generate the following text.
+
+        It is recommended to have Pydantic installed in order to get inputs validated. This is preferable as it allow
+        early failures.
+
+        API endpoint is supposed to run with the `text-generation-inference` backend (TGI). This backend is the
+        go-to solution to run large language models at scale. However, for some smaller models (e.g. "gpt2") the
+        default `transformers` + `api-inference` solution is still in use. Both approaches have very similar APIs, but
+        not exactly the same. This method is compatible with both approaches but some parameters are only available for
+        `text-generation-inference`. If some parameters are ignored, a warning message is triggered but the process
+        continues correctly.
+
+        To learn more about the TGI project, please refer to https://github.com/huggingface/text-generation-inference.
+
+        Args:
+            prompt (`str`):
+                Input text.
+            details (`bool`, *optional*):
+                By default, text_generation returns a string. Pass `details=True` if you want a detailed output (tokens,
+                probabilities, seed, finish reason, etc.). Only available for models running on with the
+                `text-generation-inference` backend.
+            stream (`bool`, *optional*):
+                By default, text_generation returns the full generated text. Pass `stream=True` if you want a stream of
+                tokens to be returned. Only available for models running on with the `text-generation-inference`
+                backend.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+            do_sample (`bool`):
+                Activate logits sampling
+            max_new_tokens (`int`):
+                Maximum number of generated tokens
+            best_of (`int`):
+                Generate best_of sequences and return the one if the highest token logprobs
+            repetition_penalty (`float`):
+                The parameter for repetition penalty. 1.0 means no penalty. See [this
+                paper](https://arxiv.org/pdf/1909.05858.pdf) for more details.
+            return_full_text (`bool`):
+                Whether to prepend the prompt to the generated text
+            seed (`int`):
+                Random sampling seed
+            stop_sequences (`List[str]`):
+                Stop generating tokens if a member of `stop_sequences` is generated
+            temperature (`float`):
+                The value used to module the logits distribution.
+            top_k (`int`):
+                The number of highest probability vocabulary tokens to keep for top-k-filtering.
+            top_p (`float`):
+                If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or
+                higher are kept for generation.
+            truncate (`int`):
+                Truncate inputs tokens to the given size
+            typical_p (`float`):
+                Typical Decoding mass
+                See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) for more information
+            watermark (`bool`):
+                Watermarking with [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226)
+            decoder_input_details (`bool`):
+                Return the decoder input token logprobs and ids. You must set `details=True` as well for it to be taken
+                into account. Defaults to `False`.
+
+        Returns:
+            `Union[str, TextGenerationResponse, Iterable[str], Iterable[TextGenerationStreamResponse]]`:
+            Generated text returned from the server:
+            - if `stream=False` and `details=False`, the generated text is returned as a `str` (default)
+            - if `stream=True` and `details=False`, the generated text is returned token by token as a `Iterable[str]`
+            - if `stream=False` and `details=True`, the generated text is returned with more details as a [`~huggingface_hub.inference._text_generation.TextGenerationResponse`]
+            - if `details=True` and `stream=True`, the generated text is returned token by token as a iterable of [`~huggingface_hub.inference._text_generation.TextGenerationStreamResponse`]
+
+        Raises:
+            `ValidationError`:
+                If input values are not valid. No HTTP call is made to the server.
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+
+        # Case 1: generate text
+        >>> await client.text_generation("The huggingface_hub library is ", max_new_tokens=12)
+        '100% open source and built to be easy to use.'
+
+        # Case 2: iterate over the generated tokens. Useful async for large generation.
+        >>> async for token in await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, stream=True):
+        ...     print(token)
+        100
+        %
+        open
+        source
+        and
+        built
+        to
+        be
+        easy
+        to
+        use
+        .
+
+        # Case 3: get more details about the generation process.
+        >>> await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True)
+        TextGenerationResponse(
+            generated_text='100% open source and built to be easy to use.',
+            details=Details(
+                finish_reason=<FinishReason.Length: 'length'>,
+                generated_tokens=12,
+                seed=None,
+                prefill=[
+                    InputToken(id=487, text='The', logprob=None),
+                    InputToken(id=53789, text=' hugging', logprob=-13.171875),
+                    (...)
+                    InputToken(id=204, text=' ', logprob=-7.0390625)
+                ],
+                tokens=[
+                    Token(id=1425, text='100', logprob=-1.0175781, special=False),
+                    Token(id=16, text='%', logprob=-0.0463562, special=False),
+                    (...)
+                    Token(id=25, text='.', logprob=-0.5703125, special=False)
+                ],
+                best_of_sequences=None
+            )
+        )
+
+        # Case 4: iterate over the generated tokens with more details.
+        # Last object is more complete, containing the full generated text and the finish reason.
+        >>> async for details in await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True, stream=True):
+        ...     print(details)
+        ...
+        TextGenerationStreamResponse(token=Token(id=1425, text='100', logprob=-1.0175781, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=16, text='%', logprob=-0.0463562, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=1314, text=' open', logprob=-1.3359375, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=3178, text=' source', logprob=-0.28100586, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=273, text=' and', logprob=-0.5961914, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=3426, text=' built', logprob=-1.9423828, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-1.4121094, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=314, text=' be', logprob=-1.5224609, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=1833, text=' easy', logprob=-2.1132812, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-0.08520508, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(id=745, text=' use', logprob=-0.39453125, special=False), generated_text=None, details=None)
+        TextGenerationStreamResponse(token=Token(
+            id=25,
+            text='.',
+            logprob=-0.5703125,
+            special=False),
+            generated_text='100% open source and built to be easy to use.',
+            details=StreamDetails(finish_reason=<FinishReason.Length: 'length'>, generated_tokens=12, seed=None)
+        )
+        ```
+        """
+        # NOTE: Text-generation integration is taken from the text-generation-inference project. It has more features
+        # like input/output validation (if Pydantic is installed). See `_text_generation.py` header for more details.
+
+        if decoder_input_details and not details:
+            warnings.warn(
+                "`decoder_input_details=True` has been passed to the server but `details=False` is set meaning that"
+                " the output from the server will be truncated."
+            )
+            decoder_input_details = False
+
+        # Validate parameters
+        parameters = TextGenerationParameters(
+            best_of=best_of,
+            details=details,
+            do_sample=do_sample,
+            max_new_tokens=max_new_tokens,
+            repetition_penalty=repetition_penalty,
+            return_full_text=return_full_text,
+            seed=seed,
+            stop=stop_sequences if stop_sequences is not None else [],
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p,
+            truncate=truncate,
+            typical_p=typical_p,
+            watermark=watermark,
+            decoder_input_details=decoder_input_details,
+        )
+        request = TextGenerationRequest(inputs=prompt, stream=stream, parameters=parameters)
+        payload = asdict(request)
+
+        # Remove some parameters if not a TGI server
+        if not _is_tgi_server(model):
+            ignored_parameters = []
+            for key in "watermark", "stop", "details", "decoder_input_details":
+                if payload["parameters"][key] is not None:
+                    ignored_parameters.append(key)
+                del payload["parameters"][key]
+            if len(ignored_parameters) > 0:
+                warnings.warn(
+                    "API endpoint/model for text-generation is not served via TGI. Ignoring parameters"
+                    f" {ignored_parameters}.",
+                    UserWarning,
+                )
+            if details:
+                warnings.warn(
+                    "API endpoint/model for text-generation is not served via TGI. Parameter `details=True` will"
+                    " be ignored meaning only the generated text will be returned.",
+                    UserWarning,
+                )
+                details = False
+            if stream:
+                raise ValueError(
+                    "API endpoint/model for text-generation is not served via TGI. Cannot return output as a stream."
+                    " Please pass `stream=False` as input."
+                )
+
+        # Handle errors separately for more precise error messages
+        try:
+            bytes_output = await self.post(json=payload, model=model, task="text-generation", stream=stream)  # type: ignore
+        except _import_aiohttp().ClientResponseError as e:
+            error_message = getattr(e, "response_error_payload", {}).get("error", "")
+            if e.code == 400 and "The following `model_kwargs` are not used by the model" in error_message:
+                _set_as_non_tgi(model)
+                return await self.text_generation(  # type: ignore
+                    prompt=prompt,
+                    details=details,
+                    stream=stream,
+                    model=model,
+                    do_sample=do_sample,
+                    max_new_tokens=max_new_tokens,
+                    best_of=best_of,
+                    repetition_penalty=repetition_penalty,
+                    return_full_text=return_full_text,
+                    seed=seed,
+                    stop_sequences=stop_sequences,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    truncate=truncate,
+                    typical_p=typical_p,
+                    watermark=watermark,
+                    decoder_input_details=decoder_input_details,
+                )
+            raise_text_generation_error(e)
+
+        # Parse output
+        if stream:
+            return _async_stream_text_generation_response(bytes_output, details)  # type: ignore
+
+        data = _bytes_to_dict(bytes_output)[0]
+        return TextGenerationResponse(**data) if details else data["generated_text"]
+
+    async def text_to_image(
+        self,
+        prompt: str,
+        *,
+        negative_prompt: Optional[str] = None,
+        height: Optional[float] = None,
+        width: Optional[float] = None,
+        num_inference_steps: Optional[float] = None,
+        guidance_scale: Optional[float] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> "Image":
+        """
+        Generate an image based on a given text using a specified model.
+
+        <Tip warning={true}>
+
+        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
+
+        </Tip>
+
+        Args:
+            prompt (`str`):
+                The prompt to generate an image from.
+            negative_prompt (`str`, *optional*):
+                An optional negative prompt for the image generation.
+            height (`float`, *optional*):
+                The height in pixels of the image to generate.
+            width (`float`, *optional*):
+                The width in pixels of the image to generate.
+            num_inference_steps (`int`, *optional*):
+                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+                expense of slower inference.
+            guidance_scale (`float`, *optional*):
+                Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
+                usually at the expense of lower image quality.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `Image`: The generated image.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+
+        >>> image = await client.text_to_image("An astronaut riding a horse on the moon.")
+        >>> image.save("astronaut.png")
+
+        >>> image = await client.text_to_image(
+        ...     "An astronaut riding a horse on the moon.",
+        ...     negative_prompt="low resolution, blurry",
+        ...     model="stabilityai/stable-diffusion-2-1",
+        ... )
+        >>> image.save("better_astronaut.png")
+        ```
+        """
+        payload = {"inputs": prompt}
+        parameters = {
+            "negative_prompt": negative_prompt,
+            "height": height,
+            "width": width,
+            "num_inference_steps": num_inference_steps,
+            "guidance_scale": guidance_scale,
+            **kwargs,
+        }
+        for key, value in parameters.items():
+            if value is not None:
+                payload.setdefault("parameters", {})[key] = value  # type: ignore
+        response = await self.post(json=payload, model=model, task="text-to-image")
+        return _bytes_to_image(response)
+
+    async def text_to_speech(self, text: str, *, model: Optional[str] = None) -> bytes:
+        """
+        Synthesize an audio of a voice pronouncing a given text.
+
+        Args:
+            text (`str`):
+                The text to synthesize.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `bytes`: The generated audio.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from pathlib import Path
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+
+        >>> audio = await client.text_to_speech("Hello world")
+        >>> Path("hello_world.flac").write_bytes(audio)
+        ```
+        """
+        return await self.post(json={"inputs": text}, model=model, task="text-to-speech")
+
+    async def token_classification(self, text: str, *, model: Optional[str] = None) -> List[TokenClassificationOutput]:
+        """
+        Perform token classification on the given text.
+        Usually used for sentence parsing, either grammatical, or Named Entity Recognition (NER) to understand keywords contained within text.
+
+        Args:
+            text (`str`):
+                A string to be classified.
+            model (`str`, *optional*):
+                The model to use for the token classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended token classification model will be used.
+                Defaults to None.
+
+        Returns:
+            `List[Dict]`: List of token classification outputs containing the entity group, confidence score, word, start and end index.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.token_classification("My name is Sarah Jessica Parker but you can call me Jessica")
+        [{'entity_group': 'PER',
+        'score': 0.9971321225166321,
+        'word': 'Sarah Jessica Parker',
+        'start': 11,
+        'end': 31},
+        {'entity_group': 'PER',
+        'score': 0.9773476123809814,
+        'word': 'Jessica',
+        'start': 52,
+        'end': 59}]
+        ```
+        """
+        payload: Dict[str, Any] = {"inputs": text}
+        response = await self.post(
+            json=payload,
+            model=model,
+            task="token-classification",
+        )
+        return _bytes_to_list(response)
+
+    async def translation(
+        self, text: str, *, model: Optional[str] = None, src_lang: Optional[str] = None, tgt_lang: Optional[str] = None
+    ) -> str:
+        """
+        Convert text from one language to another.
+
+        Check out https://huggingface.co/tasks/translation for more information on how to choose the best model for
+        your specific use case. Source and target languages usually depend on the model.
+        However, it is possible to specify source and target languages for certain models. If you are working with one of these models,
+        you can use `src_lang` and `tgt_lang` arguments to pass the relevant information.
+        You can find this information in the model card.
+
+        Args:
+            text (`str`):
+                A string to be translated.
+            model (`str`, *optional*):
+                The model to use for the translation task. Can be a model ID hosted on the Hugging Face Hub or a URL to
+                a deployed Inference Endpoint. If not provided, the default recommended translation model will be used.
+                Defaults to None.
+            src_lang (`str`, *optional*):
+                Source language of the translation task, i.e. input language. Cannot be passed without `tgt_lang`.
+            tgt_lang (`str`, *optional*):
+                Target language of the translation task, i.e. output language. Cannot be passed without `src_lang`.
+
+        Returns:
+            `str`: The generated translated text.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+            `ValueError`:
+                If only one of the `src_lang` and `tgt_lang` arguments are provided.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.translation("My name is Wolfgang and I live in Berlin")
+        'Mein Name ist Wolfgang und ich lebe in Berlin.'
+        >>> await client.translation("My name is Wolfgang and I live in Berlin", model="Helsinki-NLP/opus-mt-en-fr")
+        "Je m'appelle Wolfgang et je vis à Berlin."
+        ```
+
+        Specifying languages:
+        ```py
+        >>> client.translation("My name is Sarah Jessica Parker but you can call me Jessica", model="facebook/mbart-large-50-many-to-many-mmt", src_lang="en_XX", tgt_lang="fr_XX")
+        "Mon nom est Sarah Jessica Parker mais vous pouvez m\'appeler Jessica"
+        ```
+        """
+        # Throw error if only one of `src_lang` and `tgt_lang` was given
+        if src_lang is not None and tgt_lang is None:
+            raise ValueError("You cannot specify `src_lang` without specifying `tgt_lang`.")
+
+        if src_lang is None and tgt_lang is not None:
+            raise ValueError("You cannot specify `tgt_lang` without specifying `src_lang`.")
+
+        # If both `src_lang` and `tgt_lang` are given, pass them to the request body
+        payload: Dict = {"inputs": text}
+        if src_lang and tgt_lang:
+            payload["parameters"] = {"src_lang": src_lang, "tgt_lang": tgt_lang}
+        response = await self.post(json=payload, model=model, task="translation")
+        return _bytes_to_dict(response)[0]["translation_text"]
+
+    async def zero_shot_classification(
+        self, text: str, labels: List[str], *, multi_label: bool = False, model: Optional[str] = None
+    ) -> List[ClassificationOutput]:
+        """
+        Provide as input a text and a set of candidate labels to classify the input text.
+
+        Args:
+            text (`str`):
+                The input text to classify.
+            labels (`List[str]`):
+                List of string possible labels. There must be at least 2 labels.
+            multi_label (`bool`):
+                Boolean that is set to True if classes can overlap.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `List[Dict]`: List of classification outputs containing the predicted labels and their confidence.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> text = (
+        ...     "A new model offers an explanation async for how the Galilean satellites formed around the solar system's"
+        ...     "largest world. Konstantin Batygin did not set out to solve one of the solar system's most puzzling"
+        ...     " mysteries when he went async for a run up a hill in Nice, France."
+        ... )
+        >>> labels = ["space & cosmos", "scientific discovery", "microbiology", "robots", "archeology"]
+        >>> await client.zero_shot_classification(text, labels)
+        [
+            {"label": "scientific discovery", "score": 0.7961668968200684},
+            {"label": "space & cosmos", "score": 0.18570658564567566},
+            {"label": "microbiology", "score": 0.00730885099619627},
+            {"label": "archeology", "score": 0.006258360575884581},
+            {"label": "robots", "score": 0.004559356719255447},
+        ]
+        >>> await client.zero_shot_classification(text, labels, multi_label=True)
+        [
+            {"label": "scientific discovery", "score": 0.9829297661781311},
+            {"label": "space & cosmos", "score": 0.755190908908844},
+            {"label": "microbiology", "score": 0.0005462635890580714},
+            {"label": "archeology", "score": 0.00047131875180639327},
+            {"label": "robots", "score": 0.00030448526376858354},
+        ]
+        ```
+        """
+        # Raise ValueError if input is less than 2 labels
+        if len(labels) < 2:
+            raise ValueError("You must specify at least 2 classes to compare.")
+
+        response = await self.post(
+            json={
+                "inputs": text,
+                "parameters": {
+                    "candidate_labels": ",".join(labels),
+                    "multi_label": multi_label,
+                },
+            },
+            model=model,
+            task="zero-shot-classification",
+        )
+        output = _bytes_to_dict(response)
+        return [{"label": label, "score": score} for label, score in zip(output["labels"], output["scores"])]
+
+    async def zero_shot_image_classification(
+        self, image: ContentT, labels: List[str], *, model: Optional[str] = None
+    ) -> List[ClassificationOutput]:
+        """
+        Provide input image and text labels to predict text labels for the image.
+
+        Args:
+            image (`Union[str, Path, bytes, BinaryIO]`):
+                The input image to caption. It can be raw bytes, an image file, or a URL to an online image.
+            labels (`List[str]`):
+                List of string possible labels. There must be at least 2 labels.
+            model (`str`, *optional*):
+                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
+                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
+
+        Returns:
+            `List[Dict]`: List of classification outputs containing the predicted labels and their confidence.
+
+        Raises:
+            [`InferenceTimeoutError`]:
+                If the model is unavailable or the request times out.
+            `aiohttp.ClientResponseError`:
+                If the request fails with an HTTP error status code other than HTTP 503.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+
+        >>> await client.zero_shot_image_classification(
+        ...     "https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg",
+        ...     labels=["dog", "cat", "horse"],
+        ... )
+        [{"label": "dog", "score": 0.956}, ...]
+        ```
+        """
+        # Raise ValueError if input is less than 2 labels
+        if len(labels) < 2:
+            raise ValueError("You must specify at least 2 classes to compare.")
+
+        response = await self.post(
+            json={"image": _b64_encode(image), "parameters": {"candidate_labels": ",".join(labels)}},
+            model=model,
+            task="zero-shot-image-classification",
+        )
+        return _bytes_to_list(response)
+
+    def _resolve_url(self, model: Optional[str] = None, task: Optional[str] = None) -> str:
+        model = model or self.model
+
+        # If model is already a URL, ignore `task` and return directly
+        if model is not None and (model.startswith("http://") or model.startswith("https://")):
+            return model
+
+        # # If no model but task is set => fetch the recommended one for this task
+        if model is None:
+            if task is None:
+                raise ValueError(
+                    "You must specify at least a model (repo_id or URL) or a task, either when instantiating"
+                    " `InferenceClient` or when making a request."
+                )
+            model = self.get_recommended_model(task)
+            logger.info(
+                f"Using recommended model {model} for task {task}. Note that it is"
+                f" encouraged to explicitly set `model='{model}'` as the recommended"
+                " models list might get updated without prior notice."
+            )
+
+        # Compute InferenceAPI url
+        return (
+            # Feature-extraction and sentence-similarity are the only cases where we handle models with several tasks.
+            f"{INFERENCE_ENDPOINT}/pipeline/{task}/{model}"
+            if task in ("feature-extraction", "sentence-similarity")
+            # Otherwise, we use the default endpoint
+            else f"{INFERENCE_ENDPOINT}/models/{model}"
+        )
+
+    @staticmethod
+    def get_recommended_model(task: str) -> str:
+        """
+        Get the model Hugging Face recommends for the input task.
+
+        Args:
+            task (`str`):
+                The Hugging Face task to get which model Hugging Face recommends.
+                All available tasks can be found [here](https://huggingface.co/tasks).
+
+        Returns:
+            `str`: Name of the model recommended for the input task.
+
+        Raises:
+            `ValueError`: If Hugging Face has no recommendation for the input task.
+        """
+        model = _fetch_recommended_models().get(task)
+        if model is None:
+            raise ValueError(
+                f"Task {task} has no recommended model. Please specify a model"
+                " explicitly. Visit https://huggingface.co/tasks for more info."
+            )
+        return model
+
+    async def get_model_status(self, model: Optional[str] = None) -> ModelStatus:
+        """
+        Get the status of a model hosted on the Inference API.
+
+        <Tip>
+
+        This endpoint is mostly useful when you already know which model you want to use and want to check its
+        availability. If you want to discover already deployed models, you should rather use [`~InferenceClient.list_deployed_models`].
+
+        </Tip>
+
+        Args:
+            model (`str`, *optional*):
+                Identifier of the model for witch the status gonna be checked. If model is not provided,
+                the model associated with this instance of [`InferenceClient`] will be used. Only InferenceAPI service can be checked so the
+                identifier cannot be a URL.
+
+
+        Returns:
+            [`ModelStatus`]: An instance of ModelStatus dataclass, containing information,
+                         about the state of the model: load, state, compute type and framework.
+
+        Example:
+        ```py
+        # Must be run in an async context
+        >>> from huggingface_hub import AsyncInferenceClient
+        >>> client = AsyncInferenceClient()
+        >>> await client.get_model_status("bigcode/starcoder")
+        ModelStatus(loaded=True, state='Loaded', compute_type='gpu', framework='text-generation-inference')
+        ```
+        """
+        model = model or self.model
+        if model is None:
+            raise ValueError("Model id not provided.")
+        if model.startswith("https://"):
+            raise NotImplementedError("Model status is only available for Inference API endpoints.")
+        url = f"{INFERENCE_ENDPOINT}/status/{model}"
+
+        async with _import_aiohttp().ClientSession(headers=self.headers) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            response_data = await response.json()
+
+        if "error" in response_data:
+            raise ValueError(response_data["error"])
+
+        return ModelStatus(
+            loaded=response_data["loaded"],
+            state=response_data["state"],
+            compute_type=response_data["compute_type"],
+            framework=response_data["framework"],
+        )
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_text_generation.py b/lib/python3.11/site-packages/huggingface_hub/inference/_text_generation.py
new file mode 100644
index 0000000000000000000000000000000000000000..f48b0424e3d512c3ff6b6d651c932dbff010a9cd
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/inference/_text_generation.py
@@ -0,0 +1,546 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Original implementation taken from the `text-generation` Python client (see https://pypi.org/project/text-generation/
+# and https://github.com/huggingface/text-generation-inference/tree/main/clients/python)
+#
+# Changes compared to original implementation:
+# - use pydantic.dataclasses instead of BaseModel
+# - default to Python's dataclasses if Pydantic is not installed (same implementation but no validation)
+# - added default values for all parameters (not needed in BaseModel but dataclasses yes)
+# - integrated in `huggingface_hub.InferenceClient``
+# - added `stream: bool` and `details: bool` in the `text_generation` method instead of having different methods for each use case
+import warnings
+from dataclasses import field
+from enum import Enum
+from typing import List, NoReturn, Optional
+
+from requests import HTTPError
+
+from ..utils import is_pydantic_available
+
+
+if is_pydantic_available():
+    from pydantic import validator as pydantic_validator
+    from pydantic.dataclasses import dataclass
+
+    def validator(*args, **kwargs):
+        # Pydantic v1's `@validator` is deprecated in favor of `@field_validator`. In order to support both pydantic v1
+        # and v2 without changing the logic, we catch the warning message in pydantic v2 and ignore it. If we want to
+        # support pydantic v3 in the future, we will drop support for pydantic v1 and use `pydantic.field_validator`
+        # correctly.
+        #
+        # Related:
+        # - https://docs.pydantic.dev/latest/migration/#changes-to-validators
+        # - https://github.com/huggingface/huggingface_hub/pull/1837
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", message="Pydantic V1 style `@validator` validators are deprecated.")
+            return pydantic_validator(*args, **kwargs)
+else:
+    # No validation if Pydantic is not installed
+    from dataclasses import dataclass  # type: ignore
+
+    def validator(x):  # type: ignore
+        return lambda y: y
+
+
+@dataclass
+class TextGenerationParameters:
+    """
+    Parameters for text generation.
+
+    Args:
+        do_sample (`bool`, *optional*):
+            Activate logits sampling. Defaults to False.
+        max_new_tokens (`int`, *optional*):
+            Maximum number of generated tokens. Defaults to 20.
+        repetition_penalty (`Optional[float]`, *optional*):
+            The parameter for repetition penalty. A value of 1.0 means no penalty. See [this paper](https://arxiv.org/pdf/1909.05858.pdf)
+            for more details. Defaults to None.
+        return_full_text (`bool`, *optional*):
+            Whether to prepend the prompt to the generated text. Defaults to False.
+        stop (`List[str]`, *optional*):
+            Stop generating tokens if a member of `stop_sequences` is generated. Defaults to an empty list.
+        seed (`Optional[int]`, *optional*):
+            Random sampling seed. Defaults to None.
+        temperature (`Optional[float]`, *optional*):
+            The value used to modulate the logits distribution. Defaults to None.
+        top_k (`Optional[int]`, *optional*):
+            The number of highest probability vocabulary tokens to keep for top-k-filtering. Defaults to None.
+        top_p (`Optional[float]`, *optional*):
+            If set to a value less than 1, only the smallest set of most probable tokens with probabilities that add up
+            to `top_p` or higher are kept for generation. Defaults to None.
+        truncate (`Optional[int]`, *optional*):
+            Truncate input tokens to the given size. Defaults to None.
+        typical_p (`Optional[float]`, *optional*):
+            Typical Decoding mass. See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666)
+            for more information. Defaults to None.
+        best_of (`Optional[int]`, *optional*):
+            Generate `best_of` sequences and return the one with the highest token logprobs. Defaults to None.
+        watermark (`bool`, *optional*):
+            Watermarking with [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226). Defaults to False.
+        details (`bool`, *optional*):
+            Get generation details. Defaults to False.
+        decoder_input_details (`bool`, *optional*):
+            Get decoder input token logprobs and ids. Defaults to False.
+    """
+
+    # Activate logits sampling
+    do_sample: bool = False
+    # Maximum number of generated tokens
+    max_new_tokens: int = 20
+    # The parameter for repetition penalty. 1.0 means no penalty.
+    # See [this paper](https://arxiv.org/pdf/1909.05858.pdf) for more details.
+    repetition_penalty: Optional[float] = None
+    # Whether to prepend the prompt to the generated text
+    return_full_text: bool = False
+    # Stop generating tokens if a member of `stop_sequences` is generated
+    stop: List[str] = field(default_factory=lambda: [])
+    # Random sampling seed
+    seed: Optional[int] = None
+    # The value used to module the logits distribution.
+    temperature: Optional[float] = None
+    # The number of highest probability vocabulary tokens to keep for top-k-filtering.
+    top_k: Optional[int] = None
+    # If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or
+    # higher are kept for generation.
+    top_p: Optional[float] = None
+    # truncate inputs tokens to the given size
+    truncate: Optional[int] = None
+    # Typical Decoding mass
+    # See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) for more information
+    typical_p: Optional[float] = None
+    # Generate best_of sequences and return the one if the highest token logprobs
+    best_of: Optional[int] = None
+    # Watermarking with [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226)
+    watermark: bool = False
+    # Get generation details
+    details: bool = False
+    # Get decoder input token logprobs and ids
+    decoder_input_details: bool = False
+
+    @validator("best_of")
+    def valid_best_of(cls, field_value, values):
+        if field_value is not None:
+            if field_value <= 0:
+                raise ValueError("`best_of` must be strictly positive")
+            if field_value > 1 and values["seed"] is not None:
+                raise ValueError("`seed` must not be set when `best_of` is > 1")
+            sampling = (
+                values["do_sample"]
+                | (values["temperature"] is not None)
+                | (values["top_k"] is not None)
+                | (values["top_p"] is not None)
+                | (values["typical_p"] is not None)
+            )
+            if field_value > 1 and not sampling:
+                raise ValueError("you must use sampling when `best_of` is > 1")
+
+        return field_value
+
+    @validator("repetition_penalty")
+    def valid_repetition_penalty(cls, v):
+        if v is not None and v <= 0:
+            raise ValueError("`repetition_penalty` must be strictly positive")
+        return v
+
+    @validator("seed")
+    def valid_seed(cls, v):
+        if v is not None and v < 0:
+            raise ValueError("`seed` must be positive")
+        return v
+
+    @validator("temperature")
+    def valid_temp(cls, v):
+        if v is not None and v <= 0:
+            raise ValueError("`temperature` must be strictly positive")
+        return v
+
+    @validator("top_k")
+    def valid_top_k(cls, v):
+        if v is not None and v <= 0:
+            raise ValueError("`top_k` must be strictly positive")
+        return v
+
+    @validator("top_p")
+    def valid_top_p(cls, v):
+        if v is not None and (v <= 0 or v >= 1.0):
+            raise ValueError("`top_p` must be > 0.0 and < 1.0")
+        return v
+
+    @validator("truncate")
+    def valid_truncate(cls, v):
+        if v is not None and v <= 0:
+            raise ValueError("`truncate` must be strictly positive")
+        return v
+
+    @validator("typical_p")
+    def valid_typical_p(cls, v):
+        if v is not None and (v <= 0 or v >= 1.0):
+            raise ValueError("`typical_p` must be > 0.0 and < 1.0")
+        return v
+
+
+@dataclass
+class TextGenerationRequest:
+    """
+    Request object for text generation (only for internal use).
+
+    Args:
+        inputs (`str`):
+            The prompt for text generation.
+        parameters (`Optional[TextGenerationParameters]`, *optional*):
+            Generation parameters.
+        stream (`bool`, *optional*):
+            Whether to stream output tokens. Defaults to False.
+    """
+
+    # Prompt
+    inputs: str
+    # Generation parameters
+    parameters: Optional[TextGenerationParameters] = None
+    # Whether to stream output tokens
+    stream: bool = False
+
+    @validator("inputs")
+    def valid_input(cls, v):
+        if not v:
+            raise ValueError("`inputs` cannot be empty")
+        return v
+
+    @validator("stream")
+    def valid_best_of_stream(cls, field_value, values):
+        parameters = values["parameters"]
+        if parameters is not None and parameters.best_of is not None and parameters.best_of > 1 and field_value:
+            raise ValueError("`best_of` != 1 is not supported when `stream` == True")
+        return field_value
+
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            if self.parameters is not None and isinstance(self.parameters, dict):
+                self.parameters = TextGenerationParameters(**self.parameters)
+
+
+# Decoder input tokens
+@dataclass
+class InputToken:
+    """
+    Represents an input token.
+
+    Args:
+        id (`int`):
+            Token ID from the model tokenizer.
+        text (`str`):
+            Token text.
+        logprob (`float` or `None`):
+            Log probability of the token. Optional since the logprob of the first token cannot be computed.
+    """
+
+    # Token ID from the model tokenizer
+    id: int
+    # Token text
+    text: str
+    # Logprob
+    # Optional since the logprob of the first token cannot be computed
+    logprob: Optional[float] = None
+
+
+# Generated tokens
+@dataclass
+class Token:
+    """
+    Represents a token.
+
+    Args:
+        id (`int`):
+            Token ID from the model tokenizer.
+        text (`str`):
+            Token text.
+        logprob (`float`):
+            Log probability of the token.
+        special (`bool`):
+            Indicates whether the token is a special token. It can be used to ignore
+            tokens when concatenating.
+    """
+
+    # Token ID from the model tokenizer
+    id: int
+    # Token text
+    text: str
+    # Logprob
+    logprob: float
+    # Is the token a special token
+    # Can be used to ignore tokens when concatenating
+    special: bool
+
+
+# Generation finish reason
+class FinishReason(str, Enum):
+    # number of generated tokens == `max_new_tokens`
+    Length = "length"
+    # the model generated its end of sequence token
+    EndOfSequenceToken = "eos_token"
+    # the model generated a text included in `stop_sequences`
+    StopSequence = "stop_sequence"
+
+
+# Additional sequences when using the `best_of` parameter
+@dataclass
+class BestOfSequence:
+    """
+    Represents a best-of sequence generated during text generation.
+
+    Args:
+        generated_text (`str`):
+            The generated text.
+        finish_reason (`FinishReason`):
+            The reason for the generation to finish, represented by a `FinishReason` value.
+        generated_tokens (`int`):
+            The number of generated tokens in the sequence.
+        seed (`Optional[int]`):
+            The sampling seed if sampling was activated.
+        prefill (`List[InputToken]`):
+            The decoder input tokens. Empty if `decoder_input_details` is False. Defaults to an empty list.
+        tokens (`List[Token]`):
+            The generated tokens. Defaults to an empty list.
+    """
+
+    # Generated text
+    generated_text: str
+    # Generation finish reason
+    finish_reason: FinishReason
+    # Number of generated tokens
+    generated_tokens: int
+    # Sampling seed if sampling was activated
+    seed: Optional[int] = None
+    # Decoder input tokens, empty if decoder_input_details is False
+    prefill: List[InputToken] = field(default_factory=lambda: [])
+    # Generated tokens
+    tokens: List[Token] = field(default_factory=lambda: [])
+
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            self.prefill = [
+                InputToken(**input_token) if isinstance(input_token, dict) else input_token
+                for input_token in self.prefill
+            ]
+            self.tokens = [Token(**token) if isinstance(token, dict) else token for token in self.tokens]
+
+
+# `generate` details
+@dataclass
+class Details:
+    """
+    Represents details of a text generation.
+
+    Args:
+        finish_reason (`FinishReason`):
+            The reason for the generation to finish, represented by a `FinishReason` value.
+        generated_tokens (`int`):
+            The number of generated tokens.
+        seed (`Optional[int]`):
+            The sampling seed if sampling was activated.
+        prefill (`List[InputToken]`, *optional*):
+            The decoder input tokens. Empty if `decoder_input_details` is False. Defaults to an empty list.
+        tokens (`List[Token]`):
+            The generated tokens. Defaults to an empty list.
+        best_of_sequences (`Optional[List[BestOfSequence]]`):
+            Additional sequences when using the `best_of` parameter.
+    """
+
+    # Generation finish reason
+    finish_reason: FinishReason
+    # Number of generated tokens
+    generated_tokens: int
+    # Sampling seed if sampling was activated
+    seed: Optional[int] = None
+    # Decoder input tokens, empty if decoder_input_details is False
+    prefill: List[InputToken] = field(default_factory=lambda: [])
+    # Generated tokens
+    tokens: List[Token] = field(default_factory=lambda: [])
+    # Additional sequences when using the `best_of` parameter
+    best_of_sequences: Optional[List[BestOfSequence]] = None
+
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            self.prefill = [
+                InputToken(**input_token) if isinstance(input_token, dict) else input_token
+                for input_token in self.prefill
+            ]
+            self.tokens = [Token(**token) if isinstance(token, dict) else token for token in self.tokens]
+            if self.best_of_sequences is not None:
+                self.best_of_sequences = [
+                    BestOfSequence(**best_of_sequence) if isinstance(best_of_sequence, dict) else best_of_sequence
+                    for best_of_sequence in self.best_of_sequences
+                ]
+
+
+# `generate` return value
+@dataclass
+class TextGenerationResponse:
+    """
+    Represents a response for text generation.
+
+    Only returned when `details=True`, otherwise a string is returned.
+
+    Args:
+        generated_text (`str`):
+            The generated text.
+        details (`Optional[Details]`):
+            Generation details. Returned only if `details=True` is sent to the server.
+    """
+
+    # Generated text
+    generated_text: str
+    # Generation details
+    details: Optional[Details] = None
+
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            if self.details is not None and isinstance(self.details, dict):
+                self.details = Details(**self.details)
+
+
+# `generate_stream` details
+@dataclass
+class StreamDetails:
+    """
+    Represents details of a text generation stream.
+
+    Args:
+        finish_reason (`FinishReason`):
+            The reason for the generation to finish, represented by a `FinishReason` value.
+        generated_tokens (`int`):
+            The number of generated tokens.
+        seed (`Optional[int]`):
+            The sampling seed if sampling was activated.
+    """
+
+    # Generation finish reason
+    finish_reason: FinishReason
+    # Number of generated tokens
+    generated_tokens: int
+    # Sampling seed if sampling was activated
+    seed: Optional[int] = None
+
+
+# `generate_stream` return value
+@dataclass
+class TextGenerationStreamResponse:
+    """
+    Represents a response for streaming text generation.
+
+    Only returned when `details=True` and `stream=True`.
+
+    Args:
+        token (`Token`):
+            The generated token.
+        generated_text (`Optional[str]`, *optional*):
+            The complete generated text. Only available when the generation is finished.
+        details (`Optional[StreamDetails]`, *optional*):
+            Generation details. Only available when the generation is finished.
+    """
+
+    # Generated token
+    token: Token
+    # Complete generated text
+    # Only available when the generation is finished
+    generated_text: Optional[str] = None
+    # Generation details
+    # Only available when the generation is finished
+    details: Optional[StreamDetails] = None
+
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            if isinstance(self.token, dict):
+                self.token = Token(**self.token)
+            if self.details is not None and isinstance(self.details, dict):
+                self.details = StreamDetails(**self.details)
+
+
+# TEXT GENERATION ERRORS
+# ----------------------
+# Text-generation errors are parsed separately to handle as much as possible the errors returned by the text generation
+# inference project (https://github.com/huggingface/text-generation-inference).
+# ----------------------
+
+
+class TextGenerationError(HTTPError):
+    """Generic error raised if text-generation went wrong."""
+
+
+# Text Generation Inference Errors
+class ValidationError(TextGenerationError):
+    """Server-side validation error."""
+
+
+class GenerationError(TextGenerationError):
+    pass
+
+
+class OverloadedError(TextGenerationError):
+    pass
+
+
+class IncompleteGenerationError(TextGenerationError):
+    pass
+
+
+class UnknownError(TextGenerationError):
+    pass
+
+
+def raise_text_generation_error(http_error: HTTPError) -> NoReturn:
+    """
+    Try to parse text-generation-inference error message and raise HTTPError in any case.
+
+    Args:
+        error (`HTTPError`):
+            The HTTPError that have been raised.
+    """
+    # Try to parse a Text Generation Inference error
+
+    try:
+        # Hacky way to retrieve payload in case of aiohttp error
+        payload = getattr(http_error, "response_error_payload", None) or http_error.response.json()
+        error = payload.get("error")
+        error_type = payload.get("error_type")
+    except Exception:  # no payload
+        raise http_error
+
+    # If error_type => more information than `hf_raise_for_status`
+    if error_type is not None:
+        exception = _parse_text_generation_error(error, error_type)
+        raise exception from http_error
+
+    # Otherwise, fallback to default error
+    raise http_error
+
+
+def _parse_text_generation_error(error: Optional[str], error_type: Optional[str]) -> TextGenerationError:
+    if error_type == "generation":
+        return GenerationError(error)  # type: ignore
+    if error_type == "incomplete_generation":
+        return IncompleteGenerationError(error)  # type: ignore
+    if error_type == "overloaded":
+        return OverloadedError(error)  # type: ignore
+    if error_type == "validation":
+        return ValidationError(error)  # type: ignore
+    return UnknownError(error)  # type: ignore
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference/_types.py b/lib/python3.11/site-packages/huggingface_hub/inference/_types.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb5537b9240cba26f04d5385a15cfa954c9d1d91
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/inference/_types.py
@@ -0,0 +1,183 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import TYPE_CHECKING, List, TypedDict
+
+
+if TYPE_CHECKING:
+    from PIL import Image
+
+
+class ClassificationOutput(TypedDict):
+    """Dictionary containing the output of a [`~InferenceClient.audio_classification`] and  [`~InferenceClient.image_classification`] task.
+
+    Args:
+        label (`str`):
+            The label predicted by the model.
+        score (`float`):
+            The score of the label predicted by the model.
+    """
+
+    label: str
+    score: float
+
+
+class ConversationalOutputConversation(TypedDict):
+    """Dictionary containing the "conversation" part of a [`~InferenceClient.conversational`] task.
+
+    Args:
+        generated_responses (`List[str]`):
+            A list of the responses from the model.
+        past_user_inputs (`List[str]`):
+            A list of the inputs from the user. Must be the same length as `generated_responses`.
+    """
+
+    generated_responses: List[str]
+    past_user_inputs: List[str]
+
+
+class ConversationalOutput(TypedDict):
+    """Dictionary containing the output of a  [`~InferenceClient.conversational`] task.
+
+    Args:
+        generated_text (`str`):
+            The last response from the model.
+        conversation (`ConversationalOutputConversation`):
+            The past conversation.
+        warnings (`List[str]`):
+            A list of warnings associated with the process.
+    """
+
+    conversation: ConversationalOutputConversation
+    generated_text: str
+    warnings: List[str]
+
+
+class FillMaskOutput(TypedDict):
+    """Dictionary containing information about a [`~InferenceClient.fill_mask`] task.
+
+    Args:
+        score (`float`):
+            The probability of the token.
+        token (`int`):
+            The id of the token.
+        token_str (`str`):
+            The string representation of the token.
+        sequence (`str`):
+            The actual sequence of tokens that ran against the model (may contain special tokens).
+    """
+
+    score: float
+    token: int
+    token_str: str
+    sequence: str
+
+
+class ImageSegmentationOutput(TypedDict):
+    """Dictionary containing information about a [`~InferenceClient.image_segmentation`] task. In practice, image segmentation returns a
+    list of `ImageSegmentationOutput` with 1 item per mask.
+
+    Args:
+        label (`str`):
+            The label corresponding to the mask.
+        mask (`Image`):
+            An Image object representing the mask predicted by the model.
+        score (`float`):
+            The score associated with the label for this mask.
+    """
+
+    label: str
+    mask: "Image"
+    score: float
+
+
+class ObjectDetectionOutput(TypedDict):
+    """Dictionary containing information about a [`~InferenceClient.object_detection`] task.
+
+    Args:
+        label (`str`):
+            The label corresponding to the detected object.
+        box (`dict`):
+            A dict response of bounding box coordinates of
+            the detected object: xmin, ymin, xmax, ymax
+        score (`float`):
+            The score corresponding to the detected object.
+    """
+
+    label: str
+    box: dict
+    score: float
+
+
+class QuestionAnsweringOutput(TypedDict):
+    """Dictionary containing information about a [`~InferenceClient.question_answering`] task.
+
+    Args:
+        score (`float`):
+            A float that represents how likely that the answer is correct.
+        start (`int`):
+            The index (string wise) of the start of the answer within context.
+        end (`int`):
+            The index (string wise) of the end of the answer within context.
+        answer (`str`):
+            A string that is the answer within the text.
+    """
+
+    score: float
+    start: int
+    end: int
+    answer: str
+
+
+class TableQuestionAnsweringOutput(TypedDict):
+    """Dictionary containing information about a [`~InferenceClient.table_question_answering`] task.
+
+    Args:
+        answer (`str`):
+            The plaintext answer.
+        coordinates (`List[List[int]]`):
+            A list of coordinates of the cells referenced in the answer.
+        cells (`List[int]`):
+            A list of coordinates of the cells contents.
+        aggregator (`str`):
+            The aggregator used to get the answer.
+    """
+
+    answer: str
+    coordinates: List[List[int]]
+    cells: List[List[int]]
+    aggregator: str
+
+
+class TokenClassificationOutput(TypedDict):
+    """Dictionary containing the output of a [`~InferenceClient.token_classification`] task.
+
+    Args:
+        entity_group (`str`):
+            The type for the entity being recognized (model specific).
+        score (`float`):
+            The score of the label predicted by the model.
+        word (`str`):
+            The string that was captured.
+        start (`int`):
+            The offset stringwise where the answer is located. Useful to disambiguate if word occurs multiple times.
+        end (`int`):
+            The offset stringwise where the answer is located. Useful to disambiguate if word occurs multiple times.
+    """
+
+    entity_group: str
+    score: float
+    word: str
+    start: int
+    end: int
diff --git a/lib/python3.11/site-packages/huggingface_hub/inference_api.py b/lib/python3.11/site-packages/huggingface_hub/inference_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..c889a6d8720a5242f50f81955916df3cb33357e1
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/inference_api.py
@@ -0,0 +1,217 @@
+import io
+from typing import Any, Dict, List, Optional, Union
+
+from .constants import INFERENCE_ENDPOINT
+from .hf_api import HfApi
+from .utils import build_hf_headers, get_session, is_pillow_available, logging, validate_hf_hub_args
+from .utils._deprecation import _deprecate_method
+
+
+logger = logging.get_logger(__name__)
+
+
+ALL_TASKS = [
+    # NLP
+    "text-classification",
+    "token-classification",
+    "table-question-answering",
+    "question-answering",
+    "zero-shot-classification",
+    "translation",
+    "summarization",
+    "conversational",
+    "feature-extraction",
+    "text-generation",
+    "text2text-generation",
+    "fill-mask",
+    "sentence-similarity",
+    # Audio
+    "text-to-speech",
+    "automatic-speech-recognition",
+    "audio-to-audio",
+    "audio-classification",
+    "voice-activity-detection",
+    # Computer vision
+    "image-classification",
+    "object-detection",
+    "image-segmentation",
+    "text-to-image",
+    "image-to-image",
+    # Others
+    "tabular-classification",
+    "tabular-regression",
+]
+
+
+class InferenceApi:
+    """Client to configure requests and make calls to the HuggingFace Inference API.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub.inference_api import InferenceApi
+
+    >>> # Mask-fill example
+    >>> inference = InferenceApi("bert-base-uncased")
+    >>> inference(inputs="The goal of life is [MASK].")
+    [{'sequence': 'the goal of life is life.', 'score': 0.10933292657136917, 'token': 2166, 'token_str': 'life'}]
+
+    >>> # Question Answering example
+    >>> inference = InferenceApi("deepset/roberta-base-squad2")
+    >>> inputs = {
+    ...     "question": "What's my name?",
+    ...     "context": "My name is Clara and I live in Berkeley.",
+    ... }
+    >>> inference(inputs)
+    {'score': 0.9326569437980652, 'start': 11, 'end': 16, 'answer': 'Clara'}
+
+    >>> # Zero-shot example
+    >>> inference = InferenceApi("typeform/distilbert-base-uncased-mnli")
+    >>> inputs = "Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!"
+    >>> params = {"candidate_labels": ["refund", "legal", "faq"]}
+    >>> inference(inputs, params)
+    {'sequence': 'Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!', 'labels': ['refund', 'faq', 'legal'], 'scores': [0.9378499388694763, 0.04914155602455139, 0.013008488342165947]}
+
+    >>> # Overriding configured task
+    >>> inference = InferenceApi("bert-base-uncased", task="feature-extraction")
+
+    >>> # Text-to-image
+    >>> inference = InferenceApi("stabilityai/stable-diffusion-2-1")
+    >>> inference("cat")
+    <PIL.PngImagePlugin.PngImageFile image (...)>
+
+    >>> # Return as raw response to parse the output yourself
+    >>> inference = InferenceApi("mio/amadeus")
+    >>> response = inference("hello world", raw_response=True)
+    >>> response.headers
+    {"Content-Type": "audio/flac", ...}
+    >>> response.content # raw bytes from server
+    b'(...)'
+    ```
+    """
+
+    @validate_hf_hub_args
+    @_deprecate_method(
+        version="1.0",
+        message=(
+            "`InferenceApi` client is deprecated in favor of the more feature-complete `InferenceClient`. Check out"
+            " this guide to learn how to convert your script to use it:"
+            " https://huggingface.co/docs/huggingface_hub/guides/inference#legacy-inferenceapi-client."
+        ),
+    )
+    def __init__(
+        self,
+        repo_id: str,
+        task: Optional[str] = None,
+        token: Optional[str] = None,
+        gpu: bool = False,
+    ):
+        """Inits headers and API call information.
+
+        Args:
+            repo_id (``str``):
+                Id of repository (e.g. `user/bert-base-uncased`).
+            task (``str``, `optional`, defaults ``None``):
+                Whether to force a task instead of using task specified in the
+                repository.
+            token (`str`, `optional`):
+                The API token to use as HTTP bearer authorization. This is not
+                the authentication token. You can find the token in
+                https://huggingface.co/settings/token. Alternatively, you can
+                find both your organizations and personal API tokens using
+                `HfApi().whoami(token)`.
+            gpu (`bool`, `optional`, defaults `False`):
+                Whether to use GPU instead of CPU for inference(requires Startup
+                plan at least).
+        """
+        self.options = {"wait_for_model": True, "use_gpu": gpu}
+        self.headers = build_hf_headers(token=token)
+
+        # Configure task
+        model_info = HfApi(token=token).model_info(repo_id=repo_id)
+        if not model_info.pipeline_tag and not task:
+            raise ValueError(
+                "Task not specified in the repository. Please add it to the model card"
+                " using pipeline_tag"
+                " (https://huggingface.co/docs#how-is-a-models-type-of-inference-api-and-widget-determined)"
+            )
+
+        if task and task != model_info.pipeline_tag:
+            if task not in ALL_TASKS:
+                raise ValueError(f"Invalid task {task}. Make sure it's valid.")
+
+            logger.warning(
+                "You're using a different task than the one specified in the"
+                " repository. Be sure to know what you're doing :)"
+            )
+            self.task = task
+        else:
+            assert model_info.pipeline_tag is not None, "Pipeline tag cannot be None"
+            self.task = model_info.pipeline_tag
+
+        self.api_url = f"{INFERENCE_ENDPOINT}/pipeline/{self.task}/{repo_id}"
+
+    def __repr__(self):
+        # Do not add headers to repr to avoid leaking token.
+        return f"InferenceAPI(api_url='{self.api_url}', task='{self.task}', options={self.options})"
+
+    def __call__(
+        self,
+        inputs: Optional[Union[str, Dict, List[str], List[List[str]]]] = None,
+        params: Optional[Dict] = None,
+        data: Optional[bytes] = None,
+        raw_response: bool = False,
+    ) -> Any:
+        """Make a call to the Inference API.
+
+        Args:
+            inputs (`str` or `Dict` or `List[str]` or `List[List[str]]`, *optional*):
+                Inputs for the prediction.
+            params (`Dict`, *optional*):
+                Additional parameters for the models. Will be sent as `parameters` in the
+                payload.
+            data (`bytes`, *optional*):
+                Bytes content of the request. In this case, leave `inputs` and `params` empty.
+            raw_response (`bool`, defaults to `False`):
+                If `True`, the raw `Response` object is returned. You can parse its content
+                as preferred. By default, the content is parsed into a more practical format
+                (json dictionary or PIL Image for example).
+        """
+        # Build payload
+        payload: Dict[str, Any] = {
+            "options": self.options,
+        }
+        if inputs:
+            payload["inputs"] = inputs
+        if params:
+            payload["parameters"] = params
+
+        # Make API call
+        response = get_session().post(self.api_url, headers=self.headers, json=payload, data=data)
+
+        # Let the user handle the response
+        if raw_response:
+            return response
+
+        # By default, parse the response for the user.
+        content_type = response.headers.get("Content-Type") or ""
+        if content_type.startswith("image"):
+            if not is_pillow_available():
+                raise ImportError(
+                    f"Task '{self.task}' returned as image but Pillow is not installed."
+                    " Please install it (`pip install Pillow`) or pass"
+                    " `raw_response=True` to get the raw `Response` object and parse"
+                    " the image by yourself."
+                )
+
+            from PIL import Image
+
+            return Image.open(io.BytesIO(response.content))
+        elif content_type == "application/json":
+            return response.json()
+        else:
+            raise NotImplementedError(
+                f"{content_type} output type is not implemented yet. You can pass"
+                " `raw_response=True` to get the raw `Response` object and parse the"
+                " output by yourself."
+            )
diff --git a/lib/python3.11/site-packages/huggingface_hub/keras_mixin.py b/lib/python3.11/site-packages/huggingface_hub/keras_mixin.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ecdb8150f0f9dd488252bf41a254b9bb8453577
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/keras_mixin.py
@@ -0,0 +1,480 @@
+import collections.abc as collections
+import json
+import os
+import warnings
+from pathlib import Path
+from shutil import copytree
+from typing import Any, Dict, List, Optional, Union
+
+from huggingface_hub import ModelHubMixin, snapshot_download
+from huggingface_hub.utils import (
+    get_tf_version,
+    is_graphviz_available,
+    is_pydot_available,
+    is_tf_available,
+    yaml_dump,
+)
+
+from .constants import CONFIG_NAME
+from .hf_api import HfApi
+from .utils import SoftTemporaryDirectory, logging, validate_hf_hub_args
+
+
+logger = logging.get_logger(__name__)
+
+if is_tf_available():
+    import tensorflow as tf  # type: ignore
+
+
+def _flatten_dict(dictionary, parent_key=""):
+    """Flatten a nested dictionary.
+    Reference: https://stackoverflow.com/a/6027615/10319735
+
+    Args:
+        dictionary (`dict`):
+            The nested dictionary to be flattened.
+        parent_key (`str`):
+            The parent key to be prefixed to the children keys.
+            Necessary for recursing over the nested dictionary.
+
+    Returns:
+        The flattened dictionary.
+    """
+    items = []
+    for key, value in dictionary.items():
+        new_key = f"{parent_key}.{key}" if parent_key else key
+        if isinstance(value, collections.MutableMapping):
+            items.extend(
+                _flatten_dict(
+                    value,
+                    new_key,
+                ).items()
+            )
+        else:
+            items.append((new_key, value))
+    return dict(items)
+
+
+def _create_hyperparameter_table(model):
+    """Parse hyperparameter dictionary into a markdown table."""
+    if model.optimizer is not None:
+        optimizer_params = model.optimizer.get_config()
+        # flatten the configuration
+        optimizer_params = _flatten_dict(optimizer_params)
+        optimizer_params["training_precision"] = tf.keras.mixed_precision.global_policy().name
+        table = "| Hyperparameters | Value |\n| :-- | :-- |\n"
+        for key, value in optimizer_params.items():
+            table += f"| {key} | {value} |\n"
+    else:
+        table = None
+    return table
+
+
+def _plot_network(model, save_directory):
+    tf.keras.utils.plot_model(
+        model,
+        to_file=f"{save_directory}/model.png",
+        show_shapes=False,
+        show_dtype=False,
+        show_layer_names=True,
+        rankdir="TB",
+        expand_nested=False,
+        dpi=96,
+        layer_range=None,
+    )
+
+
+def _create_model_card(
+    model,
+    repo_dir: Path,
+    plot_model: bool = True,
+    metadata: Optional[dict] = None,
+):
+    """
+    Creates a model card for the repository.
+
+    Do not overwrite an existing README.md file.
+    """
+    readme_path = repo_dir / "README.md"
+    if readme_path.exists():
+        return
+
+    hyperparameters = _create_hyperparameter_table(model)
+    if plot_model and is_graphviz_available() and is_pydot_available():
+        _plot_network(model, repo_dir)
+    if metadata is None:
+        metadata = {}
+    metadata["library_name"] = "keras"
+    model_card: str = "---\n"
+    model_card += yaml_dump(metadata, default_flow_style=False)
+    model_card += "---\n"
+    model_card += "\n## Model description\n\nMore information needed\n"
+    model_card += "\n## Intended uses & limitations\n\nMore information needed\n"
+    model_card += "\n## Training and evaluation data\n\nMore information needed\n"
+    if hyperparameters is not None:
+        model_card += "\n## Training procedure\n"
+        model_card += "\n### Training hyperparameters\n"
+        model_card += "\nThe following hyperparameters were used during training:\n\n"
+        model_card += hyperparameters
+        model_card += "\n"
+    if plot_model and os.path.exists(f"{repo_dir}/model.png"):
+        model_card += "\n ## Model Plot\n"
+        model_card += "\n<details>"
+        model_card += "\n<summary>View Model Plot</summary>\n"
+        path_to_plot = "./model.png"
+        model_card += f"\n![Model Image]({path_to_plot})\n"
+        model_card += "\n</details>"
+
+    readme_path.write_text(model_card)
+
+
+def save_pretrained_keras(
+    model,
+    save_directory: Union[str, Path],
+    config: Optional[Dict[str, Any]] = None,
+    include_optimizer: bool = False,
+    plot_model: bool = True,
+    tags: Optional[Union[list, str]] = None,
+    **model_save_kwargs,
+):
+    """
+    Saves a Keras model to save_directory in SavedModel format. Use this if
+    you're using the Functional or Sequential APIs.
+
+    Args:
+        model (`Keras.Model`):
+            The [Keras
+            model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)
+            you'd like to save. The model must be compiled and built.
+        save_directory (`str` or `Path`):
+            Specify directory in which you want to save the Keras model.
+        config (`dict`, *optional*):
+            Configuration object to be saved alongside the model weights.
+        include_optimizer(`bool`, *optional*, defaults to `False`):
+            Whether or not to include optimizer in serialization.
+        plot_model (`bool`, *optional*, defaults to `True`):
+            Setting this to `True` will plot the model and put it in the model
+            card. Requires graphviz and pydot to be installed.
+        tags (Union[`str`,`list`], *optional*):
+            List of tags that are related to model or string of a single tag. See example tags
+            [here](https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1).
+        model_save_kwargs(`dict`, *optional*):
+            model_save_kwargs will be passed to
+            [`tf.keras.models.save_model()`](https://www.tensorflow.org/api_docs/python/tf/keras/models/save_model).
+    """
+    if is_tf_available():
+        import tensorflow as tf
+    else:
+        raise ImportError("Called a Tensorflow-specific function but could not import it.")
+
+    if not model.built:
+        raise ValueError("Model should be built before trying to save")
+
+    save_directory = Path(save_directory)
+    save_directory.mkdir(parents=True, exist_ok=True)
+
+    # saving config
+    if config:
+        if not isinstance(config, dict):
+            raise RuntimeError(f"Provided config to save_pretrained_keras should be a dict. Got: '{type(config)}'")
+
+        with (save_directory / CONFIG_NAME).open("w") as f:
+            json.dump(config, f)
+
+    metadata = {}
+    if isinstance(tags, list):
+        metadata["tags"] = tags
+    elif isinstance(tags, str):
+        metadata["tags"] = [tags]
+
+    task_name = model_save_kwargs.pop("task_name", None)
+    if task_name is not None:
+        warnings.warn(
+            "`task_name` input argument is deprecated. Pass `tags` instead.",
+            FutureWarning,
+        )
+        if "tags" in metadata:
+            metadata["tags"].append(task_name)
+        else:
+            metadata["tags"] = [task_name]
+
+    if model.history is not None:
+        if model.history.history != {}:
+            path = save_directory / "history.json"
+            if path.exists():
+                warnings.warn(
+                    "`history.json` file already exists, it will be overwritten by the history of this version.",
+                    UserWarning,
+                )
+            with path.open("w", encoding="utf-8") as f:
+                json.dump(model.history.history, f, indent=2, sort_keys=True)
+
+    _create_model_card(model, save_directory, plot_model, metadata)
+    tf.keras.models.save_model(model, save_directory, include_optimizer=include_optimizer, **model_save_kwargs)
+
+
+def from_pretrained_keras(*args, **kwargs) -> "KerasModelHubMixin":
+    r"""
+    Instantiate a pretrained Keras model from a pre-trained model from the Hub.
+    The model is expected to be in `SavedModel` format.
+
+    Args:
+        pretrained_model_name_or_path (`str` or `os.PathLike`):
+            Can be either:
+                - A string, the `model id` of a pretrained model hosted inside a
+                  model repo on huggingface.co. Valid model ids can be located
+                  at the root-level, like `bert-base-uncased`, or namespaced
+                  under a user or organization name, like
+                  `dbmdz/bert-base-german-cased`.
+                - You can add `revision` by appending `@` at the end of model_id
+                  simply like this: `dbmdz/bert-base-german-cased@main` Revision
+                  is the specific model version to use. It can be a branch name,
+                  a tag name, or a commit id, since we use a git-based system
+                  for storing models and other artifacts on huggingface.co, so
+                  `revision` can be any identifier allowed by git.
+                - A path to a `directory` containing model weights saved using
+                  [`~transformers.PreTrainedModel.save_pretrained`], e.g.,
+                  `./my_model_directory/`.
+                - `None` if you are both providing the configuration and state
+                  dictionary (resp. with keyword arguments `config` and
+                  `state_dict`).
+        force_download (`bool`, *optional*, defaults to `False`):
+            Whether to force the (re-)download of the model weights and
+            configuration files, overriding the cached versions if they exist.
+        resume_download (`bool`, *optional*, defaults to `False`):
+            Whether to delete incompletely received files. Will attempt to
+            resume the download if such a file exists.
+        proxies (`Dict[str, str]`, *optional*):
+            A dictionary of proxy servers to use by protocol or endpoint, e.g.,
+            `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The
+            proxies are used on each request.
+        token (`str` or `bool`, *optional*):
+            The token to use as HTTP bearer authorization for remote files. If
+            `True`, will use the token generated when running `transformers-cli
+            login` (stored in `~/.huggingface`).
+        cache_dir (`Union[str, os.PathLike]`, *optional*):
+            Path to a directory in which a downloaded pretrained model
+            configuration should be cached if the standard cache should not be
+            used.
+        local_files_only(`bool`, *optional*, defaults to `False`):
+            Whether to only look at local files (i.e., do not try to download
+            the model).
+        model_kwargs (`Dict`, *optional*):
+            model_kwargs will be passed to the model during initialization
+
+    <Tip>
+
+    Passing `token=True` is required when you want to use a private
+    model.
+
+    </Tip>
+    """
+    return KerasModelHubMixin.from_pretrained(*args, **kwargs)
+
+
+@validate_hf_hub_args
+def push_to_hub_keras(
+    model,
+    repo_id: str,
+    *,
+    config: Optional[dict] = None,
+    commit_message: str = "Push Keras model using huggingface_hub.",
+    private: bool = False,
+    api_endpoint: Optional[str] = None,
+    token: Optional[str] = None,
+    branch: Optional[str] = None,
+    create_pr: Optional[bool] = None,
+    allow_patterns: Optional[Union[List[str], str]] = None,
+    ignore_patterns: Optional[Union[List[str], str]] = None,
+    delete_patterns: Optional[Union[List[str], str]] = None,
+    log_dir: Optional[str] = None,
+    include_optimizer: bool = False,
+    tags: Optional[Union[list, str]] = None,
+    plot_model: bool = True,
+    **model_save_kwargs,
+):
+    """
+    Upload model checkpoint to the Hub.
+
+    Use `allow_patterns` and `ignore_patterns` to precisely filter which files should be pushed to the hub. Use
+    `delete_patterns` to delete existing remote files in the same commit. See [`upload_folder`] reference for more
+    details.
+
+    Args:
+        model (`Keras.Model`):
+            The [Keras model](`https://www.tensorflow.org/api_docs/python/tf/keras/Model`) you'd like to push to the
+            Hub. The model must be compiled and built.
+        repo_id (`str`):
+                ID of the repository to push to (example: `"username/my-model"`).
+        commit_message (`str`, *optional*, defaults to "Add Keras model"):
+            Message to commit while pushing.
+        private (`bool`, *optional*, defaults to `False`):
+            Whether the repository created should be private.
+        api_endpoint (`str`, *optional*):
+            The API endpoint to use when pushing the model to the hub.
+        token (`str`, *optional*):
+            The token to use as HTTP bearer authorization for remote files. If
+            not set, will use the token set when logging in with
+            `huggingface-cli login` (stored in `~/.huggingface`).
+        branch (`str`, *optional*):
+            The git branch on which to push the model. This defaults to
+            the default branch as specified in your repository, which
+            defaults to `"main"`.
+        create_pr (`boolean`, *optional*):
+            Whether or not to create a Pull Request from `branch` with that commit.
+            Defaults to `False`.
+        config (`dict`, *optional*):
+            Configuration object to be saved alongside the model weights.
+        allow_patterns (`List[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are pushed.
+        ignore_patterns (`List[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not pushed.
+        delete_patterns (`List[str]` or `str`, *optional*):
+            If provided, remote files matching any of the patterns will be deleted from the repo.
+        log_dir (`str`, *optional*):
+            TensorBoard logging directory to be pushed. The Hub automatically
+            hosts and displays a TensorBoard instance if log files are included
+            in the repository.
+        include_optimizer (`bool`, *optional*, defaults to `False`):
+            Whether or not to include optimizer during serialization.
+        tags (Union[`list`, `str`], *optional*):
+            List of tags that are related to model or string of a single tag. See example tags
+            [here](https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1).
+        plot_model (`bool`, *optional*, defaults to `True`):
+            Setting this to `True` will plot the model and put it in the model
+            card. Requires graphviz and pydot to be installed.
+        model_save_kwargs(`dict`, *optional*):
+            model_save_kwargs will be passed to
+            [`tf.keras.models.save_model()`](https://www.tensorflow.org/api_docs/python/tf/keras/models/save_model).
+
+    Returns:
+        The url of the commit of your model in the given repository.
+    """
+    api = HfApi(endpoint=api_endpoint)
+    repo_id = api.create_repo(repo_id=repo_id, token=token, private=private, exist_ok=True).repo_id
+
+    # Push the files to the repo in a single commit
+    with SoftTemporaryDirectory() as tmp:
+        saved_path = Path(tmp) / repo_id
+        save_pretrained_keras(
+            model,
+            saved_path,
+            config=config,
+            include_optimizer=include_optimizer,
+            tags=tags,
+            plot_model=plot_model,
+            **model_save_kwargs,
+        )
+
+        # If `log_dir` provided, delete remote logs and upload new ones
+        if log_dir is not None:
+            delete_patterns = (
+                []
+                if delete_patterns is None
+                else (
+                    [delete_patterns]  # convert `delete_patterns` to a list
+                    if isinstance(delete_patterns, str)
+                    else delete_patterns
+                )
+            )
+            delete_patterns.append("logs/*")
+            copytree(log_dir, saved_path / "logs")
+
+        return api.upload_folder(
+            repo_type="model",
+            repo_id=repo_id,
+            folder_path=saved_path,
+            commit_message=commit_message,
+            token=token,
+            revision=branch,
+            create_pr=create_pr,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            delete_patterns=delete_patterns,
+        )
+
+
+class KerasModelHubMixin(ModelHubMixin):
+    """
+    Implementation of [`ModelHubMixin`] to provide model Hub upload/download
+    capabilities to Keras models.
+
+
+    ```python
+    >>> import tensorflow as tf
+    >>> from huggingface_hub import KerasModelHubMixin
+
+
+    >>> class MyModel(tf.keras.Model, KerasModelHubMixin):
+    ...     def __init__(self, **kwargs):
+    ...         super().__init__()
+    ...         self.config = kwargs.pop("config", None)
+    ...         self.dummy_inputs = ...
+    ...         self.layer = ...
+
+    ...     def call(self, *args):
+    ...         return ...
+
+
+    >>> # Initialize and compile the model as you normally would
+    >>> model = MyModel()
+    >>> model.compile(...)
+    >>> # Build the graph by training it or passing dummy inputs
+    >>> _ = model(model.dummy_inputs)
+    >>> # Save model weights to local directory
+    >>> model.save_pretrained("my-awesome-model")
+    >>> # Push model weights to the Hub
+    >>> model.push_to_hub("my-awesome-model")
+    >>> # Download and initialize weights from the Hub
+    >>> model = MyModel.from_pretrained("username/super-cool-model")
+    ```
+    """
+
+    def _save_pretrained(self, save_directory):
+        save_pretrained_keras(self, save_directory)
+
+    @classmethod
+    def _from_pretrained(
+        cls,
+        model_id,
+        revision,
+        cache_dir,
+        force_download,
+        proxies,
+        resume_download,
+        local_files_only,
+        token,
+        **model_kwargs,
+    ):
+        """Here we just call [`from_pretrained_keras`] function so both the mixin and
+        functional APIs stay in sync.
+
+                TODO - Some args above aren't used since we are calling
+                snapshot_download instead of hf_hub_download.
+        """
+        if is_tf_available():
+            import tensorflow as tf
+        else:
+            raise ImportError("Called a TensorFlow-specific function but could not import it.")
+
+        # TODO - Figure out what to do about these config values. Config is not going to be needed to load model
+        cfg = model_kwargs.pop("config", None)
+
+        # Root is either a local filepath matching model_id or a cached snapshot
+        if not os.path.isdir(model_id):
+            storage_folder = snapshot_download(
+                repo_id=model_id,
+                revision=revision,
+                cache_dir=cache_dir,
+                library_name="keras",
+                library_version=get_tf_version(),
+            )
+        else:
+            storage_folder = model_id
+
+        model = tf.keras.models.load_model(storage_folder, **model_kwargs)
+
+        # For now, we add a new attribute, config, to store the config loaded from the hub/a local dir.
+        model.config = cfg
+
+        return model
diff --git a/lib/python3.11/site-packages/huggingface_hub/lfs.py b/lib/python3.11/site-packages/huggingface_hub/lfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..709ae7198c7765decaf2bec15f0cab4f182e3bd4
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/lfs.py
@@ -0,0 +1,522 @@
+# coding=utf-8
+# Copyright 2019-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Git LFS related type definitions and utilities"""
+import inspect
+import io
+import os
+import re
+import warnings
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from math import ceil
+from os.path import getsize
+from pathlib import Path
+from typing import TYPE_CHECKING, BinaryIO, Dict, Iterable, List, Optional, Tuple, TypedDict
+from urllib.parse import unquote
+
+from huggingface_hub.constants import ENDPOINT, HF_HUB_ENABLE_HF_TRANSFER, REPO_TYPES_URL_PREFIXES
+from huggingface_hub.utils import get_session
+
+from .utils import (
+    build_hf_headers,
+    hf_raise_for_status,
+    http_backoff,
+    logging,
+    tqdm,
+    validate_hf_hub_args,
+)
+from .utils.sha import sha256, sha_fileobj
+
+
+if TYPE_CHECKING:
+    from ._commit_api import CommitOperationAdd
+
+logger = logging.get_logger(__name__)
+
+OID_REGEX = re.compile(r"^[0-9a-f]{40}$")
+
+LFS_MULTIPART_UPLOAD_COMMAND = "lfs-multipart-upload"
+
+LFS_HEADERS = {
+    "Accept": "application/vnd.git-lfs+json",
+    "Content-Type": "application/vnd.git-lfs+json",
+}
+
+
+@dataclass
+class UploadInfo:
+    """
+    Dataclass holding required information to determine whether a blob
+    should be uploaded to the hub using the LFS protocol or the regular protocol
+
+    Args:
+        sha256 (`bytes`):
+            SHA256 hash of the blob
+        size (`int`):
+            Size in bytes of the blob
+        sample (`bytes`):
+            First 512 bytes of the blob
+    """
+
+    sha256: bytes
+    size: int
+    sample: bytes
+
+    @classmethod
+    def from_path(cls, path: str):
+        size = getsize(path)
+        with io.open(path, "rb") as file:
+            sample = file.peek(512)[:512]
+            sha = sha_fileobj(file)
+        return cls(size=size, sha256=sha, sample=sample)
+
+    @classmethod
+    def from_bytes(cls, data: bytes):
+        sha = sha256(data).digest()
+        return cls(size=len(data), sample=data[:512], sha256=sha)
+
+    @classmethod
+    def from_fileobj(cls, fileobj: BinaryIO):
+        sample = fileobj.read(512)
+        fileobj.seek(0, io.SEEK_SET)
+        sha = sha_fileobj(fileobj)
+        size = fileobj.tell()
+        fileobj.seek(0, io.SEEK_SET)
+        return cls(size=size, sha256=sha, sample=sample)
+
+
+@validate_hf_hub_args
+def post_lfs_batch_info(
+    upload_infos: Iterable[UploadInfo],
+    token: Optional[str],
+    repo_type: str,
+    repo_id: str,
+    revision: Optional[str] = None,
+    endpoint: Optional[str] = None,
+) -> Tuple[List[dict], List[dict]]:
+    """
+    Requests the LFS batch endpoint to retrieve upload instructions
+
+    Learn more: https://github.com/git-lfs/git-lfs/blob/main/docs/api/batch.md
+
+    Args:
+        upload_infos (`Iterable` of `UploadInfo`):
+            `UploadInfo` for the files that are being uploaded, typically obtained
+            from `CommitOperationAdd.upload_info`
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        token (`str`, *optional*):
+            An authentication token ( See https://huggingface.co/settings/tokens )
+        revision (`str`, *optional*):
+            The git revision to upload to.
+
+    Returns:
+        `LfsBatchInfo`: 2-tuple:
+            - First element is the list of upload instructions from the server
+            - Second element is an list of errors, if any
+
+    Raises:
+        `ValueError`: If an argument is invalid or the server response is malformed
+
+        `HTTPError`: If the server returned an error
+    """
+    endpoint = endpoint if endpoint is not None else ENDPOINT
+    url_prefix = ""
+    if repo_type in REPO_TYPES_URL_PREFIXES:
+        url_prefix = REPO_TYPES_URL_PREFIXES[repo_type]
+    batch_url = f"{endpoint}/{url_prefix}{repo_id}.git/info/lfs/objects/batch"
+    payload: Dict = {
+        "operation": "upload",
+        "transfers": ["basic", "multipart"],
+        "objects": [
+            {
+                "oid": upload.sha256.hex(),
+                "size": upload.size,
+            }
+            for upload in upload_infos
+        ],
+        "hash_algo": "sha256",
+    }
+    if revision is not None:
+        payload["ref"] = {"name": unquote(revision)}  # revision has been previously 'quoted'
+    headers = {**LFS_HEADERS, **build_hf_headers(token=token or True)}  # Token must be provided or retrieved
+    resp = get_session().post(batch_url, headers=headers, json=payload)
+    hf_raise_for_status(resp)
+    batch_info = resp.json()
+
+    objects = batch_info.get("objects", None)
+    if not isinstance(objects, list):
+        raise ValueError("Malformed response from server")
+
+    return (
+        [_validate_batch_actions(obj) for obj in objects if "error" not in obj],
+        [_validate_batch_error(obj) for obj in objects if "error" in obj],
+    )
+
+
+class PayloadPartT(TypedDict):
+    partNumber: int
+    etag: str
+
+
+class CompletionPayloadT(TypedDict):
+    """Payload that will be sent to the Hub when uploading multi-part."""
+
+    oid: str
+    parts: List[PayloadPartT]
+
+
+def lfs_upload(operation: "CommitOperationAdd", lfs_batch_action: Dict, token: Optional[str]) -> None:
+    """
+    Handles uploading a given object to the Hub with the LFS protocol.
+
+    Can be a No-op if the content of the file is already present on the hub large file storage.
+
+    Args:
+        operation (`CommitOperationAdd`):
+            The add operation triggering this upload.
+        lfs_batch_action (`dict`):
+            Upload instructions from the LFS batch endpoint for this object. See [`~utils.lfs.post_lfs_batch_info`] for
+            more details.
+        token (`str`, *optional*):
+            A [user access token](https://hf.co/settings/tokens) to authenticate requests against the Hub
+
+    Raises:
+        - `ValueError` if `lfs_batch_action` is improperly formatted
+        - `HTTPError` if the upload resulted in an error
+    """
+    # 0. If LFS file is already present, skip upload
+    _validate_batch_actions(lfs_batch_action)
+    actions = lfs_batch_action.get("actions")
+    if actions is None:
+        # The file was already uploaded
+        logger.debug(f"Content of file {operation.path_in_repo} is already present upstream - skipping upload")
+        return
+
+    # 1. Validate server response (check required keys in dict)
+    upload_action = lfs_batch_action["actions"]["upload"]
+    _validate_lfs_action(upload_action)
+    verify_action = lfs_batch_action["actions"].get("verify")
+    if verify_action is not None:
+        _validate_lfs_action(verify_action)
+
+    # 2. Upload file (either single part or multi-part)
+    header = upload_action.get("header", {})
+    chunk_size = header.get("chunk_size")
+    if chunk_size is not None:
+        try:
+            chunk_size = int(chunk_size)
+        except (ValueError, TypeError):
+            raise ValueError(
+                f"Malformed response from LFS batch endpoint: `chunk_size` should be an integer. Got '{chunk_size}'."
+            )
+        _upload_multi_part(operation=operation, header=header, chunk_size=chunk_size, upload_url=upload_action["href"])
+    else:
+        _upload_single_part(operation=operation, upload_url=upload_action["href"])
+
+    # 3. Verify upload went well
+    if verify_action is not None:
+        _validate_lfs_action(verify_action)
+        verify_resp = get_session().post(
+            verify_action["href"],
+            headers=build_hf_headers(token=token or True),
+            json={"oid": operation.upload_info.sha256.hex(), "size": operation.upload_info.size},
+        )
+        hf_raise_for_status(verify_resp)
+    logger.debug(f"{operation.path_in_repo}: Upload successful")
+
+
+def _validate_lfs_action(lfs_action: dict):
+    """validates response from the LFS batch endpoint"""
+    if not (
+        isinstance(lfs_action.get("href"), str)
+        and (lfs_action.get("header") is None or isinstance(lfs_action.get("header"), dict))
+    ):
+        raise ValueError("lfs_action is improperly formatted")
+    return lfs_action
+
+
+def _validate_batch_actions(lfs_batch_actions: dict):
+    """validates response from the LFS batch endpoint"""
+    if not (isinstance(lfs_batch_actions.get("oid"), str) and isinstance(lfs_batch_actions.get("size"), int)):
+        raise ValueError("lfs_batch_actions is improperly formatted")
+
+    upload_action = lfs_batch_actions.get("actions", {}).get("upload")
+    verify_action = lfs_batch_actions.get("actions", {}).get("verify")
+    if upload_action is not None:
+        _validate_lfs_action(upload_action)
+    if verify_action is not None:
+        _validate_lfs_action(verify_action)
+    return lfs_batch_actions
+
+
+def _validate_batch_error(lfs_batch_error: dict):
+    """validates response from the LFS batch endpoint"""
+    if not (isinstance(lfs_batch_error.get("oid"), str) and isinstance(lfs_batch_error.get("size"), int)):
+        raise ValueError("lfs_batch_error is improperly formatted")
+    error_info = lfs_batch_error.get("error")
+    if not (
+        isinstance(error_info, dict)
+        and isinstance(error_info.get("message"), str)
+        and isinstance(error_info.get("code"), int)
+    ):
+        raise ValueError("lfs_batch_error is improperly formatted")
+    return lfs_batch_error
+
+
+def _upload_single_part(operation: "CommitOperationAdd", upload_url: str) -> None:
+    """
+    Uploads `fileobj` as a single PUT HTTP request (basic LFS transfer protocol)
+
+    Args:
+        upload_url (`str`):
+            The URL to PUT the file to.
+        fileobj:
+            The file-like object holding the data to upload.
+
+    Returns: `requests.Response`
+
+    Raises: `requests.HTTPError` if the upload resulted in an error
+    """
+    with operation.as_file(with_tqdm=True) as fileobj:
+        # S3 might raise a transient 500 error -> let's retry if that happens
+        response = http_backoff("PUT", upload_url, data=fileobj, retry_on_status_codes=(500, 503))
+        hf_raise_for_status(response)
+
+
+def _upload_multi_part(operation: "CommitOperationAdd", header: Dict, chunk_size: int, upload_url: str) -> None:
+    """
+    Uploads file using HF multipart LFS transfer protocol.
+    """
+    # 1. Get upload URLs for each part
+    sorted_parts_urls = _get_sorted_parts_urls(header=header, upload_info=operation.upload_info, chunk_size=chunk_size)
+
+    # 2. Upload parts (either with hf_transfer or in pure Python)
+    use_hf_transfer = HF_HUB_ENABLE_HF_TRANSFER
+    if (
+        HF_HUB_ENABLE_HF_TRANSFER
+        and not isinstance(operation.path_or_fileobj, str)
+        and not isinstance(operation.path_or_fileobj, Path)
+    ):
+        warnings.warn(
+            "hf_transfer is enabled but does not support uploading from bytes or BinaryIO, falling back to regular"
+            " upload"
+        )
+        use_hf_transfer = False
+
+    response_headers = (
+        _upload_parts_hf_transfer(operation=operation, sorted_parts_urls=sorted_parts_urls, chunk_size=chunk_size)
+        if use_hf_transfer
+        else _upload_parts_iteratively(operation=operation, sorted_parts_urls=sorted_parts_urls, chunk_size=chunk_size)
+    )
+
+    # 3. Send completion request
+    completion_res = get_session().post(
+        upload_url,
+        json=_get_completion_payload(response_headers, operation.upload_info.sha256.hex()),
+        headers=LFS_HEADERS,
+    )
+    hf_raise_for_status(completion_res)
+
+
+def _get_sorted_parts_urls(header: Dict, upload_info: UploadInfo, chunk_size: int) -> List[str]:
+    sorted_part_upload_urls = [
+        upload_url
+        for _, upload_url in sorted(
+            [
+                (int(part_num, 10), upload_url)
+                for part_num, upload_url in header.items()
+                if part_num.isdigit() and len(part_num) > 0
+            ],
+            key=lambda t: t[0],
+        )
+    ]
+    num_parts = len(sorted_part_upload_urls)
+    if num_parts != ceil(upload_info.size / chunk_size):
+        raise ValueError("Invalid server response to upload large LFS file")
+    return sorted_part_upload_urls
+
+
+def _get_completion_payload(response_headers: List[Dict], oid: str) -> CompletionPayloadT:
+    parts: List[PayloadPartT] = []
+    for part_number, header in enumerate(response_headers):
+        etag = header.get("etag")
+        if etag is None or etag == "":
+            raise ValueError(f"Invalid etag (`{etag}`) returned for part {part_number + 1}")
+        parts.append(
+            {
+                "partNumber": part_number + 1,
+                "etag": etag,
+            }
+        )
+    return {"oid": oid, "parts": parts}
+
+
+def _upload_parts_iteratively(
+    operation: "CommitOperationAdd", sorted_parts_urls: List[str], chunk_size: int
+) -> List[Dict]:
+    headers = []
+    with operation.as_file(with_tqdm=True) as fileobj:
+        for part_idx, part_upload_url in enumerate(sorted_parts_urls):
+            with SliceFileObj(
+                fileobj,
+                seek_from=chunk_size * part_idx,
+                read_limit=chunk_size,
+            ) as fileobj_slice:
+                # S3 might raise a transient 500 error -> let's retry if that happens
+                part_upload_res = http_backoff(
+                    "PUT", part_upload_url, data=fileobj_slice, retry_on_status_codes=(500, 503)
+                )
+                hf_raise_for_status(part_upload_res)
+                headers.append(part_upload_res.headers)
+    return headers  # type: ignore
+
+
+def _upload_parts_hf_transfer(
+    operation: "CommitOperationAdd", sorted_parts_urls: List[str], chunk_size: int
+) -> List[Dict]:
+    # Upload file using an external Rust-based package. Upload is faster but support less features (no progress bars).
+    try:
+        from hf_transfer import multipart_upload
+    except ImportError:
+        raise ValueError(
+            "Fast uploading using 'hf_transfer' is enabled (HF_HUB_ENABLE_HF_TRANSFER=1) but 'hf_transfer' package is"
+            " not available in your environment. Try `pip install hf_transfer`."
+        )
+
+    supports_callback = "callback" in inspect.signature(multipart_upload).parameters
+    if not supports_callback:
+        warnings.warn(
+            "You are using an outdated version of `hf_transfer`. Consider upgrading to latest version to enable progress bars using `pip install -U hf_transfer`."
+        )
+
+    total = operation.upload_info.size
+    desc = operation.path_in_repo
+    if len(desc) > 40:
+        desc = f"(…){desc[-40:]}"
+    disable = bool(logger.getEffectiveLevel() == logging.NOTSET)
+
+    with tqdm(unit="B", unit_scale=True, total=total, initial=0, desc=desc, disable=disable) as progress:
+        try:
+            output = multipart_upload(
+                file_path=operation.path_or_fileobj,
+                parts_urls=sorted_parts_urls,
+                chunk_size=chunk_size,
+                max_files=128,
+                parallel_failures=127,  # could be removed
+                max_retries=5,
+                **({"callback": progress.update} if supports_callback else {}),
+            )
+        except Exception as e:
+            raise RuntimeError(
+                "An error occurred while uploading using `hf_transfer`. Consider disabling HF_HUB_ENABLE_HF_TRANSFER for"
+                " better error handling."
+            ) from e
+        if not supports_callback:
+            progress.update(total)
+        return output
+
+
+class SliceFileObj(AbstractContextManager):
+    """
+    Utility context manager to read a *slice* of a seekable file-like object as a seekable, file-like object.
+
+    This is NOT thread safe
+
+    Inspired by stackoverflow.com/a/29838711/593036
+
+    Credits to @julien-c
+
+    Args:
+        fileobj (`BinaryIO`):
+            A file-like object to slice. MUST implement `tell()` and `seek()` (and `read()` of course).
+            `fileobj` will be reset to its original position when exiting the context manager.
+        seek_from (`int`):
+            The start of the slice (offset from position 0 in bytes).
+        read_limit (`int`):
+            The maximum number of bytes to read from the slice.
+
+    Attributes:
+        previous_position (`int`):
+            The previous position
+
+    Examples:
+
+    Reading 200 bytes with an offset of 128 bytes from a file (ie bytes 128 to 327):
+    ```python
+    >>> with open("path/to/file", "rb") as file:
+    ...     with SliceFileObj(file, seek_from=128, read_limit=200) as fslice:
+    ...         fslice.read(...)
+    ```
+
+    Reading a file in chunks of 512 bytes
+    ```python
+    >>> import os
+    >>> chunk_size = 512
+    >>> file_size = os.getsize("path/to/file")
+    >>> with open("path/to/file", "rb") as file:
+    ...     for chunk_idx in range(ceil(file_size / chunk_size)):
+    ...         with SliceFileObj(file, seek_from=chunk_idx * chunk_size, read_limit=chunk_size) as fslice:
+    ...             chunk = fslice.read(...)
+
+    ```
+    """
+
+    def __init__(self, fileobj: BinaryIO, seek_from: int, read_limit: int):
+        self.fileobj = fileobj
+        self.seek_from = seek_from
+        self.read_limit = read_limit
+
+    def __enter__(self):
+        self._previous_position = self.fileobj.tell()
+        end_of_stream = self.fileobj.seek(0, os.SEEK_END)
+        self._len = min(self.read_limit, end_of_stream - self.seek_from)
+        # ^^ The actual number of bytes that can be read from the slice
+        self.fileobj.seek(self.seek_from, io.SEEK_SET)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.fileobj.seek(self._previous_position, io.SEEK_SET)
+
+    def read(self, n: int = -1):
+        pos = self.tell()
+        if pos >= self._len:
+            return b""
+        remaining_amount = self._len - pos
+        data = self.fileobj.read(remaining_amount if n < 0 else min(n, remaining_amount))
+        return data
+
+    def tell(self) -> int:
+        return self.fileobj.tell() - self.seek_from
+
+    def seek(self, offset: int, whence: int = os.SEEK_SET) -> int:
+        start = self.seek_from
+        end = start + self._len
+        if whence in (os.SEEK_SET, os.SEEK_END):
+            offset = start + offset if whence == os.SEEK_SET else end + offset
+            offset = max(start, min(offset, end))
+            whence = os.SEEK_SET
+        elif whence == os.SEEK_CUR:
+            cur_pos = self.fileobj.tell()
+            offset = max(start - cur_pos, min(offset, end - cur_pos))
+        else:
+            raise ValueError(f"whence value {whence} is not supported")
+        return self.fileobj.seek(offset, whence) - self.seek_from
+
+    def __iter__(self):
+        yield self.read(n=4 * 1024 * 1024)
diff --git a/lib/python3.11/site-packages/huggingface_hub/repocard.py b/lib/python3.11/site-packages/huggingface_hub/repocard.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6bbe96d5a8b922bd0691dac83393bb2f0f51a75
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/repocard.py
@@ -0,0 +1,818 @@
+import os
+import re
+import warnings
+from pathlib import Path
+from typing import Any, Dict, Literal, Optional, Type, Union
+
+import requests
+import yaml
+
+from huggingface_hub.file_download import hf_hub_download
+from huggingface_hub.hf_api import upload_file
+from huggingface_hub.repocard_data import (
+    CardData,
+    DatasetCardData,
+    EvalResult,
+    ModelCardData,
+    SpaceCardData,
+    eval_results_to_model_index,
+    model_index_to_eval_results,
+)
+from huggingface_hub.utils import get_session, is_jinja_available, yaml_dump
+
+from .constants import REPOCARD_NAME
+from .utils import EntryNotFoundError, SoftTemporaryDirectory, validate_hf_hub_args
+
+
+TEMPLATE_MODELCARD_PATH = Path(__file__).parent / "templates" / "modelcard_template.md"
+TEMPLATE_DATASETCARD_PATH = Path(__file__).parent / "templates" / "datasetcard_template.md"
+
+# exact same regex as in the Hub server. Please keep in sync.
+# See https://github.com/huggingface/moon-landing/blob/main/server/lib/ViewMarkdown.ts#L18
+REGEX_YAML_BLOCK = re.compile(r"^(\s*---[\r\n]+)([\S\s]*?)([\r\n]+---(\r\n|\n|$))")
+
+
+class RepoCard:
+    card_data_class = CardData
+    default_template_path = TEMPLATE_MODELCARD_PATH
+    repo_type = "model"
+
+    def __init__(self, content: str, ignore_metadata_errors: bool = False):
+        """Initialize a RepoCard from string content. The content should be a
+        Markdown file with a YAML block at the beginning and a Markdown body.
+
+        Args:
+            content (`str`): The content of the Markdown file.
+
+        Example:
+            ```python
+            >>> from huggingface_hub.repocard import RepoCard
+            >>> text = '''
+            ... ---
+            ... language: en
+            ... license: mit
+            ... ---
+            ...
+            ... # My repo
+            ... '''
+            >>> card = RepoCard(text)
+            >>> card.data.to_dict()
+            {'language': 'en', 'license': 'mit'}
+            >>> card.text
+            '\\n# My repo\\n'
+
+            ```
+        <Tip>
+        Raises the following error:
+
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              when the content of the repo card metadata is not a dictionary.
+
+        </Tip>
+        """
+
+        # Set the content of the RepoCard, as well as underlying .data and .text attributes.
+        # See the `content` property setter for more details.
+        self.ignore_metadata_errors = ignore_metadata_errors
+        self.content = content
+
+    @property
+    def content(self):
+        """The content of the RepoCard, including the YAML block and the Markdown body."""
+        line_break = _detect_line_ending(self._content) or "\n"
+        return f"---{line_break}{self.data.to_yaml(line_break=line_break)}{line_break}---{line_break}{self.text}"
+
+    @content.setter
+    def content(self, content: str):
+        """Set the content of the RepoCard."""
+        self._content = content
+
+        match = REGEX_YAML_BLOCK.search(content)
+        if match:
+            # Metadata found in the YAML block
+            yaml_block = match.group(2)
+            self.text = content[match.end() :]
+            data_dict = yaml.safe_load(yaml_block)
+
+            if data_dict is None:
+                data_dict = {}
+
+            # The YAML block's data should be a dictionary
+            if not isinstance(data_dict, dict):
+                raise ValueError("repo card metadata block should be a dict")
+        else:
+            # Model card without metadata... create empty metadata
+            warnings.warn("Repo card metadata block was not found. Setting CardData to empty.")
+            data_dict = {}
+            self.text = content
+
+        self.data = self.card_data_class(**data_dict, ignore_metadata_errors=self.ignore_metadata_errors)
+
+    def __str__(self):
+        return self.content
+
+    def save(self, filepath: Union[Path, str]):
+        r"""Save a RepoCard to a file.
+
+        Args:
+            filepath (`Union[Path, str]`): Filepath to the markdown file to save.
+
+        Example:
+            ```python
+            >>> from huggingface_hub.repocard import RepoCard
+            >>> card = RepoCard("---\nlanguage: en\n---\n# This is a test repo card")
+            >>> card.save("/tmp/test.md")
+
+            ```
+        """
+        filepath = Path(filepath)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        # Preserve newlines as in the existing file.
+        with open(filepath, mode="w", newline="", encoding="utf-8") as f:
+            f.write(str(self))
+
+    @classmethod
+    def load(
+        cls,
+        repo_id_or_path: Union[str, Path],
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+        ignore_metadata_errors: bool = False,
+    ):
+        """Initialize a RepoCard from a Hugging Face Hub repo's README.md or a local filepath.
+
+        Args:
+            repo_id_or_path (`Union[str, Path]`):
+                The repo ID associated with a Hugging Face Hub repo or a local filepath.
+            repo_type (`str`, *optional*):
+                The type of Hugging Face repo to push to. Defaults to None, which will use use "model". Other options
+                are "dataset" and "space". Not used when loading from a local filepath. If this is called from a child
+                class, the default value will be the child class's `repo_type`.
+            token (`str`, *optional*):
+                Authentication token, obtained with `huggingface_hub.HfApi.login` method. Will default to the stored token.
+            ignore_metadata_errors (`str`):
+                If True, errors while parsing the metadata section will be ignored. Some information might be lost during
+                the process. Use it at your own risk.
+
+        Returns:
+            [`huggingface_hub.repocard.RepoCard`]: The RepoCard (or subclass) initialized from the repo's
+                README.md file or filepath.
+
+        Example:
+            ```python
+            >>> from huggingface_hub.repocard import RepoCard
+            >>> card = RepoCard.load("nateraw/food")
+            >>> assert card.data.tags == ["generated_from_trainer", "image-classification", "pytorch"]
+
+            ```
+        """
+
+        if Path(repo_id_or_path).exists():
+            card_path = Path(repo_id_or_path)
+        elif isinstance(repo_id_or_path, str):
+            card_path = Path(
+                hf_hub_download(
+                    repo_id_or_path,
+                    REPOCARD_NAME,
+                    repo_type=repo_type or cls.repo_type,
+                    token=token,
+                )
+            )
+        else:
+            raise ValueError(f"Cannot load RepoCard: path not found on disk ({repo_id_or_path}).")
+
+        # Preserve newlines in the existing file.
+        with card_path.open(mode="r", newline="", encoding="utf-8") as f:
+            return cls(f.read(), ignore_metadata_errors=ignore_metadata_errors)
+
+    def validate(self, repo_type: Optional[str] = None):
+        """Validates card against Hugging Face Hub's card validation logic.
+        Using this function requires access to the internet, so it is only called
+        internally by [`huggingface_hub.repocard.RepoCard.push_to_hub`].
+
+        Args:
+            repo_type (`str`, *optional*, defaults to "model"):
+                The type of Hugging Face repo to push to. Options are "model", "dataset", and "space".
+                If this function is called from a child class, the default will be the child class's `repo_type`.
+
+        <Tip>
+        Raises the following errors:
+
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if the card fails validation checks.
+            - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+              if the request to the Hub API fails for any other reason.
+
+        </Tip>
+        """
+
+        # If repo type is provided, otherwise, use the repo type of the card.
+        repo_type = repo_type or self.repo_type
+
+        body = {
+            "repoType": repo_type,
+            "content": str(self),
+        }
+        headers = {"Accept": "text/plain"}
+
+        try:
+            r = get_session().post("https://huggingface.co/api/validate-yaml", body, headers=headers)
+            r.raise_for_status()
+        except requests.exceptions.HTTPError as exc:
+            if r.status_code == 400:
+                raise ValueError(r.text)
+            else:
+                raise exc
+
+    def push_to_hub(
+        self,
+        repo_id: str,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+    ):
+        """Push a RepoCard to a Hugging Face Hub repo.
+
+        Args:
+            repo_id (`str`):
+                The repo ID of the Hugging Face Hub repo to push to. Example: "nateraw/food".
+            token (`str`, *optional*):
+                Authentication token, obtained with `huggingface_hub.HfApi.login` method. Will default to
+                the stored token.
+            repo_type (`str`, *optional*, defaults to "model"):
+                The type of Hugging Face repo to push to. Options are "model", "dataset", and "space". If this
+                function is called by a child class, it will default to the child class's `repo_type`.
+            commit_message (`str`, *optional*):
+                The summary / title / first line of the generated commit.
+            commit_description (`str`, *optional*)
+                The description of the generated commit.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            create_pr (`bool`, *optional*):
+                Whether or not to create a Pull Request with this commit. Defaults to `False`.
+            parent_commit (`str`, *optional*):
+                The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+                If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+                If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+                Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+                especially useful if the repo is updated / committed to concurrently.
+        Returns:
+            `str`: URL of the commit which updated the card metadata.
+        """
+
+        # If repo type is provided, otherwise, use the repo type of the card.
+        repo_type = repo_type or self.repo_type
+
+        # Validate card before pushing to hub
+        self.validate(repo_type=repo_type)
+
+        with SoftTemporaryDirectory() as tmpdir:
+            tmp_path = Path(tmpdir) / REPOCARD_NAME
+            tmp_path.write_text(str(self))
+            url = upload_file(
+                path_or_fileobj=str(tmp_path),
+                path_in_repo=REPOCARD_NAME,
+                repo_id=repo_id,
+                token=token,
+                repo_type=repo_type,
+                commit_message=commit_message,
+                commit_description=commit_description,
+                create_pr=create_pr,
+                revision=revision,
+                parent_commit=parent_commit,
+            )
+        return url
+
+    @classmethod
+    def from_template(
+        cls,
+        card_data: CardData,
+        template_path: Optional[str] = None,
+        **template_kwargs,
+    ):
+        """Initialize a RepoCard from a template. By default, it uses the default template.
+
+        Templates are Jinja2 templates that can be customized by passing keyword arguments.
+
+        Args:
+            card_data (`huggingface_hub.CardData`):
+                A huggingface_hub.CardData instance containing the metadata you want to include in the YAML
+                header of the repo card on the Hugging Face Hub.
+            template_path (`str`, *optional*):
+                A path to a markdown file with optional Jinja template variables that can be filled
+                in with `template_kwargs`. Defaults to the default template.
+
+        Returns:
+            [`huggingface_hub.repocard.RepoCard`]: A RepoCard instance with the specified card data and content from the
+            template.
+        """
+        if is_jinja_available():
+            import jinja2
+        else:
+            raise ImportError(
+                "Using RepoCard.from_template requires Jinja2 to be installed. Please"
+                " install it with `pip install Jinja2`."
+            )
+
+        kwargs = card_data.to_dict().copy()
+        kwargs.update(template_kwargs)  # Template_kwargs have priority
+        template = jinja2.Template(Path(template_path or cls.default_template_path).read_text())
+        content = template.render(card_data=card_data.to_yaml(), **kwargs)
+        return cls(content)
+
+
+class ModelCard(RepoCard):
+    card_data_class = ModelCardData
+    default_template_path = TEMPLATE_MODELCARD_PATH
+    repo_type = "model"
+
+    @classmethod
+    def from_template(  # type: ignore # violates Liskov property but easier to use
+        cls,
+        card_data: ModelCardData,
+        template_path: Optional[str] = None,
+        **template_kwargs,
+    ):
+        """Initialize a ModelCard from a template. By default, it uses the default template, which can be found here:
+        https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/modelcard_template.md
+
+        Templates are Jinja2 templates that can be customized by passing keyword arguments.
+
+        Args:
+            card_data (`huggingface_hub.ModelCardData`):
+                A huggingface_hub.ModelCardData instance containing the metadata you want to include in the YAML
+                header of the model card on the Hugging Face Hub.
+            template_path (`str`, *optional*):
+                A path to a markdown file with optional Jinja template variables that can be filled
+                in with `template_kwargs`. Defaults to the default template.
+
+        Returns:
+            [`huggingface_hub.ModelCard`]: A ModelCard instance with the specified card data and content from the
+            template.
+
+        Example:
+            ```python
+            >>> from huggingface_hub import ModelCard, ModelCardData, EvalResult
+
+            >>> # Using the Default Template
+            >>> card_data = ModelCardData(
+            ...     language='en',
+            ...     license='mit',
+            ...     library_name='timm',
+            ...     tags=['image-classification', 'resnet'],
+            ...     datasets=['beans'],
+            ...     metrics=['accuracy'],
+            ... )
+            >>> card = ModelCard.from_template(
+            ...     card_data,
+            ...     model_description='This model does x + y...'
+            ... )
+
+            >>> # Including Evaluation Results
+            >>> card_data = ModelCardData(
+            ...     language='en',
+            ...     tags=['image-classification', 'resnet'],
+            ...     eval_results=[
+            ...         EvalResult(
+            ...             task_type='image-classification',
+            ...             dataset_type='beans',
+            ...             dataset_name='Beans',
+            ...             metric_type='accuracy',
+            ...             metric_value=0.9,
+            ...         ),
+            ...     ],
+            ...     model_name='my-cool-model',
+            ... )
+            >>> card = ModelCard.from_template(card_data)
+
+            >>> # Using a Custom Template
+            >>> card_data = ModelCardData(
+            ...     language='en',
+            ...     tags=['image-classification', 'resnet']
+            ... )
+            >>> card = ModelCard.from_template(
+            ...     card_data=card_data,
+            ...     template_path='./src/huggingface_hub/templates/modelcard_template.md',
+            ...     custom_template_var='custom value',  # will be replaced in template if it exists
+            ... )
+
+            ```
+        """
+        return super().from_template(card_data, template_path, **template_kwargs)
+
+
+class DatasetCard(RepoCard):
+    card_data_class = DatasetCardData
+    default_template_path = TEMPLATE_DATASETCARD_PATH
+    repo_type = "dataset"
+
+    @classmethod
+    def from_template(  # type: ignore # violates Liskov property but easier to use
+        cls,
+        card_data: DatasetCardData,
+        template_path: Optional[str] = None,
+        **template_kwargs,
+    ):
+        """Initialize a DatasetCard from a template. By default, it uses the default template, which can be found here:
+        https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/datasetcard_template.md
+
+        Templates are Jinja2 templates that can be customized by passing keyword arguments.
+
+        Args:
+            card_data (`huggingface_hub.DatasetCardData`):
+                A huggingface_hub.DatasetCardData instance containing the metadata you want to include in the YAML
+                header of the dataset card on the Hugging Face Hub.
+            template_path (`str`, *optional*):
+                A path to a markdown file with optional Jinja template variables that can be filled
+                in with `template_kwargs`. Defaults to the default template.
+
+        Returns:
+            [`huggingface_hub.DatasetCard`]: A DatasetCard instance with the specified card data and content from the
+            template.
+
+        Example:
+            ```python
+            >>> from huggingface_hub import DatasetCard, DatasetCardData
+
+            >>> # Using the Default Template
+            >>> card_data = DatasetCardData(
+            ...     language='en',
+            ...     license='mit',
+            ...     annotations_creators='crowdsourced',
+            ...     task_categories=['text-classification'],
+            ...     task_ids=['sentiment-classification', 'text-scoring'],
+            ...     multilinguality='monolingual',
+            ...     pretty_name='My Text Classification Dataset',
+            ... )
+            >>> card = DatasetCard.from_template(
+            ...     card_data,
+            ...     pretty_name=card_data.pretty_name,
+            ... )
+
+            >>> # Using a Custom Template
+            >>> card_data = DatasetCardData(
+            ...     language='en',
+            ...     license='mit',
+            ... )
+            >>> card = DatasetCard.from_template(
+            ...     card_data=card_data,
+            ...     template_path='./src/huggingface_hub/templates/datasetcard_template.md',
+            ...     custom_template_var='custom value',  # will be replaced in template if it exists
+            ... )
+
+            ```
+        """
+        return super().from_template(card_data, template_path, **template_kwargs)
+
+
+class SpaceCard(RepoCard):
+    card_data_class = SpaceCardData
+    default_template_path = TEMPLATE_MODELCARD_PATH
+    repo_type = "space"
+
+
+def _detect_line_ending(content: str) -> Literal["\r", "\n", "\r\n", None]:  # noqa: F722
+    """Detect the line ending of a string. Used by RepoCard to avoid making huge diff on newlines.
+
+    Uses same implementation as in Hub server, keep it in sync.
+
+    Returns:
+        str: The detected line ending of the string.
+    """
+    cr = content.count("\r")
+    lf = content.count("\n")
+    crlf = content.count("\r\n")
+    if cr + lf == 0:
+        return None
+    if crlf == cr and crlf == lf:
+        return "\r\n"
+    if cr > lf:
+        return "\r"
+    else:
+        return "\n"
+
+
+def metadata_load(local_path: Union[str, Path]) -> Optional[Dict]:
+    content = Path(local_path).read_text()
+    match = REGEX_YAML_BLOCK.search(content)
+    if match:
+        yaml_block = match.group(2)
+        data = yaml.safe_load(yaml_block)
+        if data is None or isinstance(data, dict):
+            return data
+        raise ValueError("repo card metadata block should be a dict")
+    else:
+        return None
+
+
+def metadata_save(local_path: Union[str, Path], data: Dict) -> None:
+    """
+    Save the metadata dict in the upper YAML part Trying to preserve newlines as
+    in the existing file. Docs about open() with newline="" parameter:
+    https://docs.python.org/3/library/functions.html?highlight=open#open Does
+    not work with "^M" linebreaks, which are replaced by \n
+    """
+    line_break = "\n"
+    content = ""
+    # try to detect existing newline character
+    if os.path.exists(local_path):
+        with open(local_path, "r", newline="", encoding="utf8") as readme:
+            content = readme.read()
+            if isinstance(readme.newlines, tuple):
+                line_break = readme.newlines[0]
+            elif isinstance(readme.newlines, str):
+                line_break = readme.newlines
+
+    # creates a new file if it not
+    with open(local_path, "w", newline="", encoding="utf8") as readme:
+        data_yaml = yaml_dump(data, sort_keys=False, line_break=line_break)
+        # sort_keys: keep dict order
+        match = REGEX_YAML_BLOCK.search(content)
+        if match:
+            output = content[: match.start()] + f"---{line_break}{data_yaml}---{line_break}" + content[match.end() :]
+        else:
+            output = f"---{line_break}{data_yaml}---{line_break}{content}"
+
+        readme.write(output)
+        readme.close()
+
+
+def metadata_eval_result(
+    *,
+    model_pretty_name: str,
+    task_pretty_name: str,
+    task_id: str,
+    metrics_pretty_name: str,
+    metrics_id: str,
+    metrics_value: Any,
+    dataset_pretty_name: str,
+    dataset_id: str,
+    metrics_config: Optional[str] = None,
+    metrics_verified: bool = False,
+    dataset_config: Optional[str] = None,
+    dataset_split: Optional[str] = None,
+    dataset_revision: Optional[str] = None,
+    metrics_verification_token: Optional[str] = None,
+) -> Dict:
+    """
+    Creates a metadata dict with the result from a model evaluated on a dataset.
+
+    Args:
+        model_pretty_name (`str`):
+            The name of the model in natural language.
+        task_pretty_name (`str`):
+            The name of a task in natural language.
+        task_id (`str`):
+            Example: automatic-speech-recognition. A task id.
+        metrics_pretty_name (`str`):
+            A name for the metric in natural language. Example: Test WER.
+        metrics_id (`str`):
+            Example: wer. A metric id from https://hf.co/metrics.
+        metrics_value (`Any`):
+            The value from the metric. Example: 20.0 or "20.0 ± 1.2".
+        dataset_pretty_name (`str`):
+            The name of the dataset in natural language.
+        dataset_id (`str`):
+            Example: common_voice. A dataset id from https://hf.co/datasets.
+        metrics_config (`str`, *optional*):
+            The name of the metric configuration used in `load_metric()`.
+            Example: bleurt-large-512 in `load_metric("bleurt", "bleurt-large-512")`.
+        metrics_verified (`bool`, *optional*, defaults to `False`):
+            Indicates whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. Automatically computed by Hugging Face, do not set.
+        dataset_config (`str`, *optional*):
+            Example: fr. The name of the dataset configuration used in `load_dataset()`.
+        dataset_split (`str`, *optional*):
+            Example: test. The name of the dataset split used in `load_dataset()`.
+        dataset_revision (`str`, *optional*):
+            Example: 5503434ddd753f426f4b38109466949a1217c2bb. The name of the dataset dataset revision
+            used in `load_dataset()`.
+        metrics_verification_token (`bool`, *optional*):
+            A JSON Web Token that is used to verify whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not.
+
+    Returns:
+        `dict`: a metadata dict with the result from a model evaluated on a dataset.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import metadata_eval_result
+        >>> results = metadata_eval_result(
+        ...         model_pretty_name="RoBERTa fine-tuned on ReactionGIF",
+        ...         task_pretty_name="Text Classification",
+        ...         task_id="text-classification",
+        ...         metrics_pretty_name="Accuracy",
+        ...         metrics_id="accuracy",
+        ...         metrics_value=0.2662102282047272,
+        ...         dataset_pretty_name="ReactionJPEG",
+        ...         dataset_id="julien-c/reactionjpeg",
+        ...         dataset_config="default",
+        ...         dataset_split="test",
+        ... )
+        >>> results == {
+        ...     'model-index': [
+        ...         {
+        ...             'name': 'RoBERTa fine-tuned on ReactionGIF',
+        ...             'results': [
+        ...                 {
+        ...                     'task': {
+        ...                         'type': 'text-classification',
+        ...                         'name': 'Text Classification'
+        ...                     },
+        ...                     'dataset': {
+        ...                         'name': 'ReactionJPEG',
+        ...                         'type': 'julien-c/reactionjpeg',
+        ...                         'config': 'default',
+        ...                         'split': 'test'
+        ...                     },
+        ...                     'metrics': [
+        ...                         {
+        ...                             'type': 'accuracy',
+        ...                             'value': 0.2662102282047272,
+        ...                             'name': 'Accuracy',
+        ...                             'verified': False
+        ...                         }
+        ...                     ]
+        ...                 }
+        ...             ]
+        ...         }
+        ...     ]
+        ... }
+        True
+
+        ```
+    """
+
+    return {
+        "model-index": eval_results_to_model_index(
+            model_name=model_pretty_name,
+            eval_results=[
+                EvalResult(
+                    task_name=task_pretty_name,
+                    task_type=task_id,
+                    metric_name=metrics_pretty_name,
+                    metric_type=metrics_id,
+                    metric_value=metrics_value,
+                    dataset_name=dataset_pretty_name,
+                    dataset_type=dataset_id,
+                    metric_config=metrics_config,
+                    verified=metrics_verified,
+                    verify_token=metrics_verification_token,
+                    dataset_config=dataset_config,
+                    dataset_split=dataset_split,
+                    dataset_revision=dataset_revision,
+                )
+            ],
+        )
+    }
+
+
+@validate_hf_hub_args
+def metadata_update(
+    repo_id: str,
+    metadata: Dict,
+    *,
+    repo_type: Optional[str] = None,
+    overwrite: bool = False,
+    token: Optional[str] = None,
+    commit_message: Optional[str] = None,
+    commit_description: Optional[str] = None,
+    revision: Optional[str] = None,
+    create_pr: bool = False,
+    parent_commit: Optional[str] = None,
+) -> str:
+    """
+    Updates the metadata in the README.md of a repository on the Hugging Face Hub.
+    If the README.md file doesn't exist yet, a new one is created with metadata and an
+    the default ModelCard or DatasetCard template. For `space` repo, an error is thrown
+    as a Space cannot exist without a `README.md` file.
+
+    Args:
+        repo_id (`str`):
+            The name of the repository.
+        metadata (`dict`):
+            A dictionary containing the metadata to be updated.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"` or `"space"` if updating to a dataset or space,
+            `None` or `"model"` if updating to a model. Default is `None`.
+        overwrite (`bool`, *optional*, defaults to `False`):
+            If set to `True` an existing field can be overwritten, otherwise
+            attempting to overwrite an existing field will cause an error.
+        token (`str`, *optional*):
+            The Hugging Face authentication token.
+        commit_message (`str`, *optional*):
+            The summary / title / first line of the generated commit. Defaults to
+            `f"Update metadata with huggingface_hub"`
+        commit_description (`str` *optional*)
+            The description of the generated commit
+        revision (`str`, *optional*):
+            The git revision to commit from. Defaults to the head of the
+            `"main"` branch.
+        create_pr (`boolean`, *optional*):
+            Whether or not to create a Pull Request from `revision` with that commit.
+            Defaults to `False`.
+        parent_commit (`str`, *optional*):
+            The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+            If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+            If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+            Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+            especially useful if the repo is updated / committed to concurrently.
+    Returns:
+        `str`: URL of the commit which updated the card metadata.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import metadata_update
+        >>> metadata = {'model-index': [{'name': 'RoBERTa fine-tuned on ReactionGIF',
+        ...             'results': [{'dataset': {'name': 'ReactionGIF',
+        ...                                      'type': 'julien-c/reactiongif'},
+        ...                           'metrics': [{'name': 'Recall',
+        ...                                        'type': 'recall',
+        ...                                        'value': 0.7762102282047272}],
+        ...                          'task': {'name': 'Text Classification',
+        ...                                   'type': 'text-classification'}}]}]}
+        >>> url = metadata_update("hf-internal-testing/reactiongif-roberta-card", metadata)
+
+        ```
+    """
+    commit_message = commit_message if commit_message is not None else "Update metadata with huggingface_hub"
+
+    # Card class given repo_type
+    card_class: Type[RepoCard]
+    if repo_type is None or repo_type == "model":
+        card_class = ModelCard
+    elif repo_type == "dataset":
+        card_class = DatasetCard
+    elif repo_type == "space":
+        card_class = RepoCard
+    else:
+        raise ValueError(f"Unknown repo_type: {repo_type}")
+
+    # Either load repo_card from the Hub or create an empty one.
+    # NOTE: Will not create the repo if it doesn't exist.
+    try:
+        card = card_class.load(repo_id, token=token, repo_type=repo_type)
+    except EntryNotFoundError:
+        if repo_type == "space":
+            raise ValueError("Cannot update metadata on a Space that doesn't contain a `README.md` file.")
+
+        # Initialize a ModelCard or DatasetCard from default template and no data.
+        card = card_class.from_template(CardData())
+
+    for key, value in metadata.items():
+        if key == "model-index":
+            # if the new metadata doesn't include a name, either use existing one or repo name
+            if "name" not in value[0]:
+                value[0]["name"] = getattr(card, "model_name", repo_id)
+            model_name, new_results = model_index_to_eval_results(value)
+            if card.data.eval_results is None:
+                card.data.eval_results = new_results
+                card.data.model_name = model_name
+            else:
+                existing_results = card.data.eval_results
+
+                # Iterate over new results
+                #   Iterate over existing results
+                #       If both results describe the same metric but value is different:
+                #           If overwrite=True: overwrite the metric value
+                #           Else: raise ValueError
+                #       Else: append new result to existing ones.
+                for new_result in new_results:
+                    result_found = False
+                    for existing_result in existing_results:
+                        if new_result.is_equal_except_value(existing_result):
+                            if new_result != existing_result and not overwrite:
+                                raise ValueError(
+                                    "You passed a new value for the existing metric"
+                                    f" 'name: {new_result.metric_name}, type: "
+                                    f"{new_result.metric_type}'. Set `overwrite=True`"
+                                    " to overwrite existing metrics."
+                                )
+                            result_found = True
+                            existing_result.metric_value = new_result.metric_value
+                            if existing_result.verified is True:
+                                existing_result.verify_token = new_result.verify_token
+                    if not result_found:
+                        card.data.eval_results.append(new_result)
+        else:
+            # Any metadata that is not a result metric
+            if card.data.get(key) is not None and not overwrite and card.data.get(key) != value:
+                raise ValueError(
+                    f"You passed a new value for the existing meta data field '{key}'."
+                    " Set `overwrite=True` to overwrite existing metadata."
+                )
+            else:
+                card.data[key] = value
+
+    return card.push_to_hub(
+        repo_id,
+        token=token,
+        repo_type=repo_type,
+        commit_message=commit_message,
+        commit_description=commit_description,
+        create_pr=create_pr,
+        revision=revision,
+        parent_commit=parent_commit,
+    )
diff --git a/lib/python3.11/site-packages/huggingface_hub/repocard_data.py b/lib/python3.11/site-packages/huggingface_hub/repocard_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc6d5426d2695c5055e3024044fab0d841376616
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/repocard_data.py
@@ -0,0 +1,711 @@
+import copy
+import warnings
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from huggingface_hub.utils import yaml_dump
+
+
+@dataclass
+class EvalResult:
+    """
+    Flattened representation of individual evaluation results found in model-index of Model Cards.
+
+    For more information on the model-index spec, see https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1.
+
+    Args:
+        task_type (`str`):
+            The task identifier. Example: "image-classification".
+        dataset_type (`str`):
+            The dataset identifier. Example: "common_voice". Use dataset id from https://hf.co/datasets.
+        dataset_name (`str`):
+            A pretty name for the dataset. Example: "Common Voice (French)".
+        metric_type (`str`):
+            The metric identifier. Example: "wer". Use metric id from https://hf.co/metrics.
+        metric_value (`Any`):
+            The metric value. Example: 0.9 or "20.0 ± 1.2".
+        task_name (`str`, *optional*):
+            A pretty name for the task. Example: "Speech Recognition".
+        dataset_config (`str`, *optional*):
+            The name of the dataset configuration used in `load_dataset()`.
+            Example: fr in `load_dataset("common_voice", "fr")`. See the `datasets` docs for more info:
+            https://hf.co/docs/datasets/package_reference/loading_methods#datasets.load_dataset.name
+        dataset_split (`str`, *optional*):
+            The split used in `load_dataset()`. Example: "test".
+        dataset_revision (`str`, *optional*):
+            The revision (AKA Git Sha) of the dataset used in `load_dataset()`.
+            Example: 5503434ddd753f426f4b38109466949a1217c2bb
+        dataset_args (`Dict[str, Any]`, *optional*):
+            The arguments passed during `Metric.compute()`. Example for `bleu`: `{"max_order": 4}`
+        metric_name (`str`, *optional*):
+            A pretty name for the metric. Example: "Test WER".
+        metric_config (`str`, *optional*):
+            The name of the metric configuration used in `load_metric()`.
+            Example: bleurt-large-512 in `load_metric("bleurt", "bleurt-large-512")`.
+            See the `datasets` docs for more info: https://huggingface.co/docs/datasets/v2.1.0/en/loading#load-configurations
+        metric_args (`Dict[str, Any]`, *optional*):
+            The arguments passed during `Metric.compute()`. Example for `bleu`: max_order: 4
+        verified (`bool`, *optional*):
+            Indicates whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. Automatically computed by Hugging Face, do not set.
+        verify_token (`str`, *optional*):
+            A JSON Web Token that is used to verify whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not.
+        source_name (`str`, *optional*):
+            The name of the source of the evaluation result. Example: "Open LLM Leaderboard".
+        source_url (`str`, *optional*):
+            The URL of the source of the evaluation result. Example: "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard".
+    """
+
+    # Required
+
+    # The task identifier
+    # Example: automatic-speech-recognition
+    task_type: str
+
+    # The dataset identifier
+    # Example: common_voice. Use dataset id from https://hf.co/datasets
+    dataset_type: str
+
+    # A pretty name for the dataset.
+    # Example: Common Voice (French)
+    dataset_name: str
+
+    # The metric identifier
+    # Example: wer. Use metric id from https://hf.co/metrics
+    metric_type: str
+
+    # Value of the metric.
+    # Example: 20.0 or "20.0 ± 1.2"
+    metric_value: Any
+
+    # Optional
+
+    # A pretty name for the task.
+    # Example: Speech Recognition
+    task_name: Optional[str] = None
+
+    # The name of the dataset configuration used in `load_dataset()`.
+    # Example: fr in `load_dataset("common_voice", "fr")`.
+    # See the `datasets` docs for more info:
+    # https://huggingface.co/docs/datasets/package_reference/loading_methods#datasets.load_dataset.name
+    dataset_config: Optional[str] = None
+
+    # The split used in `load_dataset()`.
+    # Example: test
+    dataset_split: Optional[str] = None
+
+    # The revision (AKA Git Sha) of the dataset used in `load_dataset()`.
+    # Example: 5503434ddd753f426f4b38109466949a1217c2bb
+    dataset_revision: Optional[str] = None
+
+    # The arguments passed during `Metric.compute()`.
+    # Example for `bleu`: max_order: 4
+    dataset_args: Optional[Dict[str, Any]] = None
+
+    # A pretty name for the metric.
+    # Example: Test WER
+    metric_name: Optional[str] = None
+
+    # The name of the metric configuration used in `load_metric()`.
+    # Example: bleurt-large-512 in `load_metric("bleurt", "bleurt-large-512")`.
+    # See the `datasets` docs for more info: https://huggingface.co/docs/datasets/v2.1.0/en/loading#load-configurations
+    metric_config: Optional[str] = None
+
+    # The arguments passed during `Metric.compute()`.
+    # Example for `bleu`: max_order: 4
+    metric_args: Optional[Dict[str, Any]] = None
+
+    # Indicates whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. Automatically computed by Hugging Face, do not set.
+    verified: Optional[bool] = None
+
+    # A JSON Web Token that is used to verify whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not.
+    verify_token: Optional[str] = None
+
+    # The name of the source of the evaluation result.
+    # Example: Open LLM Leaderboard
+    source_name: Optional[str] = None
+
+    # The URL of the source of the evaluation result.
+    # Example: https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard
+    source_url: Optional[str] = None
+
+    @property
+    def unique_identifier(self) -> tuple:
+        """Returns a tuple that uniquely identifies this evaluation."""
+        return (
+            self.task_type,
+            self.dataset_type,
+            self.dataset_config,
+            self.dataset_split,
+            self.dataset_revision,
+        )
+
+    def is_equal_except_value(self, other: "EvalResult") -> bool:
+        """
+        Return True if `self` and `other` describe exactly the same metric but with a
+        different value.
+        """
+        for key, _ in self.__dict__.items():
+            if key == "metric_value":
+                continue
+            # For metrics computed by Hugging Face's evaluation service, `verify_token` is derived from `metric_value`,
+            # so we exclude it here in the comparison.
+            if key != "verify_token" and getattr(self, key) != getattr(other, key):
+                return False
+        return True
+
+    def __post_init__(self) -> None:
+        if self.source_name is not None and self.source_url is None:
+            raise ValueError("If `source_name` is provided, `source_url` must also be provided.")
+
+
+@dataclass
+class CardData:
+    """Structure containing metadata from a RepoCard.
+
+    [`CardData`] is the parent class of [`ModelCardData`] and [`DatasetCardData`].
+
+    Metadata can be exported as a dictionary or YAML. Export can be customized to alter the representation of the data
+    (example: flatten evaluation results). `CardData` behaves as a dictionary (can get, pop, set values) but do not
+    inherit from `dict` to allow this export step.
+    """
+
+    def __init__(self, ignore_metadata_errors: bool = False, **kwargs):
+        self.__dict__.update(kwargs)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Converts CardData to a dict.
+
+        Returns:
+            `dict`: CardData represented as a dictionary ready to be dumped to a YAML
+            block for inclusion in a README.md file.
+        """
+
+        data_dict = copy.deepcopy(self.__dict__)
+        self._to_dict(data_dict)
+        return _remove_none(data_dict)
+
+    def _to_dict(self, data_dict):
+        """Use this method in child classes to alter the dict representation of the data. Alter the dict in-place.
+
+        Args:
+            data_dict (`dict`): The raw dict representation of the card data.
+        """
+        pass
+
+    def to_yaml(self, line_break=None) -> str:
+        """Dumps CardData to a YAML block for inclusion in a README.md file.
+
+        Args:
+            line_break (str, *optional*):
+                The line break to use when dumping to yaml.
+
+        Returns:
+            `str`: CardData represented as a YAML block.
+        """
+        return yaml_dump(self.to_dict(), sort_keys=False, line_break=line_break).strip()
+
+    def __repr__(self):
+        return repr(self.__dict__)
+
+    def __str__(self):
+        return self.to_yaml()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get value for a given metadata key."""
+        return self.__dict__.get(key, default)
+
+    def pop(self, key: str, default: Any = None) -> Any:
+        """Pop value for a given metadata key."""
+        return self.__dict__.pop(key, default)
+
+    def __getitem__(self, key: str) -> Any:
+        """Get value for a given metadata key."""
+        return self.__dict__[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """Set value for a given metadata key."""
+        self.__dict__[key] = value
+
+    def __contains__(self, key: str) -> bool:
+        """Check if a given metadata key is set."""
+        return key in self.__dict__
+
+    def __len__(self) -> int:
+        """Return the number of metadata keys set."""
+        return len(self.__dict__)
+
+
+class ModelCardData(CardData):
+    """Model Card Metadata that is used by Hugging Face Hub when included at the top of your README.md
+
+    Args:
+        language (`Union[str, List[str]]`, *optional*):
+            Language of model's training data or metadata. It must be an ISO 639-1, 639-2 or
+            639-3 code (two/three letters), or a special value like "code", "multilingual". Defaults to `None`.
+        license (`str`, *optional*):
+            License of this model. Example: apache-2.0 or any license from
+            https://huggingface.co/docs/hub/repositories-licenses. Defaults to None.
+        library_name (`str`, *optional*):
+            Name of library used by this model. Example: keras or any library from
+            https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/src/model-libraries.ts.
+            Defaults to None.
+        tags (`List[str]`, *optional*):
+            List of tags to add to your model that can be used when filtering on the Hugging
+            Face Hub. Defaults to None.
+        datasets (`List[str]`, *optional*):
+            List of datasets that were used to train this model. Should be a dataset ID
+            found on https://hf.co/datasets. Defaults to None.
+        metrics (`List[str]`, *optional*):
+            List of metrics used to evaluate this model. Should be a metric name that can be found
+            at https://hf.co/metrics. Example: 'accuracy'. Defaults to None.
+        eval_results (`Union[List[EvalResult], EvalResult]`, *optional*):
+            List of `huggingface_hub.EvalResult` that define evaluation results of the model. If provided,
+            `model_name` is used to as a name on PapersWithCode's leaderboards. Defaults to `None`.
+        model_name (`str`, *optional*):
+            A name for this model. It is used along with
+            `eval_results` to construct the `model-index` within the card's metadata. The name
+            you supply here is what will be used on PapersWithCode's leaderboards. If None is provided
+            then the repo name is used as a default. Defaults to None.
+        ignore_metadata_errors (`str`):
+            If True, errors while parsing the metadata section will be ignored. Some information might be lost during
+            the process. Use it at your own risk.
+        kwargs (`dict`, *optional*):
+            Additional metadata that will be added to the model card. Defaults to None.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import ModelCardData
+        >>> card_data = ModelCardData(
+        ...     language="en",
+        ...     license="mit",
+        ...     library_name="timm",
+        ...     tags=['image-classification', 'resnet'],
+        ... )
+        >>> card_data.to_dict()
+        {'language': 'en', 'license': 'mit', 'library_name': 'timm', 'tags': ['image-classification', 'resnet']}
+
+        ```
+    """
+
+    def __init__(
+        self,
+        *,
+        language: Optional[Union[str, List[str]]] = None,
+        license: Optional[str] = None,
+        library_name: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        datasets: Optional[List[str]] = None,
+        metrics: Optional[List[str]] = None,
+        eval_results: Optional[List[EvalResult]] = None,
+        model_name: Optional[str] = None,
+        ignore_metadata_errors: bool = False,
+        **kwargs,
+    ):
+        self.language = language
+        self.license = license
+        self.library_name = library_name
+        self.tags = tags
+        self.datasets = datasets
+        self.metrics = metrics
+        self.eval_results = eval_results
+        self.model_name = model_name
+
+        model_index = kwargs.pop("model-index", None)
+        if model_index:
+            try:
+                model_name, eval_results = model_index_to_eval_results(model_index)
+                self.model_name = model_name
+                self.eval_results = eval_results
+            except (KeyError, TypeError) as error:
+                if ignore_metadata_errors:
+                    warnings.warn("Invalid model-index. Not loading eval results into CardData.")
+                else:
+                    raise ValueError(
+                        f"Invalid `model_index` in metadata cannot be parsed: {error.__class__} {error}. Pass"
+                        " `ignore_metadata_errors=True` to ignore this error while loading a Model Card. Warning:"
+                        " some information will be lost. Use it at your own risk."
+                    )
+
+        super().__init__(**kwargs)
+
+        if self.eval_results:
+            if type(self.eval_results) == EvalResult:
+                self.eval_results = [self.eval_results]
+            if self.model_name is None:
+                raise ValueError("Passing `eval_results` requires `model_name` to be set.")
+
+    def _to_dict(self, data_dict):
+        """Format the internal data dict. In this case, we convert eval results to a valid model index"""
+        if self.eval_results is not None:
+            data_dict["model-index"] = eval_results_to_model_index(self.model_name, self.eval_results)
+            del data_dict["eval_results"], data_dict["model_name"]
+
+
+class DatasetCardData(CardData):
+    """Dataset Card Metadata that is used by Hugging Face Hub when included at the top of your README.md
+
+    Args:
+        language (`List[str]`, *optional*):
+            Language of dataset's data or metadata. It must be an ISO 639-1, 639-2 or
+            639-3 code (two/three letters), or a special value like "code", "multilingual".
+        license (`Union[str, List[str]]`, *optional*):
+            License(s) of this dataset. Example: apache-2.0 or any license from
+            https://huggingface.co/docs/hub/repositories-licenses.
+        annotations_creators (`Union[str, List[str]]`, *optional*):
+            How the annotations for the dataset were created.
+            Options are: 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'no-annotation', 'other'.
+        language_creators (`Union[str, List[str]]`, *optional*):
+            How the text-based data in the dataset was created.
+            Options are: 'found', 'crowdsourced', 'expert-generated', 'machine-generated', 'other'
+        multilinguality (`Union[str, List[str]]`, *optional*):
+            Whether the dataset is multilingual.
+            Options are: 'monolingual', 'multilingual', 'translation', 'other'.
+        size_categories (`Union[str, List[str]]`, *optional*):
+            The number of examples in the dataset. Options are: 'n<1K', '1K<n<10K', '10K<n<100K',
+            '100K<n<1M', '1M<n<10M', '10M<n<100M', '100M<n<1B', '1B<n<10B', '10B<n<100B', '100B<n<1T', 'n>1T', and 'other'.
+        source_datasets (`List[str]]`, *optional*):
+            Indicates whether the dataset is an original dataset or extended from another existing dataset.
+            Options are: 'original' and 'extended'.
+        task_categories (`Union[str, List[str]]`, *optional*):
+            What categories of task does the dataset support?
+        task_ids (`Union[str, List[str]]`, *optional*):
+            What specific tasks does the dataset support?
+        paperswithcode_id (`str`, *optional*):
+            ID of the dataset on PapersWithCode.
+        pretty_name (`str`, *optional*):
+            A more human-readable name for the dataset. (ex. "Cats vs. Dogs")
+        train_eval_index (`Dict`, *optional*):
+            A dictionary that describes the necessary spec for doing evaluation on the Hub.
+            If not provided, it will be gathered from the 'train-eval-index' key of the kwargs.
+        config_names (`Union[str, List[str]]`, *optional*):
+            A list of the available dataset configs for the dataset.
+    """
+
+    def __init__(
+        self,
+        *,
+        language: Optional[Union[str, List[str]]] = None,
+        license: Optional[Union[str, List[str]]] = None,
+        annotations_creators: Optional[Union[str, List[str]]] = None,
+        language_creators: Optional[Union[str, List[str]]] = None,
+        multilinguality: Optional[Union[str, List[str]]] = None,
+        size_categories: Optional[Union[str, List[str]]] = None,
+        source_datasets: Optional[List[str]] = None,
+        task_categories: Optional[Union[str, List[str]]] = None,
+        task_ids: Optional[Union[str, List[str]]] = None,
+        paperswithcode_id: Optional[str] = None,
+        pretty_name: Optional[str] = None,
+        train_eval_index: Optional[Dict] = None,
+        config_names: Optional[Union[str, List[str]]] = None,
+        ignore_metadata_errors: bool = False,
+        **kwargs,
+    ):
+        self.annotations_creators = annotations_creators
+        self.language_creators = language_creators
+        self.language = language
+        self.license = license
+        self.multilinguality = multilinguality
+        self.size_categories = size_categories
+        self.source_datasets = source_datasets
+        self.task_categories = task_categories
+        self.task_ids = task_ids
+        self.paperswithcode_id = paperswithcode_id
+        self.pretty_name = pretty_name
+        self.config_names = config_names
+
+        # TODO - maybe handle this similarly to EvalResult?
+        self.train_eval_index = train_eval_index or kwargs.pop("train-eval-index", None)
+        super().__init__(**kwargs)
+
+    def _to_dict(self, data_dict):
+        data_dict["train-eval-index"] = data_dict.pop("train_eval_index")
+
+
+class SpaceCardData(CardData):
+    """Space Card Metadata that is used by Hugging Face Hub when included at the top of your README.md
+
+    To get an exhaustive reference of Spaces configuration, please visit https://huggingface.co/docs/hub/spaces-config-reference#spaces-configuration-reference.
+
+    Args:
+        title (`str`, *optional*)
+            Title of the Space.
+        sdk (`str`, *optional*)
+            SDK of the Space (one of `gradio`, `streamlit`, `docker`, or `static`).
+        sdk_version (`str`, *optional*)
+            Version of the used SDK (if Gradio/Streamlit sdk).
+        python_version (`str`, *optional*)
+            Python version used in the Space (if Gradio/Streamlit sdk).
+        app_file (`str`, *optional*)
+            Path to your main application file (which contains either gradio or streamlit Python code, or static html code).
+            Path is relative to the root of the repository.
+        app_port (`str`, *optional*)
+            Port on which your application is running. Used only if sdk is `docker`.
+        license (`str`, *optional*)
+            License of this model. Example: apache-2.0 or any license from
+            https://huggingface.co/docs/hub/repositories-licenses.
+        duplicated_from (`str`, *optional*)
+            ID of the original Space if this is a duplicated Space.
+        models (List[`str`], *optional*)
+            List of models related to this Space. Should be a dataset ID found on https://hf.co/models.
+        datasets (`List[str]`, *optional*)
+            List of datasets related to this Space. Should be a dataset ID found on https://hf.co/datasets.
+        tags (`List[str]`, *optional*)
+            List of tags to add to your Space that can be used when filtering on the Hub.
+        ignore_metadata_errors (`str`):
+            If True, errors while parsing the metadata section will be ignored. Some information might be lost during
+            the process. Use it at your own risk.
+        kwargs (`dict`, *optional*):
+            Additional metadata that will be added to the space card.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import SpaceCardData
+        >>> card_data = SpaceCardData(
+        ...     title="Dreambooth Training",
+        ...     license="mit",
+        ...     sdk="gradio",
+        ...     duplicated_from="multimodalart/dreambooth-training"
+        ... )
+        >>> card_data.to_dict()
+        {'title': 'Dreambooth Training', 'sdk': 'gradio', 'license': 'mit', 'duplicated_from': 'multimodalart/dreambooth-training'}
+        ```
+    """
+
+    def __init__(
+        self,
+        *,
+        title: Optional[str] = None,
+        sdk: Optional[str] = None,
+        sdk_version: Optional[str] = None,
+        python_version: Optional[str] = None,
+        app_file: Optional[str] = None,
+        app_port: Optional[int] = None,
+        license: Optional[str] = None,
+        duplicated_from: Optional[str] = None,
+        models: Optional[List[str]] = None,
+        datasets: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
+        ignore_metadata_errors: bool = False,
+        **kwargs,
+    ):
+        self.title = title
+        self.sdk = sdk
+        self.sdk_version = sdk_version
+        self.python_version = python_version
+        self.app_file = app_file
+        self.app_port = app_port
+        self.license = license
+        self.duplicated_from = duplicated_from
+        self.models = models
+        self.datasets = datasets
+        self.tags = tags
+        super().__init__(**kwargs)
+
+
+def model_index_to_eval_results(model_index: List[Dict[str, Any]]) -> Tuple[str, List[EvalResult]]:
+    """Takes in a model index and returns the model name and a list of `huggingface_hub.EvalResult` objects.
+
+    A detailed spec of the model index can be found here:
+    https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1
+
+    Args:
+        model_index (`List[Dict[str, Any]]`):
+            A model index data structure, likely coming from a README.md file on the
+            Hugging Face Hub.
+
+    Returns:
+        model_name (`str`):
+            The name of the model as found in the model index. This is used as the
+            identifier for the model on leaderboards like PapersWithCode.
+        eval_results (`List[EvalResult]`):
+            A list of `huggingface_hub.EvalResult` objects containing the metrics
+            reported in the provided model_index.
+
+    Example:
+        ```python
+        >>> from huggingface_hub.repocard_data import model_index_to_eval_results
+        >>> # Define a minimal model index
+        >>> model_index = [
+        ...     {
+        ...         "name": "my-cool-model",
+        ...         "results": [
+        ...             {
+        ...                 "task": {
+        ...                     "type": "image-classification"
+        ...                 },
+        ...                 "dataset": {
+        ...                     "type": "beans",
+        ...                     "name": "Beans"
+        ...                 },
+        ...                 "metrics": [
+        ...                     {
+        ...                         "type": "accuracy",
+        ...                         "value": 0.9
+        ...                     }
+        ...                 ]
+        ...             }
+        ...         ]
+        ...     }
+        ... ]
+        >>> model_name, eval_results = model_index_to_eval_results(model_index)
+        >>> model_name
+        'my-cool-model'
+        >>> eval_results[0].task_type
+        'image-classification'
+        >>> eval_results[0].metric_type
+        'accuracy'
+
+        ```
+    """
+
+    eval_results = []
+    for elem in model_index:
+        name = elem["name"]
+        results = elem["results"]
+        for result in results:
+            task_type = result["task"]["type"]
+            task_name = result["task"].get("name")
+            dataset_type = result["dataset"]["type"]
+            dataset_name = result["dataset"]["name"]
+            dataset_config = result["dataset"].get("config")
+            dataset_split = result["dataset"].get("split")
+            dataset_revision = result["dataset"].get("revision")
+            dataset_args = result["dataset"].get("args")
+            source_name = result.get("source", {}).get("name")
+            source_url = result.get("source", {}).get("url")
+
+            for metric in result["metrics"]:
+                metric_type = metric["type"]
+                metric_value = metric["value"]
+                metric_name = metric.get("name")
+                metric_args = metric.get("args")
+                metric_config = metric.get("config")
+                verified = metric.get("verified")
+                verify_token = metric.get("verifyToken")
+
+                eval_result = EvalResult(
+                    task_type=task_type,  # Required
+                    dataset_type=dataset_type,  # Required
+                    dataset_name=dataset_name,  # Required
+                    metric_type=metric_type,  # Required
+                    metric_value=metric_value,  # Required
+                    task_name=task_name,
+                    dataset_config=dataset_config,
+                    dataset_split=dataset_split,
+                    dataset_revision=dataset_revision,
+                    dataset_args=dataset_args,
+                    metric_name=metric_name,
+                    metric_args=metric_args,
+                    metric_config=metric_config,
+                    verified=verified,
+                    verify_token=verify_token,
+                    source_name=source_name,
+                    source_url=source_url,
+                )
+                eval_results.append(eval_result)
+    return name, eval_results
+
+
+def _remove_none(obj):
+    """
+    Recursively remove `None` values from a dict. Borrowed from: https://stackoverflow.com/a/20558778
+    """
+    if isinstance(obj, (list, tuple, set)):
+        return type(obj)(_remove_none(x) for x in obj if x is not None)
+    elif isinstance(obj, dict):
+        return type(obj)((_remove_none(k), _remove_none(v)) for k, v in obj.items() if k is not None and v is not None)
+    else:
+        return obj
+
+
+def eval_results_to_model_index(model_name: str, eval_results: List[EvalResult]) -> List[Dict[str, Any]]:
+    """Takes in given model name and list of `huggingface_hub.EvalResult` and returns a
+    valid model-index that will be compatible with the format expected by the
+    Hugging Face Hub.
+
+    Args:
+        model_name (`str`):
+            Name of the model (ex. "my-cool-model"). This is used as the identifier
+            for the model on leaderboards like PapersWithCode.
+        eval_results (`List[EvalResult]`):
+            List of `huggingface_hub.EvalResult` objects containing the metrics to be
+            reported in the model-index.
+
+    Returns:
+        model_index (`List[Dict[str, Any]]`): The eval_results converted to a model-index.
+
+    Example:
+        ```python
+        >>> from huggingface_hub.repocard_data import eval_results_to_model_index, EvalResult
+        >>> # Define minimal eval_results
+        >>> eval_results = [
+        ...     EvalResult(
+        ...         task_type="image-classification",  # Required
+        ...         dataset_type="beans",  # Required
+        ...         dataset_name="Beans",  # Required
+        ...         metric_type="accuracy",  # Required
+        ...         metric_value=0.9,  # Required
+        ...     )
+        ... ]
+        >>> eval_results_to_model_index("my-cool-model", eval_results)
+        [{'name': 'my-cool-model', 'results': [{'task': {'type': 'image-classification'}, 'dataset': {'name': 'Beans', 'type': 'beans'}, 'metrics': [{'type': 'accuracy', 'value': 0.9}]}]}]
+
+        ```
+    """
+
+    # Metrics are reported on a unique task-and-dataset basis.
+    # Here, we make a map of those pairs and the associated EvalResults.
+    task_and_ds_types_map: Dict[Any, List[EvalResult]] = defaultdict(list)
+    for eval_result in eval_results:
+        task_and_ds_types_map[eval_result.unique_identifier].append(eval_result)
+
+    # Use the map from above to generate the model index data.
+    model_index_data = []
+    for results in task_and_ds_types_map.values():
+        # All items from `results` share same metadata
+        sample_result = results[0]
+        data = {
+            "task": {
+                "type": sample_result.task_type,
+                "name": sample_result.task_name,
+            },
+            "dataset": {
+                "name": sample_result.dataset_name,
+                "type": sample_result.dataset_type,
+                "config": sample_result.dataset_config,
+                "split": sample_result.dataset_split,
+                "revision": sample_result.dataset_revision,
+                "args": sample_result.dataset_args,
+            },
+            "metrics": [
+                {
+                    "type": result.metric_type,
+                    "value": result.metric_value,
+                    "name": result.metric_name,
+                    "config": result.metric_config,
+                    "args": result.metric_args,
+                    "verified": result.verified,
+                    "verifyToken": result.verify_token,
+                }
+                for result in results
+            ],
+        }
+        if sample_result.source_url is not None:
+            source = {
+                "url": sample_result.source_url,
+            }
+            if sample_result.source_name is not None:
+                source["name"] = sample_result.source_name
+            data["source"] = source
+        model_index_data.append(data)
+
+    # TODO - Check if there cases where this list is longer than one?
+    # Finally, the model index itself is list of dicts.
+    model_index = [
+        {
+            "name": model_name,
+            "results": model_index_data,
+        }
+    ]
+    return _remove_none(model_index)
diff --git a/lib/python3.11/site-packages/huggingface_hub/repository.py b/lib/python3.11/site-packages/huggingface_hub/repository.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7aff2eb66318803ee8c2fa4e3cccb29e0036801
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/repository.py
@@ -0,0 +1,1476 @@
+import atexit
+import os
+import re
+import subprocess
+import threading
+import time
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable, Dict, Iterator, List, Optional, Tuple, TypedDict, Union
+from urllib.parse import urlparse
+
+from huggingface_hub.constants import REPO_TYPES_URL_PREFIXES, REPOCARD_NAME
+from huggingface_hub.repocard import metadata_load, metadata_save
+
+from .hf_api import HfApi, repo_type_and_id_from_hf_id
+from .lfs import LFS_MULTIPART_UPLOAD_COMMAND
+from .utils import (
+    SoftTemporaryDirectory,
+    get_token,
+    logging,
+    run_subprocess,
+    tqdm,
+    validate_hf_hub_args,
+)
+from .utils._deprecation import _deprecate_method
+
+
+logger = logging.get_logger(__name__)
+
+
+class CommandInProgress:
+    """
+    Utility to follow commands launched asynchronously.
+    """
+
+    def __init__(
+        self,
+        title: str,
+        is_done_method: Callable,
+        status_method: Callable,
+        process: subprocess.Popen,
+        post_method: Optional[Callable] = None,
+    ):
+        self.title = title
+        self._is_done = is_done_method
+        self._status = status_method
+        self._process = process
+        self._stderr = ""
+        self._stdout = ""
+        self._post_method = post_method
+
+    @property
+    def is_done(self) -> bool:
+        """
+        Whether the process is done.
+        """
+        result = self._is_done()
+
+        if result and self._post_method is not None:
+            self._post_method()
+            self._post_method = None
+
+        return result
+
+    @property
+    def status(self) -> int:
+        """
+        The exit code/status of the current action. Will return `0` if the
+        command has completed successfully, and a number between 1 and 255 if
+        the process errored-out.
+
+        Will return -1 if the command is still ongoing.
+        """
+        return self._status()
+
+    @property
+    def failed(self) -> bool:
+        """
+        Whether the process errored-out.
+        """
+        return self.status > 0
+
+    @property
+    def stderr(self) -> str:
+        """
+        The current output message on the standard error.
+        """
+        if self._process.stderr is not None:
+            self._stderr += self._process.stderr.read()
+        return self._stderr
+
+    @property
+    def stdout(self) -> str:
+        """
+        The current output message on the standard output.
+        """
+        if self._process.stdout is not None:
+            self._stdout += self._process.stdout.read()
+        return self._stdout
+
+    def __repr__(self):
+        status = self.status
+
+        if status == -1:
+            status = "running"
+
+        return (
+            f"[{self.title} command, status code: {status},"
+            f" {'in progress.' if not self.is_done else 'finished.'} PID:"
+            f" {self._process.pid}]"
+        )
+
+
+def is_git_repo(folder: Union[str, Path]) -> bool:
+    """
+    Check if the folder is the root or part of a git repository
+
+    Args:
+        folder (`str`):
+            The folder in which to run the command.
+
+    Returns:
+        `bool`: `True` if the repository is part of a repository, `False`
+        otherwise.
+    """
+    folder_exists = os.path.exists(os.path.join(folder, ".git"))
+    git_branch = subprocess.run("git branch".split(), cwd=folder, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    return folder_exists and git_branch.returncode == 0
+
+
+def is_local_clone(folder: Union[str, Path], remote_url: str) -> bool:
+    """
+    Check if the folder is a local clone of the remote_url
+
+    Args:
+        folder (`str` or `Path`):
+            The folder in which to run the command.
+        remote_url (`str`):
+            The url of a git repository.
+
+    Returns:
+        `bool`: `True` if the repository is a local clone of the remote
+        repository specified, `False` otherwise.
+    """
+    if not is_git_repo(folder):
+        return False
+
+    remotes = run_subprocess("git remote -v", folder).stdout
+
+    # Remove token for the test with remotes.
+    remote_url = re.sub(r"https://.*@", "https://", remote_url)
+    remotes = [re.sub(r"https://.*@", "https://", remote) for remote in remotes.split()]
+    return remote_url in remotes
+
+
+def is_tracked_with_lfs(filename: Union[str, Path]) -> bool:
+    """
+    Check if the file passed is tracked with git-lfs.
+
+    Args:
+        filename (`str` or `Path`):
+            The filename to check.
+
+    Returns:
+        `bool`: `True` if the file passed is tracked with git-lfs, `False`
+        otherwise.
+    """
+    folder = Path(filename).parent
+    filename = Path(filename).name
+
+    try:
+        p = run_subprocess("git check-attr -a".split() + [filename], folder)
+        attributes = p.stdout.strip()
+    except subprocess.CalledProcessError as exc:
+        if not is_git_repo(folder):
+            return False
+        else:
+            raise OSError(exc.stderr)
+
+    if len(attributes) == 0:
+        return False
+
+    found_lfs_tag = {"diff": False, "merge": False, "filter": False}
+
+    for attribute in attributes.split("\n"):
+        for tag in found_lfs_tag.keys():
+            if tag in attribute and "lfs" in attribute:
+                found_lfs_tag[tag] = True
+
+    return all(found_lfs_tag.values())
+
+
+def is_git_ignored(filename: Union[str, Path]) -> bool:
+    """
+    Check if file is git-ignored. Supports nested .gitignore files.
+
+    Args:
+        filename (`str` or `Path`):
+            The filename to check.
+
+    Returns:
+        `bool`: `True` if the file passed is ignored by `git`, `False`
+        otherwise.
+    """
+    folder = Path(filename).parent
+    filename = Path(filename).name
+
+    try:
+        p = run_subprocess("git check-ignore".split() + [filename], folder, check=False)
+        # Will return exit code 1 if not gitignored
+        is_ignored = not bool(p.returncode)
+    except subprocess.CalledProcessError as exc:
+        raise OSError(exc.stderr)
+
+    return is_ignored
+
+
+def is_binary_file(filename: Union[str, Path]) -> bool:
+    """
+    Check if file is a binary file.
+
+    Args:
+        filename (`str` or `Path`):
+            The filename to check.
+
+    Returns:
+        `bool`: `True` if the file passed is a binary file, `False` otherwise.
+    """
+    try:
+        with open(filename, "rb") as f:
+            content = f.read(10 * (1024**2))  # Read a maximum of 10MB
+
+        # Code sample taken from the following stack overflow thread
+        # https://stackoverflow.com/questions/898669/how-can-i-detect-if-a-file-is-binary-non-text-in-python/7392391#7392391
+        text_chars = bytearray({7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100)) - {0x7F})
+        return bool(content.translate(None, text_chars))
+    except UnicodeDecodeError:
+        return True
+
+
+def files_to_be_staged(pattern: str = ".", folder: Union[str, Path, None] = None) -> List[str]:
+    """
+    Returns a list of filenames that are to be staged.
+
+    Args:
+        pattern (`str` or `Path`):
+            The pattern of filenames to check. Put `.` to get all files.
+        folder (`str` or `Path`):
+            The folder in which to run the command.
+
+    Returns:
+        `List[str]`: List of files that are to be staged.
+    """
+    try:
+        p = run_subprocess("git ls-files --exclude-standard -mo".split() + [pattern], folder)
+        if len(p.stdout.strip()):
+            files = p.stdout.strip().split("\n")
+        else:
+            files = []
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+    return files
+
+
+def is_tracked_upstream(folder: Union[str, Path]) -> bool:
+    """
+    Check if the current checked-out branch is tracked upstream.
+
+    Args:
+        folder (`str` or `Path`):
+            The folder in which to run the command.
+
+    Returns:
+        `bool`: `True` if the current checked-out branch is tracked upstream,
+        `False` otherwise.
+    """
+    try:
+        run_subprocess("git rev-parse --symbolic-full-name --abbrev-ref @{u}", folder)
+        return True
+    except subprocess.CalledProcessError as exc:
+        if "HEAD" in exc.stderr:
+            raise OSError("No branch checked out")
+
+        return False
+
+
+def commits_to_push(folder: Union[str, Path], upstream: Optional[str] = None) -> int:
+    """
+        Check the number of commits that would be pushed upstream
+
+        Args:
+            folder (`str` or `Path`):
+                The folder in which to run the command.
+            upstream (`str`, *optional*):
+    The name of the upstream repository with which the comparison should be
+    made.
+
+        Returns:
+            `int`: Number of commits that would be pushed upstream were a `git
+            push` to proceed.
+    """
+    try:
+        result = run_subprocess(f"git cherry -v {upstream or ''}", folder)
+        return len(result.stdout.split("\n")) - 1
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+
+class PbarT(TypedDict):
+    # Used to store an opened progress bar in `_lfs_log_progress`
+    bar: tqdm
+    past_bytes: int
+
+
+@contextmanager
+def _lfs_log_progress():
+    """
+    This is a context manager that will log the Git LFS progress of cleaning,
+    smudging, pulling and pushing.
+    """
+
+    if logger.getEffectiveLevel() >= logging.ERROR:
+        try:
+            yield
+        except Exception:
+            pass
+        return
+
+    def output_progress(stopping_event: threading.Event):
+        """
+        To be launched as a separate thread with an event meaning it should stop
+        the tail.
+        """
+        # Key is tuple(state, filename), value is a dict(tqdm bar and a previous value)
+        pbars: Dict[Tuple[str, str], PbarT] = {}
+
+        def close_pbars():
+            for pbar in pbars.values():
+                pbar["bar"].update(pbar["bar"].total - pbar["past_bytes"])
+                pbar["bar"].refresh()
+                pbar["bar"].close()
+
+        def tail_file(filename) -> Iterator[str]:
+            """
+            Creates a generator to be iterated through, which will return each
+            line one by one. Will stop tailing the file if the stopping_event is
+            set.
+            """
+            with open(filename, "r") as file:
+                current_line = ""
+                while True:
+                    if stopping_event.is_set():
+                        close_pbars()
+                        break
+
+                    line_bit = file.readline()
+                    if line_bit is not None and not len(line_bit.strip()) == 0:
+                        current_line += line_bit
+                        if current_line.endswith("\n"):
+                            yield current_line
+                            current_line = ""
+                    else:
+                        time.sleep(1)
+
+        # If the file isn't created yet, wait for a few seconds before trying again.
+        # Can be interrupted with the stopping_event.
+        while not os.path.exists(os.environ["GIT_LFS_PROGRESS"]):
+            if stopping_event.is_set():
+                close_pbars()
+                return
+
+            time.sleep(2)
+
+        for line in tail_file(os.environ["GIT_LFS_PROGRESS"]):
+            try:
+                state, file_progress, byte_progress, filename = line.split()
+            except ValueError as error:
+                # Try/except to ease debugging. See https://github.com/huggingface/huggingface_hub/issues/1373.
+                raise ValueError(f"Cannot unpack LFS progress line:\n{line}") from error
+            description = f"{state.capitalize()} file {filename}"
+
+            current_bytes, total_bytes = byte_progress.split("/")
+            current_bytes_int = int(current_bytes)
+            total_bytes_int = int(total_bytes)
+
+            pbar = pbars.get((state, filename))
+            if pbar is None:
+                # Initialize progress bar
+                pbars[(state, filename)] = {
+                    "bar": tqdm(
+                        desc=description,
+                        initial=current_bytes_int,
+                        total=total_bytes_int,
+                        unit="B",
+                        unit_scale=True,
+                        unit_divisor=1024,
+                    ),
+                    "past_bytes": int(current_bytes),
+                }
+            else:
+                # Update progress bar
+                pbar["bar"].update(current_bytes_int - pbar["past_bytes"])
+                pbar["past_bytes"] = current_bytes_int
+
+    current_lfs_progress_value = os.environ.get("GIT_LFS_PROGRESS", "")
+
+    with SoftTemporaryDirectory() as tmpdir:
+        os.environ["GIT_LFS_PROGRESS"] = os.path.join(tmpdir, "lfs_progress")
+        logger.debug(f"Following progress in {os.environ['GIT_LFS_PROGRESS']}")
+
+        exit_event = threading.Event()
+        x = threading.Thread(target=output_progress, args=(exit_event,), daemon=True)
+        x.start()
+
+        try:
+            yield
+        finally:
+            exit_event.set()
+            x.join()
+
+            os.environ["GIT_LFS_PROGRESS"] = current_lfs_progress_value
+
+
+class Repository:
+    """
+    Helper class to wrap the git and git-lfs commands.
+
+    The aim is to facilitate interacting with huggingface.co hosted model or
+    dataset repos, though not a lot here (if any) is actually specific to
+    huggingface.co.
+
+    <Tip warning={true}>
+
+    [`Repository`] is deprecated in favor of the http-based alternatives implemented in
+    [`HfApi`]. Given its large adoption in legacy code, the complete removal of
+    [`Repository`] will only happen in release `v1.0`. For more details, please read
+    https://huggingface.co/docs/huggingface_hub/concepts/git_vs_http.
+
+    </Tip>
+    """
+
+    command_queue: List[CommandInProgress]
+
+    @validate_hf_hub_args
+    @_deprecate_method(
+        version="1.0",
+        message=(
+            "Please prefer the http-based alternatives instead. Given its large adoption in legacy code, the complete"
+            " removal is only planned on next major release.\nFor more details, please read"
+            " https://huggingface.co/docs/huggingface_hub/concepts/git_vs_http."
+        ),
+    )
+    def __init__(
+        self,
+        local_dir: Union[str, Path],
+        clone_from: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        token: Union[bool, str] = True,
+        git_user: Optional[str] = None,
+        git_email: Optional[str] = None,
+        revision: Optional[str] = None,
+        skip_lfs_files: bool = False,
+        client: Optional[HfApi] = None,
+    ):
+        """
+        Instantiate a local clone of a git repo.
+
+        If `clone_from` is set, the repo will be cloned from an existing remote repository.
+        If the remote repo does not exist, a `EnvironmentError` exception will be thrown.
+        Please create the remote repo first using [`create_repo`].
+
+        `Repository` uses the local git credentials by default. If explicitly set, the `token`
+        or the `git_user`/`git_email` pair will be used instead.
+
+        Args:
+            local_dir (`str` or `Path`):
+                path (e.g. `'my_trained_model/'`) to the local directory, where
+                the `Repository` will be initialized.
+            clone_from (`str`, *optional*):
+                Either a repository url or `repo_id`.
+                Example:
+                - `"https://huggingface.co/philschmid/playground-tests"`
+                - `"philschmid/playground-tests"`
+            repo_type (`str`, *optional*):
+                To set when cloning a repo from a repo_id. Default is model.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
+            git_user (`str`, *optional*):
+                will override the `git config user.name` for committing and
+                pushing files to the hub.
+            git_email (`str`, *optional*):
+                will override the `git config user.email` for committing and
+                pushing files to the hub.
+            revision (`str`, *optional*):
+                Revision to checkout after initializing the repository. If the
+                revision doesn't exist, a branch will be created with that
+                revision name from the default branch's current HEAD.
+            skip_lfs_files (`bool`, *optional*, defaults to `False`):
+                whether to skip git-LFS files or not.
+            client (`HfApi`, *optional*):
+                Instance of [`HfApi`] to use when calling the HF Hub API. A new
+                instance will be created if this is left to `None`.
+
+        Raises:
+            - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+              if the remote repository set in `clone_from` does not exist.
+        """
+        if isinstance(local_dir, Path):
+            local_dir = str(local_dir)
+        os.makedirs(local_dir, exist_ok=True)
+        self.local_dir = os.path.join(os.getcwd(), local_dir)
+        self._repo_type = repo_type
+        self.command_queue = []
+        self.skip_lfs_files = skip_lfs_files
+        self.client = client if client is not None else HfApi()
+
+        self.check_git_versions()
+
+        if isinstance(token, str):
+            self.huggingface_token: Optional[str] = token
+        elif token is False:
+            self.huggingface_token = None
+        else:
+            # if `True` -> explicit use of the cached token
+            # if `None` -> implicit use of the cached token
+            self.huggingface_token = get_token()
+
+        if clone_from is not None:
+            self.clone_from(repo_url=clone_from)
+        else:
+            if is_git_repo(self.local_dir):
+                logger.debug("[Repository] is a valid git repo")
+            else:
+                raise ValueError("If not specifying `clone_from`, you need to pass Repository a valid git clone.")
+
+        if self.huggingface_token is not None and (git_email is None or git_user is None):
+            user = self.client.whoami(self.huggingface_token)
+
+            if git_email is None:
+                git_email = user["email"]
+
+            if git_user is None:
+                git_user = user["fullname"]
+
+        if git_user is not None or git_email is not None:
+            self.git_config_username_and_email(git_user, git_email)
+
+        self.lfs_enable_largefiles()
+        self.git_credential_helper_store()
+
+        if revision is not None:
+            self.git_checkout(revision, create_branch_ok=True)
+
+        # This ensures that all commands exit before exiting the Python runtime.
+        # This will ensure all pushes register on the hub, even if other errors happen in subsequent operations.
+        atexit.register(self.wait_for_commands)
+
+    @property
+    def current_branch(self) -> str:
+        """
+        Returns the current checked out branch.
+
+        Returns:
+            `str`: Current checked out branch.
+        """
+        try:
+            result = run_subprocess("git rev-parse --abbrev-ref HEAD", self.local_dir).stdout.strip()
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+        return result
+
+    def check_git_versions(self):
+        """
+        Checks that `git` and `git-lfs` can be run.
+
+        Raises:
+            - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+              if `git` or `git-lfs` are not installed.
+        """
+        try:
+            git_version = run_subprocess("git --version", self.local_dir).stdout.strip()
+        except FileNotFoundError:
+            raise EnvironmentError("Looks like you do not have git installed, please install.")
+
+        try:
+            lfs_version = run_subprocess("git-lfs --version", self.local_dir).stdout.strip()
+        except FileNotFoundError:
+            raise EnvironmentError(
+                "Looks like you do not have git-lfs installed, please install."
+                " You can install from https://git-lfs.github.com/."
+                " Then run `git lfs install` (you only have to do this once)."
+            )
+        logger.info(git_version + "\n" + lfs_version)
+
+    @validate_hf_hub_args
+    def clone_from(self, repo_url: str, token: Union[bool, str, None] = None):
+        """
+        Clone from a remote. If the folder already exists, will try to clone the
+        repository within it.
+
+        If this folder is a git repository with linked history, will try to
+        update the repository.
+
+        Args:
+            repo_url (`str`):
+                The URL from which to clone the repository
+            token (`Union[str, bool]`, *optional*):
+                Whether to use the authentication token. It can be:
+                 - a string which is the token itself
+                 - `False`, which would not use the authentication token
+                 - `True`, which would fetch the authentication token from the
+                   local folder and use it (you should be logged in for this to
+                   work).
+                - `None`, which would retrieve the value of
+                  `self.huggingface_token`.
+
+        <Tip>
+
+        Raises the following error:
+
+            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+              if an organization token (starts with "api_org") is passed. Use must use
+              your own personal access token (see https://hf.co/settings/tokens).
+
+            - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+              if you are trying to clone the repository in a non-empty folder, or if the
+              `git` operations raise errors.
+
+        </Tip>
+        """
+        token = (
+            token  # str -> use it
+            if isinstance(token, str)
+            else (
+                None  # `False` -> explicit no token
+                if token is False
+                else self.huggingface_token  # `None` or `True` -> use default
+            )
+        )
+        if token is not None and token.startswith("api_org"):
+            raise ValueError(
+                "You must use your personal access token, not an Organization token"
+                " (see https://hf.co/settings/tokens)."
+            )
+
+        hub_url = self.client.endpoint
+        if hub_url in repo_url or ("http" not in repo_url and len(repo_url.split("/")) <= 2):
+            repo_type, namespace, repo_name = repo_type_and_id_from_hf_id(repo_url, hub_url=hub_url)
+            repo_id = f"{namespace}/{repo_name}" if namespace is not None else repo_name
+
+            if repo_type is not None:
+                self._repo_type = repo_type
+
+            repo_url = hub_url + "/"
+
+            if self._repo_type in REPO_TYPES_URL_PREFIXES:
+                repo_url += REPO_TYPES_URL_PREFIXES[self._repo_type]
+
+            if token is not None:
+                # Add token in git url when provided
+                scheme = urlparse(repo_url).scheme
+                repo_url = repo_url.replace(f"{scheme}://", f"{scheme}://user:{token}@")
+
+            repo_url += repo_id
+
+        # For error messages, it's cleaner to show the repo url without the token.
+        clean_repo_url = re.sub(r"(https?)://.*@", r"\1://", repo_url)
+        try:
+            run_subprocess("git lfs install", self.local_dir)
+
+            # checks if repository is initialized in a empty repository or in one with files
+            if len(os.listdir(self.local_dir)) == 0:
+                logger.warning(f"Cloning {clean_repo_url} into local empty directory.")
+
+                with _lfs_log_progress():
+                    env = os.environ.copy()
+
+                    if self.skip_lfs_files:
+                        env.update({"GIT_LFS_SKIP_SMUDGE": "1"})
+
+                    run_subprocess(
+                        # 'git lfs clone' is deprecated (will display a warning in the terminal)
+                        # but we still use it as it provides a nicer UX when downloading large
+                        # files (shows progress).
+                        f"{'git clone' if self.skip_lfs_files else 'git lfs clone'} {repo_url} .",
+                        self.local_dir,
+                        env=env,
+                    )
+            else:
+                # Check if the folder is the root of a git repository
+                if not is_git_repo(self.local_dir):
+                    raise EnvironmentError(
+                        "Tried to clone a repository in a non-empty folder that isn't"
+                        f" a git repository ('{self.local_dir}'). If you really want to"
+                        f" do this, do it manually:\n cd {self.local_dir} && git init"
+                        " && git remote add origin && git pull origin main\n or clone"
+                        " repo to a new folder and move your existing files there"
+                        " afterwards."
+                    )
+
+                if is_local_clone(self.local_dir, repo_url):
+                    logger.warning(
+                        f"{self.local_dir} is already a clone of {clean_repo_url}."
+                        " Make sure you pull the latest changes with"
+                        " `repo.git_pull()`."
+                    )
+                else:
+                    output = run_subprocess("git remote get-url origin", self.local_dir, check=False)
+
+                    error_msg = (
+                        f"Tried to clone {clean_repo_url} in an unrelated git"
+                        " repository.\nIf you believe this is an error, please add"
+                        f" a remote with the following URL: {clean_repo_url}."
+                    )
+                    if output.returncode == 0:
+                        clean_local_remote_url = re.sub(r"https://.*@", "https://", output.stdout)
+                        error_msg += f"\nLocal path has its origin defined as: {clean_local_remote_url}"
+                    raise EnvironmentError(error_msg)
+
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_config_username_and_email(self, git_user: Optional[str] = None, git_email: Optional[str] = None):
+        """
+        Sets git username and email (only in the current repo).
+
+        Args:
+            git_user (`str`, *optional*):
+                The username to register through `git`.
+            git_email (`str`, *optional*):
+                The email to register through `git`.
+        """
+        try:
+            if git_user is not None:
+                run_subprocess("git config user.name".split() + [git_user], self.local_dir)
+
+            if git_email is not None:
+                run_subprocess(f"git config user.email {git_email}".split(), self.local_dir)
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_credential_helper_store(self):
+        """
+        Sets the git credential helper to `store`
+        """
+        try:
+            run_subprocess("git config credential.helper store", self.local_dir)
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_head_hash(self) -> str:
+        """
+        Get commit sha on top of HEAD.
+
+        Returns:
+            `str`: The current checked out commit SHA.
+        """
+        try:
+            p = run_subprocess("git rev-parse HEAD", self.local_dir)
+            return p.stdout.strip()
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_remote_url(self) -> str:
+        """
+        Get URL to origin remote.
+
+        Returns:
+            `str`: The URL of the `origin` remote.
+        """
+        try:
+            p = run_subprocess("git config --get remote.origin.url", self.local_dir)
+            url = p.stdout.strip()
+            # Strip basic auth info.
+            return re.sub(r"https://.*@", "https://", url)
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_head_commit_url(self) -> str:
+        """
+        Get URL to last commit on HEAD. We assume it's been pushed, and the url
+        scheme is the same one as for GitHub or HuggingFace.
+
+        Returns:
+            `str`: The URL to the current checked-out commit.
+        """
+        sha = self.git_head_hash()
+        url = self.git_remote_url()
+        if url.endswith("/"):
+            url = url[:-1]
+        return f"{url}/commit/{sha}"
+
+    def list_deleted_files(self) -> List[str]:
+        """
+        Returns a list of the files that are deleted in the working directory or
+        index.
+
+        Returns:
+            `List[str]`: A list of files that have been deleted in the working
+            directory or index.
+        """
+        try:
+            git_status = run_subprocess("git status -s", self.local_dir).stdout.strip()
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+        if len(git_status) == 0:
+            return []
+
+        # Receives a status like the following
+        #  D .gitignore
+        #  D new_file.json
+        # AD new_file1.json
+        # ?? new_file2.json
+        # ?? new_file4.json
+
+        # Strip each line of whitespaces
+        modified_files_statuses = [status.strip() for status in git_status.split("\n")]
+
+        # Only keep files that are deleted using the D prefix
+        deleted_files_statuses = [status for status in modified_files_statuses if "D" in status.split()[0]]
+
+        # Remove the D prefix and strip to keep only the relevant filename
+        deleted_files = [status.split()[-1].strip() for status in deleted_files_statuses]
+
+        return deleted_files
+
+    def lfs_track(self, patterns: Union[str, List[str]], filename: bool = False):
+        """
+        Tell git-lfs to track files according to a pattern.
+
+        Setting the `filename` argument to `True` will treat the arguments as
+        literal filenames, not as patterns. Any special glob characters in the
+        filename will be escaped when writing to the `.gitattributes` file.
+
+        Args:
+            patterns (`Union[str, List[str]]`):
+                The pattern, or list of patterns, to track with git-lfs.
+            filename (`bool`, *optional*, defaults to `False`):
+                Whether to use the patterns as literal filenames.
+        """
+        if isinstance(patterns, str):
+            patterns = [patterns]
+        try:
+            for pattern in patterns:
+                run_subprocess(
+                    f"git lfs track {'--filename' if filename else ''} {pattern}",
+                    self.local_dir,
+                )
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def lfs_untrack(self, patterns: Union[str, List[str]]):
+        """
+        Tell git-lfs to untrack those files.
+
+        Args:
+            patterns (`Union[str, List[str]]`):
+                The pattern, or list of patterns, to untrack with git-lfs.
+        """
+        if isinstance(patterns, str):
+            patterns = [patterns]
+        try:
+            for pattern in patterns:
+                run_subprocess("git lfs untrack".split() + [pattern], self.local_dir)
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def lfs_enable_largefiles(self):
+        """
+        HF-specific. This enables upload support of files >5GB.
+        """
+        try:
+            lfs_config = "git config lfs.customtransfer.multipart"
+            run_subprocess(f"{lfs_config}.path huggingface-cli", self.local_dir)
+            run_subprocess(
+                f"{lfs_config}.args {LFS_MULTIPART_UPLOAD_COMMAND}",
+                self.local_dir,
+            )
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def auto_track_binary_files(self, pattern: str = ".") -> List[str]:
+        """
+        Automatically track binary files with git-lfs.
+
+        Args:
+            pattern (`str`, *optional*, defaults to "."):
+                The pattern with which to track files that are binary.
+
+        Returns:
+            `List[str]`: List of filenames that are now tracked due to being
+            binary files
+        """
+        files_to_be_tracked_with_lfs = []
+
+        deleted_files = self.list_deleted_files()
+
+        for filename in files_to_be_staged(pattern, folder=self.local_dir):
+            if filename in deleted_files:
+                continue
+
+            path_to_file = os.path.join(os.getcwd(), self.local_dir, filename)
+
+            if not (is_tracked_with_lfs(path_to_file) or is_git_ignored(path_to_file)):
+                size_in_mb = os.path.getsize(path_to_file) / (1024 * 1024)
+
+                if size_in_mb >= 10:
+                    logger.warning(
+                        "Parsing a large file to check if binary or not. Tracking large"
+                        " files using `repository.auto_track_large_files` is"
+                        " recommended so as to not load the full file in memory."
+                    )
+
+                is_binary = is_binary_file(path_to_file)
+
+                if is_binary:
+                    self.lfs_track(filename)
+                    files_to_be_tracked_with_lfs.append(filename)
+
+        # Cleanup the .gitattributes if files were deleted
+        self.lfs_untrack(deleted_files)
+
+        return files_to_be_tracked_with_lfs
+
+    def auto_track_large_files(self, pattern: str = ".") -> List[str]:
+        """
+        Automatically track large files (files that weigh more than 10MBs) with
+        git-lfs.
+
+        Args:
+            pattern (`str`, *optional*, defaults to "."):
+                The pattern with which to track files that are above 10MBs.
+
+        Returns:
+            `List[str]`: List of filenames that are now tracked due to their
+            size.
+        """
+        files_to_be_tracked_with_lfs = []
+
+        deleted_files = self.list_deleted_files()
+
+        for filename in files_to_be_staged(pattern, folder=self.local_dir):
+            if filename in deleted_files:
+                continue
+
+            path_to_file = os.path.join(os.getcwd(), self.local_dir, filename)
+            size_in_mb = os.path.getsize(path_to_file) / (1024 * 1024)
+
+            if size_in_mb >= 10 and not is_tracked_with_lfs(path_to_file) and not is_git_ignored(path_to_file):
+                self.lfs_track(filename)
+                files_to_be_tracked_with_lfs.append(filename)
+
+        # Cleanup the .gitattributes if files were deleted
+        self.lfs_untrack(deleted_files)
+
+        return files_to_be_tracked_with_lfs
+
+    def lfs_prune(self, recent=False):
+        """
+        git lfs prune
+
+        Args:
+            recent (`bool`, *optional*, defaults to `False`):
+                Whether to prune files even if they were referenced by recent
+                commits. See the following
+                [link](https://github.com/git-lfs/git-lfs/blob/f3d43f0428a84fc4f1e5405b76b5a73ec2437e65/docs/man/git-lfs-prune.1.ronn#recent-files)
+                for more information.
+        """
+        try:
+            with _lfs_log_progress():
+                result = run_subprocess(f"git lfs prune {'--recent' if recent else ''}", self.local_dir)
+                logger.info(result.stdout)
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_pull(self, rebase: bool = False, lfs: bool = False):
+        """
+        git pull
+
+        Args:
+            rebase (`bool`, *optional*, defaults to `False`):
+                Whether to rebase the current branch on top of the upstream
+                branch after fetching.
+            lfs (`bool`, *optional*, defaults to `False`):
+                Whether to fetch the LFS files too. This option only changes the
+                behavior when a repository was cloned without fetching the LFS
+                files; calling `repo.git_pull(lfs=True)` will then fetch the LFS
+                file from the remote repository.
+        """
+        command = "git pull" if not lfs else "git lfs pull"
+        if rebase:
+            command += " --rebase"
+        try:
+            with _lfs_log_progress():
+                result = run_subprocess(command, self.local_dir)
+                logger.info(result.stdout)
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_add(self, pattern: str = ".", auto_lfs_track: bool = False):
+        """
+        git add
+
+        Setting the `auto_lfs_track` parameter to `True` will automatically
+        track files that are larger than 10MB with `git-lfs`.
+
+        Args:
+            pattern (`str`, *optional*, defaults to "."):
+                The pattern with which to add files to staging.
+            auto_lfs_track (`bool`, *optional*, defaults to `False`):
+                Whether to automatically track large and binary files with
+                git-lfs. Any file over 10MB in size, or in binary format, will
+                be automatically tracked.
+        """
+        if auto_lfs_track:
+            # Track files according to their size (>=10MB)
+            tracked_files = self.auto_track_large_files(pattern)
+
+            # Read the remaining files and track them if they're binary
+            tracked_files.extend(self.auto_track_binary_files(pattern))
+
+            if tracked_files:
+                logger.warning(
+                    f"Adding files tracked by Git LFS: {tracked_files}. This may take a"
+                    " bit of time if the files are large."
+                )
+
+        try:
+            result = run_subprocess("git add -v".split() + [pattern], self.local_dir)
+            logger.info(f"Adding to index:\n{result.stdout}\n")
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+    def git_commit(self, commit_message: str = "commit files to HF hub"):
+        """
+        git commit
+
+        Args:
+            commit_message (`str`, *optional*, defaults to "commit files to HF hub"):
+                The message attributed to the commit.
+        """
+        try:
+            result = run_subprocess("git commit -v -m".split() + [commit_message], self.local_dir)
+            logger.info(f"Committed:\n{result.stdout}\n")
+        except subprocess.CalledProcessError as exc:
+            if len(exc.stderr) > 0:
+                raise EnvironmentError(exc.stderr)
+            else:
+                raise EnvironmentError(exc.stdout)
+
+    def git_push(
+        self,
+        upstream: Optional[str] = None,
+        blocking: bool = True,
+        auto_lfs_prune: bool = False,
+    ) -> Union[str, Tuple[str, CommandInProgress]]:
+        """
+        git push
+
+        If used without setting `blocking`, will return url to commit on remote
+        repo. If used with `blocking=True`, will return a tuple containing the
+        url to commit and the command object to follow for information about the
+        process.
+
+        Args:
+            upstream (`str`, *optional*):
+                Upstream to which this should push. If not specified, will push
+                to the lastly defined upstream or to the default one (`origin
+                main`).
+            blocking (`bool`, *optional*, defaults to `True`):
+                Whether the function should return only when the push has
+                finished. Setting this to `False` will return an
+                `CommandInProgress` object which has an `is_done` property. This
+                property will be set to `True` when the push is finished.
+            auto_lfs_prune (`bool`, *optional*, defaults to `False`):
+                Whether to automatically prune files once they have been pushed
+                to the remote.
+        """
+        command = "git push"
+
+        if upstream:
+            command += f" --set-upstream {upstream}"
+
+        number_of_commits = commits_to_push(self.local_dir, upstream)
+
+        if number_of_commits > 1:
+            logger.warning(f"Several commits ({number_of_commits}) will be pushed upstream.")
+            if blocking:
+                logger.warning("The progress bars may be unreliable.")
+
+        try:
+            with _lfs_log_progress():
+                process = subprocess.Popen(
+                    command.split(),
+                    stderr=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    encoding="utf-8",
+                    cwd=self.local_dir,
+                )
+
+                if blocking:
+                    stdout, stderr = process.communicate()
+                    return_code = process.poll()
+                    process.kill()
+
+                    if len(stderr):
+                        logger.warning(stderr)
+
+                    if return_code:
+                        raise subprocess.CalledProcessError(return_code, process.args, output=stdout, stderr=stderr)
+
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+        if not blocking:
+
+            def status_method():
+                status = process.poll()
+                if status is None:
+                    return -1
+                else:
+                    return status
+
+            command_in_progress = CommandInProgress(
+                "push",
+                is_done_method=lambda: process.poll() is not None,
+                status_method=status_method,
+                process=process,
+                post_method=self.lfs_prune if auto_lfs_prune else None,
+            )
+
+            self.command_queue.append(command_in_progress)
+
+            return self.git_head_commit_url(), command_in_progress
+
+        if auto_lfs_prune:
+            self.lfs_prune()
+
+        return self.git_head_commit_url()
+
+    def git_checkout(self, revision: str, create_branch_ok: bool = False):
+        """
+        git checkout a given revision
+
+        Specifying `create_branch_ok` to `True` will create the branch to the
+        given revision if that revision doesn't exist.
+
+        Args:
+            revision (`str`):
+                The revision to checkout.
+            create_branch_ok (`str`, *optional*, defaults to `False`):
+                Whether creating a branch named with the `revision` passed at
+                the current checked-out reference if `revision` isn't an
+                existing revision is allowed.
+        """
+        try:
+            result = run_subprocess(f"git checkout {revision}", self.local_dir)
+            logger.warning(f"Checked out {revision} from {self.current_branch}.")
+            logger.warning(result.stdout)
+        except subprocess.CalledProcessError as exc:
+            if not create_branch_ok:
+                raise EnvironmentError(exc.stderr)
+            else:
+                try:
+                    result = run_subprocess(f"git checkout -b {revision}", self.local_dir)
+                    logger.warning(
+                        f"Revision `{revision}` does not exist. Created and checked out branch `{revision}`."
+                    )
+                    logger.warning(result.stdout)
+                except subprocess.CalledProcessError as exc:
+                    raise EnvironmentError(exc.stderr)
+
+    def tag_exists(self, tag_name: str, remote: Optional[str] = None) -> bool:
+        """
+        Check if a tag exists or not.
+
+        Args:
+            tag_name (`str`):
+                The name of the tag to check.
+            remote (`str`, *optional*):
+                Whether to check if the tag exists on a remote. This parameter
+                should be the identifier of the remote.
+
+        Returns:
+            `bool`: Whether the tag exists.
+        """
+        if remote:
+            try:
+                result = run_subprocess(f"git ls-remote origin refs/tags/{tag_name}", self.local_dir).stdout.strip()
+            except subprocess.CalledProcessError as exc:
+                raise EnvironmentError(exc.stderr)
+
+            return len(result) != 0
+        else:
+            try:
+                git_tags = run_subprocess("git tag", self.local_dir).stdout.strip()
+            except subprocess.CalledProcessError as exc:
+                raise EnvironmentError(exc.stderr)
+
+            git_tags = git_tags.split("\n")
+            return tag_name in git_tags
+
+    def delete_tag(self, tag_name: str, remote: Optional[str] = None) -> bool:
+        """
+        Delete a tag, both local and remote, if it exists
+
+        Args:
+            tag_name (`str`):
+                The tag name to delete.
+            remote (`str`, *optional*):
+                The remote on which to delete the tag.
+
+        Returns:
+             `bool`: `True` if deleted, `False` if the tag didn't exist.
+                If remote is not passed, will just be updated locally
+        """
+        delete_locally = True
+        delete_remotely = True
+
+        if not self.tag_exists(tag_name):
+            delete_locally = False
+
+        if not self.tag_exists(tag_name, remote=remote):
+            delete_remotely = False
+
+        if delete_locally:
+            try:
+                run_subprocess(["git", "tag", "-d", tag_name], self.local_dir).stdout.strip()
+            except subprocess.CalledProcessError as exc:
+                raise EnvironmentError(exc.stderr)
+
+        if remote and delete_remotely:
+            try:
+                run_subprocess(f"git push {remote} --delete {tag_name}", self.local_dir).stdout.strip()
+            except subprocess.CalledProcessError as exc:
+                raise EnvironmentError(exc.stderr)
+
+        return True
+
+    def add_tag(self, tag_name: str, message: Optional[str] = None, remote: Optional[str] = None):
+        """
+        Add a tag at the current head and push it
+
+        If remote is None, will just be updated locally
+
+        If no message is provided, the tag will be lightweight. if a message is
+        provided, the tag will be annotated.
+
+        Args:
+            tag_name (`str`):
+                The name of the tag to be added.
+            message (`str`, *optional*):
+                The message that accompanies the tag. The tag will turn into an
+                annotated tag if a message is passed.
+            remote (`str`, *optional*):
+                The remote on which to add the tag.
+        """
+        if message:
+            tag_args = ["git", "tag", "-a", tag_name, "-m", message]
+        else:
+            tag_args = ["git", "tag", tag_name]
+
+        try:
+            run_subprocess(tag_args, self.local_dir).stdout.strip()
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+        if remote:
+            try:
+                run_subprocess(f"git push {remote} {tag_name}", self.local_dir).stdout.strip()
+            except subprocess.CalledProcessError as exc:
+                raise EnvironmentError(exc.stderr)
+
+    def is_repo_clean(self) -> bool:
+        """
+        Return whether or not the git status is clean or not
+
+        Returns:
+            `bool`: `True` if the git status is clean, `False` otherwise.
+        """
+        try:
+            git_status = run_subprocess("git status --porcelain", self.local_dir).stdout.strip()
+        except subprocess.CalledProcessError as exc:
+            raise EnvironmentError(exc.stderr)
+
+        return len(git_status) == 0
+
+    def push_to_hub(
+        self,
+        commit_message: str = "commit files to HF hub",
+        blocking: bool = True,
+        clean_ok: bool = True,
+        auto_lfs_prune: bool = False,
+    ) -> Union[None, str, Tuple[str, CommandInProgress]]:
+        """
+        Helper to add, commit, and push files to remote repository on the
+        HuggingFace Hub. Will automatically track large files (>10MB).
+
+        Args:
+            commit_message (`str`):
+                Message to use for the commit.
+            blocking (`bool`, *optional*, defaults to `True`):
+                Whether the function should return only when the `git push` has
+                finished.
+            clean_ok (`bool`, *optional*, defaults to `True`):
+                If True, this function will return None if the repo is
+                untouched. Default behavior is to fail because the git command
+                fails.
+            auto_lfs_prune (`bool`, *optional*, defaults to `False`):
+                Whether to automatically prune files once they have been pushed
+                to the remote.
+        """
+        if clean_ok and self.is_repo_clean():
+            logger.info("Repo currently clean. Ignoring push_to_hub")
+            return None
+        self.git_add(auto_lfs_track=True)
+        self.git_commit(commit_message)
+        return self.git_push(
+            upstream=f"origin {self.current_branch}",
+            blocking=blocking,
+            auto_lfs_prune=auto_lfs_prune,
+        )
+
+    @contextmanager
+    def commit(
+        self,
+        commit_message: str,
+        branch: Optional[str] = None,
+        track_large_files: bool = True,
+        blocking: bool = True,
+        auto_lfs_prune: bool = False,
+    ):
+        """
+        Context manager utility to handle committing to a repository. This
+        automatically tracks large files (>10Mb) with git-lfs. Set the
+        `track_large_files` argument to `False` if you wish to ignore that
+        behavior.
+
+        Args:
+            commit_message (`str`):
+                Message to use for the commit.
+            branch (`str`, *optional*):
+                The branch on which the commit will appear. This branch will be
+                checked-out before any operation.
+            track_large_files (`bool`, *optional*, defaults to `True`):
+                Whether to automatically track large files or not. Will do so by
+                default.
+            blocking (`bool`, *optional*, defaults to `True`):
+                Whether the function should return only when the `git push` has
+                finished.
+            auto_lfs_prune (`bool`, defaults to `True`):
+                Whether to automatically prune files once they have been pushed
+                to the remote.
+
+        Examples:
+
+        ```python
+        >>> with Repository(
+        ...     "text-files",
+        ...     clone_from="<user>/text-files",
+        ...     token=True,
+        >>> ).commit("My first file :)"):
+        ...     with open("file.txt", "w+") as f:
+        ...         f.write(json.dumps({"hey": 8}))
+
+        >>> import torch
+
+        >>> model = torch.nn.Transformer()
+        >>> with Repository(
+        ...     "torch-model",
+        ...     clone_from="<user>/torch-model",
+        ...     token=True,
+        >>> ).commit("My cool model :)"):
+        ...     torch.save(model.state_dict(), "model.pt")
+        ```
+
+        """
+
+        files_to_stage = files_to_be_staged(".", folder=self.local_dir)
+
+        if len(files_to_stage):
+            files_in_msg = str(files_to_stage[:5])[:-1] + ", ...]" if len(files_to_stage) > 5 else str(files_to_stage)
+            logger.error(
+                "There exists some updated files in the local repository that are not"
+                f" committed: {files_in_msg}. This may lead to errors if checking out"
+                " a branch. These files and their modifications will be added to the"
+                " current commit."
+            )
+
+        if branch is not None:
+            self.git_checkout(branch, create_branch_ok=True)
+
+        if is_tracked_upstream(self.local_dir):
+            logger.warning("Pulling changes ...")
+            self.git_pull(rebase=True)
+        else:
+            logger.warning(f"The current branch has no upstream branch. Will push to 'origin {self.current_branch}'")
+
+        current_working_directory = os.getcwd()
+        os.chdir(os.path.join(current_working_directory, self.local_dir))
+
+        try:
+            yield self
+        finally:
+            self.git_add(auto_lfs_track=track_large_files)
+
+            try:
+                self.git_commit(commit_message)
+            except OSError as e:
+                # If no changes are detected, there is nothing to commit.
+                if "nothing to commit" not in str(e):
+                    raise e
+
+            try:
+                self.git_push(
+                    upstream=f"origin {self.current_branch}",
+                    blocking=blocking,
+                    auto_lfs_prune=auto_lfs_prune,
+                )
+            except OSError as e:
+                # If no changes are detected, there is nothing to commit.
+                if "could not read Username" in str(e):
+                    raise OSError("Couldn't authenticate user for push. Did you set `token` to `True`?") from e
+                else:
+                    raise e
+
+            os.chdir(current_working_directory)
+
+    def repocard_metadata_load(self) -> Optional[Dict]:
+        filepath = os.path.join(self.local_dir, REPOCARD_NAME)
+        if os.path.isfile(filepath):
+            return metadata_load(filepath)
+        return None
+
+    def repocard_metadata_save(self, data: Dict) -> None:
+        return metadata_save(os.path.join(self.local_dir, REPOCARD_NAME), data)
+
+    @property
+    def commands_failed(self):
+        """
+        Returns the asynchronous commands that failed.
+        """
+        return [c for c in self.command_queue if c.status > 0]
+
+    @property
+    def commands_in_progress(self):
+        """
+        Returns the asynchronous commands that are currently in progress.
+        """
+        return [c for c in self.command_queue if not c.is_done]
+
+    def wait_for_commands(self):
+        """
+        Blocking method: blocks all subsequent execution until all commands have
+        been processed.
+        """
+        index = 0
+        for command_failed in self.commands_failed:
+            logger.error(f"The {command_failed.title} command with PID {command_failed._process.pid} failed.")
+            logger.error(command_failed.stderr)
+
+        while self.commands_in_progress:
+            if index % 10 == 0:
+                logger.warning(
+                    f"Waiting for the following commands to finish before shutting down: {self.commands_in_progress}."
+                )
+
+            index += 1
+
+            time.sleep(1)
diff --git a/lib/python3.11/site-packages/huggingface_hub/templates/datasetcard_template.md b/lib/python3.11/site-packages/huggingface_hub/templates/datasetcard_template.md
new file mode 100644
index 0000000000000000000000000000000000000000..f8cb4c80bfe647627589bb2a0b58273c8478cd00
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/templates/datasetcard_template.md
@@ -0,0 +1,143 @@
+---
+# For reference on dataset card metadata, see the spec: https://github.com/huggingface/hub-docs/blob/main/datasetcard.md?plain=1
+# Doc / guide: https://huggingface.co/docs/hub/datasets-cards
+{{ card_data }}
+---
+
+# Dataset Card for {{ pretty_name | default("Dataset Name", true) }}
+
+<!-- Provide a quick summary of the dataset. -->
+
+{{ dataset_summary | default("", true) }}
+
+## Dataset Details
+
+### Dataset Description
+
+<!-- Provide a longer summary of what this dataset is. -->
+
+{{ dataset_description | default("", true) }}
+
+- **Curated by:** {{ curators | default("[More Information Needed]", true)}}
+- **Funded by [optional]:** {{ funded_by | default("[More Information Needed]", true)}}
+- **Shared by [optional]:** {{ shared_by | default("[More Information Needed]", true)}}
+- **Language(s) (NLP):** {{ language | default("[More Information Needed]", true)}}
+- **License:** {{ license | default("[More Information Needed]", true)}}
+
+### Dataset Sources [optional]
+
+<!-- Provide the basic links for the dataset. -->
+
+- **Repository:** {{ repo | default("[More Information Needed]", true)}}
+- **Paper [optional]:** {{ paper | default("[More Information Needed]", true)}}
+- **Demo [optional]:** {{ demo | default("[More Information Needed]", true)}}
+
+## Uses
+
+<!-- Address questions around how the dataset is intended to be used. -->
+
+### Direct Use
+
+<!-- This section describes suitable use cases for the dataset. -->
+
+{{ direct_use | default("[More Information Needed]", true)}}
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the dataset will not work well for. -->
+
+{{ out_of_scope_use | default("[More Information Needed]", true)}}
+
+## Dataset Structure
+
+<!-- This section provides a description of the dataset fields, and additional information about the dataset structure such as criteria used to create the splits, relationships between data points, etc. -->
+
+{{ dataset_structure | default("[More Information Needed]", true)}}
+
+## Dataset Creation
+
+### Curation Rationale
+
+<!-- Motivation for the creation of this dataset. -->
+
+{{ curation_rationale_section | default("[More Information Needed]", true)}}
+
+### Source Data
+
+<!-- This section describes the source data (e.g. news text and headlines, social media posts, translated sentences, ...). -->
+
+#### Data Collection and Processing
+
+<!-- This section describes the data collection and processing process such as data selection criteria, filtering and normalization methods, tools and libraries used, etc. -->
+
+{{ data_collection_and_processing_section | default("[More Information Needed]", true)}}
+
+#### Who are the source data producers?
+
+<!-- This section describes the people or systems who originally created the data. It should also include self-reported demographic or identity information for the source data creators if this information is available. -->
+
+{{ source_data_producers_section | default("[More Information Needed]", true)}}
+
+### Annotations [optional]
+
+<!-- If the dataset contains annotations which are not part of the initial data collection, use this section to describe them. -->
+
+#### Annotation process
+
+<!-- This section describes the annotation process such as annotation tools used in the process, the amount of data annotated, annotation guidelines provided to the annotators, interannotator statistics, annotation validation, etc. -->
+
+{{ annotation_process_section | default("[More Information Needed]", true)}}
+
+#### Who are the annotators?
+
+<!-- This section describes the people or systems who created the annotations. -->
+
+{{ who_are_annotators_section | default("[More Information Needed]", true)}}
+
+#### Personal and Sensitive Information
+
+<!-- State whether the dataset contains data that might be considered personal, sensitive, or private (e.g., data that reveals addresses, uniquely identifiable names or aliases, racial or ethnic origins, sexual orientations, religious beliefs, political opinions, financial or health data, etc.). If efforts were made to anonymize the data, describe the anonymization process. -->
+
+{{ personal_and_sensitive_information | default("[More Information Needed]", true)}}
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+{{ bias_risks_limitations | default("[More Information Needed]", true)}}
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+{{ bias_recommendations | default("Users should be made aware of the risks, biases and limitations of the dataset. More information needed for further recommendations.", true)}}
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the dataset, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+{{ citation_bibtex | default("[More Information Needed]", true)}}
+
+**APA:**
+
+{{ citation_apa | default("[More Information Needed]", true)}}
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the dataset or dataset card. -->
+
+{{ glossary | default("[More Information Needed]", true)}}
+
+## More Information [optional]
+
+{{ more_information | default("[More Information Needed]", true)}}
+
+## Dataset Card Authors [optional]
+
+{{ dataset_card_authors | default("[More Information Needed]", true)}}
+
+## Dataset Card Contact
+
+{{ dataset_card_contact | default("[More Information Needed]", true)}}
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/huggingface_hub/templates/modelcard_template.md b/lib/python3.11/site-packages/huggingface_hub/templates/modelcard_template.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a1bc02704ada2d19f83f85af4558f1fbe2a2097
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/templates/modelcard_template.md
@@ -0,0 +1,203 @@
+---
+# For reference on model card metadata, see the spec: https://github.com/huggingface/hub-docs/blob/main/modelcard.md?plain=1
+# Doc / guide: https://huggingface.co/docs/hub/model-cards
+{{ card_data }}
+---
+
+# Model Card for {{ model_id | default("Model ID", true) }}
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+{{ model_summary | default("", true) }}
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+{{ model_description | default("", true) }}
+
+- **Developed by:** {{ developers | default("[More Information Needed]", true)}}
+- **Funded by [optional]:** {{ funded_by | default("[More Information Needed]", true)}}
+- **Shared by [optional]:** {{ shared_by | default("[More Information Needed]", true)}}
+- **Model type:** {{ model_type | default("[More Information Needed]", true)}}
+- **Language(s) (NLP):** {{ language | default("[More Information Needed]", true)}}
+- **License:** {{ license | default("[More Information Needed]", true)}}
+- **Finetuned from model [optional]:** {{ base_model | default("[More Information Needed]", true)}}
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** {{ repo | default("[More Information Needed]", true)}}
+- **Paper [optional]:** {{ paper | default("[More Information Needed]", true)}}
+- **Demo [optional]:** {{ demo | default("[More Information Needed]", true)}}
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+{{ direct_use | default("[More Information Needed]", true)}}
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+{{ downstream_use | default("[More Information Needed]", true)}}
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+{{ out_of_scope_use | default("[More Information Needed]", true)}}
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+{{ bias_risks_limitations | default("[More Information Needed]", true)}}
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+{{ bias_recommendations | default("Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.", true)}}
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+{{ get_started_code | default("[More Information Needed]", true)}}
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+{{ training_data | default("[More Information Needed]", true)}}
+
+### Training Procedure 
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+{{ preprocessing | default("[More Information Needed]", true)}}
+
+
+#### Training Hyperparameters
+
+- **Training regime:** {{ training_regime | default("[More Information Needed]", true)}} <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+{{ speeds_sizes_times | default("[More Information Needed]", true)}}
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+{{ testing_data | default("[More Information Needed]", true)}}
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+{{ testing_factors | default("[More Information Needed]", true)}}
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+{{ testing_metrics | default("[More Information Needed]", true)}}
+
+### Results
+
+{{ results | default("[More Information Needed]", true)}}
+
+#### Summary
+
+{{ results_summary | default("", true) }}
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+{{ model_examination | default("[More Information Needed]", true)}}
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** {{ hardware_type | default("[More Information Needed]", true)}}
+- **Hours used:** {{ hours_used | default("[More Information Needed]", true)}}
+- **Cloud Provider:** {{ cloud_provider | default("[More Information Needed]", true)}}
+- **Compute Region:** {{ cloud_region | default("[More Information Needed]", true)}}
+- **Carbon Emitted:** {{ co2_emitted | default("[More Information Needed]", true)}}
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+{{ model_specs | default("[More Information Needed]", true)}}
+
+### Compute Infrastructure
+
+{{ compute_infrastructure | default("[More Information Needed]", true)}}
+
+#### Hardware
+
+{{ hardware_requirements | default("[More Information Needed]", true)}}
+
+#### Software
+
+{{ software | default("[More Information Needed]", true)}}
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+{{ citation_bibtex | default("[More Information Needed]", true)}}
+
+**APA:**
+
+{{ citation_apa | default("[More Information Needed]", true)}}
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+{{ glossary | default("[More Information Needed]", true)}}
+
+## More Information [optional]
+
+{{ more_information | default("[More Information Needed]", true)}}
+
+## Model Card Authors [optional]
+
+{{ model_card_authors | default("[More Information Needed]", true)}}
+
+## Model Card Contact
+
+{{ model_card_contact | default("[More Information Needed]", true)}}
+
+
+
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__init__.py b/lib/python3.11/site-packages/huggingface_hub/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a15434e0004ccb3a993eaeeffecc1f9a8c3ff928
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/__init__.py
@@ -0,0 +1,108 @@
+# flake8: noqa
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+from . import tqdm as _tqdm  # _tqdm is the module
+from ._cache_assets import cached_assets_path
+from ._cache_manager import (
+    CachedFileInfo,
+    CachedRepoInfo,
+    CachedRevisionInfo,
+    CacheNotFound,
+    CorruptedCacheException,
+    DeleteCacheStrategy,
+    HFCacheInfo,
+    scan_cache_dir,
+)
+from ._chunk_utils import chunk_iterable
+from ._datetime import parse_datetime
+from ._errors import (
+    BadRequestError,
+    EntryNotFoundError,
+    FileMetadataError,
+    GatedRepoError,
+    HfHubHTTPError,
+    LocalEntryNotFoundError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+    hf_raise_for_status,
+)
+from ._token import get_token
+from ._fixes import SoftTemporaryDirectory, yaml_dump
+from ._git_credential import list_credential_helpers, set_git_credential, unset_git_credential
+from ._headers import build_hf_headers, get_token_to_send, LocalTokenNotFoundError
+from ._hf_folder import HfFolder
+from ._http import configure_http_backend, get_session, http_backoff, reset_sessions, OfflineModeIsEnabled
+from ._pagination import paginate
+from ._paths import filter_repo_objects, IGNORE_GIT_FOLDER_PATTERNS
+from ._experimental import experimental
+from ._runtime import (
+    dump_environment_info,
+    get_aiohttp_version,
+    get_fastai_version,
+    get_fastcore_version,
+    get_gradio_version,
+    get_graphviz_version,
+    get_hf_hub_version,
+    get_hf_transfer_version,
+    get_jinja_version,
+    get_numpy_version,
+    get_pillow_version,
+    get_pydantic_version,
+    get_pydot_version,
+    get_python_version,
+    get_tensorboard_version,
+    get_tf_version,
+    get_torch_version,
+    is_aiohttp_available,
+    is_fastai_available,
+    is_fastcore_available,
+    is_numpy_available,
+    is_google_colab,
+    is_gradio_available,
+    is_graphviz_available,
+    is_hf_transfer_available,
+    is_jinja_available,
+    is_notebook,
+    is_pillow_available,
+    is_pydantic_available,
+    is_pydot_available,
+    is_tensorboard_available,
+    is_tf_available,
+    is_torch_available,
+)
+from ._safetensors import (
+    SafetensorsFileMetadata,
+    SafetensorsRepoMetadata,
+    TensorInfo,
+    SafetensorsParsingError,
+    NotASafetensorsRepoError,
+)
+from ._subprocess import capture_output, run_interactive_subprocess, run_subprocess
+from ._validators import (
+    HFValidationError,
+    smoothly_deprecate_use_auth_token,
+    validate_hf_hub_args,
+    validate_repo_id,
+)
+from .tqdm import (
+    are_progress_bars_disabled,
+    disable_progress_bars,
+    enable_progress_bars,
+    tqdm,
+    tqdm_stream_file,
+)
+from ._telemetry import send_telemetry
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c338f2f7b931a0409302c9a43dc4fa8f4cd8d33f
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_cache_assets.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_cache_assets.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..056c4666afdf15f104214ece87e2f063ce507ce1
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_cache_assets.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_cache_manager.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_cache_manager.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b59f51185c1c401b9a18526e40709a3f7fe7eb4
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_cache_manager.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_chunk_utils.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_chunk_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4a46399556d562c072bc1699c7ea251d54e4c30
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_chunk_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_datetime.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_datetime.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90d4ce5fa61679eef320b2a6118a299ed09002fd
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_datetime.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_deprecation.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_deprecation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ad27f0946224d0ddd351b2bde4a567f670553fc3
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_deprecation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_errors.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_errors.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..79bb75b08d420baa8a8824d9a081130b55e4cc65
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_errors.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_experimental.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_experimental.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5cf480e19fa5deb379a652d345c5ef02c157541
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_experimental.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_fixes.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_fixes.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd73ca9df37fade7c0118f5161f50101c2761788
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_fixes.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_git_credential.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_git_credential.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91616cc2f554922f77d37fefce7af8d1227a772c
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_git_credential.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_headers.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_headers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61fcdad5bcc6cd871049fadb9209d99a59684ea1
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_headers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_hf_folder.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_hf_folder.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6be6e686cb3ccd1aeddeff134e13349f546b8757
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_hf_folder.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_http.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_http.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ae6e58663f3c9f4ea6884ed71e34c6af30039e5
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_http.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_pagination.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_pagination.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61f59ba9c81bf1ac8062bd1c132e5c806cb76fd4
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_pagination.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_paths.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_paths.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5c47048ea728095cf4710e0882ab793734fb23d
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_paths.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_runtime.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_runtime.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a21ea9bf8eee5baeca4fec33502df56c5bd2049
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_runtime.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_safetensors.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_safetensors.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..caf36de7ddfc0e702eaf69308f11434283e9de09
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_safetensors.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_subprocess.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_subprocess.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05702a1bdcc25339719eb83da548d352b4ea051b
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_subprocess.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_telemetry.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_telemetry.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f29b1aa66c10f71cf9e010bf9cf2c6316dd1af8
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_telemetry.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_token.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_token.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..140bbfb0f4ff84bd7304845c1f3a09d3f8b1fc43
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_token.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_typing.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_typing.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ec318e72c0c986d8f5c72faacfb49d123c6915e3
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_typing.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_validators.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_validators.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7702038f88e62a86ef1d214da2408a2a72615e63
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/_validators.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/endpoint_helpers.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/endpoint_helpers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e03014b9d6d2d77f6c831e89d943551a20ee407
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/endpoint_helpers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/insecure_hashlib.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/insecure_hashlib.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ef0013e7d9be32992d4d0f58d001ea903d77709
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/insecure_hashlib.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/logging.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/logging.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9768787a7ed3f9c2166d3d655ef3da1d4b1edb55
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/logging.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/sha.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/sha.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..074c4d703bffab2cd72700df6ac0e1e6714b7ee5
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/sha.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/tqdm.cpython-311.pyc b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/tqdm.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ecff0248526fa2e0bb794db8b4e179c1b70fbd6c
Binary files /dev/null and b/lib/python3.11/site-packages/huggingface_hub/utils/__pycache__/tqdm.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_cache_assets.py b/lib/python3.11/site-packages/huggingface_hub/utils/_cache_assets.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5d435df9b0bb0c67c0bcb5ef65711e9aef367f6
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_cache_assets.py
@@ -0,0 +1,135 @@
+# coding=utf-8
+# Copyright 2019-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from pathlib import Path
+from typing import Union
+
+from ..constants import HF_ASSETS_CACHE
+
+
+def cached_assets_path(
+    library_name: str,
+    namespace: str = "default",
+    subfolder: str = "default",
+    *,
+    assets_dir: Union[str, Path, None] = None,
+):
+    """Return a folder path to cache arbitrary files.
+
+    `huggingface_hub` provides a canonical folder path to store assets. This is the
+    recommended way to integrate cache in a downstream library as it will benefit from
+    the builtins tools to scan and delete the cache properly.
+
+    The distinction is made between files cached from the Hub and assets. Files from the
+    Hub are cached in a git-aware manner and entirely managed by `huggingface_hub`. See
+    [related documentation](https://huggingface.co/docs/huggingface_hub/how-to-cache).
+    All other files that a downstream library caches are considered to be "assets"
+    (files downloaded from external sources, extracted from a .tar archive, preprocessed
+    for training,...).
+
+    Once the folder path is generated, it is guaranteed to exist and to be a directory.
+    The path is based on 3 levels of depth: the library name, a namespace and a
+    subfolder. Those 3 levels grants flexibility while allowing `huggingface_hub` to
+    expect folders when scanning/deleting parts of the assets cache. Within a library,
+    it is expected that all namespaces share the same subset of subfolder names but this
+    is not a mandatory rule. The downstream library has then full control on which file
+    structure to adopt within its cache. Namespace and subfolder are optional (would
+    default to a `"default/"` subfolder) but library name is mandatory as we want every
+    downstream library to manage its own cache.
+
+    Expected tree:
+    ```text
+        assets/
+        └── datasets/
+        │   ├── SQuAD/
+        │   │   ├── downloaded/
+        │   │   ├── extracted/
+        │   │   └── processed/
+        │   ├── Helsinki-NLP--tatoeba_mt/
+        │       ├── downloaded/
+        │       ├── extracted/
+        │       └── processed/
+        └── transformers/
+            ├── default/
+            │   ├── something/
+            ├── bert-base-cased/
+            │   ├── default/
+            │   └── training/
+        hub/
+        └── models--julien-c--EsperBERTo-small/
+            ├── blobs/
+            │   ├── (...)
+            │   ├── (...)
+            ├── refs/
+            │   └── (...)
+            └── [ 128]  snapshots/
+                ├── 2439f60ef33a0d46d85da5001d52aeda5b00ce9f/
+                │   ├── (...)
+                └── bbc77c8132af1cc5cf678da3f1ddf2de43606d48/
+                    └── (...)
+    ```
+
+
+    Args:
+        library_name (`str`):
+            Name of the library that will manage the cache folder. Example: `"dataset"`.
+        namespace (`str`, *optional*, defaults to "default"):
+            Namespace to which the data belongs. Example: `"SQuAD"`.
+        subfolder (`str`, *optional*, defaults to "default"):
+            Subfolder in which the data will be stored. Example: `extracted`.
+        assets_dir (`str`, `Path`, *optional*):
+            Path to the folder where assets are cached. This must not be the same folder
+            where Hub files are cached. Defaults to `HF_HOME / "assets"` if not provided.
+            Can also be set with `HF_ASSETS_CACHE` environment variable.
+
+    Returns:
+        Path to the cache folder (`Path`).
+
+    Example:
+    ```py
+    >>> from huggingface_hub import cached_assets_path
+
+    >>> cached_assets_path(library_name="datasets", namespace="SQuAD", subfolder="download")
+    PosixPath('/home/wauplin/.cache/huggingface/extra/datasets/SQuAD/download')
+
+    >>> cached_assets_path(library_name="datasets", namespace="SQuAD", subfolder="extracted")
+    PosixPath('/home/wauplin/.cache/huggingface/extra/datasets/SQuAD/extracted')
+
+    >>> cached_assets_path(library_name="datasets", namespace="Helsinki-NLP/tatoeba_mt")
+    PosixPath('/home/wauplin/.cache/huggingface/extra/datasets/Helsinki-NLP--tatoeba_mt/default')
+
+    >>> cached_assets_path(library_name="datasets", assets_dir="/tmp/tmp123456")
+    PosixPath('/tmp/tmp123456/datasets/default/default')
+    ```
+    """
+    # Resolve assets_dir
+    if assets_dir is None:
+        assets_dir = HF_ASSETS_CACHE
+    assets_dir = Path(assets_dir).expanduser().resolve()
+
+    # Avoid names that could create path issues
+    for part in (" ", "/", "\\"):
+        library_name = library_name.replace(part, "--")
+        namespace = namespace.replace(part, "--")
+        subfolder = subfolder.replace(part, "--")
+
+    # Path to subfolder is created
+    path = assets_dir / library_name / namespace / subfolder
+    try:
+        path.mkdir(exist_ok=True, parents=True)
+    except (FileExistsError, NotADirectoryError):
+        raise ValueError(f"Corrupted assets folder: cannot create directory because of an existing file ({path}).")
+
+    # Return
+    return path
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_cache_manager.py b/lib/python3.11/site-packages/huggingface_hub/utils/_cache_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..896eee724b90deb6dc24f57fe50847ce69287d47
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_cache_manager.py
@@ -0,0 +1,806 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to manage the HF cache directory."""
+import os
+import shutil
+import time
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, FrozenSet, List, Literal, Optional, Set, Union
+
+from ..constants import HF_HUB_CACHE
+from . import logging
+
+
+logger = logging.get_logger(__name__)
+
+REPO_TYPE_T = Literal["model", "dataset", "space"]
+
+
+class CacheNotFound(Exception):
+    """Exception thrown when the Huggingface cache is not found."""
+
+    cache_dir: Union[str, Path]
+
+    def __init__(self, msg: str, cache_dir: Union[str, Path], *args, **kwargs):
+        super().__init__(msg, *args, **kwargs)
+        self.cache_dir = cache_dir
+
+
+class CorruptedCacheException(Exception):
+    """Exception for any unexpected structure in the Huggingface cache-system."""
+
+
+@dataclass(frozen=True)
+class CachedFileInfo:
+    """Frozen data structure holding information about a single cached file.
+
+    Args:
+        file_name (`str`):
+            Name of the file. Example: `config.json`.
+        file_path (`Path`):
+            Path of the file in the `snapshots` directory. The file path is a symlink
+            referring to a blob in the `blobs` folder.
+        blob_path (`Path`):
+            Path of the blob file. This is equivalent to `file_path.resolve()`.
+        size_on_disk (`int`):
+            Size of the blob file in bytes.
+        blob_last_accessed (`float`):
+            Timestamp of the last time the blob file has been accessed (from any
+            revision).
+        blob_last_modified (`float`):
+            Timestamp of the last time the blob file has been modified/created.
+
+    <Tip warning={true}>
+
+    `blob_last_accessed` and `blob_last_modified` reliability can depend on the OS you
+    are using. See [python documentation](https://docs.python.org/3/library/os.html#os.stat_result)
+    for more details.
+
+    </Tip>
+    """
+
+    file_name: str
+    file_path: Path
+    blob_path: Path
+    size_on_disk: int
+
+    blob_last_accessed: float
+    blob_last_modified: float
+
+    @property
+    def blob_last_accessed_str(self) -> str:
+        """
+        (property) Timestamp of the last time the blob file has been accessed (from any
+        revision), returned as a human-readable string.
+
+        Example: "2 weeks ago".
+        """
+        return _format_timesince(self.blob_last_accessed)
+
+    @property
+    def blob_last_modified_str(self) -> str:
+        """
+        (property) Timestamp of the last time the blob file has been modified, returned
+        as a human-readable string.
+
+        Example: "2 weeks ago".
+        """
+        return _format_timesince(self.blob_last_modified)
+
+    @property
+    def size_on_disk_str(self) -> str:
+        """
+        (property) Size of the blob file as a human-readable string.
+
+        Example: "42.2K".
+        """
+        return _format_size(self.size_on_disk)
+
+
+@dataclass(frozen=True)
+class CachedRevisionInfo:
+    """Frozen data structure holding information about a revision.
+
+    A revision correspond to a folder in the `snapshots` folder and is populated with
+    the exact tree structure as the repo on the Hub but contains only symlinks. A
+    revision can be either referenced by 1 or more `refs` or be "detached" (no refs).
+
+    Args:
+        commit_hash (`str`):
+            Hash of the revision (unique).
+            Example: `"9338f7b671827df886678df2bdd7cc7b4f36dffd"`.
+        snapshot_path (`Path`):
+            Path to the revision directory in the `snapshots` folder. It contains the
+            exact tree structure as the repo on the Hub.
+        files: (`FrozenSet[CachedFileInfo]`):
+            Set of [`~CachedFileInfo`] describing all files contained in the snapshot.
+        refs (`FrozenSet[str]`):
+            Set of `refs` pointing to this revision. If the revision has no `refs`, it
+            is considered detached.
+            Example: `{"main", "2.4.0"}` or `{"refs/pr/1"}`.
+        size_on_disk (`int`):
+            Sum of the blob file sizes that are symlink-ed by the revision.
+        last_modified (`float`):
+            Timestamp of the last time the revision has been created/modified.
+
+    <Tip warning={true}>
+
+    `last_accessed` cannot be determined correctly on a single revision as blob files
+    are shared across revisions.
+
+    </Tip>
+
+    <Tip warning={true}>
+
+    `size_on_disk` is not necessarily the sum of all file sizes because of possible
+    duplicated files. Besides, only blobs are taken into account, not the (negligible)
+    size of folders and symlinks.
+
+    </Tip>
+    """
+
+    commit_hash: str
+    snapshot_path: Path
+    size_on_disk: int
+    files: FrozenSet[CachedFileInfo]
+    refs: FrozenSet[str]
+
+    last_modified: float
+
+    @property
+    def last_modified_str(self) -> str:
+        """
+        (property) Timestamp of the last time the revision has been modified, returned
+        as a human-readable string.
+
+        Example: "2 weeks ago".
+        """
+        return _format_timesince(self.last_modified)
+
+    @property
+    def size_on_disk_str(self) -> str:
+        """
+        (property) Sum of the blob file sizes as a human-readable string.
+
+        Example: "42.2K".
+        """
+        return _format_size(self.size_on_disk)
+
+    @property
+    def nb_files(self) -> int:
+        """
+        (property) Total number of files in the revision.
+        """
+        return len(self.files)
+
+
+@dataclass(frozen=True)
+class CachedRepoInfo:
+    """Frozen data structure holding information about a cached repository.
+
+    Args:
+        repo_id (`str`):
+            Repo id of the repo on the Hub. Example: `"google/fleurs"`.
+        repo_type (`Literal["dataset", "model", "space"]`):
+            Type of the cached repo.
+        repo_path (`Path`):
+            Local path to the cached repo.
+        size_on_disk (`int`):
+            Sum of the blob file sizes in the cached repo.
+        nb_files (`int`):
+            Total number of blob files in the cached repo.
+        revisions (`FrozenSet[CachedRevisionInfo]`):
+            Set of [`~CachedRevisionInfo`] describing all revisions cached in the repo.
+        last_accessed (`float`):
+            Timestamp of the last time a blob file of the repo has been accessed.
+        last_modified (`float`):
+            Timestamp of the last time a blob file of the repo has been modified/created.
+
+    <Tip warning={true}>
+
+    `size_on_disk` is not necessarily the sum of all revisions sizes because of
+    duplicated files. Besides, only blobs are taken into account, not the (negligible)
+    size of folders and symlinks.
+
+    </Tip>
+
+    <Tip warning={true}>
+
+    `last_accessed` and `last_modified` reliability can depend on the OS you are using.
+    See [python documentation](https://docs.python.org/3/library/os.html#os.stat_result)
+    for more details.
+
+    </Tip>
+    """
+
+    repo_id: str
+    repo_type: REPO_TYPE_T
+    repo_path: Path
+    size_on_disk: int
+    nb_files: int
+    revisions: FrozenSet[CachedRevisionInfo]
+
+    last_accessed: float
+    last_modified: float
+
+    @property
+    def last_accessed_str(self) -> str:
+        """
+        (property) Last time a blob file of the repo has been accessed, returned as a
+        human-readable string.
+
+        Example: "2 weeks ago".
+        """
+        return _format_timesince(self.last_accessed)
+
+    @property
+    def last_modified_str(self) -> str:
+        """
+        (property) Last time a blob file of the repo has been modified, returned as a
+        human-readable string.
+
+        Example: "2 weeks ago".
+        """
+        return _format_timesince(self.last_modified)
+
+    @property
+    def size_on_disk_str(self) -> str:
+        """
+        (property) Sum of the blob file sizes as a human-readable string.
+
+        Example: "42.2K".
+        """
+        return _format_size(self.size_on_disk)
+
+    @property
+    def refs(self) -> Dict[str, CachedRevisionInfo]:
+        """
+        (property) Mapping between `refs` and revision data structures.
+        """
+        return {ref: revision for revision in self.revisions for ref in revision.refs}
+
+
+@dataclass(frozen=True)
+class DeleteCacheStrategy:
+    """Frozen data structure holding the strategy to delete cached revisions.
+
+    This object is not meant to be instantiated programmatically but to be returned by
+    [`~utils.HFCacheInfo.delete_revisions`]. See documentation for usage example.
+
+    Args:
+        expected_freed_size (`float`):
+            Expected freed size once strategy is executed.
+        blobs (`FrozenSet[Path]`):
+            Set of blob file paths to be deleted.
+        refs (`FrozenSet[Path]`):
+            Set of reference file paths to be deleted.
+        repos (`FrozenSet[Path]`):
+            Set of entire repo paths to be deleted.
+        snapshots (`FrozenSet[Path]`):
+            Set of snapshots to be deleted (directory of symlinks).
+    """
+
+    expected_freed_size: int
+    blobs: FrozenSet[Path]
+    refs: FrozenSet[Path]
+    repos: FrozenSet[Path]
+    snapshots: FrozenSet[Path]
+
+    @property
+    def expected_freed_size_str(self) -> str:
+        """
+        (property) Expected size that will be freed as a human-readable string.
+
+        Example: "42.2K".
+        """
+        return _format_size(self.expected_freed_size)
+
+    def execute(self) -> None:
+        """Execute the defined strategy.
+
+        <Tip warning={true}>
+
+        If this method is interrupted, the cache might get corrupted. Deletion order is
+        implemented so that references and symlinks are deleted before the actual blob
+        files.
+
+        </Tip>
+
+        <Tip warning={true}>
+
+        This method is irreversible. If executed, cached files are erased and must be
+        downloaded again.
+
+        </Tip>
+        """
+        # Deletion order matters. Blobs are deleted in last so that the user can't end
+        # up in a state where a `ref`` refers to a missing snapshot or a snapshot
+        # symlink refers to a deleted blob.
+
+        # Delete entire repos
+        for path in self.repos:
+            _try_delete_path(path, path_type="repo")
+
+        # Delete snapshot directories
+        for path in self.snapshots:
+            _try_delete_path(path, path_type="snapshot")
+
+        # Delete refs files
+        for path in self.refs:
+            _try_delete_path(path, path_type="ref")
+
+        # Delete blob files
+        for path in self.blobs:
+            _try_delete_path(path, path_type="blob")
+
+        logger.info(f"Cache deletion done. Saved {self.expected_freed_size_str}.")
+
+
+@dataclass(frozen=True)
+class HFCacheInfo:
+    """Frozen data structure holding information about the entire cache-system.
+
+    This data structure is returned by [`scan_cache_dir`] and is immutable.
+
+    Args:
+        size_on_disk (`int`):
+            Sum of all valid repo sizes in the cache-system.
+        repos (`FrozenSet[CachedRepoInfo]`):
+            Set of [`~CachedRepoInfo`] describing all valid cached repos found on the
+            cache-system while scanning.
+        warnings (`List[CorruptedCacheException]`):
+            List of [`~CorruptedCacheException`] that occurred while scanning the cache.
+            Those exceptions are captured so that the scan can continue. Corrupted repos
+            are skipped from the scan.
+
+    <Tip warning={true}>
+
+    Here `size_on_disk` is equal to the sum of all repo sizes (only blobs). However if
+    some cached repos are corrupted, their sizes are not taken into account.
+
+    </Tip>
+    """
+
+    size_on_disk: int
+    repos: FrozenSet[CachedRepoInfo]
+    warnings: List[CorruptedCacheException]
+
+    @property
+    def size_on_disk_str(self) -> str:
+        """
+        (property) Sum of all valid repo sizes in the cache-system as a human-readable
+        string.
+
+        Example: "42.2K".
+        """
+        return _format_size(self.size_on_disk)
+
+    def delete_revisions(self, *revisions: str) -> DeleteCacheStrategy:
+        """Prepare the strategy to delete one or more revisions cached locally.
+
+        Input revisions can be any revision hash. If a revision hash is not found in the
+        local cache, a warning is thrown but no error is raised. Revisions can be from
+        different cached repos since hashes are unique across repos,
+
+        Examples:
+        ```py
+        >>> from huggingface_hub import scan_cache_dir
+        >>> cache_info = scan_cache_dir()
+        >>> delete_strategy = cache_info.delete_revisions(
+        ...     "81fd1d6e7847c99f5862c9fb81387956d99ec7aa"
+        ... )
+        >>> print(f"Will free {delete_strategy.expected_freed_size_str}.")
+        Will free 7.9K.
+        >>> delete_strategy.execute()
+        Cache deletion done. Saved 7.9K.
+        ```
+
+        ```py
+        >>> from huggingface_hub import scan_cache_dir
+        >>> scan_cache_dir().delete_revisions(
+        ...     "81fd1d6e7847c99f5862c9fb81387956d99ec7aa",
+        ...     "e2983b237dccf3ab4937c97fa717319a9ca1a96d",
+        ...     "6c0e6080953db56375760c0471a8c5f2929baf11",
+        ... ).execute()
+        Cache deletion done. Saved 8.6G.
+        ```
+
+        <Tip warning={true}>
+
+        `delete_revisions` returns a [`~utils.DeleteCacheStrategy`] object that needs to
+        be executed. The [`~utils.DeleteCacheStrategy`] is not meant to be modified but
+        allows having a dry run before actually executing the deletion.
+
+        </Tip>
+        """
+        hashes_to_delete: Set[str] = set(revisions)
+
+        repos_with_revisions: Dict[CachedRepoInfo, Set[CachedRevisionInfo]] = defaultdict(set)
+
+        for repo in self.repos:
+            for revision in repo.revisions:
+                if revision.commit_hash in hashes_to_delete:
+                    repos_with_revisions[repo].add(revision)
+                    hashes_to_delete.remove(revision.commit_hash)
+
+        if len(hashes_to_delete) > 0:
+            logger.warning(f"Revision(s) not found - cannot delete them: {', '.join(hashes_to_delete)}")
+
+        delete_strategy_blobs: Set[Path] = set()
+        delete_strategy_refs: Set[Path] = set()
+        delete_strategy_repos: Set[Path] = set()
+        delete_strategy_snapshots: Set[Path] = set()
+        delete_strategy_expected_freed_size = 0
+
+        for affected_repo, revisions_to_delete in repos_with_revisions.items():
+            other_revisions = affected_repo.revisions - revisions_to_delete
+
+            # If no other revisions, it means all revisions are deleted
+            # -> delete the entire cached repo
+            if len(other_revisions) == 0:
+                delete_strategy_repos.add(affected_repo.repo_path)
+                delete_strategy_expected_freed_size += affected_repo.size_on_disk
+                continue
+
+            # Some revisions of the repo will be deleted but not all. We need to filter
+            # which blob files will not be linked anymore.
+            for revision_to_delete in revisions_to_delete:
+                # Snapshot dir
+                delete_strategy_snapshots.add(revision_to_delete.snapshot_path)
+
+                # Refs dir
+                for ref in revision_to_delete.refs:
+                    delete_strategy_refs.add(affected_repo.repo_path / "refs" / ref)
+
+                # Blobs dir
+                for file in revision_to_delete.files:
+                    if file.blob_path not in delete_strategy_blobs:
+                        is_file_alone = True
+                        for revision in other_revisions:
+                            for rev_file in revision.files:
+                                if file.blob_path == rev_file.blob_path:
+                                    is_file_alone = False
+                                    break
+                            if not is_file_alone:
+                                break
+
+                        # Blob file not referenced by remaining revisions -> delete
+                        if is_file_alone:
+                            delete_strategy_blobs.add(file.blob_path)
+                            delete_strategy_expected_freed_size += file.size_on_disk
+
+        # Return the strategy instead of executing it.
+        return DeleteCacheStrategy(
+            blobs=frozenset(delete_strategy_blobs),
+            refs=frozenset(delete_strategy_refs),
+            repos=frozenset(delete_strategy_repos),
+            snapshots=frozenset(delete_strategy_snapshots),
+            expected_freed_size=delete_strategy_expected_freed_size,
+        )
+
+
+def scan_cache_dir(cache_dir: Optional[Union[str, Path]] = None) -> HFCacheInfo:
+    """Scan the entire HF cache-system and return a [`~HFCacheInfo`] structure.
+
+    Use `scan_cache_dir` in order to programmatically scan your cache-system. The cache
+    will be scanned repo by repo. If a repo is corrupted, a [`~CorruptedCacheException`]
+    will be thrown internally but captured and returned in the [`~HFCacheInfo`]
+    structure. Only valid repos get a proper report.
+
+    ```py
+    >>> from huggingface_hub import scan_cache_dir
+
+    >>> hf_cache_info = scan_cache_dir()
+    HFCacheInfo(
+        size_on_disk=3398085269,
+        repos=frozenset({
+            CachedRepoInfo(
+                repo_id='t5-small',
+                repo_type='model',
+                repo_path=PosixPath(...),
+                size_on_disk=970726914,
+                nb_files=11,
+                revisions=frozenset({
+                    CachedRevisionInfo(
+                        commit_hash='d78aea13fa7ecd06c29e3e46195d6341255065d5',
+                        size_on_disk=970726339,
+                        snapshot_path=PosixPath(...),
+                        files=frozenset({
+                            CachedFileInfo(
+                                file_name='config.json',
+                                size_on_disk=1197
+                                file_path=PosixPath(...),
+                                blob_path=PosixPath(...),
+                            ),
+                            CachedFileInfo(...),
+                            ...
+                        }),
+                    ),
+                    CachedRevisionInfo(...),
+                    ...
+                }),
+            ),
+            CachedRepoInfo(...),
+            ...
+        }),
+        warnings=[
+            CorruptedCacheException("Snapshots dir doesn't exist in cached repo: ..."),
+            CorruptedCacheException(...),
+            ...
+        ],
+    )
+    ```
+
+    You can also print a detailed report directly from the `huggingface-cli` using:
+    ```text
+    > huggingface-cli scan-cache
+    REPO ID                     REPO TYPE SIZE ON DISK NB FILES REFS                LOCAL PATH
+    --------------------------- --------- ------------ -------- ------------------- -------------------------------------------------------------------------
+    glue                        dataset         116.3K       15 1.17.0, main, 2.4.0 /Users/lucain/.cache/huggingface/hub/datasets--glue
+    google/fleurs               dataset          64.9M        6 main, refs/pr/1     /Users/lucain/.cache/huggingface/hub/datasets--google--fleurs
+    Jean-Baptiste/camembert-ner model           441.0M        7 main                /Users/lucain/.cache/huggingface/hub/models--Jean-Baptiste--camembert-ner
+    bert-base-cased             model             1.9G       13 main                /Users/lucain/.cache/huggingface/hub/models--bert-base-cased
+    t5-base                     model            10.1K        3 main                /Users/lucain/.cache/huggingface/hub/models--t5-base
+    t5-small                    model           970.7M       11 refs/pr/1, main     /Users/lucain/.cache/huggingface/hub/models--t5-small
+
+    Done in 0.0s. Scanned 6 repo(s) for a total of 3.4G.
+    Got 1 warning(s) while scanning. Use -vvv to print details.
+    ```
+
+    Args:
+        cache_dir (`str` or `Path`, `optional`):
+            Cache directory to cache. Defaults to the default HF cache directory.
+
+    <Tip warning={true}>
+
+    Raises:
+
+        `CacheNotFound`
+          If the cache directory does not exist.
+
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+          If the cache directory is a file, instead of a directory.
+
+    </Tip>
+
+    Returns: a [`~HFCacheInfo`] object.
+    """
+    if cache_dir is None:
+        cache_dir = HF_HUB_CACHE
+
+    cache_dir = Path(cache_dir).expanduser().resolve()
+    if not cache_dir.exists():
+        raise CacheNotFound(
+            f"Cache directory not found: {cache_dir}. Please use `cache_dir` argument or set `HF_HUB_CACHE` environment variable.",
+            cache_dir=cache_dir,
+        )
+
+    if cache_dir.is_file():
+        raise ValueError(
+            f"Scan cache expects a directory but found a file: {cache_dir}. Please use `cache_dir` argument or set `HF_HUB_CACHE` environment variable."
+        )
+
+    repos: Set[CachedRepoInfo] = set()
+    warnings: List[CorruptedCacheException] = []
+    for repo_path in cache_dir.iterdir():
+        if repo_path.name == ".locks":  # skip './.locks/' folder
+            continue
+        try:
+            repos.add(_scan_cached_repo(repo_path))
+        except CorruptedCacheException as e:
+            warnings.append(e)
+
+    return HFCacheInfo(
+        repos=frozenset(repos),
+        size_on_disk=sum(repo.size_on_disk for repo in repos),
+        warnings=warnings,
+    )
+
+
+def _scan_cached_repo(repo_path: Path) -> CachedRepoInfo:
+    """Scan a single cache repo and return information about it.
+
+    Any unexpected behavior will raise a [`~CorruptedCacheException`].
+    """
+    if not repo_path.is_dir():
+        raise CorruptedCacheException(f"Repo path is not a directory: {repo_path}")
+
+    if "--" not in repo_path.name:
+        raise CorruptedCacheException(f"Repo path is not a valid HuggingFace cache directory: {repo_path}")
+
+    repo_type, repo_id = repo_path.name.split("--", maxsplit=1)
+    repo_type = repo_type[:-1]  # "models" -> "model"
+    repo_id = repo_id.replace("--", "/")  # google/fleurs -> "google/fleurs"
+
+    if repo_type not in {"dataset", "model", "space"}:
+        raise CorruptedCacheException(
+            f"Repo type must be `dataset`, `model` or `space`, found `{repo_type}` ({repo_path})."
+        )
+
+    blob_stats: Dict[Path, os.stat_result] = {}  # Key is blob_path, value is blob stats
+
+    snapshots_path = repo_path / "snapshots"
+    refs_path = repo_path / "refs"
+
+    if not snapshots_path.exists() or not snapshots_path.is_dir():
+        raise CorruptedCacheException(f"Snapshots dir doesn't exist in cached repo: {snapshots_path}")
+
+    # Scan over `refs` directory
+
+    # key is revision hash, value is set of refs
+    refs_by_hash: Dict[str, Set[str]] = defaultdict(set)
+    if refs_path.exists():
+        # Example of `refs` directory
+        # ── refs
+        #     ├── main
+        #     └── refs
+        #         └── pr
+        #             └── 1
+        if refs_path.is_file():
+            raise CorruptedCacheException(f"Refs directory cannot be a file: {refs_path}")
+
+        for ref_path in refs_path.glob("**/*"):
+            # glob("**/*") iterates over all files and directories -> skip directories
+            if ref_path.is_dir():
+                continue
+
+            ref_name = str(ref_path.relative_to(refs_path))
+            with ref_path.open() as f:
+                commit_hash = f.read()
+
+            refs_by_hash[commit_hash].add(ref_name)
+
+    # Scan snapshots directory
+    cached_revisions: Set[CachedRevisionInfo] = set()
+    for revision_path in snapshots_path.iterdir():
+        if revision_path.is_file():
+            raise CorruptedCacheException(f"Snapshots folder corrupted. Found a file: {revision_path}")
+
+        cached_files = set()
+        for file_path in revision_path.glob("**/*"):
+            # glob("**/*") iterates over all files and directories -> skip directories
+            if file_path.is_dir():
+                continue
+
+            blob_path = Path(file_path).resolve()
+            if not blob_path.exists():
+                raise CorruptedCacheException(f"Blob missing (broken symlink): {blob_path}")
+
+            if blob_path not in blob_stats:
+                blob_stats[blob_path] = blob_path.stat()
+
+            cached_files.add(
+                CachedFileInfo(
+                    file_name=file_path.name,
+                    file_path=file_path,
+                    size_on_disk=blob_stats[blob_path].st_size,
+                    blob_path=blob_path,
+                    blob_last_accessed=blob_stats[blob_path].st_atime,
+                    blob_last_modified=blob_stats[blob_path].st_mtime,
+                )
+            )
+
+        # Last modified is either the last modified blob file or the revision folder
+        # itself if it is empty
+        if len(cached_files) > 0:
+            revision_last_modified = max(blob_stats[file.blob_path].st_mtime for file in cached_files)
+        else:
+            revision_last_modified = revision_path.stat().st_mtime
+
+        cached_revisions.add(
+            CachedRevisionInfo(
+                commit_hash=revision_path.name,
+                files=frozenset(cached_files),
+                refs=frozenset(refs_by_hash.pop(revision_path.name, set())),
+                size_on_disk=sum(
+                    blob_stats[blob_path].st_size for blob_path in set(file.blob_path for file in cached_files)
+                ),
+                snapshot_path=revision_path,
+                last_modified=revision_last_modified,
+            )
+        )
+
+    # Check that all refs referred to an existing revision
+    if len(refs_by_hash) > 0:
+        raise CorruptedCacheException(
+            f"Reference(s) refer to missing commit hashes: {dict(refs_by_hash)} ({repo_path})."
+        )
+
+    # Last modified is either the last modified blob file or the repo folder itself if
+    # no blob files has been found. Same for last accessed.
+    if len(blob_stats) > 0:
+        repo_last_accessed = max(stat.st_atime for stat in blob_stats.values())
+        repo_last_modified = max(stat.st_mtime for stat in blob_stats.values())
+    else:
+        repo_stats = repo_path.stat()
+        repo_last_accessed = repo_stats.st_atime
+        repo_last_modified = repo_stats.st_mtime
+
+    # Build and return frozen structure
+    return CachedRepoInfo(
+        nb_files=len(blob_stats),
+        repo_id=repo_id,
+        repo_path=repo_path,
+        repo_type=repo_type,  # type: ignore
+        revisions=frozenset(cached_revisions),
+        size_on_disk=sum(stat.st_size for stat in blob_stats.values()),
+        last_accessed=repo_last_accessed,
+        last_modified=repo_last_modified,
+    )
+
+
+def _format_size(num: int) -> str:
+    """Format size in bytes into a human-readable string.
+
+    Taken from https://stackoverflow.com/a/1094933
+    """
+    num_f = float(num)
+    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
+        if abs(num_f) < 1000.0:
+            return f"{num_f:3.1f}{unit}"
+        num_f /= 1000.0
+    return f"{num_f:.1f}Y"
+
+
+_TIMESINCE_CHUNKS = (
+    # Label, divider, max value
+    ("second", 1, 60),
+    ("minute", 60, 60),
+    ("hour", 60 * 60, 24),
+    ("day", 60 * 60 * 24, 6),
+    ("week", 60 * 60 * 24 * 7, 6),
+    ("month", 60 * 60 * 24 * 30, 11),
+    ("year", 60 * 60 * 24 * 365, None),
+)
+
+
+def _format_timesince(ts: float) -> str:
+    """Format timestamp in seconds into a human-readable string, relative to now.
+
+    Vaguely inspired by Django's `timesince` formatter.
+    """
+    delta = time.time() - ts
+    if delta < 20:
+        return "a few seconds ago"
+    for label, divider, max_value in _TIMESINCE_CHUNKS:  # noqa: B007
+        value = round(delta / divider)
+        if max_value is not None and value <= max_value:
+            break
+    return f"{value} {label}{'s' if value > 1 else ''} ago"
+
+
+def _try_delete_path(path: Path, path_type: str) -> None:
+    """Try to delete a local file or folder.
+
+    If the path does not exists, error is logged as a warning and then ignored.
+
+    Args:
+        path (`Path`)
+            Path to delete. Can be a file or a folder.
+        path_type (`str`)
+            What path are we deleting ? Only for logging purposes. Example: "snapshot".
+    """
+    logger.info(f"Delete {path_type}: {path}")
+    try:
+        if path.is_file():
+            os.remove(path)
+        else:
+            shutil.rmtree(path)
+    except FileNotFoundError:
+        logger.warning(f"Couldn't delete {path_type}: file not found ({path})", exc_info=True)
+    except PermissionError:
+        logger.warning(f"Couldn't delete {path_type}: permission denied ({path})", exc_info=True)
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_chunk_utils.py b/lib/python3.11/site-packages/huggingface_hub/utils/_chunk_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ff0b8125ece381b1270754669ae8e708c370f61
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_chunk_utils.py
@@ -0,0 +1,64 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains a utility to iterate by chunks over an iterator."""
+import itertools
+from typing import Iterable, TypeVar
+
+
+T = TypeVar("T")
+
+
+def chunk_iterable(iterable: Iterable[T], chunk_size: int) -> Iterable[Iterable[T]]:
+    """Iterates over an iterator chunk by chunk.
+
+    Taken from https://stackoverflow.com/a/8998040.
+    See also https://github.com/huggingface/huggingface_hub/pull/920#discussion_r938793088.
+
+    Args:
+        iterable (`Iterable`):
+            The iterable on which we want to iterate.
+        chunk_size (`int`):
+            Size of the chunks. Must be a strictly positive integer (e.g. >0).
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub.utils import chunk_iterable
+
+    >>> for items in chunk_iterable(range(17), chunk_size=8):
+    ...     print(items)
+    # [0, 1, 2, 3, 4, 5, 6, 7]
+    # [8, 9, 10, 11, 12, 13, 14, 15]
+    # [16] # smaller last chunk
+    ```
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `chunk_size` <= 0.
+
+    <Tip warning={true}>
+        The last chunk can be smaller than `chunk_size`.
+    </Tip>
+    """
+    if not isinstance(chunk_size, int) or chunk_size <= 0:
+        raise ValueError("`chunk_size` must be a strictly positive integer (>0).")
+
+    iterator = iter(iterable)
+    while True:
+        try:
+            next_item = next(iterator)
+        except StopIteration:
+            return
+        yield itertools.chain((next_item,), itertools.islice(iterator, chunk_size - 1))
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_datetime.py b/lib/python3.11/site-packages/huggingface_hub/utils/_datetime.py
new file mode 100644
index 0000000000000000000000000000000000000000..716f373e2eef30ac312c4fa9d2acb1fd4614f4c5
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_datetime.py
@@ -0,0 +1,68 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to handle datetimes in Huggingface Hub."""
+from datetime import datetime, timedelta, timezone
+
+
+# Local machine offset compared to UTC.
+# Taken from https://stackoverflow.com/a/3168394.
+# `utcoffset()` returns `None` if no offset -> empty timedelta.
+UTC_OFFSET = datetime.now(timezone.utc).astimezone().utcoffset() or timedelta()
+
+
+def parse_datetime(date_string: str) -> datetime:
+    """
+    Parses a date_string returned from the server to a datetime object.
+
+    This parser is a weak-parser is the sense that it handles only a single format of
+    date_string. It is expected that the server format will never change. The
+    implementation depends only on the standard lib to avoid an external dependency
+    (python-dateutil). See full discussion about this decision on PR:
+    https://github.com/huggingface/huggingface_hub/pull/999.
+
+    Example:
+        ```py
+        > parse_datetime('2022-08-19T07:19:38.123Z')
+        datetime.datetime(2022, 8, 19, 7, 19, 38, 123000, tzinfo=timezone.utc)
+        ```
+
+    Args:
+        date_string (`str`):
+            A string representing a datetime returned by the Hub server.
+            String is expected to follow '%Y-%m-%dT%H:%M:%S.%fZ' pattern.
+
+    Returns:
+        A python datetime object.
+
+    Raises:
+        :class:`ValueError`:
+            If `date_string` cannot be parsed.
+    """
+    try:
+        # Datetime ending with a Z means "UTC". Here we parse the date as local machine
+        # timezone and then move it to the appropriate UTC timezone.
+        # See https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)
+        # Taken from https://stackoverflow.com/a/3168394.
+        if len(date_string) == 30:
+            # Means timezoned-timestamp with nanoseconds precision. We need to truncate the last 3 digits.
+            date_string = date_string[:-4] + "Z"
+        dt = datetime.strptime(date_string, "%Y-%m-%dT%H:%M:%S.%fZ")
+        dt += UTC_OFFSET  # By default, datetime is not timezoned -> move to UTC time
+        return dt.astimezone(timezone.utc)  # Set explicit timezone
+    except ValueError as e:
+        raise ValueError(
+            f"Cannot parse '{date_string}' as a datetime. Date string is expected to"
+            " follow '%Y-%m-%dT%H:%M:%S.%fZ' pattern."
+        ) from e
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_deprecation.py b/lib/python3.11/site-packages/huggingface_hub/utils/_deprecation.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cb8d6e418c76accd1ecd61158b4bdd265e12f71
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_deprecation.py
@@ -0,0 +1,136 @@
+import warnings
+from functools import wraps
+from inspect import Parameter, signature
+from typing import Iterable, Optional
+
+
+def _deprecate_positional_args(*, version: str):
+    """Decorator for methods that issues warnings for positional arguments.
+    Using the keyword-only argument syntax in pep 3102, arguments after the
+    * will issue a warning when passed as a positional argument.
+
+    Args:
+        version (`str`):
+            The version when positional arguments will result in error.
+    """
+
+    def _inner_deprecate_positional_args(f):
+        sig = signature(f)
+        kwonly_args = []
+        all_args = []
+        for name, param in sig.parameters.items():
+            if param.kind == Parameter.POSITIONAL_OR_KEYWORD:
+                all_args.append(name)
+            elif param.kind == Parameter.KEYWORD_ONLY:
+                kwonly_args.append(name)
+
+        @wraps(f)
+        def inner_f(*args, **kwargs):
+            extra_args = len(args) - len(all_args)
+            if extra_args <= 0:
+                return f(*args, **kwargs)
+            # extra_args > 0
+            args_msg = [
+                f"{name}='{arg}'" if isinstance(arg, str) else f"{name}={arg}"
+                for name, arg in zip(kwonly_args[:extra_args], args[-extra_args:])
+            ]
+            args_msg = ", ".join(args_msg)
+            warnings.warn(
+                f"Deprecated positional argument(s) used in '{f.__name__}': pass"
+                f" {args_msg} as keyword args. From version {version} passing these"
+                " as positional arguments will result in an error,",
+                FutureWarning,
+            )
+            kwargs.update(zip(sig.parameters, args))
+            return f(**kwargs)
+
+        return inner_f
+
+    return _inner_deprecate_positional_args
+
+
+def _deprecate_arguments(
+    *,
+    version: str,
+    deprecated_args: Iterable[str],
+    custom_message: Optional[str] = None,
+):
+    """Decorator to issue warnings when using deprecated arguments.
+
+    TODO: could be useful to be able to set a custom error message.
+
+    Args:
+        version (`str`):
+            The version when deprecated arguments will result in error.
+        deprecated_args (`List[str]`):
+            List of the arguments to be deprecated.
+        custom_message (`str`, *optional*):
+            Warning message that is raised. If not passed, a default warning message
+            will be created.
+    """
+
+    def _inner_deprecate_positional_args(f):
+        sig = signature(f)
+
+        @wraps(f)
+        def inner_f(*args, **kwargs):
+            # Check for used deprecated arguments
+            used_deprecated_args = []
+            for _, parameter in zip(args, sig.parameters.values()):
+                if parameter.name in deprecated_args:
+                    used_deprecated_args.append(parameter.name)
+            for kwarg_name, kwarg_value in kwargs.items():
+                if (
+                    # If argument is deprecated but still used
+                    kwarg_name in deprecated_args
+                    # And then the value is not the default value
+                    and kwarg_value != sig.parameters[kwarg_name].default
+                ):
+                    used_deprecated_args.append(kwarg_name)
+
+            # Warn and proceed
+            if len(used_deprecated_args) > 0:
+                message = (
+                    f"Deprecated argument(s) used in '{f.__name__}':"
+                    f" {', '.join(used_deprecated_args)}. Will not be supported from"
+                    f" version '{version}'."
+                )
+                if custom_message is not None:
+                    message += "\n\n" + custom_message
+                warnings.warn(message, FutureWarning)
+            return f(*args, **kwargs)
+
+        return inner_f
+
+    return _inner_deprecate_positional_args
+
+
+def _deprecate_method(*, version: str, message: Optional[str] = None):
+    """Decorator to issue warnings when using a deprecated method.
+
+    Args:
+        version (`str`):
+            The version when deprecated arguments will result in error.
+        message (`str`, *optional*):
+            Warning message that is raised. If not passed, a default warning message
+            will be created.
+    """
+
+    def _inner_deprecate_method(f):
+        name = f.__name__
+        if name == "__init__":
+            name = f.__qualname__.split(".")[0]  # class name instead of method name
+
+        @wraps(f)
+        def inner_f(*args, **kwargs):
+            warning_message = (
+                f"'{name}' (from '{f.__module__}') is deprecated and will be removed from version '{version}'."
+            )
+            if message is not None:
+                warning_message += " " + message
+            warnings.warn(warning_message, FutureWarning)
+            return f(*args, **kwargs)
+
+        return inner_f
+
+    return _inner_deprecate_method
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_errors.py b/lib/python3.11/site-packages/huggingface_hub/utils/_errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..37bddf331dddd4a8b5a825028f505f3685e2d6a1
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_errors.py
@@ -0,0 +1,359 @@
+import re
+from typing import Optional
+
+from requests import HTTPError, Response
+
+from ._fixes import JSONDecodeError
+
+
+REPO_API_REGEX = re.compile(
+    r"""
+        # staging or production endpoint
+        ^https://(hub-ci.)?huggingface.co
+        (
+            # on /api/repo_type/repo_id
+            /api/(models|datasets|spaces)/(.+)
+            |
+            # or /repo_id/resolve/revision/...
+            /(.+)/resolve/(.+)
+        )
+    """,
+    flags=re.VERBOSE,
+)
+
+
+class FileMetadataError(OSError):
+    """Error triggered when the metadata of a file on the Hub cannot be retrieved (missing ETag or commit_hash).
+
+    Inherits from `OSError` for backward compatibility.
+    """
+
+
+class HfHubHTTPError(HTTPError):
+    """
+    HTTPError to inherit from for any custom HTTP Error raised in HF Hub.
+
+    Any HTTPError is converted at least into a `HfHubHTTPError`. If some information is
+    sent back by the server, it will be added to the error message.
+
+    Added details:
+    - Request id from "X-Request-Id" header if exists.
+    - Server error message from the header "X-Error-Message".
+    - Server error message if we can found one in the response body.
+
+    Example:
+    ```py
+        import requests
+        from huggingface_hub.utils import get_session, hf_raise_for_status, HfHubHTTPError
+
+        response = get_session().post(...)
+        try:
+            hf_raise_for_status(response)
+        except HfHubHTTPError as e:
+            print(str(e)) # formatted message
+            e.request_id, e.server_message # details returned by server
+
+            # Complete the error message with additional information once it's raised
+            e.append_to_message("\n`create_commit` expects the repository to exist.")
+            raise
+    ```
+    """
+
+    request_id: Optional[str] = None
+    server_message: Optional[str] = None
+
+    def __init__(self, message: str, response: Optional[Response] = None):
+        # Parse server information if any.
+        if response is not None:
+            self.request_id = response.headers.get("X-Request-Id")
+            try:
+                server_data = response.json()
+            except JSONDecodeError:
+                server_data = {}
+
+            # Retrieve server error message from multiple sources
+            server_message_from_headers = response.headers.get("X-Error-Message")
+            server_message_from_body = server_data.get("error")
+            server_multiple_messages_from_body = "\n".join(
+                error["message"] for error in server_data.get("errors", []) if "message" in error
+            )
+
+            # Concatenate error messages
+            _server_message = ""
+            if server_message_from_headers is not None:  # from headers
+                _server_message += server_message_from_headers + "\n"
+            if server_message_from_body is not None:  # from body "error"
+                if isinstance(server_message_from_body, list):
+                    server_message_from_body = "\n".join(server_message_from_body)
+                if server_message_from_body not in _server_message:
+                    _server_message += server_message_from_body + "\n"
+            if server_multiple_messages_from_body is not None:  # from body "errors"
+                if server_multiple_messages_from_body not in _server_message:
+                    _server_message += server_multiple_messages_from_body + "\n"
+            _server_message = _server_message.strip()
+
+            # Set message to `HfHubHTTPError` (if any)
+            if _server_message != "":
+                self.server_message = _server_message
+
+        super().__init__(
+            _format_error_message(
+                message,
+                request_id=self.request_id,
+                server_message=self.server_message,
+            ),
+            response=response,  # type: ignore
+            request=response.request if response is not None else None,  # type: ignore
+        )
+
+    def append_to_message(self, additional_message: str) -> None:
+        """Append additional information to the `HfHubHTTPError` initial message."""
+        self.args = (self.args[0] + additional_message,) + self.args[1:]
+
+
+class RepositoryNotFoundError(HfHubHTTPError):
+    """
+    Raised when trying to access a hf.co URL with an invalid repository name, or
+    with a private repo name the user does not have access to.
+
+    Example:
+
+    ```py
+    >>> from huggingface_hub import model_info
+    >>> model_info("<non_existent_repository>")
+    (...)
+    huggingface_hub.utils._errors.RepositoryNotFoundError: 401 Client Error. (Request ID: PvMw_VjBMjVdMz53WKIzP)
+
+    Repository Not Found for url: https://huggingface.co/api/models/%3Cnon_existent_repository%3E.
+    Please make sure you specified the correct `repo_id` and `repo_type`.
+    If the repo is private, make sure you are authenticated.
+    Invalid username or password.
+    ```
+    """
+
+
+class GatedRepoError(RepositoryNotFoundError):
+    """
+    Raised when trying to access a gated repository for which the user is not on the
+    authorized list.
+
+    Note: derives from `RepositoryNotFoundError` to ensure backward compatibility.
+
+    Example:
+
+    ```py
+    >>> from huggingface_hub import model_info
+    >>> model_info("<gated_repository>")
+    (...)
+    huggingface_hub.utils._errors.GatedRepoError: 403 Client Error. (Request ID: ViT1Bf7O_026LGSQuVqfa)
+
+    Cannot access gated repo for url https://huggingface.co/api/models/ardent-figment/gated-model.
+    Access to model ardent-figment/gated-model is restricted and you are not in the authorized list.
+    Visit https://huggingface.co/ardent-figment/gated-model to ask for access.
+    ```
+    """
+
+
+class RevisionNotFoundError(HfHubHTTPError):
+    """
+    Raised when trying to access a hf.co URL with a valid repository but an invalid
+    revision.
+
+    Example:
+
+    ```py
+    >>> from huggingface_hub import hf_hub_download
+    >>> hf_hub_download('bert-base-cased', 'config.json', revision='<non-existent-revision>')
+    (...)
+    huggingface_hub.utils._errors.RevisionNotFoundError: 404 Client Error. (Request ID: Mwhe_c3Kt650GcdKEFomX)
+
+    Revision Not Found for url: https://huggingface.co/bert-base-cased/resolve/%3Cnon-existent-revision%3E/config.json.
+    ```
+    """
+
+
+class EntryNotFoundError(HfHubHTTPError):
+    """
+    Raised when trying to access a hf.co URL with a valid repository and revision
+    but an invalid filename.
+
+    Example:
+
+    ```py
+    >>> from huggingface_hub import hf_hub_download
+    >>> hf_hub_download('bert-base-cased', '<non-existent-file>')
+    (...)
+    huggingface_hub.utils._errors.EntryNotFoundError: 404 Client Error. (Request ID: 53pNl6M0MxsnG5Sw8JA6x)
+
+    Entry Not Found for url: https://huggingface.co/bert-base-cased/resolve/main/%3Cnon-existent-file%3E.
+    ```
+    """
+
+
+class LocalEntryNotFoundError(EntryNotFoundError, FileNotFoundError, ValueError):
+    """
+    Raised when trying to access a file or snapshot that is not on the disk when network is
+    disabled or unavailable (connection issue). The entry may exist on the Hub.
+
+    Note: `ValueError` type is to ensure backward compatibility.
+    Note: `LocalEntryNotFoundError` derives from `HTTPError` because of `EntryNotFoundError`
+          even when it is not a network issue.
+
+    Example:
+
+    ```py
+    >>> from huggingface_hub import hf_hub_download
+    >>> hf_hub_download('bert-base-cased', '<non-cached-file>',  local_files_only=True)
+    (...)
+    huggingface_hub.utils._errors.LocalEntryNotFoundError: Cannot find the requested files in the disk cache and outgoing traffic has been disabled. To enable hf.co look-ups and downloads online, set 'local_files_only' to False.
+    ```
+    """
+
+    def __init__(self, message: str):
+        super().__init__(message, response=None)
+
+
+class BadRequestError(HfHubHTTPError, ValueError):
+    """
+    Raised by `hf_raise_for_status` when the server returns a HTTP 400 error.
+
+    Example:
+
+    ```py
+    >>> resp = requests.post("hf.co/api/check", ...)
+    >>> hf_raise_for_status(resp, endpoint_name="check")
+    huggingface_hub.utils._errors.BadRequestError: Bad request for check endpoint: {details} (Request ID: XXX)
+    ```
+    """
+
+
+def hf_raise_for_status(response: Response, endpoint_name: Optional[str] = None) -> None:
+    """
+    Internal version of `response.raise_for_status()` that will refine a
+    potential HTTPError. Raised exception will be an instance of `HfHubHTTPError`.
+
+    This helper is meant to be the unique method to raise_for_status when making a call
+    to the Hugging Face Hub.
+
+    Example:
+    ```py
+        import requests
+        from huggingface_hub.utils import get_session, hf_raise_for_status, HfHubHTTPError
+
+        response = get_session().post(...)
+        try:
+            hf_raise_for_status(response)
+        except HfHubHTTPError as e:
+            print(str(e)) # formatted message
+            e.request_id, e.server_message # details returned by server
+
+            # Complete the error message with additional information once it's raised
+            e.append_to_message("\n`create_commit` expects the repository to exist.")
+            raise
+    ```
+
+    Args:
+        response (`Response`):
+            Response from the server.
+        endpoint_name (`str`, *optional*):
+            Name of the endpoint that has been called. If provided, the error message
+            will be more complete.
+
+    <Tip warning={true}>
+
+    Raises when the request has failed:
+
+        - [`~utils.RepositoryNotFoundError`]
+            If the repository to download from cannot be found. This may be because it
+            doesn't exist, because `repo_type` is not set correctly, or because the repo
+            is `private` and you do not have access.
+        - [`~utils.GatedRepoError`]
+            If the repository exists but is gated and the user is not on the authorized
+            list.
+        - [`~utils.RevisionNotFoundError`]
+            If the repository exists but the revision couldn't be find.
+        - [`~utils.EntryNotFoundError`]
+            If the repository exists but the entry (e.g. the requested file) couldn't be
+            find.
+        - [`~utils.BadRequestError`]
+            If request failed with a HTTP 400 BadRequest error.
+        - [`~utils.HfHubHTTPError`]
+            If request failed for a reason not listed above.
+
+    </Tip>
+    """
+    try:
+        response.raise_for_status()
+    except HTTPError as e:
+        error_code = response.headers.get("X-Error-Code")
+
+        if error_code == "RevisionNotFound":
+            message = f"{response.status_code} Client Error." + "\n\n" + f"Revision Not Found for url: {response.url}."
+            raise RevisionNotFoundError(message, response) from e
+
+        elif error_code == "EntryNotFound":
+            message = f"{response.status_code} Client Error." + "\n\n" + f"Entry Not Found for url: {response.url}."
+            raise EntryNotFoundError(message, response) from e
+
+        elif error_code == "GatedRepo":
+            message = (
+                f"{response.status_code} Client Error." + "\n\n" + f"Cannot access gated repo for url {response.url}."
+            )
+            raise GatedRepoError(message, response) from e
+
+        elif error_code == "RepoNotFound" or (
+            response.status_code == 401
+            and response.request is not None
+            and response.request.url is not None
+            and REPO_API_REGEX.search(response.request.url) is not None
+        ):
+            # 401 is misleading as it is returned for:
+            #    - private and gated repos if user is not authenticated
+            #    - missing repos
+            # => for now, we process them as `RepoNotFound` anyway.
+            # See https://gist.github.com/Wauplin/46c27ad266b15998ce56a6603796f0b9
+            message = (
+                f"{response.status_code} Client Error."
+                + "\n\n"
+                + f"Repository Not Found for url: {response.url}."
+                + "\nPlease make sure you specified the correct `repo_id` and"
+                " `repo_type`.\nIf you are trying to access a private or gated repo,"
+                " make sure you are authenticated."
+            )
+            raise RepositoryNotFoundError(message, response) from e
+
+        elif response.status_code == 400:
+            message = (
+                f"\n\nBad request for {endpoint_name} endpoint:" if endpoint_name is not None else "\n\nBad request:"
+            )
+            raise BadRequestError(message, response=response) from e
+
+        # Convert `HTTPError` into a `HfHubHTTPError` to display request information
+        # as well (request id and/or server error message)
+        raise HfHubHTTPError(str(e), response=response) from e
+
+
+def _format_error_message(message: str, request_id: Optional[str], server_message: Optional[str]) -> str:
+    """
+    Format the `HfHubHTTPError` error message based on initial message and information
+    returned by the server.
+
+    Used when initializing `HfHubHTTPError`.
+    """
+    # Add message from response body
+    if server_message is not None and len(server_message) > 0 and server_message.lower() not in message.lower():
+        if "\n\n" in message:
+            message += "\n" + server_message
+        else:
+            message += "\n\n" + server_message
+
+    # Add Request ID
+    if request_id is not None and str(request_id).lower() not in message.lower():
+        request_id_message = f" (Request ID: {request_id})"
+        if "\n" in message:
+            newline_index = message.index("\n")
+            message = message[:newline_index] + request_id_message + message[newline_index:]
+        else:
+            message += request_id_message
+
+    return message
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_experimental.py b/lib/python3.11/site-packages/huggingface_hub/utils/_experimental.py
new file mode 100644
index 0000000000000000000000000000000000000000..34162d22aca71b8a0d2513bc08e9e0a5325109c0
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_experimental.py
@@ -0,0 +1,65 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to flag a feature as "experimental" in Huggingface Hub."""
+import warnings
+from functools import wraps
+from typing import Callable
+
+from .. import constants
+
+
+def experimental(fn: Callable) -> Callable:
+    """Decorator to flag a feature as experimental.
+
+    An experimental feature trigger a warning when used as it might be subject to breaking changes in the future.
+    Warnings can be disabled by setting the environment variable `HF_EXPERIMENTAL_WARNING` to `0`.
+
+    Args:
+        fn (`Callable`):
+            The function to flag as experimental.
+
+    Returns:
+        `Callable`: The decorated function.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub.utils import experimental
+
+    >>> @experimental
+    ... def my_function():
+    ...     print("Hello world!")
+
+    >>> my_function()
+    UserWarning: 'my_function' is experimental and might be subject to breaking changes in the future. You can disable
+    this warning by setting `HF_HUB_DISABLE_EXPERIMENTAL_WARNING=1` as environment variable.
+    Hello world!
+    ```
+    """
+    # For classes, put the "experimental" around the "__new__" method => __new__ will be removed in warning message
+    name = fn.__qualname__[: -len(".__new__")] if fn.__qualname__.endswith(".__new__") else fn.__qualname__
+
+    @wraps(fn)
+    def _inner_fn(*args, **kwargs):
+        if not constants.HF_HUB_DISABLE_EXPERIMENTAL_WARNING:
+            warnings.warn(
+                f"'{name}' is experimental and might be subject to breaking changes in the future."
+                " You can disable this warning by setting `HF_HUB_DISABLE_EXPERIMENTAL_WARNING=1` as environment"
+                " variable.",
+                UserWarning,
+            )
+        return fn(*args, **kwargs)
+
+    return _inner_fn
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_fixes.py b/lib/python3.11/site-packages/huggingface_hub/utils/_fixes.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff4f9e2d70e323e108fbd7bade2fbed3f5595cbe
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_fixes.py
@@ -0,0 +1,77 @@
+# JSONDecodeError was introduced in requests=2.27 released in 2022.
+# This allows us to support older requests for users
+# More information: https://github.com/psf/requests/pull/5856
+try:
+    from requests import JSONDecodeError  # type: ignore  # noqa: F401
+except ImportError:
+    try:
+        from simplejson import JSONDecodeError  # type: ignore # noqa: F401
+    except ImportError:
+        from json import JSONDecodeError  # type: ignore  # noqa: F401
+
+import contextlib
+import os
+import shutil
+import stat
+import tempfile
+from functools import partial
+from pathlib import Path
+from typing import Callable, Generator, Optional, Union
+
+import yaml
+
+
+# Wrap `yaml.dump` to set `allow_unicode=True` by default.
+#
+# Example:
+# ```py
+# >>> yaml.dump({"emoji": "👀", "some unicode": "日本か"})
+# 'emoji: "\\U0001F440"\nsome unicode: "\\u65E5\\u672C\\u304B"\n'
+#
+# >>> yaml_dump({"emoji": "👀", "some unicode": "日本か"})
+# 'emoji: "👀"\nsome unicode: "日本か"\n'
+# ```
+yaml_dump: Callable[..., str] = partial(yaml.dump, stream=None, allow_unicode=True)  # type: ignore
+
+
+@contextlib.contextmanager
+def SoftTemporaryDirectory(
+    suffix: Optional[str] = None,
+    prefix: Optional[str] = None,
+    dir: Optional[Union[Path, str]] = None,
+    **kwargs,
+) -> Generator[str, None, None]:
+    """
+    Context manager to create a temporary directory and safely delete it.
+
+    If tmp directory cannot be deleted normally, we set the WRITE permission and retry.
+    If cleanup still fails, we give up but don't raise an exception. This is equivalent
+    to  `tempfile.TemporaryDirectory(..., ignore_cleanup_errors=True)` introduced in
+    Python 3.10.
+
+    See https://www.scivision.dev/python-tempfile-permission-error-windows/.
+    """
+    tmpdir = tempfile.TemporaryDirectory(prefix=prefix, suffix=suffix, dir=dir, **kwargs)
+    yield tmpdir.name
+
+    try:
+        # First once with normal cleanup
+        shutil.rmtree(tmpdir.name)
+    except Exception:
+        # If failed, try to set write permission and retry
+        try:
+            shutil.rmtree(tmpdir.name, onerror=_set_write_permission_and_retry)
+        except Exception:
+            pass
+
+    # And finally, cleanup the tmpdir.
+    # If it fails again, give up but do not throw error
+    try:
+        tmpdir.cleanup()
+    except Exception:
+        pass
+
+
+def _set_write_permission_and_retry(func, path, excinfo):
+    os.chmod(path, stat.S_IWRITE)
+    func(path)
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_git_credential.py b/lib/python3.11/site-packages/huggingface_hub/utils/_git_credential.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f078365d08387cc4c6c4459488045869fb0db73
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_git_credential.py
@@ -0,0 +1,120 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to manage Git credentials."""
+import re
+import subprocess
+from typing import List, Optional
+
+from ..constants import ENDPOINT
+from ._subprocess import run_interactive_subprocess, run_subprocess
+
+
+GIT_CREDENTIAL_REGEX = re.compile(
+    r"""
+        ^\s* # start of line
+        credential\.helper # credential.helper value
+        \s*=\s* # separator
+        (\w+) # the helper name (group 1)
+        (\s|$) # whitespace or end of line
+    """,
+    flags=re.MULTILINE | re.IGNORECASE | re.VERBOSE,
+)
+
+
+def list_credential_helpers(folder: Optional[str] = None) -> List[str]:
+    """Return the list of git credential helpers configured.
+
+    See https://git-scm.com/docs/gitcredentials.
+
+    Credentials are saved in all configured helpers (store, cache, macOS keychain,...).
+    Calls "`git credential approve`" internally. See https://git-scm.com/docs/git-credential.
+
+    Args:
+        folder (`str`, *optional*):
+            The folder in which to check the configured helpers.
+    """
+    try:
+        output = run_subprocess("git config --list", folder=folder).stdout
+        parsed = _parse_credential_output(output)
+        return parsed
+    except subprocess.CalledProcessError as exc:
+        raise EnvironmentError(exc.stderr)
+
+
+def set_git_credential(token: str, username: str = "hf_user", folder: Optional[str] = None) -> None:
+    """Save a username/token pair in git credential for HF Hub registry.
+
+    Credentials are saved in all configured helpers (store, cache, macOS keychain,...).
+    Calls "`git credential approve`" internally. See https://git-scm.com/docs/git-credential.
+
+    Args:
+        username (`str`, defaults to `"hf_user"`):
+            A git username. Defaults to `"hf_user"`, the default user used in the Hub.
+        token (`str`, defaults to `"hf_user"`):
+            A git password. In practice, the User Access Token for the Hub.
+            See https://huggingface.co/settings/tokens.
+        folder (`str`, *optional*):
+            The folder in which to check the configured helpers.
+    """
+    with run_interactive_subprocess("git credential approve", folder=folder) as (
+        stdin,
+        _,
+    ):
+        stdin.write(f"url={ENDPOINT}\nusername={username.lower()}\npassword={token}\n\n")
+        stdin.flush()
+
+
+def unset_git_credential(username: str = "hf_user", folder: Optional[str] = None) -> None:
+    """Erase credentials from git credential for HF Hub registry.
+
+    Credentials are erased from the configured helpers (store, cache, macOS
+    keychain,...), if any. If `username` is not provided, any credential configured for
+    HF Hub endpoint is erased.
+    Calls "`git credential erase`" internally. See https://git-scm.com/docs/git-credential.
+
+    Args:
+        username (`str`, defaults to `"hf_user"`):
+            A git username. Defaults to `"hf_user"`, the default user used in the Hub.
+        folder (`str`, *optional*):
+            The folder in which to check the configured helpers.
+    """
+    with run_interactive_subprocess("git credential reject", folder=folder) as (
+        stdin,
+        _,
+    ):
+        standard_input = f"url={ENDPOINT}\n"
+        if username is not None:
+            standard_input += f"username={username.lower()}\n"
+        standard_input += "\n"
+
+        stdin.write(standard_input)
+        stdin.flush()
+
+
+def _parse_credential_output(output: str) -> List[str]:
+    """Parse the output of `git credential fill` to extract the password.
+
+    Args:
+        output (`str`):
+            The output of `git credential fill`.
+    """
+    # NOTE: If user has set an helper for a custom URL, it will not we caught here.
+    #       Example: `credential.https://huggingface.co.helper=store`
+    #       See: https://github.com/huggingface/huggingface_hub/pull/1138#discussion_r1013324508
+    return sorted(  # Sort for nice printing
+        set(  # Might have some duplicates
+            match[0] for match in GIT_CREDENTIAL_REGEX.findall(output)
+        )
+    )
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_headers.py b/lib/python3.11/site-packages/huggingface_hub/utils/_headers.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea5123d20d2e262d6aafd6d929886e442f45db6e
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_headers.py
@@ -0,0 +1,234 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to handle headers to send in calls to Huggingface Hub."""
+from typing import Dict, Optional, Union
+
+from .. import constants
+from ._runtime import (
+    get_fastai_version,
+    get_fastcore_version,
+    get_hf_hub_version,
+    get_python_version,
+    get_tf_version,
+    get_torch_version,
+    is_fastai_available,
+    is_fastcore_available,
+    is_tf_available,
+    is_torch_available,
+)
+from ._token import get_token
+from ._validators import validate_hf_hub_args
+
+
+class LocalTokenNotFoundError(EnvironmentError):
+    """Raised if local token is required but not found."""
+
+
+@validate_hf_hub_args
+def build_hf_headers(
+    *,
+    token: Optional[Union[bool, str]] = None,
+    is_write_action: bool = False,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    user_agent: Union[Dict, str, None] = None,
+) -> Dict[str, str]:
+    """
+    Build headers dictionary to send in a HF Hub call.
+
+    By default, authorization token is always provided either from argument (explicit
+    use) or retrieved from the cache (implicit use). To explicitly avoid sending the
+    token to the Hub, set `token=False` or set the `HF_HUB_DISABLE_IMPLICIT_TOKEN`
+    environment variable.
+
+    In case of an API call that requires write access, an error is thrown if token is
+    `None` or token is an organization token (starting with `"api_org***"`).
+
+    In addition to the auth header, a user-agent is added to provide information about
+    the installed packages (versions of python, huggingface_hub, torch, tensorflow,
+    fastai and fastcore).
+
+    Args:
+        token (`str`, `bool`, *optional*):
+            The token to be sent in authorization header for the Hub call:
+                - if a string, it is used as the Hugging Face token
+                - if `True`, the token is read from the machine (cache or env variable)
+                - if `False`, authorization header is not set
+                - if `None`, the token is read from the machine only except if
+                  `HF_HUB_DISABLE_IMPLICIT_TOKEN` env variable is set.
+        is_write_action (`bool`, default to `False`):
+            Set to True if the API call requires a write access. If `True`, the token
+            will be validated (cannot be `None`, cannot start by `"api_org***"`).
+        library_name (`str`, *optional*):
+            The name of the library that is making the HTTP request. Will be added to
+            the user-agent header.
+        library_version (`str`, *optional*):
+            The version of the library that is making the HTTP request. Will be added
+            to the user-agent header.
+        user_agent (`str`, `dict`, *optional*):
+            The user agent info in the form of a dictionary or a single string. It will
+            be completed with information about the installed packages.
+
+    Returns:
+        A `Dict` of headers to pass in your API call.
+
+    Example:
+    ```py
+        >>> build_hf_headers(token="hf_***") # explicit token
+        {"authorization": "Bearer hf_***", "user-agent": ""}
+
+        >>> build_hf_headers(token=True) # explicitly use cached token
+        {"authorization": "Bearer hf_***",...}
+
+        >>> build_hf_headers(token=False) # explicitly don't use cached token
+        {"user-agent": ...}
+
+        >>> build_hf_headers() # implicit use of the cached token
+        {"authorization": "Bearer hf_***",...}
+
+        # HF_HUB_DISABLE_IMPLICIT_TOKEN=True # to set as env variable
+        >>> build_hf_headers() # token is not sent
+        {"user-agent": ...}
+
+        >>> build_hf_headers(token="api_org_***", is_write_action=True)
+        ValueError: You must use your personal account token for write-access methods.
+
+        >>> build_hf_headers(library_name="transformers", library_version="1.2.3")
+        {"authorization": ..., "user-agent": "transformers/1.2.3; hf_hub/0.10.2; python/3.10.4; tensorflow/1.55"}
+    ```
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If organization token is passed and "write" access is required.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If "write" access is required but token is not passed and not saved locally.
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If `token=True` but token is not saved locally.
+    """
+    # Get auth token to send
+    token_to_send = get_token_to_send(token)
+    _validate_token_to_send(token_to_send, is_write_action=is_write_action)
+
+    # Combine headers
+    headers = {
+        "user-agent": _http_user_agent(
+            library_name=library_name,
+            library_version=library_version,
+            user_agent=user_agent,
+        )
+    }
+    if token_to_send is not None:
+        headers["authorization"] = f"Bearer {token_to_send}"
+    return headers
+
+
+def get_token_to_send(token: Optional[Union[bool, str]]) -> Optional[str]:
+    """Select the token to send from either `token` or the cache."""
+    # Case token is explicitly provided
+    if isinstance(token, str):
+        return token
+
+    # Case token is explicitly forbidden
+    if token is False:
+        return None
+
+    # Token is not provided: we get it from local cache
+    cached_token = get_token()
+
+    # Case token is explicitly required
+    if token is True:
+        if cached_token is None:
+            raise LocalTokenNotFoundError(
+                "Token is required (`token=True`), but no token found. You"
+                " need to provide a token or be logged in to Hugging Face with"
+                " `huggingface-cli login` or `huggingface_hub.login`. See"
+                " https://huggingface.co/settings/tokens."
+            )
+        return cached_token
+
+    # Case implicit use of the token is forbidden by env variable
+    if constants.HF_HUB_DISABLE_IMPLICIT_TOKEN:
+        return None
+
+    # Otherwise: we use the cached token as the user has not explicitly forbidden it
+    return cached_token
+
+
+def _validate_token_to_send(token: Optional[str], is_write_action: bool) -> None:
+    if is_write_action:
+        if token is None:
+            raise ValueError(
+                "Token is required (write-access action) but no token found. You need"
+                " to provide a token or be logged in to Hugging Face with"
+                " `huggingface-cli login` or `huggingface_hub.login`. See"
+                " https://huggingface.co/settings/tokens."
+            )
+        if token.startswith("api_org"):
+            raise ValueError(
+                "You must use your personal account token for write-access methods. To"
+                " generate a write-access token, go to"
+                " https://huggingface.co/settings/tokens"
+            )
+
+
+def _http_user_agent(
+    *,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    user_agent: Union[Dict, str, None] = None,
+) -> str:
+    """Format a user-agent string containing information about the installed packages.
+
+    Args:
+        library_name (`str`, *optional*):
+            The name of the library that is making the HTTP request.
+        library_version (`str`, *optional*):
+            The version of the library that is making the HTTP request.
+        user_agent (`str`, `dict`, *optional*):
+            The user agent info in the form of a dictionary or a single string.
+
+    Returns:
+        The formatted user-agent string.
+    """
+    if library_name is not None:
+        ua = f"{library_name}/{library_version}"
+    else:
+        ua = "unknown/None"
+    ua += f"; hf_hub/{get_hf_hub_version()}"
+    ua += f"; python/{get_python_version()}"
+
+    if not constants.HF_HUB_DISABLE_TELEMETRY:
+        if is_torch_available():
+            ua += f"; torch/{get_torch_version()}"
+        if is_tf_available():
+            ua += f"; tensorflow/{get_tf_version()}"
+        if is_fastai_available():
+            ua += f"; fastai/{get_fastai_version()}"
+        if is_fastcore_available():
+            ua += f"; fastcore/{get_fastcore_version()}"
+
+    if isinstance(user_agent, dict):
+        ua += "; " + "; ".join(f"{k}/{v}" for k, v in user_agent.items())
+    elif isinstance(user_agent, str):
+        ua += "; " + user_agent
+
+    return _deduplicate_user_agent(ua)
+
+
+def _deduplicate_user_agent(user_agent: str) -> str:
+    """Deduplicate redundant information in the generated user-agent."""
+    # Split around ";" > Strip whitespaces > Store as dict keys (ensure unicity) > format back as string
+    # Order is implicitly preserved by dictionary structure (see https://stackoverflow.com/a/53657523).
+    return "; ".join({key.strip(): None for key in user_agent.split(";")}.keys())
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_hf_folder.py b/lib/python3.11/site-packages/huggingface_hub/utils/_hf_folder.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb091ee9545fae83ac01efe14f88f9ba5dec150d
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_hf_folder.py
@@ -0,0 +1,114 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contain helper class to retrieve/store token from/to local cache."""
+import os
+import warnings
+from pathlib import Path
+from typing import Optional
+
+from .. import constants
+
+
+class HfFolder:
+    path_token = Path(constants.HF_TOKEN_PATH)
+    # Private attribute. Will be removed in v0.15
+    _old_path_token = Path(constants._OLD_HF_TOKEN_PATH)
+
+    # TODO: deprecate when adapted in transformers/datasets/gradio
+    # @_deprecate_method(version="1.0", message="Use `huggingface_hub.login` instead.")
+    @classmethod
+    def save_token(cls, token: str) -> None:
+        """
+        Save token, creating folder as needed.
+
+        Token is saved in the huggingface home folder. You can configure it by setting
+        the `HF_HOME` environment variable.
+
+        Args:
+            token (`str`):
+                The token to save to the [`HfFolder`]
+        """
+        cls.path_token.parent.mkdir(parents=True, exist_ok=True)
+        cls.path_token.write_text(token)
+
+    # TODO: deprecate when adapted in transformers/datasets/gradio
+    # @_deprecate_method(version="1.0", message="Use `huggingface_hub.get_token` instead.")
+    @classmethod
+    def get_token(cls) -> Optional[str]:
+        """
+        Get token or None if not existent.
+
+        Note that a token can be also provided using the `HF_TOKEN` environment variable.
+
+        Token is saved in the huggingface home folder. You can configure it by setting
+        the `HF_HOME` environment variable. Previous location was `~/.huggingface/token`.
+        If token is found in old location but not in new location, it is copied there first.
+        For more details, see https://github.com/huggingface/huggingface_hub/issues/1232.
+
+        Returns:
+            `str` or `None`: The token, `None` if it doesn't exist.
+        """
+        # 0. Check if token exist in old path but not new location
+        try:
+            cls._copy_to_new_path_and_warn()
+        except Exception:  # if not possible (e.g. PermissionError), do not raise
+            pass
+
+        # 1. Is it set by environment variable ?
+        token: Optional[str] = os.environ.get("HF_TOKEN")
+        if token is None:  # Ensure backward compatibility but doesn't have priority
+            token = os.environ.get("HUGGING_FACE_HUB_TOKEN")
+        if token is not None:
+            token = token.replace("\r", "").replace("\n", "").strip()
+        if token != "":
+            return token
+
+        # 2. Is it set in token path ?
+        try:
+            token = cls.path_token.read_text()
+            token = token.replace("\r", "").replace("\n", "").strip()
+            return token
+        except FileNotFoundError:
+            return None
+
+    # TODO: deprecate when adapted in transformers/datasets/gradio
+    # @_deprecate_method(version="1.0", message="Use `huggingface_hub.logout` instead.")
+    @classmethod
+    def delete_token(cls) -> None:
+        """
+        Deletes the token from storage. Does not fail if token does not exist.
+        """
+        try:
+            cls.path_token.unlink()
+        except FileNotFoundError:
+            pass
+
+        try:
+            cls._old_path_token.unlink()
+        except FileNotFoundError:
+            pass
+
+    @classmethod
+    def _copy_to_new_path_and_warn(cls):
+        if cls._old_path_token.exists() and not cls.path_token.exists():
+            cls.save_token(cls._old_path_token.read_text())
+            warnings.warn(
+                f"A token has been found in `{cls._old_path_token}`. This is the old"
+                " path where tokens were stored. The new location is"
+                f" `{cls.path_token}` which is configurable using `HF_HOME` environment"
+                " variable. Your token has been copied to this new location. You can"
+                " now safely delete the old token file manually or use"
+                " `huggingface-cli logout`."
+            )
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_http.py b/lib/python3.11/site-packages/huggingface_hub/utils/_http.py
new file mode 100644
index 0000000000000000000000000000000000000000..69cbfc22574cd872a946dceae6791a56b1487523
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_http.py
@@ -0,0 +1,307 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to handle HTTP requests in Huggingface Hub."""
+import io
+import os
+import threading
+import time
+import uuid
+from functools import lru_cache
+from http import HTTPStatus
+from typing import Callable, Tuple, Type, Union
+
+import requests
+from requests import Response
+from requests.adapters import HTTPAdapter
+from requests.models import PreparedRequest
+
+from .. import constants
+from . import logging
+from ._typing import HTTP_METHOD_T
+
+
+logger = logging.get_logger(__name__)
+
+# Both headers are used by the Hub to debug failed requests.
+# `X_AMZN_TRACE_ID` is better as it also works to debug on Cloudfront and ALB.
+# If `X_AMZN_TRACE_ID` is set, the Hub will use it as well.
+X_AMZN_TRACE_ID = "X-Amzn-Trace-Id"
+X_REQUEST_ID = "x-request-id"
+
+
+class OfflineModeIsEnabled(ConnectionError):
+    """Raised when a request is made but `HF_HUB_OFFLINE=1` is set as environment variable."""
+
+
+class UniqueRequestIdAdapter(HTTPAdapter):
+    X_AMZN_TRACE_ID = "X-Amzn-Trace-Id"
+
+    def add_headers(self, request, **kwargs):
+        super().add_headers(request, **kwargs)
+
+        # Add random request ID => easier for server-side debug
+        if X_AMZN_TRACE_ID not in request.headers:
+            request.headers[X_AMZN_TRACE_ID] = request.headers.get(X_REQUEST_ID) or str(uuid.uuid4())
+
+        # Add debug log
+        has_token = str(request.headers.get("authorization", "")).startswith("Bearer hf_")
+        logger.debug(
+            f"Request {request.headers[X_AMZN_TRACE_ID]}: {request.method} {request.url} (authenticated: {has_token})"
+        )
+
+    def send(self, request: PreparedRequest, *args, **kwargs) -> Response:
+        """Catch any RequestException to append request id to the error message for debugging."""
+        try:
+            return super().send(request, *args, **kwargs)
+        except requests.RequestException as e:
+            request_id = request.headers.get(X_AMZN_TRACE_ID)
+            if request_id is not None:
+                # Taken from https://stackoverflow.com/a/58270258
+                e.args = (*e.args, f"(Request ID: {request_id})")
+            raise
+
+
+class OfflineAdapter(HTTPAdapter):
+    def send(self, request: PreparedRequest, *args, **kwargs) -> Response:
+        raise OfflineModeIsEnabled(
+            f"Cannot reach {request.url}: offline mode is enabled. To disable it, please unset the `HF_HUB_OFFLINE` environment variable."
+        )
+
+
+def _default_backend_factory() -> requests.Session:
+    session = requests.Session()
+    if constants.HF_HUB_OFFLINE:
+        session.mount("http://", OfflineAdapter())
+        session.mount("https://", OfflineAdapter())
+    else:
+        session.mount("http://", UniqueRequestIdAdapter())
+        session.mount("https://", UniqueRequestIdAdapter())
+    return session
+
+
+BACKEND_FACTORY_T = Callable[[], requests.Session]
+_GLOBAL_BACKEND_FACTORY: BACKEND_FACTORY_T = _default_backend_factory
+
+
+def configure_http_backend(backend_factory: BACKEND_FACTORY_T = _default_backend_factory) -> None:
+    """
+    Configure the HTTP backend by providing a `backend_factory`. Any HTTP calls made by `huggingface_hub` will use a
+    Session object instantiated by this factory. This can be useful if you are running your scripts in a specific
+    environment requiring custom configuration (e.g. custom proxy or certifications).
+
+    Use [`get_session`] to get a configured Session. Since `requests.Session` is not guaranteed to be thread-safe,
+    `huggingface_hub` creates 1 Session instance per thread. They are all instantiated using the same `backend_factory`
+    set in [`configure_http_backend`]. A LRU cache is used to cache the created sessions (and connections) between
+    calls. Max size is 128 to avoid memory leaks if thousands of threads are spawned.
+
+    See [this issue](https://github.com/psf/requests/issues/2766) to know more about thread-safety in `requests`.
+
+    Example:
+    ```py
+    import requests
+    from huggingface_hub import configure_http_backend, get_session
+
+    # Create a factory function that returns a Session with configured proxies
+    def backend_factory() -> requests.Session:
+        session = requests.Session()
+        session.proxies = {"http": "http://10.10.1.10:3128", "https": "https://10.10.1.11:1080"}
+        return session
+
+    # Set it as the default session factory
+    configure_http_backend(backend_factory=backend_factory)
+
+    # In practice, this is mostly done internally in `huggingface_hub`
+    session = get_session()
+    ```
+    """
+    global _GLOBAL_BACKEND_FACTORY
+    _GLOBAL_BACKEND_FACTORY = backend_factory
+    reset_sessions()
+
+
+def get_session() -> requests.Session:
+    """
+    Get a `requests.Session` object, using the session factory from the user.
+
+    Use [`get_session`] to get a configured Session. Since `requests.Session` is not guaranteed to be thread-safe,
+    `huggingface_hub` creates 1 Session instance per thread. They are all instantiated using the same `backend_factory`
+    set in [`configure_http_backend`]. A LRU cache is used to cache the created sessions (and connections) between
+    calls. Max size is 128 to avoid memory leaks if thousands of threads are spawned.
+
+    See [this issue](https://github.com/psf/requests/issues/2766) to know more about thread-safety in `requests`.
+
+    Example:
+    ```py
+    import requests
+    from huggingface_hub import configure_http_backend, get_session
+
+    # Create a factory function that returns a Session with configured proxies
+    def backend_factory() -> requests.Session:
+        session = requests.Session()
+        session.proxies = {"http": "http://10.10.1.10:3128", "https": "https://10.10.1.11:1080"}
+        return session
+
+    # Set it as the default session factory
+    configure_http_backend(backend_factory=backend_factory)
+
+    # In practice, this is mostly done internally in `huggingface_hub`
+    session = get_session()
+    ```
+    """
+    return _get_session_from_cache(process_id=os.getpid(), thread_id=threading.get_ident())
+
+
+def reset_sessions() -> None:
+    """Reset the cache of sessions.
+
+    Mostly used internally when sessions are reconfigured or an SSLError is raised.
+    See [`configure_http_backend`] for more details.
+    """
+    _get_session_from_cache.cache_clear()
+
+
+@lru_cache
+def _get_session_from_cache(process_id: int, thread_id: int) -> requests.Session:
+    """
+    Create a new session per thread using global factory. Using LRU cache (maxsize 128) to avoid memory leaks when
+    using thousands of threads. Cache is cleared when `configure_http_backend` is called.
+    """
+    return _GLOBAL_BACKEND_FACTORY()
+
+
+def http_backoff(
+    method: HTTP_METHOD_T,
+    url: str,
+    *,
+    max_retries: int = 5,
+    base_wait_time: float = 1,
+    max_wait_time: float = 8,
+    retry_on_exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]] = (
+        requests.Timeout,
+        requests.ConnectionError,
+    ),
+    retry_on_status_codes: Union[int, Tuple[int, ...]] = HTTPStatus.SERVICE_UNAVAILABLE,
+    **kwargs,
+) -> Response:
+    """Wrapper around requests to retry calls on an endpoint, with exponential backoff.
+
+    Endpoint call is retried on exceptions (ex: connection timeout, proxy error,...)
+    and/or on specific status codes (ex: service unavailable). If the call failed more
+    than `max_retries`, the exception is thrown or `raise_for_status` is called on the
+    response object.
+
+    Re-implement mechanisms from the `backoff` library to avoid adding an external
+    dependencies to `hugging_face_hub`. See https://github.com/litl/backoff.
+
+    Args:
+        method (`Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"]`):
+            HTTP method to perform.
+        url (`str`):
+            The URL of the resource to fetch.
+        max_retries (`int`, *optional*, defaults to `5`):
+            Maximum number of retries, defaults to 5 (no retries).
+        base_wait_time (`float`, *optional*, defaults to `1`):
+            Duration (in seconds) to wait before retrying the first time.
+            Wait time between retries then grows exponentially, capped by
+            `max_wait_time`.
+        max_wait_time (`float`, *optional*, defaults to `8`):
+            Maximum duration (in seconds) to wait before retrying.
+        retry_on_exceptions (`Type[Exception]` or `Tuple[Type[Exception]]`, *optional*):
+            Define which exceptions must be caught to retry the request. Can be a single type or a tuple of types.
+            By default, retry on `requests.Timeout` and `requests.ConnectionError`.
+        retry_on_status_codes (`int` or `Tuple[int]`, *optional*, defaults to `503`):
+            Define on which status codes the request must be retried. By default, only
+            HTTP 503 Service Unavailable is retried.
+        **kwargs (`dict`, *optional*):
+            kwargs to pass to `requests.request`.
+
+    Example:
+    ```
+    >>> from huggingface_hub.utils import http_backoff
+
+    # Same usage as "requests.request".
+    >>> response = http_backoff("GET", "https://www.google.com")
+    >>> response.raise_for_status()
+
+    # If you expect a Gateway Timeout from time to time
+    >>> http_backoff("PUT", upload_url, data=data, retry_on_status_codes=504)
+    >>> response.raise_for_status()
+    ```
+
+    <Tip warning={true}>
+
+    When using `requests` it is possible to stream data by passing an iterator to the
+    `data` argument. On http backoff this is a problem as the iterator is not reset
+    after a failed call. This issue is mitigated for file objects or any IO streams
+    by saving the initial position of the cursor (with `data.tell()`) and resetting the
+    cursor between each call (with `data.seek()`). For arbitrary iterators, http backoff
+    will fail. If this is a hard constraint for you, please let us know by opening an
+    issue on [Github](https://github.com/huggingface/huggingface_hub).
+
+    </Tip>
+    """
+    if isinstance(retry_on_exceptions, type):  # Tuple from single exception type
+        retry_on_exceptions = (retry_on_exceptions,)
+
+    if isinstance(retry_on_status_codes, int):  # Tuple from single status code
+        retry_on_status_codes = (retry_on_status_codes,)
+
+    nb_tries = 0
+    sleep_time = base_wait_time
+
+    # If `data` is used and is a file object (or any IO), it will be consumed on the
+    # first HTTP request. We need to save the initial position so that the full content
+    # of the file is re-sent on http backoff. See warning tip in docstring.
+    io_obj_initial_pos = None
+    if "data" in kwargs and isinstance(kwargs["data"], io.IOBase):
+        io_obj_initial_pos = kwargs["data"].tell()
+
+    session = get_session()
+    while True:
+        nb_tries += 1
+        try:
+            # If `data` is used and is a file object (or any IO), set back cursor to
+            # initial position.
+            if io_obj_initial_pos is not None:
+                kwargs["data"].seek(io_obj_initial_pos)
+
+            # Perform request and return if status_code is not in the retry list.
+            response = session.request(method=method, url=url, **kwargs)
+            if response.status_code not in retry_on_status_codes:
+                return response
+
+            # Wrong status code returned (HTTP 503 for instance)
+            logger.warning(f"HTTP Error {response.status_code} thrown while requesting {method} {url}")
+            if nb_tries > max_retries:
+                response.raise_for_status()  # Will raise uncaught exception
+                # We return response to avoid infinite loop in the corner case where the
+                # user ask for retry on a status code that doesn't raise_for_status.
+                return response
+
+        except retry_on_exceptions as err:
+            logger.warning(f"'{err}' thrown while requesting {method} {url}")
+
+            if isinstance(err, requests.ConnectionError):
+                reset_sessions()  # In case of SSLError it's best to reset the shared requests.Session objects
+
+            if nb_tries > max_retries:
+                raise err
+
+        # Sleep for X seconds
+        logger.warning(f"Retrying in {sleep_time}s [Retry {nb_tries}/{max_retries}].")
+        time.sleep(sleep_time)
+
+        # Update sleep time for next retry
+        sleep_time = min(max_wait_time, sleep_time * 2)  # Exponential backoff
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_pagination.py b/lib/python3.11/site-packages/huggingface_hub/utils/_pagination.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad9048ac55b518a1a54fe0431ac375d203bd1554
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_pagination.py
@@ -0,0 +1,51 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to handle pagination on Huggingface Hub."""
+from typing import Dict, Iterable, Optional
+
+import requests
+
+from . import get_session, hf_raise_for_status, logging
+
+
+logger = logging.get_logger(__name__)
+
+
+def paginate(path: str, params: Dict, headers: Dict) -> Iterable:
+    """Fetch a list of models/datasets/spaces and paginate through results.
+
+    This is using the same "Link" header format as GitHub.
+    See:
+    - https://requests.readthedocs.io/en/latest/api/#requests.Response.links
+    - https://docs.github.com/en/rest/guides/traversing-with-pagination#link-header
+    """
+    session = get_session()
+    r = session.get(path, params=params, headers=headers)
+    hf_raise_for_status(r)
+    yield from r.json()
+
+    # Follow pages
+    # Next link already contains query params
+    next_page = _get_next_page(r)
+    while next_page is not None:
+        logger.debug(f"Pagination detected. Requesting next page: {next_page}")
+        r = session.get(next_page, headers=headers)
+        hf_raise_for_status(r)
+        yield from r.json()
+        next_page = _get_next_page(r)
+
+
+def _get_next_page(response: requests.Response) -> Optional[str]:
+    return response.links.get("next", {}).get("url")
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_paths.py b/lib/python3.11/site-packages/huggingface_hub/utils/_paths.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a994bf5e93fa773148dbe0941fcdb5532fbc15a
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_paths.py
@@ -0,0 +1,117 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to handle paths in Huggingface Hub."""
+from fnmatch import fnmatch
+from pathlib import Path
+from typing import Callable, Generator, Iterable, List, Optional, TypeVar, Union
+
+
+T = TypeVar("T")
+
+IGNORE_GIT_FOLDER_PATTERNS = [".git", ".git/*", "*/.git", "**/.git/**"]
+
+
+def filter_repo_objects(
+    items: Iterable[T],
+    *,
+    allow_patterns: Optional[Union[List[str], str]] = None,
+    ignore_patterns: Optional[Union[List[str], str]] = None,
+    key: Optional[Callable[[T], str]] = None,
+) -> Generator[T, None, None]:
+    """Filter repo objects based on an allowlist and a denylist.
+
+    Input must be a list of paths (`str` or `Path`) or a list of arbitrary objects.
+    In the later case, `key` must be provided and specifies a function of one argument
+    that is used to extract a path from each element in iterable.
+
+    Patterns are Unix shell-style wildcards which are NOT regular expressions. See
+    https://docs.python.org/3/library/fnmatch.html for more details.
+
+    Args:
+        items (`Iterable`):
+            List of items to filter.
+        allow_patterns (`str` or `List[str]`, *optional*):
+            Patterns constituting the allowlist. If provided, item paths must match at
+            least one pattern from the allowlist.
+        ignore_patterns (`str` or `List[str]`, *optional*):
+            Patterns constituting the denylist. If provided, item paths must not match
+            any patterns from the denylist.
+        key (`Callable[[T], str]`, *optional*):
+            Single-argument function to extract a path from each item. If not provided,
+            the `items` must already be `str` or `Path`.
+
+    Returns:
+        Filtered list of objects, as a generator.
+
+    Raises:
+        :class:`ValueError`:
+            If `key` is not provided and items are not `str` or `Path`.
+
+    Example usage with paths:
+    ```python
+    >>> # Filter only PDFs that are not hidden.
+    >>> list(filter_repo_objects(
+    ...     ["aaa.PDF", "bbb.jpg", ".ccc.pdf", ".ddd.png"],
+    ...     allow_patterns=["*.pdf"],
+    ...     ignore_patterns=[".*"],
+    ... ))
+    ["aaa.pdf"]
+    ```
+
+    Example usage with objects:
+    ```python
+    >>> list(filter_repo_objects(
+    ... [
+    ...     CommitOperationAdd(path_or_fileobj="/tmp/aaa.pdf", path_in_repo="aaa.pdf")
+    ...     CommitOperationAdd(path_or_fileobj="/tmp/bbb.jpg", path_in_repo="bbb.jpg")
+    ...     CommitOperationAdd(path_or_fileobj="/tmp/.ccc.pdf", path_in_repo=".ccc.pdf")
+    ...     CommitOperationAdd(path_or_fileobj="/tmp/.ddd.png", path_in_repo=".ddd.png")
+    ... ],
+    ... allow_patterns=["*.pdf"],
+    ... ignore_patterns=[".*"],
+    ... key=lambda x: x.repo_in_path
+    ... ))
+    [CommitOperationAdd(path_or_fileobj="/tmp/aaa.pdf", path_in_repo="aaa.pdf")]
+    ```
+    """
+    if isinstance(allow_patterns, str):
+        allow_patterns = [allow_patterns]
+
+    if isinstance(ignore_patterns, str):
+        ignore_patterns = [ignore_patterns]
+
+    if key is None:
+
+        def _identity(item: T) -> str:
+            if isinstance(item, str):
+                return item
+            if isinstance(item, Path):
+                return str(item)
+            raise ValueError(f"Please provide `key` argument in `filter_repo_objects`: `{item}` is not a string.")
+
+        key = _identity  # Items must be `str` or `Path`, otherwise raise ValueError
+
+    for item in items:
+        path = key(item)
+
+        # Skip if there's an allowlist and path doesn't match any
+        if allow_patterns is not None and not any(fnmatch(path, r) for r in allow_patterns):
+            continue
+
+        # Skip if there's a denylist and path matches any
+        if ignore_patterns is not None and any(fnmatch(path, r) for r in ignore_patterns):
+            continue
+
+        yield item
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_runtime.py b/lib/python3.11/site-packages/huggingface_hub/utils/_runtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..82aa41ce1473f88197a60a463f3132a2b23ed8ad
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_runtime.py
@@ -0,0 +1,344 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Check presence of installed packages at runtime."""
+import importlib.metadata
+import platform
+import sys
+import warnings
+from typing import Any, Dict
+
+from .. import __version__, constants
+
+
+_PY_VERSION: str = sys.version.split()[0].rstrip("+")
+
+_package_versions = {}
+
+_CANDIDATES = {
+    "aiohttp": {"aiohttp"},
+    "fastai": {"fastai"},
+    "fastcore": {"fastcore"},
+    "gradio": {"gradio"},
+    "graphviz": {"graphviz"},
+    "hf_transfer": {"hf_transfer"},
+    "jinja": {"Jinja2"},
+    "numpy": {"numpy"},
+    "pillow": {"Pillow"},
+    "pydantic": {"pydantic"},
+    "pydot": {"pydot"},
+    "tensorboard": {"tensorboardX"},
+    "tensorflow": (
+        "tensorflow",
+        "tensorflow-cpu",
+        "tensorflow-gpu",
+        "tf-nightly",
+        "tf-nightly-cpu",
+        "tf-nightly-gpu",
+        "intel-tensorflow",
+        "intel-tensorflow-avx512",
+        "tensorflow-rocm",
+        "tensorflow-macos",
+    ),
+    "torch": {"torch"},
+}
+
+# Check once at runtime
+for candidate_name, package_names in _CANDIDATES.items():
+    _package_versions[candidate_name] = "N/A"
+    for name in package_names:
+        try:
+            _package_versions[candidate_name] = importlib.metadata.version(name)
+            break
+        except importlib.metadata.PackageNotFoundError:
+            pass
+
+
+def _get_version(package_name: str) -> str:
+    return _package_versions.get(package_name, "N/A")
+
+
+def _is_available(package_name: str) -> bool:
+    return _get_version(package_name) != "N/A"
+
+
+# Python
+def get_python_version() -> str:
+    return _PY_VERSION
+
+
+# Huggingface Hub
+def get_hf_hub_version() -> str:
+    return __version__
+
+
+# aiohttp
+def is_aiohttp_available() -> bool:
+    return _is_available("aiohttp")
+
+
+def get_aiohttp_version() -> str:
+    return _get_version("aiohttp")
+
+
+# FastAI
+def is_fastai_available() -> bool:
+    return _is_available("fastai")
+
+
+def get_fastai_version() -> str:
+    return _get_version("fastai")
+
+
+# Fastcore
+def is_fastcore_available() -> bool:
+    return _is_available("fastcore")
+
+
+def get_fastcore_version() -> str:
+    return _get_version("fastcore")
+
+
+# FastAI
+def is_gradio_available() -> bool:
+    return _is_available("gradio")
+
+
+def get_gradio_version() -> str:
+    return _get_version("gradio")
+
+
+# Graphviz
+def is_graphviz_available() -> bool:
+    return _is_available("graphviz")
+
+
+def get_graphviz_version() -> str:
+    return _get_version("graphviz")
+
+
+# hf_transfer
+def is_hf_transfer_available() -> bool:
+    return _is_available("hf_transfer")
+
+
+def get_hf_transfer_version() -> str:
+    return _get_version("hf_transfer")
+
+
+# Numpy
+def is_numpy_available() -> bool:
+    return _is_available("numpy")
+
+
+def get_numpy_version() -> str:
+    return _get_version("numpy")
+
+
+# Jinja
+def is_jinja_available() -> bool:
+    return _is_available("jinja")
+
+
+def get_jinja_version() -> str:
+    return _get_version("jinja")
+
+
+# Pillow
+def is_pillow_available() -> bool:
+    return _is_available("pillow")
+
+
+def get_pillow_version() -> str:
+    return _get_version("pillow")
+
+
+# Pydantic
+def is_pydantic_available() -> bool:
+    if not _is_available("pydantic"):
+        return False
+    # For Pydantic, we add an extra check to test whether it is correctly installed or not. If both pydantic 2.x and
+    # typing_extensions<=4.5.0 are installed, then pydantic will fail at import time. This should not happen when
+    # it is installed with `pip install huggingface_hub[inference]` but it can happen when it is installed manually
+    # by the user in an environment that we don't control.
+    #
+    # Usually we won't need to do this kind of check on optional dependencies. However, pydantic is a special case
+    # as it is automatically imported when doing `from huggingface_hub import ...` even if the user doesn't use it.
+    #
+    # See https://github.com/huggingface/huggingface_hub/pull/1829 for more details.
+    try:
+        from pydantic import validator  # noqa: F401
+    except ImportError:
+        # Example: "ImportError: cannot import name 'TypeAliasType' from 'typing_extensions'"
+        warnings.warn(
+            "Pydantic is installed but cannot be imported. Please check your installation. `huggingface_hub` will "
+            "default to not using Pydantic. Error message: '{e}'"
+        )
+        return False
+    return True
+
+
+def get_pydantic_version() -> str:
+    return _get_version("pydantic")
+
+
+# Pydot
+def is_pydot_available() -> bool:
+    return _is_available("pydot")
+
+
+def get_pydot_version() -> str:
+    return _get_version("pydot")
+
+
+# Tensorboard
+def is_tensorboard_available() -> bool:
+    return _is_available("tensorboard")
+
+
+def get_tensorboard_version() -> str:
+    return _get_version("tensorboard")
+
+
+# Tensorflow
+def is_tf_available() -> bool:
+    return _is_available("tensorflow")
+
+
+def get_tf_version() -> str:
+    return _get_version("tensorflow")
+
+
+# Torch
+def is_torch_available() -> bool:
+    return _is_available("torch")
+
+
+def get_torch_version() -> str:
+    return _get_version("torch")
+
+
+# Shell-related helpers
+try:
+    # Set to `True` if script is running in a Google Colab notebook.
+    # If running in Google Colab, git credential store is set globally which makes the
+    # warning disappear. See https://github.com/huggingface/huggingface_hub/issues/1043
+    #
+    # Taken from https://stackoverflow.com/a/63519730.
+    _is_google_colab = "google.colab" in str(get_ipython())  # type: ignore # noqa: F821
+except NameError:
+    _is_google_colab = False
+
+
+def is_notebook() -> bool:
+    """Return `True` if code is executed in a notebook (Jupyter, Colab, QTconsole).
+
+    Taken from https://stackoverflow.com/a/39662359.
+    Adapted to make it work with Google colab as well.
+    """
+    try:
+        shell_class = get_ipython().__class__  # type: ignore # noqa: F821
+        for parent_class in shell_class.__mro__:  # e.g. "is subclass of"
+            if parent_class.__name__ == "ZMQInteractiveShell":
+                return True  # Jupyter notebook, Google colab or qtconsole
+        return False
+    except NameError:
+        return False  # Probably standard Python interpreter
+
+
+def is_google_colab() -> bool:
+    """Return `True` if code is executed in a Google colab.
+
+    Taken from https://stackoverflow.com/a/63519730.
+    """
+    return _is_google_colab
+
+
+def dump_environment_info() -> Dict[str, Any]:
+    """Dump information about the machine to help debugging issues.
+
+    Similar helper exist in:
+    - `datasets` (https://github.com/huggingface/datasets/blob/main/src/datasets/commands/env.py)
+    - `diffusers` (https://github.com/huggingface/diffusers/blob/main/src/diffusers/commands/env.py)
+    - `transformers` (https://github.com/huggingface/transformers/blob/main/src/transformers/commands/env.py)
+    """
+    from huggingface_hub import get_token, whoami
+    from huggingface_hub.utils import list_credential_helpers
+
+    token = get_token()
+
+    # Generic machine info
+    info: Dict[str, Any] = {
+        "huggingface_hub version": get_hf_hub_version(),
+        "Platform": platform.platform(),
+        "Python version": get_python_version(),
+    }
+
+    # Interpreter info
+    try:
+        shell_class = get_ipython().__class__  # type: ignore # noqa: F821
+        info["Running in iPython ?"] = "Yes"
+        info["iPython shell"] = shell_class.__name__
+    except NameError:
+        info["Running in iPython ?"] = "No"
+    info["Running in notebook ?"] = "Yes" if is_notebook() else "No"
+    info["Running in Google Colab ?"] = "Yes" if is_google_colab() else "No"
+
+    # Login info
+    info["Token path ?"] = constants.HF_TOKEN_PATH
+    info["Has saved token ?"] = token is not None
+    if token is not None:
+        try:
+            info["Who am I ?"] = whoami()["name"]
+        except Exception:
+            pass
+
+    try:
+        info["Configured git credential helpers"] = ", ".join(list_credential_helpers())
+    except Exception:
+        pass
+
+    # Installed dependencies
+    info["FastAI"] = get_fastai_version()
+    info["Tensorflow"] = get_tf_version()
+    info["Torch"] = get_torch_version()
+    info["Jinja2"] = get_jinja_version()
+    info["Graphviz"] = get_graphviz_version()
+    info["Pydot"] = get_pydot_version()
+    info["Pillow"] = get_pillow_version()
+    info["hf_transfer"] = get_hf_transfer_version()
+    info["gradio"] = get_gradio_version()
+    info["tensorboard"] = get_tensorboard_version()
+    info["numpy"] = get_numpy_version()
+    info["pydantic"] = get_pydantic_version()
+    info["aiohttp"] = get_aiohttp_version()
+
+    # Environment variables
+    info["ENDPOINT"] = constants.ENDPOINT
+    info["HF_HUB_CACHE"] = constants.HF_HUB_CACHE
+    info["HF_ASSETS_CACHE"] = constants.HF_ASSETS_CACHE
+    info["HF_TOKEN_PATH"] = constants.HF_TOKEN_PATH
+    info["HF_HUB_OFFLINE"] = constants.HF_HUB_OFFLINE
+    info["HF_HUB_DISABLE_TELEMETRY"] = constants.HF_HUB_DISABLE_TELEMETRY
+    info["HF_HUB_DISABLE_PROGRESS_BARS"] = constants.HF_HUB_DISABLE_PROGRESS_BARS
+    info["HF_HUB_DISABLE_SYMLINKS_WARNING"] = constants.HF_HUB_DISABLE_SYMLINKS_WARNING
+    info["HF_HUB_DISABLE_EXPERIMENTAL_WARNING"] = constants.HF_HUB_DISABLE_EXPERIMENTAL_WARNING
+    info["HF_HUB_DISABLE_IMPLICIT_TOKEN"] = constants.HF_HUB_DISABLE_IMPLICIT_TOKEN
+    info["HF_HUB_ENABLE_HF_TRANSFER"] = constants.HF_HUB_ENABLE_HF_TRANSFER
+    info["HF_HUB_ETAG_TIMEOUT"] = constants.HF_HUB_ETAG_TIMEOUT
+    info["HF_HUB_DOWNLOAD_TIMEOUT"] = constants.HF_HUB_DOWNLOAD_TIMEOUT
+
+    print("\nCopy-and-paste the text below in your GitHub issue.\n")
+    print("\n".join([f"- {prop}: {val}" for prop, val in info.items()]) + "\n")
+    return info
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_safetensors.py b/lib/python3.11/site-packages/huggingface_hub/utils/_safetensors.py
new file mode 100644
index 0000000000000000000000000000000000000000..d37e8f76fee25976d48ad591fe8afb277ae6ef38
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_safetensors.py
@@ -0,0 +1,124 @@
+import functools
+import operator
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, List, Literal, Optional, Tuple
+
+
+FILENAME_T = str
+TENSOR_NAME_T = str
+DTYPE_T = Literal["F64", "F32", "F16", "BF16", "I64", "I32", "I16", "I8", "U8", "BOOL"]
+
+
+class SafetensorsParsingError(Exception):
+    """Raised when failing to parse a safetensors file metadata.
+
+    This can be the case if the file is not a safetensors file or does not respect the specification.
+    """
+
+
+class NotASafetensorsRepoError(Exception):
+    """Raised when a repo is not a Safetensors repo i.e. doesn't have either a `model.safetensors` or a
+    `model.safetensors.index.json` file.
+    """
+
+
+@dataclass
+class TensorInfo:
+    """Information about a tensor.
+
+    For more details regarding the safetensors format, check out https://huggingface.co/docs/safetensors/index#format.
+
+    Attributes:
+        dtype (`str`):
+            The data type of the tensor ("F64", "F32", "F16", "BF16", "I64", "I32", "I16", "I8", "U8", "BOOL").
+        shape (`List[int]`):
+            The shape of the tensor.
+        data_offsets (`Tuple[int, int]`):
+            The offsets of the data in the file as a tuple `[BEGIN, END]`.
+        parameter_count (`int`):
+            The number of parameters in the tensor.
+    """
+
+    dtype: DTYPE_T
+    shape: List[int]
+    data_offsets: Tuple[int, int]
+    parameter_count: int = field(init=False)
+
+    def __post_init__(self) -> None:
+        # Taken from https://stackoverflow.com/a/13840436
+        try:
+            self.parameter_count = functools.reduce(operator.mul, self.shape)
+        except TypeError:
+            self.parameter_count = 1  # scalar value has no shape
+
+
+@dataclass
+class SafetensorsFileMetadata:
+    """Metadata for a Safetensors file hosted on the Hub.
+
+    This class is returned by [`parse_safetensors_file_metadata`].
+
+    For more details regarding the safetensors format, check out https://huggingface.co/docs/safetensors/index#format.
+
+    Attributes:
+        metadata (`Dict`):
+            The metadata contained in the file.
+        tensors (`Dict[str, TensorInfo]`):
+            A map of all tensors. Keys are tensor names and values are information about the corresponding tensor, as a
+            [`TensorInfo`] object.
+        parameter_count (`Dict[str, int]`):
+            A map of the number of parameters per data type. Keys are data types and values are the number of parameters
+            of that data type.
+    """
+
+    metadata: Dict[str, str]
+    tensors: Dict[TENSOR_NAME_T, TensorInfo]
+    parameter_count: Dict[DTYPE_T, int] = field(init=False)
+
+    def __post_init__(self) -> None:
+        parameter_count: Dict[DTYPE_T, int] = defaultdict(int)
+        for tensor in self.tensors.values():
+            parameter_count[tensor.dtype] += tensor.parameter_count
+        self.parameter_count = dict(parameter_count)
+
+
+@dataclass
+class SafetensorsRepoMetadata:
+    """Metadata for a Safetensors repo.
+
+    A repo is considered to be a Safetensors repo if it contains either a 'model.safetensors' weight file (non-shared
+    model) or a 'model.safetensors.index.json' index file (sharded model) at its root.
+
+    This class is returned by [`get_safetensors_metadata`].
+
+    For more details regarding the safetensors format, check out https://huggingface.co/docs/safetensors/index#format.
+
+    Attributes:
+        metadata (`Dict`, *optional*):
+            The metadata contained in the 'model.safetensors.index.json' file, if it exists. Only populated for sharded
+            models.
+        sharded (`bool`):
+            Whether the repo contains a sharded model or not.
+        weight_map (`Dict[str, str]`):
+            A map of all weights. Keys are tensor names and values are filenames of the files containing the tensors.
+        files_metadata (`Dict[str, SafetensorsFileMetadata]`):
+            A map of all files metadata. Keys are filenames and values are the metadata of the corresponding file, as
+            a [`SafetensorsFileMetadata`] object.
+        parameter_count (`Dict[str, int]`):
+            A map of the number of parameters per data type. Keys are data types and values are the number of parameters
+            of that data type.
+    """
+
+    metadata: Optional[Dict]
+    sharded: bool
+    weight_map: Dict[TENSOR_NAME_T, FILENAME_T]  # tensor name -> filename
+    files_metadata: Dict[FILENAME_T, SafetensorsFileMetadata]  # filename -> metadata
+    parameter_count: Dict[DTYPE_T, int] = field(init=False)
+
+    def __post_init__(self) -> None:
+        parameter_count: Dict[DTYPE_T, int] = defaultdict(int)
+        for file_metadata in self.files_metadata.values():
+            for dtype, nb_parameters_ in file_metadata.parameter_count.items():
+                parameter_count[dtype] += nb_parameters_
+        self.parameter_count = dict(parameter_count)
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_subprocess.py b/lib/python3.11/site-packages/huggingface_hub/utils/_subprocess.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ec7936549c11f432c2b98a2f88a7a87d1b38772
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_subprocess.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+"""Contains utilities to easily handle subprocesses in `huggingface_hub`."""
+import os
+import subprocess
+import sys
+from contextlib import contextmanager
+from io import StringIO
+from pathlib import Path
+from typing import IO, Generator, List, Optional, Tuple, Union
+
+from .logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+@contextmanager
+def capture_output() -> Generator[StringIO, None, None]:
+    """Capture output that is printed to terminal.
+
+    Taken from https://stackoverflow.com/a/34738440
+
+    Example:
+    ```py
+    >>> with capture_output() as output:
+    ...     print("hello world")
+    >>> assert output.getvalue() == "hello world\n"
+    ```
+    """
+    output = StringIO()
+    previous_output = sys.stdout
+    sys.stdout = output
+    yield output
+    sys.stdout = previous_output
+
+
+def run_subprocess(
+    command: Union[str, List[str]],
+    folder: Optional[Union[str, Path]] = None,
+    check=True,
+    **kwargs,
+) -> subprocess.CompletedProcess:
+    """
+    Method to run subprocesses. Calling this will capture the `stderr` and `stdout`,
+    please call `subprocess.run` manually in case you would like for them not to
+    be captured.
+
+    Args:
+        command (`str` or `List[str]`):
+            The command to execute as a string or list of strings.
+        folder (`str`, *optional*):
+            The folder in which to run the command. Defaults to current working
+            directory (from `os.getcwd()`).
+        check (`bool`, *optional*, defaults to `True`):
+            Setting `check` to `True` will raise a `subprocess.CalledProcessError`
+            when the subprocess has a non-zero exit code.
+        kwargs (`Dict[str]`):
+            Keyword arguments to be passed to the `subprocess.run` underlying command.
+
+    Returns:
+        `subprocess.CompletedProcess`: The completed process.
+    """
+    if isinstance(command, str):
+        command = command.split()
+
+    if isinstance(folder, Path):
+        folder = str(folder)
+
+    return subprocess.run(
+        command,
+        stderr=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        check=check,
+        encoding="utf-8",
+        errors="replace",  # if not utf-8, replace char by �
+        cwd=folder or os.getcwd(),
+        **kwargs,
+    )
+
+
+@contextmanager
+def run_interactive_subprocess(
+    command: Union[str, List[str]],
+    folder: Optional[Union[str, Path]] = None,
+    **kwargs,
+) -> Generator[Tuple[IO[str], IO[str]], None, None]:
+    """Run a subprocess in an interactive mode in a context manager.
+
+    Args:
+        command (`str` or `List[str]`):
+            The command to execute as a string or list of strings.
+        folder (`str`, *optional*):
+            The folder in which to run the command. Defaults to current working
+            directory (from `os.getcwd()`).
+        kwargs (`Dict[str]`):
+            Keyword arguments to be passed to the `subprocess.run` underlying command.
+
+    Returns:
+        `Tuple[IO[str], IO[str]]`: A tuple with `stdin` and `stdout` to interact
+        with the process (input and output are utf-8 encoded).
+
+    Example:
+    ```python
+    with _interactive_subprocess("git credential-store get") as (stdin, stdout):
+        # Write to stdin
+        stdin.write("url=hf.co\nusername=obama\n".encode("utf-8"))
+        stdin.flush()
+
+        # Read from stdout
+        output = stdout.read().decode("utf-8")
+    ```
+    """
+    if isinstance(command, str):
+        command = command.split()
+
+    with subprocess.Popen(
+        command,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        encoding="utf-8",
+        errors="replace",  # if not utf-8, replace char by �
+        cwd=folder or os.getcwd(),
+        **kwargs,
+    ) as process:
+        assert process.stdin is not None, "subprocess is opened as subprocess.PIPE"
+        assert process.stdout is not None, "subprocess is opened as subprocess.PIPE"
+        yield process.stdin, process.stdout
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_telemetry.py b/lib/python3.11/site-packages/huggingface_hub/utils/_telemetry.py
new file mode 100644
index 0000000000000000000000000000000000000000..5de988e2795188324f69232d1beb68191591715d
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_telemetry.py
@@ -0,0 +1,118 @@
+from queue import Queue
+from threading import Lock, Thread
+from typing import Dict, Optional, Union
+from urllib.parse import quote
+
+from .. import constants, logging
+from . import build_hf_headers, get_session, hf_raise_for_status
+
+
+logger = logging.get_logger(__name__)
+
+# Telemetry is sent by a separate thread to avoid blocking the main thread.
+# A daemon thread is started once and consume tasks from the _TELEMETRY_QUEUE.
+# If the thread stops for some reason -shouldn't happen-, we restart a new one.
+_TELEMETRY_THREAD: Optional[Thread] = None
+_TELEMETRY_THREAD_LOCK = Lock()  # Lock to avoid starting multiple threads in parallel
+_TELEMETRY_QUEUE: Queue = Queue()
+
+
+def send_telemetry(
+    topic: str,
+    *,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    user_agent: Union[Dict, str, None] = None,
+) -> None:
+    """
+    Sends telemetry that helps tracking usage of different HF libraries.
+
+    This usage data helps us debug issues and prioritize new features. However, we understand that not everyone wants
+    to share additional information, and we respect your privacy. You can disable telemetry collection by setting the
+    `HF_HUB_DISABLE_TELEMETRY=1` as environment variable. Telemetry is also disabled in offline mode (i.e. when setting
+    `HF_HUB_OFFLINE=1`).
+
+    Telemetry collection is run in a separate thread to minimize impact for the user.
+
+    Args:
+        topic (`str`):
+            Name of the topic that is monitored. The topic is directly used to build the URL. If you want to monitor
+            subtopics, just use "/" separation. Examples: "gradio", "transformers/examples",...
+        library_name (`str`, *optional*):
+            The name of the library that is making the HTTP request. Will be added to the user-agent header.
+        library_version (`str`, *optional*):
+            The version of the library that is making the HTTP request. Will be added to the user-agent header.
+        user_agent (`str`, `dict`, *optional*):
+            The user agent info in the form of a dictionary or a single string. It will be completed with information about the installed packages.
+
+    Example:
+    ```py
+    >>> from huggingface_hub.utils import send_telemetry
+
+    # Send telemetry without library information
+    >>> send_telemetry("ping")
+
+    # Send telemetry to subtopic with library information
+    >>> send_telemetry("gradio/local_link", library_name="gradio", library_version="3.22.1")
+
+    # Send telemetry with additional data
+    >>> send_telemetry(
+    ...     topic="examples",
+    ...     library_name="transformers",
+    ...     library_version="4.26.0",
+    ...     user_agent={"pipeline": "text_classification", "framework": "flax"},
+    ... )
+    ```
+    """
+    if constants.HF_HUB_OFFLINE or constants.HF_HUB_DISABLE_TELEMETRY:
+        return
+
+    _start_telemetry_thread()  # starts thread only if doesn't exist yet
+    _TELEMETRY_QUEUE.put(
+        {"topic": topic, "library_name": library_name, "library_version": library_version, "user_agent": user_agent}
+    )
+
+
+def _start_telemetry_thread():
+    """Start a daemon thread to consume tasks from the telemetry queue.
+
+    If the thread is interrupted, start a new one.
+    """
+    with _TELEMETRY_THREAD_LOCK:  # avoid to start multiple threads if called concurrently
+        global _TELEMETRY_THREAD
+        if _TELEMETRY_THREAD is None or not _TELEMETRY_THREAD.is_alive():
+            _TELEMETRY_THREAD = Thread(target=_telemetry_worker, daemon=True)
+            _TELEMETRY_THREAD.start()
+
+
+def _telemetry_worker():
+    """Wait for a task and consume it."""
+    while True:
+        kwargs = _TELEMETRY_QUEUE.get()
+        _send_telemetry_in_thread(**kwargs)
+        _TELEMETRY_QUEUE.task_done()
+
+
+def _send_telemetry_in_thread(
+    topic: str,
+    *,
+    library_name: Optional[str] = None,
+    library_version: Optional[str] = None,
+    user_agent: Union[Dict, str, None] = None,
+) -> None:
+    """Contains the actual data sending data to the Hub."""
+    path = "/".join(quote(part) for part in topic.split("/") if len(part) > 0)
+    try:
+        r = get_session().head(
+            f"{constants.ENDPOINT}/api/telemetry/{path}",
+            headers=build_hf_headers(
+                token=False,  # no need to send a token for telemetry
+                library_name=library_name,
+                library_version=library_version,
+                user_agent=user_agent,
+            ),
+        )
+        hf_raise_for_status(r)
+    except Exception as e:
+        # We don't want to error in case of connection errors of any kind.
+        logger.debug(f"Error while sending telemetry: {e}")
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_token.py b/lib/python3.11/site-packages/huggingface_hub/utils/_token.py
new file mode 100644
index 0000000000000000000000000000000000000000..32362b39297d6733b0821968c698d42524c7de2d
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_token.py
@@ -0,0 +1,129 @@
+# Copyright 2023 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains an helper to get the token from machine (env variable, secret or config file)."""
+import os
+import warnings
+from pathlib import Path
+from threading import Lock
+from typing import Optional
+
+from .. import constants
+from ._runtime import is_google_colab
+
+
+_IS_GOOGLE_COLAB_CHECKED = False
+_GOOGLE_COLAB_SECRET_LOCK = Lock()
+_GOOGLE_COLAB_SECRET: Optional[str] = None
+
+
+def get_token() -> Optional[str]:
+    """
+    Get token if user is logged in.
+
+    Note: in most cases, you should use [`huggingface_hub.utils.build_hf_headers`] instead. This method is only useful
+          if you want to retrieve the token for other purposes than sending an HTTP request.
+
+    Token is retrieved in priority from the `HF_TOKEN` environment variable. Otherwise, we read the token file located
+    in the Hugging Face home folder. Returns None if user is not logged in. To log in, use [`login`] or
+    `huggingface-cli login`.
+
+    Returns:
+        `str` or `None`: The token, `None` if it doesn't exist.
+    """
+    return _get_token_from_google_colab() or _get_token_from_environment() or _get_token_from_file()
+
+
+def _get_token_from_google_colab() -> Optional[str]:
+    """Get token from Google Colab secrets vault using `google.colab.userdata.get(...)`.
+
+    Token is read from the vault only once per session and then stored in a global variable to avoid re-requesting
+    access to the vault.
+    """
+    if not is_google_colab():
+        return None
+
+    # `google.colab.userdata` is not thread-safe
+    # This can lead to a deadlock if multiple threads try to access it at the same time
+    # (typically when using `snapshot_download`)
+    # => use a lock
+    # See https://github.com/huggingface/huggingface_hub/issues/1952 for more details.
+    with _GOOGLE_COLAB_SECRET_LOCK:
+        global _GOOGLE_COLAB_SECRET
+        global _IS_GOOGLE_COLAB_CHECKED
+
+        if _IS_GOOGLE_COLAB_CHECKED:  # request access only once
+            return _GOOGLE_COLAB_SECRET
+
+        try:
+            from google.colab import userdata
+            from google.colab.errors import Error as ColabError
+        except ImportError:
+            return None
+
+        try:
+            token = userdata.get("HF_TOKEN")
+            _GOOGLE_COLAB_SECRET = _clean_token(token)
+        except userdata.NotebookAccessError:
+            # Means the user has a secret call `HF_TOKEN` and got a popup "please grand access to HF_TOKEN" and refused it
+            # => warn user but ignore error => do not re-request access to user
+            warnings.warn(
+                "\nAccess to the secret `HF_TOKEN` has not been granted on this notebook."
+                "\nYou will not be requested again."
+                "\nPlease restart the session if you want to be prompted again."
+            )
+            _GOOGLE_COLAB_SECRET = None
+        except userdata.SecretNotFoundError:
+            # Means the user did not define a `HF_TOKEN` secret => warn
+            warnings.warn(
+                "\nThe secret `HF_TOKEN` does not exist in your Colab secrets."
+                "\nTo authenticate with the Hugging Face Hub, create a token in your settings tab "
+                "(https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session."
+                "\nYou will be able to reuse this secret in all of your notebooks."
+                "\nPlease note that authentication is recommended but still optional to access public models or datasets."
+            )
+            _GOOGLE_COLAB_SECRET = None
+        except ColabError as e:
+            # Something happen but we don't know what => recommend to open a GitHub issue
+            warnings.warn(
+                f"\nError while fetching `HF_TOKEN` secret value from your vault: '{str(e)}'."
+                "\nYou are not authenticated with the Hugging Face Hub in this notebook."
+                "\nIf the error persists, please let us know by opening an issue on GitHub "
+                "(https://github.com/huggingface/huggingface_hub/issues/new)."
+            )
+            _GOOGLE_COLAB_SECRET = None
+
+        _IS_GOOGLE_COLAB_CHECKED = True
+        return _GOOGLE_COLAB_SECRET
+
+
+def _get_token_from_environment() -> Optional[str]:
+    # `HF_TOKEN` has priority (keep `HUGGING_FACE_HUB_TOKEN` for backward compatibility)
+    return _clean_token(os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN"))
+
+
+def _get_token_from_file() -> Optional[str]:
+    try:
+        return _clean_token(Path(constants.HF_TOKEN_PATH).read_text())
+    except FileNotFoundError:
+        return None
+
+
+def _clean_token(token: Optional[str]) -> Optional[str]:
+    """Clean token by removing trailing and leading spaces and newlines.
+
+    If token is an empty string, return None.
+    """
+    if token is None:
+        return None
+    return token.replace("\r", "").replace("\n", "").strip() or None
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_typing.py b/lib/python3.11/site-packages/huggingface_hub/utils/_typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..56f2ceed6bb718bbbc119c873caa1b240f5702ac
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_typing.py
@@ -0,0 +1,22 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Handle typing imports based on system compatibility."""
+from typing import Callable, Literal, TypeVar
+
+
+HTTP_METHOD_T = Literal["GET", "OPTIONS", "HEAD", "POST", "PUT", "PATCH", "DELETE"]
+
+# type hint meaning "function signature not changed by decorator"
+CallableT = TypeVar("CallableT", bound=Callable)
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/_validators.py b/lib/python3.11/site-packages/huggingface_hub/utils/_validators.py
new file mode 100644
index 0000000000000000000000000000000000000000..5dd64fa51435b97142bb61cfe12f9369e6f1488b
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/_validators.py
@@ -0,0 +1,230 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to validate argument values in `huggingface_hub`."""
+import inspect
+import re
+import warnings
+from functools import wraps
+from itertools import chain
+from typing import Any, Dict
+
+from ._typing import CallableT
+
+
+REPO_ID_REGEX = re.compile(
+    r"""
+    ^
+    (\b[\w\-.]+\b/)? # optional namespace (username or organization)
+    \b               # starts with a word boundary
+    [\w\-.]{1,96}    # repo_name: alphanumeric + . _ -
+    \b               # ends with a word boundary
+    $
+    """,
+    flags=re.VERBOSE,
+)
+
+
+class HFValidationError(ValueError):
+    """Generic exception thrown by `huggingface_hub` validators.
+
+    Inherits from [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError).
+    """
+
+
+def validate_hf_hub_args(fn: CallableT) -> CallableT:
+    """Validate values received as argument for any public method of `huggingface_hub`.
+
+    The goal of this decorator is to harmonize validation of arguments reused
+    everywhere. By default, all defined validators are tested.
+
+    Validators:
+        - [`~utils.validate_repo_id`]: `repo_id` must be `"repo_name"`
+          or `"namespace/repo_name"`. Namespace is a username or an organization.
+        - [`~utils.smoothly_deprecate_use_auth_token`]: Use `token` instead of
+          `use_auth_token` (only if `use_auth_token` is not expected by the decorated
+          function - in practice, always the case in `huggingface_hub`).
+
+    Example:
+    ```py
+    >>> from huggingface_hub.utils import validate_hf_hub_args
+
+    >>> @validate_hf_hub_args
+    ... def my_cool_method(repo_id: str):
+    ...     print(repo_id)
+
+    >>> my_cool_method(repo_id="valid_repo_id")
+    valid_repo_id
+
+    >>> my_cool_method("other..repo..id")
+    huggingface_hub.utils._validators.HFValidationError: Cannot have -- or .. in repo_id: 'other..repo..id'.
+
+    >>> my_cool_method(repo_id="other..repo..id")
+    huggingface_hub.utils._validators.HFValidationError: Cannot have -- or .. in repo_id: 'other..repo..id'.
+
+    >>> @validate_hf_hub_args
+    ... def my_cool_auth_method(token: str):
+    ...     print(token)
+
+    >>> my_cool_auth_method(token="a token")
+    "a token"
+
+    >>> my_cool_auth_method(use_auth_token="a use_auth_token")
+    "a use_auth_token"
+
+    >>> my_cool_auth_method(token="a token", use_auth_token="a use_auth_token")
+    UserWarning: Both `token` and `use_auth_token` are passed (...)
+    "a token"
+    ```
+
+    Raises:
+        [`~utils.HFValidationError`]:
+            If an input is not valid.
+    """
+    # TODO: add an argument to opt-out validation for specific argument?
+    signature = inspect.signature(fn)
+
+    # Should the validator switch `use_auth_token` values to `token`? In practice, always
+    # True in `huggingface_hub`. Might not be the case in a downstream library.
+    check_use_auth_token = "use_auth_token" not in signature.parameters and "token" in signature.parameters
+
+    @wraps(fn)
+    def _inner_fn(*args, **kwargs):
+        has_token = False
+        for arg_name, arg_value in chain(
+            zip(signature.parameters, args),  # Args values
+            kwargs.items(),  # Kwargs values
+        ):
+            if arg_name in ["repo_id", "from_id", "to_id"]:
+                validate_repo_id(arg_value)
+
+            elif arg_name == "token" and arg_value is not None:
+                has_token = True
+
+        if check_use_auth_token:
+            kwargs = smoothly_deprecate_use_auth_token(fn_name=fn.__name__, has_token=has_token, kwargs=kwargs)
+
+        return fn(*args, **kwargs)
+
+    return _inner_fn  # type: ignore
+
+
+def validate_repo_id(repo_id: str) -> None:
+    """Validate `repo_id` is valid.
+
+    This is not meant to replace the proper validation made on the Hub but rather to
+    avoid local inconsistencies whenever possible (example: passing `repo_type` in the
+    `repo_id` is forbidden).
+
+    Rules:
+    - Between 1 and 96 characters.
+    - Either "repo_name" or "namespace/repo_name"
+    - [a-zA-Z0-9] or "-", "_", "."
+    - "--" and ".." are forbidden
+
+    Valid: `"foo"`, `"foo/bar"`, `"123"`, `"Foo-BAR_foo.bar123"`
+
+    Not valid: `"datasets/foo/bar"`, `".repo_id"`, `"foo--bar"`, `"foo.git"`
+
+    Example:
+    ```py
+    >>> from huggingface_hub.utils import validate_repo_id
+    >>> validate_repo_id(repo_id="valid_repo_id")
+    >>> validate_repo_id(repo_id="other..repo..id")
+    huggingface_hub.utils._validators.HFValidationError: Cannot have -- or .. in repo_id: 'other..repo..id'.
+    ```
+
+    Discussed in https://github.com/huggingface/huggingface_hub/issues/1008.
+    In moon-landing (internal repository):
+    - https://github.com/huggingface/moon-landing/blob/main/server/lib/Names.ts#L27
+    - https://github.com/huggingface/moon-landing/blob/main/server/views/components/NewRepoForm/NewRepoForm.svelte#L138
+    """
+    if not isinstance(repo_id, str):
+        # Typically, a Path is not a repo_id
+        raise HFValidationError(f"Repo id must be a string, not {type(repo_id)}: '{repo_id}'.")
+
+    if repo_id.count("/") > 1:
+        raise HFValidationError(
+            "Repo id must be in the form 'repo_name' or 'namespace/repo_name':"
+            f" '{repo_id}'. Use `repo_type` argument if needed."
+        )
+
+    if not REPO_ID_REGEX.match(repo_id):
+        raise HFValidationError(
+            "Repo id must use alphanumeric chars or '-', '_', '.', '--' and '..' are"
+            " forbidden, '-' and '.' cannot start or end the name, max length is 96:"
+            f" '{repo_id}'."
+        )
+
+    if "--" in repo_id or ".." in repo_id:
+        raise HFValidationError(f"Cannot have -- or .. in repo_id: '{repo_id}'.")
+
+    if repo_id.endswith(".git"):
+        raise HFValidationError(f"Repo_id cannot end by '.git': '{repo_id}'.")
+
+
+def smoothly_deprecate_use_auth_token(fn_name: str, has_token: bool, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    """Smoothly deprecate `use_auth_token` in the `huggingface_hub` codebase.
+
+    The long-term goal is to remove any mention of `use_auth_token` in the codebase in
+    favor of a unique and less verbose `token` argument. This will be done a few steps:
+
+    0. Step 0: methods that require a read-access to the Hub use the `use_auth_token`
+       argument (`str`, `bool` or `None`). Methods requiring write-access have a `token`
+       argument (`str`, `None`). This implicit rule exists to be able to not send the
+       token when not necessary (`use_auth_token=False`) even if logged in.
+
+    1. Step 1: we want to harmonize everything and use `token` everywhere (supporting
+       `token=False` for read-only methods). In order not to break existing code, if
+       `use_auth_token` is passed to a function, the `use_auth_token` value is passed
+       as `token` instead, without any warning.
+       a. Corner case: if both `use_auth_token` and `token` values are passed, a warning
+          is thrown and the `use_auth_token` value is ignored.
+
+    2. Step 2: Once it is release, we should push downstream libraries to switch from
+       `use_auth_token` to `token` as much as possible, but without throwing a warning
+       (e.g. manually create issues on the corresponding repos).
+
+    3. Step 3: After a transitional period (6 months e.g. until April 2023?), we update
+       `huggingface_hub` to throw a warning on `use_auth_token`. Hopefully, very few
+       users will be impacted as it would have already been fixed.
+       In addition, unit tests in `huggingface_hub` must be adapted to expect warnings
+       to be thrown (but still use `use_auth_token` as before).
+
+    4. Step 4: After a normal deprecation cycle (3 releases ?), remove this validator.
+       `use_auth_token` will definitely not be supported.
+       In addition, we update unit tests in `huggingface_hub` to use `token` everywhere.
+
+    This has been discussed in:
+    - https://github.com/huggingface/huggingface_hub/issues/1094.
+    - https://github.com/huggingface/huggingface_hub/pull/928
+    - (related) https://github.com/huggingface/huggingface_hub/pull/1064
+    """
+    new_kwargs = kwargs.copy()  # do not mutate input !
+
+    use_auth_token = new_kwargs.pop("use_auth_token", None)  # remove from kwargs
+    if use_auth_token is not None:
+        if has_token:
+            warnings.warn(
+                "Both `token` and `use_auth_token` are passed to"
+                f" `{fn_name}` with non-None values. `token` is now the"
+                " preferred argument to pass a User Access Token."
+                " `use_auth_token` value will be ignored."
+            )
+        else:
+            # `token` argument is not passed and a non-None value is passed in
+            # `use_auth_token` => use `use_auth_token` value as `token` kwarg.
+            new_kwargs["token"] = use_auth_token
+
+    return new_kwargs
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/endpoint_helpers.py b/lib/python3.11/site-packages/huggingface_hub/utils/endpoint_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbda8938f9a65fff437d75fedf3ad97c445bb0a9
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/endpoint_helpers.py
@@ -0,0 +1,223 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Helpful utility functions and classes in relation to exploring API endpoints
+with the aim for a user-friendly interface.
+"""
+import math
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from ..repocard_data import ModelCardData
+
+
+if TYPE_CHECKING:
+    from ..hf_api import ModelInfo
+
+
+def _is_emission_within_treshold(model_info: "ModelInfo", minimum_threshold: float, maximum_threshold: float) -> bool:
+    """Checks if a model's emission is within a given threshold.
+
+    Args:
+        model_info (`ModelInfo`):
+            A model info object containing the model's emission information.
+        minimum_threshold (`float`):
+            A minimum carbon threshold to filter by, such as 1.
+        maximum_threshold (`float`):
+            A maximum carbon threshold to filter by, such as 10.
+
+    Returns:
+        `bool`: Whether the model's emission is within the given threshold.
+    """
+    if minimum_threshold is None and maximum_threshold is None:
+        raise ValueError("Both `minimum_threshold` and `maximum_threshold` cannot both be `None`")
+    if minimum_threshold is None:
+        minimum_threshold = -1
+    if maximum_threshold is None:
+        maximum_threshold = math.inf
+
+    card_data = getattr(model_info, "card_data", None)
+    if card_data is None or not isinstance(card_data, (dict, ModelCardData)):
+        return False
+
+    # Get CO2 emission metadata
+    emission = card_data.get("co2_eq_emissions", None)
+    if isinstance(emission, dict):
+        emission = emission["emissions"]
+    if not emission:
+        return False
+
+    # Filter out if value is missing or out of range
+    matched = re.search(r"\d+\.\d+|\d+", str(emission))
+    if matched is None:
+        return False
+
+    emission_value = float(matched.group(0))
+    return minimum_threshold <= emission_value <= maximum_threshold
+
+
+@dataclass
+class DatasetFilter:
+    """
+    A class that converts human-readable dataset search parameters into ones
+    compatible with the REST API. For all parameters capitalization does not
+    matter.
+
+    Args:
+        author (`str`, *optional*):
+            A string or list of strings that can be used to identify datasets on
+            the Hub by the original uploader (author or organization), such as
+            `facebook` or `huggingface`.
+        benchmark (`str` or `List`, *optional*):
+            A string or list of strings that can be used to identify datasets on
+            the Hub by their official benchmark.
+        dataset_name (`str`, *optional*):
+            A string or list of strings that can be used to identify datasets on
+            the Hub by its name, such as `SQAC` or `wikineural`
+        language_creators (`str` or `List`, *optional*):
+            A string or list of strings that can be used to identify datasets on
+            the Hub with how the data was curated, such as `crowdsourced` or
+            `machine_generated`.
+        language (`str` or `List`, *optional*):
+            A string or list of strings representing a two-character language to
+            filter datasets by on the Hub.
+        multilinguality (`str` or `List`, *optional*):
+            A string or list of strings representing a filter for datasets that
+            contain multiple languages.
+        size_categories (`str` or `List`, *optional*):
+            A string or list of strings that can be used to identify datasets on
+            the Hub by the size of the dataset such as `100K<n<1M` or
+            `1M<n<10M`.
+        task_categories (`str` or `List`, *optional*):
+            A string or list of strings that can be used to identify datasets on
+            the Hub by the designed task, such as `audio_classification` or
+            `named_entity_recognition`.
+        task_ids (`str` or `List`, *optional*):
+            A string or list of strings that can be used to identify datasets on
+            the Hub by the specific task such as `speech_emotion_recognition` or
+            `paraphrase`.
+
+    Examples:
+
+    ```py
+    >>> from huggingface_hub import DatasetFilter
+
+    >>> # Using author
+    >>> new_filter = DatasetFilter(author="facebook")
+
+    >>> # Using benchmark
+    >>> new_filter = DatasetFilter(benchmark="raft")
+
+    >>> # Using dataset_name
+    >>> new_filter = DatasetFilter(dataset_name="wikineural")
+
+    >>> # Using language_creator
+    >>> new_filter = DatasetFilter(language_creator="crowdsourced")
+
+    >>> # Using language
+    >>> new_filter = DatasetFilter(language="en")
+
+    >>> # Using multilinguality
+    >>> new_filter = DatasetFilter(multilinguality="multilingual")
+
+    >>> # Using size_categories
+    >>> new_filter = DatasetFilter(size_categories="100K<n<1M")
+
+    >>> # Using task_categories
+    >>> new_filter = DatasetFilter(task_categories="audio_classification")
+
+    >>> # Using task_ids
+    >>> new_filter = DatasetFilter(task_ids="paraphrase")
+    ```
+    """
+
+    author: Optional[str] = None
+    benchmark: Optional[Union[str, List[str]]] = None
+    dataset_name: Optional[str] = None
+    language_creators: Optional[Union[str, List[str]]] = None
+    language: Optional[Union[str, List[str]]] = None
+    multilinguality: Optional[Union[str, List[str]]] = None
+    size_categories: Optional[Union[str, List[str]]] = None
+    task_categories: Optional[Union[str, List[str]]] = None
+    task_ids: Optional[Union[str, List[str]]] = None
+
+
+@dataclass
+class ModelFilter:
+    """
+    A class that converts human-readable model search parameters into ones
+    compatible with the REST API. For all parameters capitalization does not
+    matter.
+
+    Args:
+        author (`str`, *optional*):
+            A string that can be used to identify models on the Hub by the
+            original uploader (author or organization), such as `facebook` or
+            `huggingface`.
+        library (`str` or `List`, *optional*):
+            A string or list of strings of foundational libraries models were
+            originally trained from, such as pytorch, tensorflow, or allennlp.
+        language (`str` or `List`, *optional*):
+            A string or list of strings of languages, both by name and country
+            code, such as "en" or "English"
+        model_name (`str`, *optional*):
+            A string that contain complete or partial names for models on the
+            Hub, such as "bert" or "bert-base-cased"
+        task (`str` or `List`, *optional*):
+            A string or list of strings of tasks models were designed for, such
+            as: "fill-mask" or "automatic-speech-recognition"
+        tags (`str` or `List`, *optional*):
+            A string tag or a list of tags to filter models on the Hub by, such
+            as `text-generation` or `spacy`.
+        trained_dataset (`str` or `List`, *optional*):
+            A string tag or a list of string tags of the trained dataset for a
+            model on the Hub.
+
+
+    ```python
+    >>> from huggingface_hub import ModelFilter
+
+    >>> # For the author_or_organization
+    >>> new_filter = ModelFilter(author_or_organization="facebook")
+
+    >>> # For the library
+    >>> new_filter = ModelFilter(library="pytorch")
+
+    >>> # For the language
+    >>> new_filter = ModelFilter(language="french")
+
+    >>> # For the model_name
+    >>> new_filter = ModelFilter(model_name="bert")
+
+    >>> # For the task
+    >>> new_filter = ModelFilter(task="text-classification")
+
+    >>> from huggingface_hub import HfApi
+
+    >>> api = HfApi()
+    # To list model tags
+
+    >>> new_filter = ModelFilter(tags="benchmark:raft")
+
+    >>> # Related to the dataset
+    >>> new_filter = ModelFilter(trained_dataset="common_voice")
+    ```
+    """
+
+    author: Optional[str] = None
+    library: Optional[Union[str, List[str]]] = None
+    language: Optional[Union[str, List[str]]] = None
+    model_name: Optional[str] = None
+    task: Optional[Union[str, List[str]]] = None
+    trained_dataset: Optional[Union[str, List[str]]] = None
+    tags: Optional[Union[str, List[str]]] = None
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/insecure_hashlib.py b/lib/python3.11/site-packages/huggingface_hub/utils/insecure_hashlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..f232ee0adcfc52dcc18b5ea4d9c913b206521f71
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/insecure_hashlib.py
@@ -0,0 +1,34 @@
+# Taken from https://github.com/mlflow/mlflow/pull/10119
+#
+# DO NOT use this function for security purposes (e.g., password hashing).
+#
+# In Python >= 3.9, insecure hashing algorithms such as MD5 fail in FIPS-compliant
+# environments unless `usedforsecurity=False` is explicitly passed.
+#
+# References:
+# - https://github.com/mlflow/mlflow/issues/9905
+# - https://github.com/mlflow/mlflow/pull/10119
+# - https://docs.python.org/3/library/hashlib.html
+# - https://github.com/huggingface/transformers/pull/27038
+#
+# Usage:
+#     ```python
+#     # Use
+#     from huggingface_hub.utils.insecure_hashlib import sha256
+#     # instead of
+#     from hashlib import sha256
+#
+#     # Use
+#     from huggingface_hub.utils import insecure_hashlib
+#     # instead of
+#     import hashlib
+#     ```
+import functools
+import hashlib
+import sys
+
+
+_kwargs = {"usedforsecurity": False} if sys.version_info >= (3, 9) else {}
+md5 = functools.partial(hashlib.md5, **_kwargs)
+sha1 = functools.partial(hashlib.sha1, **_kwargs)
+sha256 = functools.partial(hashlib.sha256, **_kwargs)
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/logging.py b/lib/python3.11/site-packages/huggingface_hub/utils/logging.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc4d6a00542e14a2a9d0764f52968e3e258dc593
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/logging.py
@@ -0,0 +1,182 @@
+# coding=utf-8
+# Copyright 2020 Optuna, Hugging Face
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" Logging utilities."""
+
+import logging
+import os
+from logging import (
+    CRITICAL,  # NOQA
+    DEBUG,  # NOQA
+    ERROR,  # NOQA
+    FATAL,  # NOQA
+    INFO,  # NOQA
+    NOTSET,  # NOQA
+    WARN,  # NOQA
+    WARNING,  # NOQA
+)
+from typing import Optional
+
+
+log_levels = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+_default_log_level = logging.WARNING
+
+
+def _get_library_name() -> str:
+    return __name__.split(".")[0]
+
+
+def _get_library_root_logger() -> logging.Logger:
+    return logging.getLogger(_get_library_name())
+
+
+def _get_default_logging_level():
+    """
+    If `HF_HUB_VERBOSITY` env var is set to one of the valid choices return that as the new default level. If it is not
+    - fall back to `_default_log_level`
+    """
+    env_level_str = os.getenv("HF_HUB_VERBOSITY", None)
+    if env_level_str:
+        if env_level_str in log_levels:
+            return log_levels[env_level_str]
+        else:
+            logging.getLogger().warning(
+                f"Unknown option HF_HUB_VERBOSITY={env_level_str}, has to be one of: { ', '.join(log_levels.keys()) }"
+            )
+    return _default_log_level
+
+
+def _configure_library_root_logger() -> None:
+    library_root_logger = _get_library_root_logger()
+    library_root_logger.addHandler(logging.StreamHandler())
+    library_root_logger.setLevel(_get_default_logging_level())
+
+
+def _reset_library_root_logger() -> None:
+    library_root_logger = _get_library_root_logger()
+    library_root_logger.setLevel(logging.NOTSET)
+
+
+def get_logger(name: Optional[str] = None) -> logging.Logger:
+    """
+        Returns a logger with the specified name. This function is not supposed
+        to be directly accessed by library users.
+
+        Args:
+            name (`str`, *optional*):
+                The name of the logger to get, usually the filename
+
+        Example:
+
+    ```python
+    >>> from huggingface_hub import get_logger
+
+    >>> logger = get_logger(__file__)
+    >>> logger.set_verbosity_info()
+    ```
+    """
+
+    if name is None:
+        name = _get_library_name()
+
+    return logging.getLogger(name)
+
+
+def get_verbosity() -> int:
+    """Return the current level for the HuggingFace Hub's root logger.
+
+    Returns:
+        Logging level, e.g., `huggingface_hub.logging.DEBUG` and
+        `huggingface_hub.logging.INFO`.
+
+    <Tip>
+
+    HuggingFace Hub has following logging levels:
+
+    - `huggingface_hub.logging.CRITICAL`, `huggingface_hub.logging.FATAL`
+    - `huggingface_hub.logging.ERROR`
+    - `huggingface_hub.logging.WARNING`, `huggingface_hub.logging.WARN`
+    - `huggingface_hub.logging.INFO`
+    - `huggingface_hub.logging.DEBUG`
+
+    </Tip>
+    """
+    return _get_library_root_logger().getEffectiveLevel()
+
+
+def set_verbosity(verbosity: int) -> None:
+    """
+    Sets the level for the HuggingFace Hub's root logger.
+
+    Args:
+        verbosity (`int`):
+            Logging level, e.g., `huggingface_hub.logging.DEBUG` and
+            `huggingface_hub.logging.INFO`.
+    """
+    _get_library_root_logger().setLevel(verbosity)
+
+
+def set_verbosity_info():
+    """
+    Sets the verbosity to `logging.INFO`.
+    """
+    return set_verbosity(INFO)
+
+
+def set_verbosity_warning():
+    """
+    Sets the verbosity to `logging.WARNING`.
+    """
+    return set_verbosity(WARNING)
+
+
+def set_verbosity_debug():
+    """
+    Sets the verbosity to `logging.DEBUG`.
+    """
+    return set_verbosity(DEBUG)
+
+
+def set_verbosity_error():
+    """
+    Sets the verbosity to `logging.ERROR`.
+    """
+    return set_verbosity(ERROR)
+
+
+def disable_propagation() -> None:
+    """
+    Disable propagation of the library log outputs. Note that log propagation is
+    disabled by default.
+    """
+    _get_library_root_logger().propagate = False
+
+
+def enable_propagation() -> None:
+    """
+    Enable propagation of the library log outputs. Please disable the
+    HuggingFace Hub's default handler to prevent double logging if the root
+    logger has been configured.
+    """
+    _get_library_root_logger().propagate = True
+
+
+_configure_library_root_logger()
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/sha.py b/lib/python3.11/site-packages/huggingface_hub/utils/sha.py
new file mode 100644
index 0000000000000000000000000000000000000000..adab93512428ce5fc0a1675c8353d4ee27ff89fe
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/sha.py
@@ -0,0 +1,28 @@
+"""Utilities to efficiently compute the SHA 256 hash of a bunch of bytes."""
+from typing import BinaryIO, Optional
+
+from .insecure_hashlib import sha256
+
+
+def sha_fileobj(fileobj: BinaryIO, chunk_size: Optional[int] = None) -> bytes:
+    """
+    Computes the sha256 hash of the given file object, by chunks of size `chunk_size`.
+
+    Args:
+        fileobj (file-like object):
+            The File object to compute sha256 for, typically obtained with `open(path, "rb")`
+        chunk_size (`int`, *optional*):
+            The number of bytes to read from `fileobj` at once, defaults to 1MB.
+
+    Returns:
+        `bytes`: `fileobj`'s sha256 hash as bytes
+    """
+    chunk_size = chunk_size if chunk_size is not None else 1024 * 1024
+
+    sha = sha256()
+    while True:
+        chunk = fileobj.read(chunk_size)
+        sha.update(chunk)
+        if not chunk:
+            break
+    return sha.digest()
diff --git a/lib/python3.11/site-packages/huggingface_hub/utils/tqdm.py b/lib/python3.11/site-packages/huggingface_hub/utils/tqdm.py
new file mode 100644
index 0000000000000000000000000000000000000000..cae9adb389a6e3777ce0fb2e5f0156b4746dbd3d
--- /dev/null
+++ b/lib/python3.11/site-packages/huggingface_hub/utils/tqdm.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+"""Utility helpers to handle progress bars in `huggingface_hub`.
+
+Example:
+    1. Use `huggingface_hub.utils.tqdm` as you would use `tqdm.tqdm` or `tqdm.auto.tqdm`.
+    2. To disable progress bars, either use `disable_progress_bars()` helper or set the
+       environment variable `HF_HUB_DISABLE_PROGRESS_BARS` to 1.
+    3. To re-enable progress bars, use `enable_progress_bars()`.
+    4. To check whether progress bars are disabled, use `are_progress_bars_disabled()`.
+
+NOTE: Environment variable `HF_HUB_DISABLE_PROGRESS_BARS` has the priority.
+
+Example:
+    ```py
+    from huggingface_hub.utils import (
+        are_progress_bars_disabled,
+        disable_progress_bars,
+        enable_progress_bars,
+        tqdm,
+    )
+
+    # Disable progress bars globally
+    disable_progress_bars()
+
+    # Use as normal `tqdm`
+    for _ in tqdm(range(5)):
+       do_something()
+
+    # Still not showing progress bars, as `disable=False` is overwritten to `True`.
+    for _ in tqdm(range(5), disable=False):
+       do_something()
+
+    are_progress_bars_disabled() # True
+
+    # Re-enable progress bars globally
+    enable_progress_bars()
+
+    # Progress bar will be shown !
+    for _ in tqdm(range(5)):
+       do_something()
+    ```
+"""
+import io
+import warnings
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Iterator, Optional, Union
+
+from tqdm.auto import tqdm as old_tqdm
+
+from ..constants import HF_HUB_DISABLE_PROGRESS_BARS
+
+
+# `HF_HUB_DISABLE_PROGRESS_BARS` is `Optional[bool]` while `_hf_hub_progress_bars_disabled`
+# is a `bool`. If `HF_HUB_DISABLE_PROGRESS_BARS` is set to True or False, it has priority.
+# If `HF_HUB_DISABLE_PROGRESS_BARS` is None, it means the user have not set the
+# environment variable and is free to enable/disable progress bars programmatically.
+# TL;DR: env variable has priority over code.
+#
+# By default, progress bars are enabled.
+_hf_hub_progress_bars_disabled: bool = HF_HUB_DISABLE_PROGRESS_BARS or False
+
+
+def disable_progress_bars() -> None:
+    """
+    Disable globally progress bars used in `huggingface_hub` except if `HF_HUB_DISABLE_PROGRESS_BARS` environment
+    variable has been set.
+
+    Use [`~utils.enable_progress_bars`] to re-enable them.
+    """
+    if HF_HUB_DISABLE_PROGRESS_BARS is False:
+        warnings.warn(
+            "Cannot disable progress bars: environment variable `HF_HUB_DISABLE_PROGRESS_BARS=0` is set and has"
+            " priority."
+        )
+        return
+    global _hf_hub_progress_bars_disabled
+    _hf_hub_progress_bars_disabled = True
+
+
+def enable_progress_bars() -> None:
+    """
+    Enable globally progress bars used in `huggingface_hub` except if `HF_HUB_DISABLE_PROGRESS_BARS` environment
+    variable has been set.
+
+    Use [`~utils.disable_progress_bars`] to disable them.
+    """
+    if HF_HUB_DISABLE_PROGRESS_BARS is True:
+        warnings.warn(
+            "Cannot enable progress bars: environment variable `HF_HUB_DISABLE_PROGRESS_BARS=1` is set and has"
+            " priority."
+        )
+        return
+    global _hf_hub_progress_bars_disabled
+    _hf_hub_progress_bars_disabled = False
+
+
+def are_progress_bars_disabled() -> bool:
+    """Return whether progress bars are globally disabled or not.
+
+    Progress bars used in `huggingface_hub` can be enable or disabled globally using [`~utils.enable_progress_bars`]
+    and [`~utils.disable_progress_bars`] or by setting `HF_HUB_DISABLE_PROGRESS_BARS` as environment variable.
+    """
+    global _hf_hub_progress_bars_disabled
+    return _hf_hub_progress_bars_disabled
+
+
+class tqdm(old_tqdm):
+    """
+    Class to override `disable` argument in case progress bars are globally disabled.
+
+    Taken from https://github.com/tqdm/tqdm/issues/619#issuecomment-619639324.
+    """
+
+    def __init__(self, *args, **kwargs):
+        if are_progress_bars_disabled():
+            kwargs["disable"] = True
+        super().__init__(*args, **kwargs)
+
+    def __delattr__(self, attr: str) -> None:
+        """Fix for https://github.com/huggingface/huggingface_hub/issues/1603"""
+        try:
+            super().__delattr__(attr)
+        except AttributeError:
+            if attr != "_lock":
+                raise
+
+
+@contextmanager
+def tqdm_stream_file(path: Union[Path, str]) -> Iterator[io.BufferedReader]:
+    """
+    Open a file as binary and wrap the `read` method to display a progress bar when it's streamed.
+
+    First implemented in `transformers` in 2019 but removed when switched to git-lfs. Used in `huggingface_hub` to show
+    progress bar when uploading an LFS file to the Hub. See github.com/huggingface/transformers/pull/2078#discussion_r354739608
+    for implementation details.
+
+    Note: currently implementation handles only files stored on disk as it is the most common use case. Could be
+          extended to stream any `BinaryIO` object but we might have to debug some corner cases.
+
+    Example:
+    ```py
+    >>> with tqdm_stream_file("config.json") as f:
+    >>>     requests.put(url, data=f)
+    config.json: 100%|█████████████████████████| 8.19k/8.19k [00:02<00:00, 3.72kB/s]
+    ```
+    """
+    if isinstance(path, str):
+        path = Path(path)
+
+    with path.open("rb") as f:
+        total_size = path.stat().st_size
+        pbar = tqdm(
+            unit="B",
+            unit_scale=True,
+            total=total_size,
+            initial=0,
+            desc=path.name,
+        )
+
+        f_read = f.read
+
+        def _inner_read(size: Optional[int] = -1) -> bytes:
+            data = f_read(size)
+            pbar.update(len(data))
+            return data
+
+        f.read = _inner_read  # type: ignore
+
+        yield f
+
+        pbar.close()
diff --git a/lib/python3.11/site-packages/idna-3.6.dist-info/INSTALLER b/lib/python3.11/site-packages/idna-3.6.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/idna-3.6.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/idna-3.6.dist-info/LICENSE.md b/lib/python3.11/site-packages/idna-3.6.dist-info/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..ce3670186c6e66a76f5ca85c79a359fe83ce7831
--- /dev/null
+++ b/lib/python3.11/site-packages/idna-3.6.dist-info/LICENSE.md
@@ -0,0 +1,31 @@
+BSD 3-Clause License
+
+Copyright (c) 2013-2023, Kim Davies and contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/python3.11/site-packages/idna-3.6.dist-info/METADATA b/lib/python3.11/site-packages/idna-3.6.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..9be8060939a018e2a3592d2070ab640d71dc89d0
--- /dev/null
+++ b/lib/python3.11/site-packages/idna-3.6.dist-info/METADATA
@@ -0,0 +1,243 @@
+Metadata-Version: 2.1
+Name: idna
+Version: 3.6
+Summary: Internationalized Domain Names in Applications (IDNA)
+Author-email: Kim Davies <kim+pypi@gumleaf.org>
+Requires-Python: >=3.5
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: Name Service (DNS)
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Project-URL: Changelog, https://github.com/kjd/idna/blob/master/HISTORY.rst
+Project-URL: Issue tracker, https://github.com/kjd/idna/issues
+Project-URL: Source, https://github.com/kjd/idna
+
+Internationalized Domain Names in Applications (IDNA)
+=====================================================
+
+Support for the Internationalized Domain Names in
+Applications (IDNA) protocol as specified in `RFC 5891
+<https://tools.ietf.org/html/rfc5891>`_. This is the latest version of
+the protocol and is sometimes referred to as “IDNA 2008”.
+
+This library also provides support for Unicode Technical
+Standard 46, `Unicode IDNA Compatibility Processing
+<https://unicode.org/reports/tr46/>`_.
+
+This acts as a suitable replacement for the “encodings.idna”
+module that comes with the Python standard library, but which
+only supports the older superseded IDNA specification (`RFC 3490
+<https://tools.ietf.org/html/rfc3490>`_).
+
+Basic functions are simply executed:
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('ドメイン.テスト')
+    b'xn--eckwd4c7c.xn--zckzah'
+    >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+    ドメイン.テスト
+
+
+Installation
+------------
+
+This package is available for installation from PyPI:
+
+.. code-block:: bash
+
+    $ python3 -m pip install idna
+
+
+Usage
+-----
+
+For typical usage, the ``encode`` and ``decode`` functions will take a
+domain name argument and perform a conversion to A-labels or U-labels
+respectively.
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('ドメイン.テスト')
+    b'xn--eckwd4c7c.xn--zckzah'
+    >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+    ドメイン.テスト
+
+You may use the codec encoding and decoding methods using the
+``idna.codec`` module:
+
+.. code-block:: pycon
+
+    >>> import idna.codec
+    >>> print('домен.испытание'.encode('idna2008'))
+    b'xn--d1acufc.xn--80akhbyknj4f'
+    >>> print(b'xn--d1acufc.xn--80akhbyknj4f'.decode('idna2008'))
+    домен.испытание
+
+Conversions can be applied at a per-label basis using the ``ulabel`` or
+``alabel`` functions if necessary:
+
+.. code-block:: pycon
+
+    >>> idna.alabel('测试')
+    b'xn--0zwm56d'
+
+Compatibility Mapping (UTS #46)
++++++++++++++++++++++++++++++++
+
+As described in `RFC 5895 <https://tools.ietf.org/html/rfc5895>`_, the
+IDNA specification does not normalize input from different potential
+ways a user may input a domain name. This functionality, known as
+a “mapping”, is considered by the specification to be a local
+user-interface issue distinct from IDNA conversion functionality.
+
+This library provides one such mapping that was developed by the
+Unicode Consortium. Known as `Unicode IDNA Compatibility Processing
+<https://unicode.org/reports/tr46/>`_, it provides for both a regular
+mapping for typical applications, as well as a transitional mapping to
+help migrate from older IDNA 2003 applications.
+
+For example, “Königsgäßchen” is not a permissible label as *LATIN
+CAPITAL LETTER K* is not allowed (nor are capital letters in general).
+UTS 46 will convert this into lower case prior to applying the IDNA
+conversion.
+
+.. code-block:: pycon
+
+    >>> import idna
+    >>> idna.encode('Königsgäßchen')
+    ...
+    idna.core.InvalidCodepoint: Codepoint U+004B at position 1 of 'Königsgäßchen' not allowed
+    >>> idna.encode('Königsgäßchen', uts46=True)
+    b'xn--knigsgchen-b4a3dun'
+    >>> print(idna.decode('xn--knigsgchen-b4a3dun'))
+    königsgäßchen
+
+Transitional processing provides conversions to help transition from
+the older 2003 standard to the current standard. For example, in the
+original IDNA specification, the *LATIN SMALL LETTER SHARP S* (ß) was
+converted into two *LATIN SMALL LETTER S* (ss), whereas in the current
+IDNA specification this conversion is not performed.
+
+.. code-block:: pycon
+
+    >>> idna.encode('Königsgäßchen', uts46=True, transitional=True)
+    'xn--knigsgsschen-lcb0w'
+
+Implementers should use transitional processing with caution, only in
+rare cases where conversion from legacy labels to current labels must be
+performed (i.e. IDNA implementations that pre-date 2008). For typical
+applications that just need to convert labels, transitional processing
+is unlikely to be beneficial and could produce unexpected incompatible
+results.
+
+``encodings.idna`` Compatibility
+++++++++++++++++++++++++++++++++
+
+Function calls from the Python built-in ``encodings.idna`` module are
+mapped to their IDNA 2008 equivalents using the ``idna.compat`` module.
+Simply substitute the ``import`` clause in your code to refer to the new
+module name.
+
+Exceptions
+----------
+
+All errors raised during the conversion following the specification
+should raise an exception derived from the ``idna.IDNAError`` base
+class.
+
+More specific exceptions that may be generated as ``idna.IDNABidiError``
+when the error reflects an illegal combination of left-to-right and
+right-to-left characters in a label; ``idna.InvalidCodepoint`` when
+a specific codepoint is an illegal character in an IDN label (i.e.
+INVALID); and ``idna.InvalidCodepointContext`` when the codepoint is
+illegal based on its positional context (i.e. it is CONTEXTO or CONTEXTJ
+but the contextual requirements are not satisfied.)
+
+Building and Diagnostics
+------------------------
+
+The IDNA and UTS 46 functionality relies upon pre-calculated lookup
+tables for performance. These tables are derived from computing against
+eligibility criteria in the respective standards. These tables are
+computed using the command-line script ``tools/idna-data``.
+
+This tool will fetch relevant codepoint data from the Unicode repository
+and perform the required calculations to identify eligibility. There are
+three main modes:
+
+* ``idna-data make-libdata``. Generates ``idnadata.py`` and
+  ``uts46data.py``, the pre-calculated lookup tables used for IDNA and
+  UTS 46 conversions. Implementers who wish to track this library against
+  a different Unicode version may use this tool to manually generate a
+  different version of the ``idnadata.py`` and ``uts46data.py`` files.
+
+* ``idna-data make-table``. Generate a table of the IDNA disposition
+  (e.g. PVALID, CONTEXTJ, CONTEXTO) in the format found in Appendix
+  B.1 of RFC 5892 and the pre-computed tables published by `IANA
+  <https://www.iana.org/>`_.
+
+* ``idna-data U+0061``. Prints debugging output on the various
+  properties associated with an individual Unicode codepoint (in this
+  case, U+0061), that are used to assess the IDNA and UTS 46 status of a
+  codepoint. This is helpful in debugging or analysis.
+
+The tool accepts a number of arguments, described using ``idna-data
+-h``. Most notably, the ``--version`` argument allows the specification
+of the version of Unicode to be used in computing the table data. For
+example, ``idna-data --version 9.0.0 make-libdata`` will generate
+library data against Unicode 9.0.0.
+
+
+Additional Notes
+----------------
+
+* **Packages**. The latest tagged release version is published in the
+  `Python Package Index <https://pypi.org/project/idna/>`_.
+
+* **Version support**. This library supports Python 3.5 and higher.
+  As this library serves as a low-level toolkit for a variety of
+  applications, many of which strive for broad compatibility with older
+  Python versions, there is no rush to remove older interpreter support.
+  Removing support for older versions should be well justified in that the
+  maintenance burden has become too high.
+
+* **Python 2**. Python 2 is supported by version 2.x of this library.
+  While active development of the version 2.x series has ended, notable
+  issues being corrected may be backported to 2.x. Use "idna<3" in your
+  requirements file if you need this library for a Python 2 application.
+
+* **Testing**. The library has a test suite based on each rule of the
+  IDNA specification, as well as tests that are provided as part of the
+  Unicode Technical Standard 46, `Unicode IDNA Compatibility Processing
+  <https://unicode.org/reports/tr46/>`_.
+
+* **Emoji**. It is an occasional request to support emoji domains in
+  this library. Encoding of symbols like emoji is expressly prohibited by
+  the technical standard IDNA 2008 and emoji domains are broadly phased
+  out across the domain industry due to associated security risks. For
+  now, applications that need to support these non-compliant labels
+  may wish to consider trying the encode/decode operation in this library
+  first, and then falling back to using `encodings.idna`. See `the Github
+  project <https://github.com/kjd/idna/issues/18>`_ for more discussion.
+
diff --git a/lib/python3.11/site-packages/idna-3.6.dist-info/RECORD b/lib/python3.11/site-packages/idna-3.6.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..5f13daf961aa193ba43d33f4b9a307710acd219f
--- /dev/null
+++ b/lib/python3.11/site-packages/idna-3.6.dist-info/RECORD
@@ -0,0 +1,22 @@
+idna-3.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+idna-3.6.dist-info/LICENSE.md,sha256=yy-vDKGMbTh-x8tm8yGTn7puZ-nawJ0xR3y52NP-aJk,1541
+idna-3.6.dist-info/METADATA,sha256=N93B509dkvvkd_Y0E_VxCHPkVkrD6InxoyfXvX4egds,9888
+idna-3.6.dist-info/RECORD,,
+idna-3.6.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+idna/__init__.py,sha256=KJQN1eQBr8iIK5SKrJ47lXvxG0BJ7Lm38W4zT0v_8lk,849
+idna/__pycache__/__init__.cpython-311.pyc,,
+idna/__pycache__/codec.cpython-311.pyc,,
+idna/__pycache__/compat.cpython-311.pyc,,
+idna/__pycache__/core.cpython-311.pyc,,
+idna/__pycache__/idnadata.cpython-311.pyc,,
+idna/__pycache__/intranges.cpython-311.pyc,,
+idna/__pycache__/package_data.cpython-311.pyc,,
+idna/__pycache__/uts46data.cpython-311.pyc,,
+idna/codec.py,sha256=PS6m-XmdST7Wj7J7ulRMakPDt5EBJyYrT3CPtjh-7t4,3426
+idna/compat.py,sha256=0_sOEUMT4CVw9doD3vyRhX80X19PwqFoUBs7gWsFME4,321
+idna/core.py,sha256=Bxz9L1rH0N5U-yukGfPuDRTxR2jDUl96NCq1ql3YAUw,12908
+idna/idnadata.py,sha256=9u3Ec_GRrhlcbs7QM3pAZ2ObEQzPIOm99FaVOm91UGg,44351
+idna/intranges.py,sha256=YBr4fRYuWH7kTKS2tXlFjM24ZF1Pdvcir-aywniInqg,1881
+idna/package_data.py,sha256=y-iv-qJdmHsWVR5FszYwsMo1AQg8qpdU2aU5nT-S2oQ,21
+idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idna/uts46data.py,sha256=1KuksWqLuccPXm2uyRVkhfiFLNIhM_H2m4azCcnOqEU,206503
diff --git a/lib/python3.11/site-packages/idna-3.6.dist-info/WHEEL b/lib/python3.11/site-packages/idna-3.6.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..3b5e64b5e6c4a210201d1676a891fd57b15cda99
--- /dev/null
+++ b/lib/python3.11/site-packages/idna-3.6.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/lib/python3.11/site-packages/idna/__init__.py b/lib/python3.11/site-packages/idna/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a40eeafcc914108ca79c5d83d6e81da1b29c6e80
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/__init__.py
@@ -0,0 +1,44 @@
+from .package_data import __version__
+from .core import (
+    IDNABidiError,
+    IDNAError,
+    InvalidCodepoint,
+    InvalidCodepointContext,
+    alabel,
+    check_bidi,
+    check_hyphen_ok,
+    check_initial_combiner,
+    check_label,
+    check_nfc,
+    decode,
+    encode,
+    ulabel,
+    uts46_remap,
+    valid_contextj,
+    valid_contexto,
+    valid_label_length,
+    valid_string_length,
+)
+from .intranges import intranges_contain
+
+__all__ = [
+    "IDNABidiError",
+    "IDNAError",
+    "InvalidCodepoint",
+    "InvalidCodepointContext",
+    "alabel",
+    "check_bidi",
+    "check_hyphen_ok",
+    "check_initial_combiner",
+    "check_label",
+    "check_nfc",
+    "decode",
+    "encode",
+    "intranges_contain",
+    "ulabel",
+    "uts46_remap",
+    "valid_contextj",
+    "valid_contexto",
+    "valid_label_length",
+    "valid_string_length",
+]
diff --git a/lib/python3.11/site-packages/idna/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fbd32e8a7f596b8e64ff284b07d0dae085459bfb
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/__pycache__/codec.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/codec.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2a4c1f40100765f5eaa4e1a878b1f7060ae5af8
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/codec.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/__pycache__/compat.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/compat.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3df86e9d12e0a9d28df228b095951b003b3b77bb
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/compat.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/__pycache__/core.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/core.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c05c2a2debff04921b1ecb24d008be4d709c122e
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/core.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/__pycache__/idnadata.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/idnadata.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60fad03d8b969c03d2c5826d58fefcbe327341a7
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/idnadata.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/__pycache__/intranges.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/intranges.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..600e616cf24420f5f4525c486b7eae2a9415ef31
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/intranges.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/__pycache__/package_data.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/package_data.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b79eff19ec8e3a5e06dcc8af0470dfa52752c3ee
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/package_data.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/__pycache__/uts46data.cpython-311.pyc b/lib/python3.11/site-packages/idna/__pycache__/uts46data.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb7b242f73b7389d6dadbb1e3125697d5c3c62a3
Binary files /dev/null and b/lib/python3.11/site-packages/idna/__pycache__/uts46data.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/idna/codec.py b/lib/python3.11/site-packages/idna/codec.py
new file mode 100644
index 0000000000000000000000000000000000000000..c855a4de6d781815acf2334306f41b7a036c45d4
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/codec.py
@@ -0,0 +1,118 @@
+from .core import encode, decode, alabel, ulabel, IDNAError
+import codecs
+import re
+from typing import Any, Tuple, Optional
+
+_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
+
+class Codec(codecs.Codec):
+
+    def encode(self, data: str, errors: str = 'strict') -> Tuple[bytes, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return b"", 0
+
+        return encode(data), len(data)
+
+    def decode(self, data: bytes, errors: str = 'strict') -> Tuple[str, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return '', 0
+
+        return decode(data), len(data)
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    def _buffer_encode(self, data: str, errors: str, final: bool) -> Tuple[bytes, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return b'', 0
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = b''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = b'.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = b'.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(alabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        # Join with U+002E
+        result_bytes = b'.'.join(result) + trailing_dot
+        size += len(trailing_dot)
+        return result_bytes, size
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, data: Any, errors: str, final: bool) -> Tuple[str, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return ('', 0)
+
+        if not isinstance(data, str):
+            data = str(data, 'ascii')
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = ''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = '.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = '.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(ulabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        result_str = '.'.join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result_str, size)
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+
+def search_function(name: str) -> Optional[codecs.CodecInfo]:
+    if name != 'idna2008':
+        return None
+    return codecs.CodecInfo(
+        name=name,
+        encode=Codec().encode,
+        decode=Codec().decode,
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamwriter=StreamWriter,
+        streamreader=StreamReader,
+    )
+
+codecs.register(search_function)
diff --git a/lib/python3.11/site-packages/idna/compat.py b/lib/python3.11/site-packages/idna/compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..786e6bda63699b72d588ba91dd73df017570aee5
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/compat.py
@@ -0,0 +1,13 @@
+from .core import *
+from .codec import *
+from typing import Any, Union
+
+def ToASCII(label: str) -> bytes:
+    return encode(label)
+
+def ToUnicode(label: Union[bytes, bytearray]) -> str:
+    return decode(label)
+
+def nameprep(s: Any) -> None:
+    raise NotImplementedError('IDNA 2008 does not utilise nameprep protocol')
+
diff --git a/lib/python3.11/site-packages/idna/core.py b/lib/python3.11/site-packages/idna/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..aaf7d658ba0a023eb3eea76ca05077ec7882b0be
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/core.py
@@ -0,0 +1,400 @@
+from . import idnadata
+import bisect
+import unicodedata
+import re
+from typing import Union, Optional
+from .intranges import intranges_contain
+
+_virama_combining_class = 9
+_alabel_prefix = b'xn--'
+_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
+
+class IDNAError(UnicodeError):
+    """ Base exception for all IDNA-encoding related problems """
+    pass
+
+
+class IDNABidiError(IDNAError):
+    """ Exception when bidirectional requirements are not satisfied """
+    pass
+
+
+class InvalidCodepoint(IDNAError):
+    """ Exception when a disallowed or unallocated codepoint is used """
+    pass
+
+
+class InvalidCodepointContext(IDNAError):
+    """ Exception when the codepoint is not valid in the context it is used """
+    pass
+
+
+def _combining_class(cp: int) -> int:
+    v = unicodedata.combining(chr(cp))
+    if v == 0:
+        if not unicodedata.name(chr(cp)):
+            raise ValueError('Unknown character in unicodedata')
+    return v
+
+def _is_script(cp: str, script: str) -> bool:
+    return intranges_contain(ord(cp), idnadata.scripts[script])
+
+def _punycode(s: str) -> bytes:
+    return s.encode('punycode')
+
+def _unot(s: int) -> str:
+    return 'U+{:04X}'.format(s)
+
+
+def valid_label_length(label: Union[bytes, str]) -> bool:
+    if len(label) > 63:
+        return False
+    return True
+
+
+def valid_string_length(label: Union[bytes, str], trailing_dot: bool) -> bool:
+    if len(label) > (254 if trailing_dot else 253):
+        return False
+    return True
+
+
+def check_bidi(label: str, check_ltr: bool = False) -> bool:
+    # Bidi rules should only be applied if string contains RTL characters
+    bidi_label = False
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+        if direction == '':
+            # String likely comes from a newer version of Unicode
+            raise IDNABidiError('Unknown directionality in label {} at position {}'.format(repr(label), idx))
+        if direction in ['R', 'AL', 'AN']:
+            bidi_label = True
+    if not bidi_label and not check_ltr:
+        return True
+
+    # Bidi rule 1
+    direction = unicodedata.bidirectional(label[0])
+    if direction in ['R', 'AL']:
+        rtl = True
+    elif direction == 'L':
+        rtl = False
+    else:
+        raise IDNABidiError('First codepoint in label {} must be directionality L, R or AL'.format(repr(label)))
+
+    valid_ending = False
+    number_type = None  # type: Optional[str]
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+
+        if rtl:
+            # Bidi rule 2
+            if not direction in ['R', 'AL', 'AN', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {} in a right-to-left label'.format(idx))
+            # Bidi rule 3
+            if direction in ['R', 'AL', 'EN', 'AN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+            # Bidi rule 4
+            if direction in ['AN', 'EN']:
+                if not number_type:
+                    number_type = direction
+                else:
+                    if number_type != direction:
+                        raise IDNABidiError('Can not mix numeral types in a right-to-left label')
+        else:
+            # Bidi rule 5
+            if not direction in ['L', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {} in a left-to-right label'.format(idx))
+            # Bidi rule 6
+            if direction in ['L', 'EN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+
+    if not valid_ending:
+        raise IDNABidiError('Label ends with illegal codepoint directionality')
+
+    return True
+
+
+def check_initial_combiner(label: str) -> bool:
+    if unicodedata.category(label[0])[0] == 'M':
+        raise IDNAError('Label begins with an illegal combining character')
+    return True
+
+
+def check_hyphen_ok(label: str) -> bool:
+    if label[2:4] == '--':
+        raise IDNAError('Label has disallowed hyphens in 3rd and 4th position')
+    if label[0] == '-' or label[-1] == '-':
+        raise IDNAError('Label must not start or end with a hyphen')
+    return True
+
+
+def check_nfc(label: str) -> None:
+    if unicodedata.normalize('NFC', label) != label:
+        raise IDNAError('Label must be in Normalization Form C')
+
+
+def valid_contextj(label: str, pos: int) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x200c:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+
+        ok = False
+        for i in range(pos-1, -1, -1):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            if joining_type in [ord('L'), ord('D')]:
+                ok = True
+                break
+
+        if not ok:
+            return False
+
+        ok = False
+        for i in range(pos+1, len(label)):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            if joining_type in [ord('R'), ord('D')]:
+                ok = True
+                break
+        return ok
+
+    if cp_value == 0x200d:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+        return False
+
+    else:
+
+        return False
+
+
+def valid_contexto(label: str, pos: int, exception: bool = False) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x00b7:
+        if 0 < pos < len(label)-1:
+            if ord(label[pos - 1]) == 0x006c and ord(label[pos + 1]) == 0x006c:
+                return True
+        return False
+
+    elif cp_value == 0x0375:
+        if pos < len(label)-1 and len(label) > 1:
+            return _is_script(label[pos + 1], 'Greek')
+        return False
+
+    elif cp_value == 0x05f3 or cp_value == 0x05f4:
+        if pos > 0:
+            return _is_script(label[pos - 1], 'Hebrew')
+        return False
+
+    elif cp_value == 0x30fb:
+        for cp in label:
+            if cp == '\u30fb':
+                continue
+            if _is_script(cp, 'Hiragana') or _is_script(cp, 'Katakana') or _is_script(cp, 'Han'):
+                return True
+        return False
+
+    elif 0x660 <= cp_value <= 0x669:
+        for cp in label:
+            if 0x6f0 <= ord(cp) <= 0x06f9:
+                return False
+        return True
+
+    elif 0x6f0 <= cp_value <= 0x6f9:
+        for cp in label:
+            if 0x660 <= ord(cp) <= 0x0669:
+                return False
+        return True
+
+    return False
+
+
+def check_label(label: Union[str, bytes, bytearray]) -> None:
+    if isinstance(label, (bytes, bytearray)):
+        label = label.decode('utf-8')
+    if len(label) == 0:
+        raise IDNAError('Empty Label')
+
+    check_nfc(label)
+    check_hyphen_ok(label)
+    check_initial_combiner(label)
+
+    for (pos, cp) in enumerate(label):
+        cp_value = ord(cp)
+        if intranges_contain(cp_value, idnadata.codepoint_classes['PVALID']):
+            continue
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTJ']):
+            try:
+                if not valid_contextj(label, pos):
+                    raise InvalidCodepointContext('Joiner {} not allowed at position {} in {}'.format(
+                        _unot(cp_value), pos+1, repr(label)))
+            except ValueError:
+                raise IDNAError('Unknown codepoint adjacent to joiner {} at position {} in {}'.format(
+                    _unot(cp_value), pos+1, repr(label)))
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTO']):
+            if not valid_contexto(label, pos):
+                raise InvalidCodepointContext('Codepoint {} not allowed at position {} in {}'.format(_unot(cp_value), pos+1, repr(label)))
+        else:
+            raise InvalidCodepoint('Codepoint {} at position {} of {} not allowed'.format(_unot(cp_value), pos+1, repr(label)))
+
+    check_bidi(label)
+
+
+def alabel(label: str) -> bytes:
+    try:
+        label_bytes = label.encode('ascii')
+        ulabel(label_bytes)
+        if not valid_label_length(label_bytes):
+            raise IDNAError('Label too long')
+        return label_bytes
+    except UnicodeEncodeError:
+        pass
+
+    if not label:
+        raise IDNAError('No Input')
+
+    label = str(label)
+    check_label(label)
+    label_bytes = _punycode(label)
+    label_bytes = _alabel_prefix + label_bytes
+
+    if not valid_label_length(label_bytes):
+        raise IDNAError('Label too long')
+
+    return label_bytes
+
+
+def ulabel(label: Union[str, bytes, bytearray]) -> str:
+    if not isinstance(label, (bytes, bytearray)):
+        try:
+            label_bytes = label.encode('ascii')
+        except UnicodeEncodeError:
+            check_label(label)
+            return label
+    else:
+        label_bytes = label
+
+    label_bytes = label_bytes.lower()
+    if label_bytes.startswith(_alabel_prefix):
+        label_bytes = label_bytes[len(_alabel_prefix):]
+        if not label_bytes:
+            raise IDNAError('Malformed A-label, no Punycode eligible content found')
+        if label_bytes.decode('ascii')[-1] == '-':
+            raise IDNAError('A-label must not end with a hyphen')
+    else:
+        check_label(label_bytes)
+        return label_bytes.decode('ascii')
+
+    try:
+        label = label_bytes.decode('punycode')
+    except UnicodeError:
+        raise IDNAError('Invalid A-label')
+    check_label(label)
+    return label
+
+
+def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False) -> str:
+    """Re-map the characters in the string according to UTS46 processing."""
+    from .uts46data import uts46data
+    output = ''
+
+    for pos, char in enumerate(domain):
+        code_point = ord(char)
+        try:
+            uts46row = uts46data[code_point if code_point < 256 else
+                bisect.bisect_left(uts46data, (code_point, 'Z')) - 1]
+            status = uts46row[1]
+            replacement = None  # type: Optional[str]
+            if len(uts46row) == 3:
+                replacement = uts46row[2]
+            if (status == 'V' or
+                    (status == 'D' and not transitional) or
+                    (status == '3' and not std3_rules and replacement is None)):
+                output += char
+            elif replacement is not None and (status == 'M' or
+                    (status == '3' and not std3_rules) or
+                    (status == 'D' and transitional)):
+                output += replacement
+            elif status != 'I':
+                raise IndexError()
+        except IndexError:
+            raise InvalidCodepoint(
+                'Codepoint {} not allowed at position {} in {}'.format(
+                _unot(code_point), pos + 1, repr(domain)))
+
+    return unicodedata.normalize('NFC', output)
+
+
+def encode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False, transitional: bool = False) -> bytes:
+    if not isinstance(s, str):
+        try:
+            s = str(s, 'ascii')
+        except UnicodeDecodeError:
+            raise IDNAError('should pass a unicode string to the function rather than a byte string.')
+    if uts46:
+        s = uts46_remap(s, std3_rules, transitional)
+    trailing_dot = False
+    result = []
+    if strict:
+        labels = s.split('.')
+    else:
+        labels = _unicode_dots_re.split(s)
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if labels[-1] == '':
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = alabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append(b'')
+    s = b'.'.join(result)
+    if not valid_string_length(s, trailing_dot):
+        raise IDNAError('Domain too long')
+    return s
+
+
+def decode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False) -> str:
+    try:
+        if not isinstance(s, str):
+            s = str(s, 'ascii')
+    except UnicodeDecodeError:
+        raise IDNAError('Invalid ASCII in A-label')
+    if uts46:
+        s = uts46_remap(s, std3_rules, False)
+    trailing_dot = False
+    result = []
+    if not strict:
+        labels = _unicode_dots_re.split(s)
+    else:
+        labels = s.split('.')
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if not labels[-1]:
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = ulabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append('')
+    return '.'.join(result)
diff --git a/lib/python3.11/site-packages/idna/idnadata.py b/lib/python3.11/site-packages/idna/idnadata.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cd05d9056e1f2aea5c772a59a36cab2e1ec1b1d
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/idnadata.py
@@ -0,0 +1,2150 @@
+# This file is automatically generated by tools/idna-data
+
+__version__ = '15.1.0'
+scripts = {
+    'Greek': (
+        0x37000000374,
+        0x37500000378,
+        0x37a0000037e,
+        0x37f00000380,
+        0x38400000385,
+        0x38600000387,
+        0x3880000038b,
+        0x38c0000038d,
+        0x38e000003a2,
+        0x3a3000003e2,
+        0x3f000000400,
+        0x1d2600001d2b,
+        0x1d5d00001d62,
+        0x1d6600001d6b,
+        0x1dbf00001dc0,
+        0x1f0000001f16,
+        0x1f1800001f1e,
+        0x1f2000001f46,
+        0x1f4800001f4e,
+        0x1f5000001f58,
+        0x1f5900001f5a,
+        0x1f5b00001f5c,
+        0x1f5d00001f5e,
+        0x1f5f00001f7e,
+        0x1f8000001fb5,
+        0x1fb600001fc5,
+        0x1fc600001fd4,
+        0x1fd600001fdc,
+        0x1fdd00001ff0,
+        0x1ff200001ff5,
+        0x1ff600001fff,
+        0x212600002127,
+        0xab650000ab66,
+        0x101400001018f,
+        0x101a0000101a1,
+        0x1d2000001d246,
+    ),
+    'Han': (
+        0x2e8000002e9a,
+        0x2e9b00002ef4,
+        0x2f0000002fd6,
+        0x300500003006,
+        0x300700003008,
+        0x30210000302a,
+        0x30380000303c,
+        0x340000004dc0,
+        0x4e000000a000,
+        0xf9000000fa6e,
+        0xfa700000fada,
+        0x16fe200016fe4,
+        0x16ff000016ff2,
+        0x200000002a6e0,
+        0x2a7000002b73a,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x2ebf00002ee5e,
+        0x2f8000002fa1e,
+        0x300000003134b,
+        0x31350000323b0,
+    ),
+    'Hebrew': (
+        0x591000005c8,
+        0x5d0000005eb,
+        0x5ef000005f5,
+        0xfb1d0000fb37,
+        0xfb380000fb3d,
+        0xfb3e0000fb3f,
+        0xfb400000fb42,
+        0xfb430000fb45,
+        0xfb460000fb50,
+    ),
+    'Hiragana': (
+        0x304100003097,
+        0x309d000030a0,
+        0x1b0010001b120,
+        0x1b1320001b133,
+        0x1b1500001b153,
+        0x1f2000001f201,
+    ),
+    'Katakana': (
+        0x30a1000030fb,
+        0x30fd00003100,
+        0x31f000003200,
+        0x32d0000032ff,
+        0x330000003358,
+        0xff660000ff70,
+        0xff710000ff9e,
+        0x1aff00001aff4,
+        0x1aff50001affc,
+        0x1affd0001afff,
+        0x1b0000001b001,
+        0x1b1200001b123,
+        0x1b1550001b156,
+        0x1b1640001b168,
+    ),
+}
+joining_types = {
+    0x600: 85,
+    0x601: 85,
+    0x602: 85,
+    0x603: 85,
+    0x604: 85,
+    0x605: 85,
+    0x608: 85,
+    0x60b: 85,
+    0x620: 68,
+    0x621: 85,
+    0x622: 82,
+    0x623: 82,
+    0x624: 82,
+    0x625: 82,
+    0x626: 68,
+    0x627: 82,
+    0x628: 68,
+    0x629: 82,
+    0x62a: 68,
+    0x62b: 68,
+    0x62c: 68,
+    0x62d: 68,
+    0x62e: 68,
+    0x62f: 82,
+    0x630: 82,
+    0x631: 82,
+    0x632: 82,
+    0x633: 68,
+    0x634: 68,
+    0x635: 68,
+    0x636: 68,
+    0x637: 68,
+    0x638: 68,
+    0x639: 68,
+    0x63a: 68,
+    0x63b: 68,
+    0x63c: 68,
+    0x63d: 68,
+    0x63e: 68,
+    0x63f: 68,
+    0x640: 67,
+    0x641: 68,
+    0x642: 68,
+    0x643: 68,
+    0x644: 68,
+    0x645: 68,
+    0x646: 68,
+    0x647: 68,
+    0x648: 82,
+    0x649: 68,
+    0x64a: 68,
+    0x66e: 68,
+    0x66f: 68,
+    0x671: 82,
+    0x672: 82,
+    0x673: 82,
+    0x674: 85,
+    0x675: 82,
+    0x676: 82,
+    0x677: 82,
+    0x678: 68,
+    0x679: 68,
+    0x67a: 68,
+    0x67b: 68,
+    0x67c: 68,
+    0x67d: 68,
+    0x67e: 68,
+    0x67f: 68,
+    0x680: 68,
+    0x681: 68,
+    0x682: 68,
+    0x683: 68,
+    0x684: 68,
+    0x685: 68,
+    0x686: 68,
+    0x687: 68,
+    0x688: 82,
+    0x689: 82,
+    0x68a: 82,
+    0x68b: 82,
+    0x68c: 82,
+    0x68d: 82,
+    0x68e: 82,
+    0x68f: 82,
+    0x690: 82,
+    0x691: 82,
+    0x692: 82,
+    0x693: 82,
+    0x694: 82,
+    0x695: 82,
+    0x696: 82,
+    0x697: 82,
+    0x698: 82,
+    0x699: 82,
+    0x69a: 68,
+    0x69b: 68,
+    0x69c: 68,
+    0x69d: 68,
+    0x69e: 68,
+    0x69f: 68,
+    0x6a0: 68,
+    0x6a1: 68,
+    0x6a2: 68,
+    0x6a3: 68,
+    0x6a4: 68,
+    0x6a5: 68,
+    0x6a6: 68,
+    0x6a7: 68,
+    0x6a8: 68,
+    0x6a9: 68,
+    0x6aa: 68,
+    0x6ab: 68,
+    0x6ac: 68,
+    0x6ad: 68,
+    0x6ae: 68,
+    0x6af: 68,
+    0x6b0: 68,
+    0x6b1: 68,
+    0x6b2: 68,
+    0x6b3: 68,
+    0x6b4: 68,
+    0x6b5: 68,
+    0x6b6: 68,
+    0x6b7: 68,
+    0x6b8: 68,
+    0x6b9: 68,
+    0x6ba: 68,
+    0x6bb: 68,
+    0x6bc: 68,
+    0x6bd: 68,
+    0x6be: 68,
+    0x6bf: 68,
+    0x6c0: 82,
+    0x6c1: 68,
+    0x6c2: 68,
+    0x6c3: 82,
+    0x6c4: 82,
+    0x6c5: 82,
+    0x6c6: 82,
+    0x6c7: 82,
+    0x6c8: 82,
+    0x6c9: 82,
+    0x6ca: 82,
+    0x6cb: 82,
+    0x6cc: 68,
+    0x6cd: 82,
+    0x6ce: 68,
+    0x6cf: 82,
+    0x6d0: 68,
+    0x6d1: 68,
+    0x6d2: 82,
+    0x6d3: 82,
+    0x6d5: 82,
+    0x6dd: 85,
+    0x6ee: 82,
+    0x6ef: 82,
+    0x6fa: 68,
+    0x6fb: 68,
+    0x6fc: 68,
+    0x6ff: 68,
+    0x70f: 84,
+    0x710: 82,
+    0x712: 68,
+    0x713: 68,
+    0x714: 68,
+    0x715: 82,
+    0x716: 82,
+    0x717: 82,
+    0x718: 82,
+    0x719: 82,
+    0x71a: 68,
+    0x71b: 68,
+    0x71c: 68,
+    0x71d: 68,
+    0x71e: 82,
+    0x71f: 68,
+    0x720: 68,
+    0x721: 68,
+    0x722: 68,
+    0x723: 68,
+    0x724: 68,
+    0x725: 68,
+    0x726: 68,
+    0x727: 68,
+    0x728: 82,
+    0x729: 68,
+    0x72a: 82,
+    0x72b: 68,
+    0x72c: 82,
+    0x72d: 68,
+    0x72e: 68,
+    0x72f: 82,
+    0x74d: 82,
+    0x74e: 68,
+    0x74f: 68,
+    0x750: 68,
+    0x751: 68,
+    0x752: 68,
+    0x753: 68,
+    0x754: 68,
+    0x755: 68,
+    0x756: 68,
+    0x757: 68,
+    0x758: 68,
+    0x759: 82,
+    0x75a: 82,
+    0x75b: 82,
+    0x75c: 68,
+    0x75d: 68,
+    0x75e: 68,
+    0x75f: 68,
+    0x760: 68,
+    0x761: 68,
+    0x762: 68,
+    0x763: 68,
+    0x764: 68,
+    0x765: 68,
+    0x766: 68,
+    0x767: 68,
+    0x768: 68,
+    0x769: 68,
+    0x76a: 68,
+    0x76b: 82,
+    0x76c: 82,
+    0x76d: 68,
+    0x76e: 68,
+    0x76f: 68,
+    0x770: 68,
+    0x771: 82,
+    0x772: 68,
+    0x773: 82,
+    0x774: 82,
+    0x775: 68,
+    0x776: 68,
+    0x777: 68,
+    0x778: 82,
+    0x779: 82,
+    0x77a: 68,
+    0x77b: 68,
+    0x77c: 68,
+    0x77d: 68,
+    0x77e: 68,
+    0x77f: 68,
+    0x7ca: 68,
+    0x7cb: 68,
+    0x7cc: 68,
+    0x7cd: 68,
+    0x7ce: 68,
+    0x7cf: 68,
+    0x7d0: 68,
+    0x7d1: 68,
+    0x7d2: 68,
+    0x7d3: 68,
+    0x7d4: 68,
+    0x7d5: 68,
+    0x7d6: 68,
+    0x7d7: 68,
+    0x7d8: 68,
+    0x7d9: 68,
+    0x7da: 68,
+    0x7db: 68,
+    0x7dc: 68,
+    0x7dd: 68,
+    0x7de: 68,
+    0x7df: 68,
+    0x7e0: 68,
+    0x7e1: 68,
+    0x7e2: 68,
+    0x7e3: 68,
+    0x7e4: 68,
+    0x7e5: 68,
+    0x7e6: 68,
+    0x7e7: 68,
+    0x7e8: 68,
+    0x7e9: 68,
+    0x7ea: 68,
+    0x7fa: 67,
+    0x840: 82,
+    0x841: 68,
+    0x842: 68,
+    0x843: 68,
+    0x844: 68,
+    0x845: 68,
+    0x846: 82,
+    0x847: 82,
+    0x848: 68,
+    0x849: 82,
+    0x84a: 68,
+    0x84b: 68,
+    0x84c: 68,
+    0x84d: 68,
+    0x84e: 68,
+    0x84f: 68,
+    0x850: 68,
+    0x851: 68,
+    0x852: 68,
+    0x853: 68,
+    0x854: 82,
+    0x855: 68,
+    0x856: 82,
+    0x857: 82,
+    0x858: 82,
+    0x860: 68,
+    0x861: 85,
+    0x862: 68,
+    0x863: 68,
+    0x864: 68,
+    0x865: 68,
+    0x866: 85,
+    0x867: 82,
+    0x868: 68,
+    0x869: 82,
+    0x86a: 82,
+    0x870: 82,
+    0x871: 82,
+    0x872: 82,
+    0x873: 82,
+    0x874: 82,
+    0x875: 82,
+    0x876: 82,
+    0x877: 82,
+    0x878: 82,
+    0x879: 82,
+    0x87a: 82,
+    0x87b: 82,
+    0x87c: 82,
+    0x87d: 82,
+    0x87e: 82,
+    0x87f: 82,
+    0x880: 82,
+    0x881: 82,
+    0x882: 82,
+    0x883: 67,
+    0x884: 67,
+    0x885: 67,
+    0x886: 68,
+    0x887: 85,
+    0x888: 85,
+    0x889: 68,
+    0x88a: 68,
+    0x88b: 68,
+    0x88c: 68,
+    0x88d: 68,
+    0x88e: 82,
+    0x890: 85,
+    0x891: 85,
+    0x8a0: 68,
+    0x8a1: 68,
+    0x8a2: 68,
+    0x8a3: 68,
+    0x8a4: 68,
+    0x8a5: 68,
+    0x8a6: 68,
+    0x8a7: 68,
+    0x8a8: 68,
+    0x8a9: 68,
+    0x8aa: 82,
+    0x8ab: 82,
+    0x8ac: 82,
+    0x8ad: 85,
+    0x8ae: 82,
+    0x8af: 68,
+    0x8b0: 68,
+    0x8b1: 82,
+    0x8b2: 82,
+    0x8b3: 68,
+    0x8b4: 68,
+    0x8b5: 68,
+    0x8b6: 68,
+    0x8b7: 68,
+    0x8b8: 68,
+    0x8b9: 82,
+    0x8ba: 68,
+    0x8bb: 68,
+    0x8bc: 68,
+    0x8bd: 68,
+    0x8be: 68,
+    0x8bf: 68,
+    0x8c0: 68,
+    0x8c1: 68,
+    0x8c2: 68,
+    0x8c3: 68,
+    0x8c4: 68,
+    0x8c5: 68,
+    0x8c6: 68,
+    0x8c7: 68,
+    0x8c8: 68,
+    0x8e2: 85,
+    0x1806: 85,
+    0x1807: 68,
+    0x180a: 67,
+    0x180e: 85,
+    0x1820: 68,
+    0x1821: 68,
+    0x1822: 68,
+    0x1823: 68,
+    0x1824: 68,
+    0x1825: 68,
+    0x1826: 68,
+    0x1827: 68,
+    0x1828: 68,
+    0x1829: 68,
+    0x182a: 68,
+    0x182b: 68,
+    0x182c: 68,
+    0x182d: 68,
+    0x182e: 68,
+    0x182f: 68,
+    0x1830: 68,
+    0x1831: 68,
+    0x1832: 68,
+    0x1833: 68,
+    0x1834: 68,
+    0x1835: 68,
+    0x1836: 68,
+    0x1837: 68,
+    0x1838: 68,
+    0x1839: 68,
+    0x183a: 68,
+    0x183b: 68,
+    0x183c: 68,
+    0x183d: 68,
+    0x183e: 68,
+    0x183f: 68,
+    0x1840: 68,
+    0x1841: 68,
+    0x1842: 68,
+    0x1843: 68,
+    0x1844: 68,
+    0x1845: 68,
+    0x1846: 68,
+    0x1847: 68,
+    0x1848: 68,
+    0x1849: 68,
+    0x184a: 68,
+    0x184b: 68,
+    0x184c: 68,
+    0x184d: 68,
+    0x184e: 68,
+    0x184f: 68,
+    0x1850: 68,
+    0x1851: 68,
+    0x1852: 68,
+    0x1853: 68,
+    0x1854: 68,
+    0x1855: 68,
+    0x1856: 68,
+    0x1857: 68,
+    0x1858: 68,
+    0x1859: 68,
+    0x185a: 68,
+    0x185b: 68,
+    0x185c: 68,
+    0x185d: 68,
+    0x185e: 68,
+    0x185f: 68,
+    0x1860: 68,
+    0x1861: 68,
+    0x1862: 68,
+    0x1863: 68,
+    0x1864: 68,
+    0x1865: 68,
+    0x1866: 68,
+    0x1867: 68,
+    0x1868: 68,
+    0x1869: 68,
+    0x186a: 68,
+    0x186b: 68,
+    0x186c: 68,
+    0x186d: 68,
+    0x186e: 68,
+    0x186f: 68,
+    0x1870: 68,
+    0x1871: 68,
+    0x1872: 68,
+    0x1873: 68,
+    0x1874: 68,
+    0x1875: 68,
+    0x1876: 68,
+    0x1877: 68,
+    0x1878: 68,
+    0x1880: 85,
+    0x1881: 85,
+    0x1882: 85,
+    0x1883: 85,
+    0x1884: 85,
+    0x1885: 84,
+    0x1886: 84,
+    0x1887: 68,
+    0x1888: 68,
+    0x1889: 68,
+    0x188a: 68,
+    0x188b: 68,
+    0x188c: 68,
+    0x188d: 68,
+    0x188e: 68,
+    0x188f: 68,
+    0x1890: 68,
+    0x1891: 68,
+    0x1892: 68,
+    0x1893: 68,
+    0x1894: 68,
+    0x1895: 68,
+    0x1896: 68,
+    0x1897: 68,
+    0x1898: 68,
+    0x1899: 68,
+    0x189a: 68,
+    0x189b: 68,
+    0x189c: 68,
+    0x189d: 68,
+    0x189e: 68,
+    0x189f: 68,
+    0x18a0: 68,
+    0x18a1: 68,
+    0x18a2: 68,
+    0x18a3: 68,
+    0x18a4: 68,
+    0x18a5: 68,
+    0x18a6: 68,
+    0x18a7: 68,
+    0x18a8: 68,
+    0x18aa: 68,
+    0x200c: 85,
+    0x200d: 67,
+    0x202f: 85,
+    0x2066: 85,
+    0x2067: 85,
+    0x2068: 85,
+    0x2069: 85,
+    0xa840: 68,
+    0xa841: 68,
+    0xa842: 68,
+    0xa843: 68,
+    0xa844: 68,
+    0xa845: 68,
+    0xa846: 68,
+    0xa847: 68,
+    0xa848: 68,
+    0xa849: 68,
+    0xa84a: 68,
+    0xa84b: 68,
+    0xa84c: 68,
+    0xa84d: 68,
+    0xa84e: 68,
+    0xa84f: 68,
+    0xa850: 68,
+    0xa851: 68,
+    0xa852: 68,
+    0xa853: 68,
+    0xa854: 68,
+    0xa855: 68,
+    0xa856: 68,
+    0xa857: 68,
+    0xa858: 68,
+    0xa859: 68,
+    0xa85a: 68,
+    0xa85b: 68,
+    0xa85c: 68,
+    0xa85d: 68,
+    0xa85e: 68,
+    0xa85f: 68,
+    0xa860: 68,
+    0xa861: 68,
+    0xa862: 68,
+    0xa863: 68,
+    0xa864: 68,
+    0xa865: 68,
+    0xa866: 68,
+    0xa867: 68,
+    0xa868: 68,
+    0xa869: 68,
+    0xa86a: 68,
+    0xa86b: 68,
+    0xa86c: 68,
+    0xa86d: 68,
+    0xa86e: 68,
+    0xa86f: 68,
+    0xa870: 68,
+    0xa871: 68,
+    0xa872: 76,
+    0xa873: 85,
+    0x10ac0: 68,
+    0x10ac1: 68,
+    0x10ac2: 68,
+    0x10ac3: 68,
+    0x10ac4: 68,
+    0x10ac5: 82,
+    0x10ac6: 85,
+    0x10ac7: 82,
+    0x10ac8: 85,
+    0x10ac9: 82,
+    0x10aca: 82,
+    0x10acb: 85,
+    0x10acc: 85,
+    0x10acd: 76,
+    0x10ace: 82,
+    0x10acf: 82,
+    0x10ad0: 82,
+    0x10ad1: 82,
+    0x10ad2: 82,
+    0x10ad3: 68,
+    0x10ad4: 68,
+    0x10ad5: 68,
+    0x10ad6: 68,
+    0x10ad7: 76,
+    0x10ad8: 68,
+    0x10ad9: 68,
+    0x10ada: 68,
+    0x10adb: 68,
+    0x10adc: 68,
+    0x10add: 82,
+    0x10ade: 68,
+    0x10adf: 68,
+    0x10ae0: 68,
+    0x10ae1: 82,
+    0x10ae2: 85,
+    0x10ae3: 85,
+    0x10ae4: 82,
+    0x10aeb: 68,
+    0x10aec: 68,
+    0x10aed: 68,
+    0x10aee: 68,
+    0x10aef: 82,
+    0x10b80: 68,
+    0x10b81: 82,
+    0x10b82: 68,
+    0x10b83: 82,
+    0x10b84: 82,
+    0x10b85: 82,
+    0x10b86: 68,
+    0x10b87: 68,
+    0x10b88: 68,
+    0x10b89: 82,
+    0x10b8a: 68,
+    0x10b8b: 68,
+    0x10b8c: 82,
+    0x10b8d: 68,
+    0x10b8e: 82,
+    0x10b8f: 82,
+    0x10b90: 68,
+    0x10b91: 82,
+    0x10ba9: 82,
+    0x10baa: 82,
+    0x10bab: 82,
+    0x10bac: 82,
+    0x10bad: 68,
+    0x10bae: 68,
+    0x10baf: 85,
+    0x10d00: 76,
+    0x10d01: 68,
+    0x10d02: 68,
+    0x10d03: 68,
+    0x10d04: 68,
+    0x10d05: 68,
+    0x10d06: 68,
+    0x10d07: 68,
+    0x10d08: 68,
+    0x10d09: 68,
+    0x10d0a: 68,
+    0x10d0b: 68,
+    0x10d0c: 68,
+    0x10d0d: 68,
+    0x10d0e: 68,
+    0x10d0f: 68,
+    0x10d10: 68,
+    0x10d11: 68,
+    0x10d12: 68,
+    0x10d13: 68,
+    0x10d14: 68,
+    0x10d15: 68,
+    0x10d16: 68,
+    0x10d17: 68,
+    0x10d18: 68,
+    0x10d19: 68,
+    0x10d1a: 68,
+    0x10d1b: 68,
+    0x10d1c: 68,
+    0x10d1d: 68,
+    0x10d1e: 68,
+    0x10d1f: 68,
+    0x10d20: 68,
+    0x10d21: 68,
+    0x10d22: 82,
+    0x10d23: 68,
+    0x10f30: 68,
+    0x10f31: 68,
+    0x10f32: 68,
+    0x10f33: 82,
+    0x10f34: 68,
+    0x10f35: 68,
+    0x10f36: 68,
+    0x10f37: 68,
+    0x10f38: 68,
+    0x10f39: 68,
+    0x10f3a: 68,
+    0x10f3b: 68,
+    0x10f3c: 68,
+    0x10f3d: 68,
+    0x10f3e: 68,
+    0x10f3f: 68,
+    0x10f40: 68,
+    0x10f41: 68,
+    0x10f42: 68,
+    0x10f43: 68,
+    0x10f44: 68,
+    0x10f45: 85,
+    0x10f51: 68,
+    0x10f52: 68,
+    0x10f53: 68,
+    0x10f54: 82,
+    0x10f70: 68,
+    0x10f71: 68,
+    0x10f72: 68,
+    0x10f73: 68,
+    0x10f74: 82,
+    0x10f75: 82,
+    0x10f76: 68,
+    0x10f77: 68,
+    0x10f78: 68,
+    0x10f79: 68,
+    0x10f7a: 68,
+    0x10f7b: 68,
+    0x10f7c: 68,
+    0x10f7d: 68,
+    0x10f7e: 68,
+    0x10f7f: 68,
+    0x10f80: 68,
+    0x10f81: 68,
+    0x10fb0: 68,
+    0x10fb1: 85,
+    0x10fb2: 68,
+    0x10fb3: 68,
+    0x10fb4: 82,
+    0x10fb5: 82,
+    0x10fb6: 82,
+    0x10fb7: 85,
+    0x10fb8: 68,
+    0x10fb9: 82,
+    0x10fba: 82,
+    0x10fbb: 68,
+    0x10fbc: 68,
+    0x10fbd: 82,
+    0x10fbe: 68,
+    0x10fbf: 68,
+    0x10fc0: 85,
+    0x10fc1: 68,
+    0x10fc2: 82,
+    0x10fc3: 82,
+    0x10fc4: 68,
+    0x10fc5: 85,
+    0x10fc6: 85,
+    0x10fc7: 85,
+    0x10fc8: 85,
+    0x10fc9: 82,
+    0x10fca: 68,
+    0x10fcb: 76,
+    0x110bd: 85,
+    0x110cd: 85,
+    0x1e900: 68,
+    0x1e901: 68,
+    0x1e902: 68,
+    0x1e903: 68,
+    0x1e904: 68,
+    0x1e905: 68,
+    0x1e906: 68,
+    0x1e907: 68,
+    0x1e908: 68,
+    0x1e909: 68,
+    0x1e90a: 68,
+    0x1e90b: 68,
+    0x1e90c: 68,
+    0x1e90d: 68,
+    0x1e90e: 68,
+    0x1e90f: 68,
+    0x1e910: 68,
+    0x1e911: 68,
+    0x1e912: 68,
+    0x1e913: 68,
+    0x1e914: 68,
+    0x1e915: 68,
+    0x1e916: 68,
+    0x1e917: 68,
+    0x1e918: 68,
+    0x1e919: 68,
+    0x1e91a: 68,
+    0x1e91b: 68,
+    0x1e91c: 68,
+    0x1e91d: 68,
+    0x1e91e: 68,
+    0x1e91f: 68,
+    0x1e920: 68,
+    0x1e921: 68,
+    0x1e922: 68,
+    0x1e923: 68,
+    0x1e924: 68,
+    0x1e925: 68,
+    0x1e926: 68,
+    0x1e927: 68,
+    0x1e928: 68,
+    0x1e929: 68,
+    0x1e92a: 68,
+    0x1e92b: 68,
+    0x1e92c: 68,
+    0x1e92d: 68,
+    0x1e92e: 68,
+    0x1e92f: 68,
+    0x1e930: 68,
+    0x1e931: 68,
+    0x1e932: 68,
+    0x1e933: 68,
+    0x1e934: 68,
+    0x1e935: 68,
+    0x1e936: 68,
+    0x1e937: 68,
+    0x1e938: 68,
+    0x1e939: 68,
+    0x1e93a: 68,
+    0x1e93b: 68,
+    0x1e93c: 68,
+    0x1e93d: 68,
+    0x1e93e: 68,
+    0x1e93f: 68,
+    0x1e940: 68,
+    0x1e941: 68,
+    0x1e942: 68,
+    0x1e943: 68,
+    0x1e94b: 84,
+}
+codepoint_classes = {
+    'PVALID': (
+        0x2d0000002e,
+        0x300000003a,
+        0x610000007b,
+        0xdf000000f7,
+        0xf800000100,
+        0x10100000102,
+        0x10300000104,
+        0x10500000106,
+        0x10700000108,
+        0x1090000010a,
+        0x10b0000010c,
+        0x10d0000010e,
+        0x10f00000110,
+        0x11100000112,
+        0x11300000114,
+        0x11500000116,
+        0x11700000118,
+        0x1190000011a,
+        0x11b0000011c,
+        0x11d0000011e,
+        0x11f00000120,
+        0x12100000122,
+        0x12300000124,
+        0x12500000126,
+        0x12700000128,
+        0x1290000012a,
+        0x12b0000012c,
+        0x12d0000012e,
+        0x12f00000130,
+        0x13100000132,
+        0x13500000136,
+        0x13700000139,
+        0x13a0000013b,
+        0x13c0000013d,
+        0x13e0000013f,
+        0x14200000143,
+        0x14400000145,
+        0x14600000147,
+        0x14800000149,
+        0x14b0000014c,
+        0x14d0000014e,
+        0x14f00000150,
+        0x15100000152,
+        0x15300000154,
+        0x15500000156,
+        0x15700000158,
+        0x1590000015a,
+        0x15b0000015c,
+        0x15d0000015e,
+        0x15f00000160,
+        0x16100000162,
+        0x16300000164,
+        0x16500000166,
+        0x16700000168,
+        0x1690000016a,
+        0x16b0000016c,
+        0x16d0000016e,
+        0x16f00000170,
+        0x17100000172,
+        0x17300000174,
+        0x17500000176,
+        0x17700000178,
+        0x17a0000017b,
+        0x17c0000017d,
+        0x17e0000017f,
+        0x18000000181,
+        0x18300000184,
+        0x18500000186,
+        0x18800000189,
+        0x18c0000018e,
+        0x19200000193,
+        0x19500000196,
+        0x1990000019c,
+        0x19e0000019f,
+        0x1a1000001a2,
+        0x1a3000001a4,
+        0x1a5000001a6,
+        0x1a8000001a9,
+        0x1aa000001ac,
+        0x1ad000001ae,
+        0x1b0000001b1,
+        0x1b4000001b5,
+        0x1b6000001b7,
+        0x1b9000001bc,
+        0x1bd000001c4,
+        0x1ce000001cf,
+        0x1d0000001d1,
+        0x1d2000001d3,
+        0x1d4000001d5,
+        0x1d6000001d7,
+        0x1d8000001d9,
+        0x1da000001db,
+        0x1dc000001de,
+        0x1df000001e0,
+        0x1e1000001e2,
+        0x1e3000001e4,
+        0x1e5000001e6,
+        0x1e7000001e8,
+        0x1e9000001ea,
+        0x1eb000001ec,
+        0x1ed000001ee,
+        0x1ef000001f1,
+        0x1f5000001f6,
+        0x1f9000001fa,
+        0x1fb000001fc,
+        0x1fd000001fe,
+        0x1ff00000200,
+        0x20100000202,
+        0x20300000204,
+        0x20500000206,
+        0x20700000208,
+        0x2090000020a,
+        0x20b0000020c,
+        0x20d0000020e,
+        0x20f00000210,
+        0x21100000212,
+        0x21300000214,
+        0x21500000216,
+        0x21700000218,
+        0x2190000021a,
+        0x21b0000021c,
+        0x21d0000021e,
+        0x21f00000220,
+        0x22100000222,
+        0x22300000224,
+        0x22500000226,
+        0x22700000228,
+        0x2290000022a,
+        0x22b0000022c,
+        0x22d0000022e,
+        0x22f00000230,
+        0x23100000232,
+        0x2330000023a,
+        0x23c0000023d,
+        0x23f00000241,
+        0x24200000243,
+        0x24700000248,
+        0x2490000024a,
+        0x24b0000024c,
+        0x24d0000024e,
+        0x24f000002b0,
+        0x2b9000002c2,
+        0x2c6000002d2,
+        0x2ec000002ed,
+        0x2ee000002ef,
+        0x30000000340,
+        0x34200000343,
+        0x3460000034f,
+        0x35000000370,
+        0x37100000372,
+        0x37300000374,
+        0x37700000378,
+        0x37b0000037e,
+        0x39000000391,
+        0x3ac000003cf,
+        0x3d7000003d8,
+        0x3d9000003da,
+        0x3db000003dc,
+        0x3dd000003de,
+        0x3df000003e0,
+        0x3e1000003e2,
+        0x3e3000003e4,
+        0x3e5000003e6,
+        0x3e7000003e8,
+        0x3e9000003ea,
+        0x3eb000003ec,
+        0x3ed000003ee,
+        0x3ef000003f0,
+        0x3f3000003f4,
+        0x3f8000003f9,
+        0x3fb000003fd,
+        0x43000000460,
+        0x46100000462,
+        0x46300000464,
+        0x46500000466,
+        0x46700000468,
+        0x4690000046a,
+        0x46b0000046c,
+        0x46d0000046e,
+        0x46f00000470,
+        0x47100000472,
+        0x47300000474,
+        0x47500000476,
+        0x47700000478,
+        0x4790000047a,
+        0x47b0000047c,
+        0x47d0000047e,
+        0x47f00000480,
+        0x48100000482,
+        0x48300000488,
+        0x48b0000048c,
+        0x48d0000048e,
+        0x48f00000490,
+        0x49100000492,
+        0x49300000494,
+        0x49500000496,
+        0x49700000498,
+        0x4990000049a,
+        0x49b0000049c,
+        0x49d0000049e,
+        0x49f000004a0,
+        0x4a1000004a2,
+        0x4a3000004a4,
+        0x4a5000004a6,
+        0x4a7000004a8,
+        0x4a9000004aa,
+        0x4ab000004ac,
+        0x4ad000004ae,
+        0x4af000004b0,
+        0x4b1000004b2,
+        0x4b3000004b4,
+        0x4b5000004b6,
+        0x4b7000004b8,
+        0x4b9000004ba,
+        0x4bb000004bc,
+        0x4bd000004be,
+        0x4bf000004c0,
+        0x4c2000004c3,
+        0x4c4000004c5,
+        0x4c6000004c7,
+        0x4c8000004c9,
+        0x4ca000004cb,
+        0x4cc000004cd,
+        0x4ce000004d0,
+        0x4d1000004d2,
+        0x4d3000004d4,
+        0x4d5000004d6,
+        0x4d7000004d8,
+        0x4d9000004da,
+        0x4db000004dc,
+        0x4dd000004de,
+        0x4df000004e0,
+        0x4e1000004e2,
+        0x4e3000004e4,
+        0x4e5000004e6,
+        0x4e7000004e8,
+        0x4e9000004ea,
+        0x4eb000004ec,
+        0x4ed000004ee,
+        0x4ef000004f0,
+        0x4f1000004f2,
+        0x4f3000004f4,
+        0x4f5000004f6,
+        0x4f7000004f8,
+        0x4f9000004fa,
+        0x4fb000004fc,
+        0x4fd000004fe,
+        0x4ff00000500,
+        0x50100000502,
+        0x50300000504,
+        0x50500000506,
+        0x50700000508,
+        0x5090000050a,
+        0x50b0000050c,
+        0x50d0000050e,
+        0x50f00000510,
+        0x51100000512,
+        0x51300000514,
+        0x51500000516,
+        0x51700000518,
+        0x5190000051a,
+        0x51b0000051c,
+        0x51d0000051e,
+        0x51f00000520,
+        0x52100000522,
+        0x52300000524,
+        0x52500000526,
+        0x52700000528,
+        0x5290000052a,
+        0x52b0000052c,
+        0x52d0000052e,
+        0x52f00000530,
+        0x5590000055a,
+        0x56000000587,
+        0x58800000589,
+        0x591000005be,
+        0x5bf000005c0,
+        0x5c1000005c3,
+        0x5c4000005c6,
+        0x5c7000005c8,
+        0x5d0000005eb,
+        0x5ef000005f3,
+        0x6100000061b,
+        0x62000000640,
+        0x64100000660,
+        0x66e00000675,
+        0x679000006d4,
+        0x6d5000006dd,
+        0x6df000006e9,
+        0x6ea000006f0,
+        0x6fa00000700,
+        0x7100000074b,
+        0x74d000007b2,
+        0x7c0000007f6,
+        0x7fd000007fe,
+        0x8000000082e,
+        0x8400000085c,
+        0x8600000086b,
+        0x87000000888,
+        0x8890000088f,
+        0x898000008e2,
+        0x8e300000958,
+        0x96000000964,
+        0x96600000970,
+        0x97100000984,
+        0x9850000098d,
+        0x98f00000991,
+        0x993000009a9,
+        0x9aa000009b1,
+        0x9b2000009b3,
+        0x9b6000009ba,
+        0x9bc000009c5,
+        0x9c7000009c9,
+        0x9cb000009cf,
+        0x9d7000009d8,
+        0x9e0000009e4,
+        0x9e6000009f2,
+        0x9fc000009fd,
+        0x9fe000009ff,
+        0xa0100000a04,
+        0xa0500000a0b,
+        0xa0f00000a11,
+        0xa1300000a29,
+        0xa2a00000a31,
+        0xa3200000a33,
+        0xa3500000a36,
+        0xa3800000a3a,
+        0xa3c00000a3d,
+        0xa3e00000a43,
+        0xa4700000a49,
+        0xa4b00000a4e,
+        0xa5100000a52,
+        0xa5c00000a5d,
+        0xa6600000a76,
+        0xa8100000a84,
+        0xa8500000a8e,
+        0xa8f00000a92,
+        0xa9300000aa9,
+        0xaaa00000ab1,
+        0xab200000ab4,
+        0xab500000aba,
+        0xabc00000ac6,
+        0xac700000aca,
+        0xacb00000ace,
+        0xad000000ad1,
+        0xae000000ae4,
+        0xae600000af0,
+        0xaf900000b00,
+        0xb0100000b04,
+        0xb0500000b0d,
+        0xb0f00000b11,
+        0xb1300000b29,
+        0xb2a00000b31,
+        0xb3200000b34,
+        0xb3500000b3a,
+        0xb3c00000b45,
+        0xb4700000b49,
+        0xb4b00000b4e,
+        0xb5500000b58,
+        0xb5f00000b64,
+        0xb6600000b70,
+        0xb7100000b72,
+        0xb8200000b84,
+        0xb8500000b8b,
+        0xb8e00000b91,
+        0xb9200000b96,
+        0xb9900000b9b,
+        0xb9c00000b9d,
+        0xb9e00000ba0,
+        0xba300000ba5,
+        0xba800000bab,
+        0xbae00000bba,
+        0xbbe00000bc3,
+        0xbc600000bc9,
+        0xbca00000bce,
+        0xbd000000bd1,
+        0xbd700000bd8,
+        0xbe600000bf0,
+        0xc0000000c0d,
+        0xc0e00000c11,
+        0xc1200000c29,
+        0xc2a00000c3a,
+        0xc3c00000c45,
+        0xc4600000c49,
+        0xc4a00000c4e,
+        0xc5500000c57,
+        0xc5800000c5b,
+        0xc5d00000c5e,
+        0xc6000000c64,
+        0xc6600000c70,
+        0xc8000000c84,
+        0xc8500000c8d,
+        0xc8e00000c91,
+        0xc9200000ca9,
+        0xcaa00000cb4,
+        0xcb500000cba,
+        0xcbc00000cc5,
+        0xcc600000cc9,
+        0xcca00000cce,
+        0xcd500000cd7,
+        0xcdd00000cdf,
+        0xce000000ce4,
+        0xce600000cf0,
+        0xcf100000cf4,
+        0xd0000000d0d,
+        0xd0e00000d11,
+        0xd1200000d45,
+        0xd4600000d49,
+        0xd4a00000d4f,
+        0xd5400000d58,
+        0xd5f00000d64,
+        0xd6600000d70,
+        0xd7a00000d80,
+        0xd8100000d84,
+        0xd8500000d97,
+        0xd9a00000db2,
+        0xdb300000dbc,
+        0xdbd00000dbe,
+        0xdc000000dc7,
+        0xdca00000dcb,
+        0xdcf00000dd5,
+        0xdd600000dd7,
+        0xdd800000de0,
+        0xde600000df0,
+        0xdf200000df4,
+        0xe0100000e33,
+        0xe3400000e3b,
+        0xe4000000e4f,
+        0xe5000000e5a,
+        0xe8100000e83,
+        0xe8400000e85,
+        0xe8600000e8b,
+        0xe8c00000ea4,
+        0xea500000ea6,
+        0xea700000eb3,
+        0xeb400000ebe,
+        0xec000000ec5,
+        0xec600000ec7,
+        0xec800000ecf,
+        0xed000000eda,
+        0xede00000ee0,
+        0xf0000000f01,
+        0xf0b00000f0c,
+        0xf1800000f1a,
+        0xf2000000f2a,
+        0xf3500000f36,
+        0xf3700000f38,
+        0xf3900000f3a,
+        0xf3e00000f43,
+        0xf4400000f48,
+        0xf4900000f4d,
+        0xf4e00000f52,
+        0xf5300000f57,
+        0xf5800000f5c,
+        0xf5d00000f69,
+        0xf6a00000f6d,
+        0xf7100000f73,
+        0xf7400000f75,
+        0xf7a00000f81,
+        0xf8200000f85,
+        0xf8600000f93,
+        0xf9400000f98,
+        0xf9900000f9d,
+        0xf9e00000fa2,
+        0xfa300000fa7,
+        0xfa800000fac,
+        0xfad00000fb9,
+        0xfba00000fbd,
+        0xfc600000fc7,
+        0x10000000104a,
+        0x10500000109e,
+        0x10d0000010fb,
+        0x10fd00001100,
+        0x120000001249,
+        0x124a0000124e,
+        0x125000001257,
+        0x125800001259,
+        0x125a0000125e,
+        0x126000001289,
+        0x128a0000128e,
+        0x1290000012b1,
+        0x12b2000012b6,
+        0x12b8000012bf,
+        0x12c0000012c1,
+        0x12c2000012c6,
+        0x12c8000012d7,
+        0x12d800001311,
+        0x131200001316,
+        0x13180000135b,
+        0x135d00001360,
+        0x138000001390,
+        0x13a0000013f6,
+        0x14010000166d,
+        0x166f00001680,
+        0x16810000169b,
+        0x16a0000016eb,
+        0x16f1000016f9,
+        0x170000001716,
+        0x171f00001735,
+        0x174000001754,
+        0x17600000176d,
+        0x176e00001771,
+        0x177200001774,
+        0x1780000017b4,
+        0x17b6000017d4,
+        0x17d7000017d8,
+        0x17dc000017de,
+        0x17e0000017ea,
+        0x18100000181a,
+        0x182000001879,
+        0x1880000018ab,
+        0x18b0000018f6,
+        0x19000000191f,
+        0x19200000192c,
+        0x19300000193c,
+        0x19460000196e,
+        0x197000001975,
+        0x1980000019ac,
+        0x19b0000019ca,
+        0x19d0000019da,
+        0x1a0000001a1c,
+        0x1a2000001a5f,
+        0x1a6000001a7d,
+        0x1a7f00001a8a,
+        0x1a9000001a9a,
+        0x1aa700001aa8,
+        0x1ab000001abe,
+        0x1abf00001acf,
+        0x1b0000001b4d,
+        0x1b5000001b5a,
+        0x1b6b00001b74,
+        0x1b8000001bf4,
+        0x1c0000001c38,
+        0x1c4000001c4a,
+        0x1c4d00001c7e,
+        0x1cd000001cd3,
+        0x1cd400001cfb,
+        0x1d0000001d2c,
+        0x1d2f00001d30,
+        0x1d3b00001d3c,
+        0x1d4e00001d4f,
+        0x1d6b00001d78,
+        0x1d7900001d9b,
+        0x1dc000001e00,
+        0x1e0100001e02,
+        0x1e0300001e04,
+        0x1e0500001e06,
+        0x1e0700001e08,
+        0x1e0900001e0a,
+        0x1e0b00001e0c,
+        0x1e0d00001e0e,
+        0x1e0f00001e10,
+        0x1e1100001e12,
+        0x1e1300001e14,
+        0x1e1500001e16,
+        0x1e1700001e18,
+        0x1e1900001e1a,
+        0x1e1b00001e1c,
+        0x1e1d00001e1e,
+        0x1e1f00001e20,
+        0x1e2100001e22,
+        0x1e2300001e24,
+        0x1e2500001e26,
+        0x1e2700001e28,
+        0x1e2900001e2a,
+        0x1e2b00001e2c,
+        0x1e2d00001e2e,
+        0x1e2f00001e30,
+        0x1e3100001e32,
+        0x1e3300001e34,
+        0x1e3500001e36,
+        0x1e3700001e38,
+        0x1e3900001e3a,
+        0x1e3b00001e3c,
+        0x1e3d00001e3e,
+        0x1e3f00001e40,
+        0x1e4100001e42,
+        0x1e4300001e44,
+        0x1e4500001e46,
+        0x1e4700001e48,
+        0x1e4900001e4a,
+        0x1e4b00001e4c,
+        0x1e4d00001e4e,
+        0x1e4f00001e50,
+        0x1e5100001e52,
+        0x1e5300001e54,
+        0x1e5500001e56,
+        0x1e5700001e58,
+        0x1e5900001e5a,
+        0x1e5b00001e5c,
+        0x1e5d00001e5e,
+        0x1e5f00001e60,
+        0x1e6100001e62,
+        0x1e6300001e64,
+        0x1e6500001e66,
+        0x1e6700001e68,
+        0x1e6900001e6a,
+        0x1e6b00001e6c,
+        0x1e6d00001e6e,
+        0x1e6f00001e70,
+        0x1e7100001e72,
+        0x1e7300001e74,
+        0x1e7500001e76,
+        0x1e7700001e78,
+        0x1e7900001e7a,
+        0x1e7b00001e7c,
+        0x1e7d00001e7e,
+        0x1e7f00001e80,
+        0x1e8100001e82,
+        0x1e8300001e84,
+        0x1e8500001e86,
+        0x1e8700001e88,
+        0x1e8900001e8a,
+        0x1e8b00001e8c,
+        0x1e8d00001e8e,
+        0x1e8f00001e90,
+        0x1e9100001e92,
+        0x1e9300001e94,
+        0x1e9500001e9a,
+        0x1e9c00001e9e,
+        0x1e9f00001ea0,
+        0x1ea100001ea2,
+        0x1ea300001ea4,
+        0x1ea500001ea6,
+        0x1ea700001ea8,
+        0x1ea900001eaa,
+        0x1eab00001eac,
+        0x1ead00001eae,
+        0x1eaf00001eb0,
+        0x1eb100001eb2,
+        0x1eb300001eb4,
+        0x1eb500001eb6,
+        0x1eb700001eb8,
+        0x1eb900001eba,
+        0x1ebb00001ebc,
+        0x1ebd00001ebe,
+        0x1ebf00001ec0,
+        0x1ec100001ec2,
+        0x1ec300001ec4,
+        0x1ec500001ec6,
+        0x1ec700001ec8,
+        0x1ec900001eca,
+        0x1ecb00001ecc,
+        0x1ecd00001ece,
+        0x1ecf00001ed0,
+        0x1ed100001ed2,
+        0x1ed300001ed4,
+        0x1ed500001ed6,
+        0x1ed700001ed8,
+        0x1ed900001eda,
+        0x1edb00001edc,
+        0x1edd00001ede,
+        0x1edf00001ee0,
+        0x1ee100001ee2,
+        0x1ee300001ee4,
+        0x1ee500001ee6,
+        0x1ee700001ee8,
+        0x1ee900001eea,
+        0x1eeb00001eec,
+        0x1eed00001eee,
+        0x1eef00001ef0,
+        0x1ef100001ef2,
+        0x1ef300001ef4,
+        0x1ef500001ef6,
+        0x1ef700001ef8,
+        0x1ef900001efa,
+        0x1efb00001efc,
+        0x1efd00001efe,
+        0x1eff00001f08,
+        0x1f1000001f16,
+        0x1f2000001f28,
+        0x1f3000001f38,
+        0x1f4000001f46,
+        0x1f5000001f58,
+        0x1f6000001f68,
+        0x1f7000001f71,
+        0x1f7200001f73,
+        0x1f7400001f75,
+        0x1f7600001f77,
+        0x1f7800001f79,
+        0x1f7a00001f7b,
+        0x1f7c00001f7d,
+        0x1fb000001fb2,
+        0x1fb600001fb7,
+        0x1fc600001fc7,
+        0x1fd000001fd3,
+        0x1fd600001fd8,
+        0x1fe000001fe3,
+        0x1fe400001fe8,
+        0x1ff600001ff7,
+        0x214e0000214f,
+        0x218400002185,
+        0x2c3000002c60,
+        0x2c6100002c62,
+        0x2c6500002c67,
+        0x2c6800002c69,
+        0x2c6a00002c6b,
+        0x2c6c00002c6d,
+        0x2c7100002c72,
+        0x2c7300002c75,
+        0x2c7600002c7c,
+        0x2c8100002c82,
+        0x2c8300002c84,
+        0x2c8500002c86,
+        0x2c8700002c88,
+        0x2c8900002c8a,
+        0x2c8b00002c8c,
+        0x2c8d00002c8e,
+        0x2c8f00002c90,
+        0x2c9100002c92,
+        0x2c9300002c94,
+        0x2c9500002c96,
+        0x2c9700002c98,
+        0x2c9900002c9a,
+        0x2c9b00002c9c,
+        0x2c9d00002c9e,
+        0x2c9f00002ca0,
+        0x2ca100002ca2,
+        0x2ca300002ca4,
+        0x2ca500002ca6,
+        0x2ca700002ca8,
+        0x2ca900002caa,
+        0x2cab00002cac,
+        0x2cad00002cae,
+        0x2caf00002cb0,
+        0x2cb100002cb2,
+        0x2cb300002cb4,
+        0x2cb500002cb6,
+        0x2cb700002cb8,
+        0x2cb900002cba,
+        0x2cbb00002cbc,
+        0x2cbd00002cbe,
+        0x2cbf00002cc0,
+        0x2cc100002cc2,
+        0x2cc300002cc4,
+        0x2cc500002cc6,
+        0x2cc700002cc8,
+        0x2cc900002cca,
+        0x2ccb00002ccc,
+        0x2ccd00002cce,
+        0x2ccf00002cd0,
+        0x2cd100002cd2,
+        0x2cd300002cd4,
+        0x2cd500002cd6,
+        0x2cd700002cd8,
+        0x2cd900002cda,
+        0x2cdb00002cdc,
+        0x2cdd00002cde,
+        0x2cdf00002ce0,
+        0x2ce100002ce2,
+        0x2ce300002ce5,
+        0x2cec00002ced,
+        0x2cee00002cf2,
+        0x2cf300002cf4,
+        0x2d0000002d26,
+        0x2d2700002d28,
+        0x2d2d00002d2e,
+        0x2d3000002d68,
+        0x2d7f00002d97,
+        0x2da000002da7,
+        0x2da800002daf,
+        0x2db000002db7,
+        0x2db800002dbf,
+        0x2dc000002dc7,
+        0x2dc800002dcf,
+        0x2dd000002dd7,
+        0x2dd800002ddf,
+        0x2de000002e00,
+        0x2e2f00002e30,
+        0x300500003008,
+        0x302a0000302e,
+        0x303c0000303d,
+        0x304100003097,
+        0x30990000309b,
+        0x309d0000309f,
+        0x30a1000030fb,
+        0x30fc000030ff,
+        0x310500003130,
+        0x31a0000031c0,
+        0x31f000003200,
+        0x340000004dc0,
+        0x4e000000a48d,
+        0xa4d00000a4fe,
+        0xa5000000a60d,
+        0xa6100000a62c,
+        0xa6410000a642,
+        0xa6430000a644,
+        0xa6450000a646,
+        0xa6470000a648,
+        0xa6490000a64a,
+        0xa64b0000a64c,
+        0xa64d0000a64e,
+        0xa64f0000a650,
+        0xa6510000a652,
+        0xa6530000a654,
+        0xa6550000a656,
+        0xa6570000a658,
+        0xa6590000a65a,
+        0xa65b0000a65c,
+        0xa65d0000a65e,
+        0xa65f0000a660,
+        0xa6610000a662,
+        0xa6630000a664,
+        0xa6650000a666,
+        0xa6670000a668,
+        0xa6690000a66a,
+        0xa66b0000a66c,
+        0xa66d0000a670,
+        0xa6740000a67e,
+        0xa67f0000a680,
+        0xa6810000a682,
+        0xa6830000a684,
+        0xa6850000a686,
+        0xa6870000a688,
+        0xa6890000a68a,
+        0xa68b0000a68c,
+        0xa68d0000a68e,
+        0xa68f0000a690,
+        0xa6910000a692,
+        0xa6930000a694,
+        0xa6950000a696,
+        0xa6970000a698,
+        0xa6990000a69a,
+        0xa69b0000a69c,
+        0xa69e0000a6e6,
+        0xa6f00000a6f2,
+        0xa7170000a720,
+        0xa7230000a724,
+        0xa7250000a726,
+        0xa7270000a728,
+        0xa7290000a72a,
+        0xa72b0000a72c,
+        0xa72d0000a72e,
+        0xa72f0000a732,
+        0xa7330000a734,
+        0xa7350000a736,
+        0xa7370000a738,
+        0xa7390000a73a,
+        0xa73b0000a73c,
+        0xa73d0000a73e,
+        0xa73f0000a740,
+        0xa7410000a742,
+        0xa7430000a744,
+        0xa7450000a746,
+        0xa7470000a748,
+        0xa7490000a74a,
+        0xa74b0000a74c,
+        0xa74d0000a74e,
+        0xa74f0000a750,
+        0xa7510000a752,
+        0xa7530000a754,
+        0xa7550000a756,
+        0xa7570000a758,
+        0xa7590000a75a,
+        0xa75b0000a75c,
+        0xa75d0000a75e,
+        0xa75f0000a760,
+        0xa7610000a762,
+        0xa7630000a764,
+        0xa7650000a766,
+        0xa7670000a768,
+        0xa7690000a76a,
+        0xa76b0000a76c,
+        0xa76d0000a76e,
+        0xa76f0000a770,
+        0xa7710000a779,
+        0xa77a0000a77b,
+        0xa77c0000a77d,
+        0xa77f0000a780,
+        0xa7810000a782,
+        0xa7830000a784,
+        0xa7850000a786,
+        0xa7870000a789,
+        0xa78c0000a78d,
+        0xa78e0000a790,
+        0xa7910000a792,
+        0xa7930000a796,
+        0xa7970000a798,
+        0xa7990000a79a,
+        0xa79b0000a79c,
+        0xa79d0000a79e,
+        0xa79f0000a7a0,
+        0xa7a10000a7a2,
+        0xa7a30000a7a4,
+        0xa7a50000a7a6,
+        0xa7a70000a7a8,
+        0xa7a90000a7aa,
+        0xa7af0000a7b0,
+        0xa7b50000a7b6,
+        0xa7b70000a7b8,
+        0xa7b90000a7ba,
+        0xa7bb0000a7bc,
+        0xa7bd0000a7be,
+        0xa7bf0000a7c0,
+        0xa7c10000a7c2,
+        0xa7c30000a7c4,
+        0xa7c80000a7c9,
+        0xa7ca0000a7cb,
+        0xa7d10000a7d2,
+        0xa7d30000a7d4,
+        0xa7d50000a7d6,
+        0xa7d70000a7d8,
+        0xa7d90000a7da,
+        0xa7f60000a7f8,
+        0xa7fa0000a828,
+        0xa82c0000a82d,
+        0xa8400000a874,
+        0xa8800000a8c6,
+        0xa8d00000a8da,
+        0xa8e00000a8f8,
+        0xa8fb0000a8fc,
+        0xa8fd0000a92e,
+        0xa9300000a954,
+        0xa9800000a9c1,
+        0xa9cf0000a9da,
+        0xa9e00000a9ff,
+        0xaa000000aa37,
+        0xaa400000aa4e,
+        0xaa500000aa5a,
+        0xaa600000aa77,
+        0xaa7a0000aac3,
+        0xaadb0000aade,
+        0xaae00000aaf0,
+        0xaaf20000aaf7,
+        0xab010000ab07,
+        0xab090000ab0f,
+        0xab110000ab17,
+        0xab200000ab27,
+        0xab280000ab2f,
+        0xab300000ab5b,
+        0xab600000ab69,
+        0xabc00000abeb,
+        0xabec0000abee,
+        0xabf00000abfa,
+        0xac000000d7a4,
+        0xfa0e0000fa10,
+        0xfa110000fa12,
+        0xfa130000fa15,
+        0xfa1f0000fa20,
+        0xfa210000fa22,
+        0xfa230000fa25,
+        0xfa270000fa2a,
+        0xfb1e0000fb1f,
+        0xfe200000fe30,
+        0xfe730000fe74,
+        0x100000001000c,
+        0x1000d00010027,
+        0x100280001003b,
+        0x1003c0001003e,
+        0x1003f0001004e,
+        0x100500001005e,
+        0x10080000100fb,
+        0x101fd000101fe,
+        0x102800001029d,
+        0x102a0000102d1,
+        0x102e0000102e1,
+        0x1030000010320,
+        0x1032d00010341,
+        0x103420001034a,
+        0x103500001037b,
+        0x103800001039e,
+        0x103a0000103c4,
+        0x103c8000103d0,
+        0x104280001049e,
+        0x104a0000104aa,
+        0x104d8000104fc,
+        0x1050000010528,
+        0x1053000010564,
+        0x10597000105a2,
+        0x105a3000105b2,
+        0x105b3000105ba,
+        0x105bb000105bd,
+        0x1060000010737,
+        0x1074000010756,
+        0x1076000010768,
+        0x1078000010781,
+        0x1080000010806,
+        0x1080800010809,
+        0x1080a00010836,
+        0x1083700010839,
+        0x1083c0001083d,
+        0x1083f00010856,
+        0x1086000010877,
+        0x108800001089f,
+        0x108e0000108f3,
+        0x108f4000108f6,
+        0x1090000010916,
+        0x109200001093a,
+        0x10980000109b8,
+        0x109be000109c0,
+        0x10a0000010a04,
+        0x10a0500010a07,
+        0x10a0c00010a14,
+        0x10a1500010a18,
+        0x10a1900010a36,
+        0x10a3800010a3b,
+        0x10a3f00010a40,
+        0x10a6000010a7d,
+        0x10a8000010a9d,
+        0x10ac000010ac8,
+        0x10ac900010ae7,
+        0x10b0000010b36,
+        0x10b4000010b56,
+        0x10b6000010b73,
+        0x10b8000010b92,
+        0x10c0000010c49,
+        0x10cc000010cf3,
+        0x10d0000010d28,
+        0x10d3000010d3a,
+        0x10e8000010eaa,
+        0x10eab00010ead,
+        0x10eb000010eb2,
+        0x10efd00010f1d,
+        0x10f2700010f28,
+        0x10f3000010f51,
+        0x10f7000010f86,
+        0x10fb000010fc5,
+        0x10fe000010ff7,
+        0x1100000011047,
+        0x1106600011076,
+        0x1107f000110bb,
+        0x110c2000110c3,
+        0x110d0000110e9,
+        0x110f0000110fa,
+        0x1110000011135,
+        0x1113600011140,
+        0x1114400011148,
+        0x1115000011174,
+        0x1117600011177,
+        0x11180000111c5,
+        0x111c9000111cd,
+        0x111ce000111db,
+        0x111dc000111dd,
+        0x1120000011212,
+        0x1121300011238,
+        0x1123e00011242,
+        0x1128000011287,
+        0x1128800011289,
+        0x1128a0001128e,
+        0x1128f0001129e,
+        0x1129f000112a9,
+        0x112b0000112eb,
+        0x112f0000112fa,
+        0x1130000011304,
+        0x113050001130d,
+        0x1130f00011311,
+        0x1131300011329,
+        0x1132a00011331,
+        0x1133200011334,
+        0x113350001133a,
+        0x1133b00011345,
+        0x1134700011349,
+        0x1134b0001134e,
+        0x1135000011351,
+        0x1135700011358,
+        0x1135d00011364,
+        0x113660001136d,
+        0x1137000011375,
+        0x114000001144b,
+        0x114500001145a,
+        0x1145e00011462,
+        0x11480000114c6,
+        0x114c7000114c8,
+        0x114d0000114da,
+        0x11580000115b6,
+        0x115b8000115c1,
+        0x115d8000115de,
+        0x1160000011641,
+        0x1164400011645,
+        0x116500001165a,
+        0x11680000116b9,
+        0x116c0000116ca,
+        0x117000001171b,
+        0x1171d0001172c,
+        0x117300001173a,
+        0x1174000011747,
+        0x118000001183b,
+        0x118c0000118ea,
+        0x118ff00011907,
+        0x119090001190a,
+        0x1190c00011914,
+        0x1191500011917,
+        0x1191800011936,
+        0x1193700011939,
+        0x1193b00011944,
+        0x119500001195a,
+        0x119a0000119a8,
+        0x119aa000119d8,
+        0x119da000119e2,
+        0x119e3000119e5,
+        0x11a0000011a3f,
+        0x11a4700011a48,
+        0x11a5000011a9a,
+        0x11a9d00011a9e,
+        0x11ab000011af9,
+        0x11c0000011c09,
+        0x11c0a00011c37,
+        0x11c3800011c41,
+        0x11c5000011c5a,
+        0x11c7200011c90,
+        0x11c9200011ca8,
+        0x11ca900011cb7,
+        0x11d0000011d07,
+        0x11d0800011d0a,
+        0x11d0b00011d37,
+        0x11d3a00011d3b,
+        0x11d3c00011d3e,
+        0x11d3f00011d48,
+        0x11d5000011d5a,
+        0x11d6000011d66,
+        0x11d6700011d69,
+        0x11d6a00011d8f,
+        0x11d9000011d92,
+        0x11d9300011d99,
+        0x11da000011daa,
+        0x11ee000011ef7,
+        0x11f0000011f11,
+        0x11f1200011f3b,
+        0x11f3e00011f43,
+        0x11f5000011f5a,
+        0x11fb000011fb1,
+        0x120000001239a,
+        0x1248000012544,
+        0x12f9000012ff1,
+        0x1300000013430,
+        0x1344000013456,
+        0x1440000014647,
+        0x1680000016a39,
+        0x16a4000016a5f,
+        0x16a6000016a6a,
+        0x16a7000016abf,
+        0x16ac000016aca,
+        0x16ad000016aee,
+        0x16af000016af5,
+        0x16b0000016b37,
+        0x16b4000016b44,
+        0x16b5000016b5a,
+        0x16b6300016b78,
+        0x16b7d00016b90,
+        0x16e6000016e80,
+        0x16f0000016f4b,
+        0x16f4f00016f88,
+        0x16f8f00016fa0,
+        0x16fe000016fe2,
+        0x16fe300016fe5,
+        0x16ff000016ff2,
+        0x17000000187f8,
+        0x1880000018cd6,
+        0x18d0000018d09,
+        0x1aff00001aff4,
+        0x1aff50001affc,
+        0x1affd0001afff,
+        0x1b0000001b123,
+        0x1b1320001b133,
+        0x1b1500001b153,
+        0x1b1550001b156,
+        0x1b1640001b168,
+        0x1b1700001b2fc,
+        0x1bc000001bc6b,
+        0x1bc700001bc7d,
+        0x1bc800001bc89,
+        0x1bc900001bc9a,
+        0x1bc9d0001bc9f,
+        0x1cf000001cf2e,
+        0x1cf300001cf47,
+        0x1da000001da37,
+        0x1da3b0001da6d,
+        0x1da750001da76,
+        0x1da840001da85,
+        0x1da9b0001daa0,
+        0x1daa10001dab0,
+        0x1df000001df1f,
+        0x1df250001df2b,
+        0x1e0000001e007,
+        0x1e0080001e019,
+        0x1e01b0001e022,
+        0x1e0230001e025,
+        0x1e0260001e02b,
+        0x1e0300001e06e,
+        0x1e08f0001e090,
+        0x1e1000001e12d,
+        0x1e1300001e13e,
+        0x1e1400001e14a,
+        0x1e14e0001e14f,
+        0x1e2900001e2af,
+        0x1e2c00001e2fa,
+        0x1e4d00001e4fa,
+        0x1e7e00001e7e7,
+        0x1e7e80001e7ec,
+        0x1e7ed0001e7ef,
+        0x1e7f00001e7ff,
+        0x1e8000001e8c5,
+        0x1e8d00001e8d7,
+        0x1e9220001e94c,
+        0x1e9500001e95a,
+        0x200000002a6e0,
+        0x2a7000002b73a,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x2ebf00002ee5e,
+        0x300000003134b,
+        0x31350000323b0,
+    ),
+    'CONTEXTJ': (
+        0x200c0000200e,
+    ),
+    'CONTEXTO': (
+        0xb7000000b8,
+        0x37500000376,
+        0x5f3000005f5,
+        0x6600000066a,
+        0x6f0000006fa,
+        0x30fb000030fc,
+    ),
+}
diff --git a/lib/python3.11/site-packages/idna/intranges.py b/lib/python3.11/site-packages/idna/intranges.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a43b0475347cb50d0d65ada1000a82eeca9e882
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/intranges.py
@@ -0,0 +1,54 @@
+"""
+Given a list of integers, made up of (hopefully) a small number of long runs
+of consecutive integers, compute a representation of the form
+((start1, end1), (start2, end2) ...). Then answer the question "was x present
+in the original list?" in time O(log(# runs)).
+"""
+
+import bisect
+from typing import List, Tuple
+
+def intranges_from_list(list_: List[int]) -> Tuple[int, ...]:
+    """Represent a list of integers as a sequence of ranges:
+    ((start_0, end_0), (start_1, end_1), ...), such that the original
+    integers are exactly those x such that start_i <= x < end_i for some i.
+
+    Ranges are encoded as single integers (start << 32 | end), not as tuples.
+    """
+
+    sorted_list = sorted(list_)
+    ranges = []
+    last_write = -1
+    for i in range(len(sorted_list)):
+        if i+1 < len(sorted_list):
+            if sorted_list[i] == sorted_list[i+1]-1:
+                continue
+        current_range = sorted_list[last_write+1:i+1]
+        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
+        last_write = i
+
+    return tuple(ranges)
+
+def _encode_range(start: int, end: int) -> int:
+    return (start << 32) | end
+
+def _decode_range(r: int) -> Tuple[int, int]:
+    return (r >> 32), (r & ((1 << 32) - 1))
+
+
+def intranges_contain(int_: int, ranges: Tuple[int, ...]) -> bool:
+    """Determine if `int_` falls into one of the ranges in `ranges`."""
+    tuple_ = _encode_range(int_, 0)
+    pos = bisect.bisect_left(ranges, tuple_)
+    # we could be immediately ahead of a tuple (start, end)
+    # with start < int_ <= end
+    if pos > 0:
+        left, right = _decode_range(ranges[pos-1])
+        if left <= int_ < right:
+            return True
+    # or we could be immediately behind a tuple (int_, end)
+    if pos < len(ranges):
+        left, _ = _decode_range(ranges[pos])
+        if left == int_:
+            return True
+    return False
diff --git a/lib/python3.11/site-packages/idna/package_data.py b/lib/python3.11/site-packages/idna/package_data.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5b7220c97050152164e006b9b1c614a62f1dd46
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/package_data.py
@@ -0,0 +1,2 @@
+__version__ = '3.6'
+
diff --git a/lib/python3.11/site-packages/idna/py.typed b/lib/python3.11/site-packages/idna/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/idna/uts46data.py b/lib/python3.11/site-packages/idna/uts46data.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a1eddbfd7543b5e2d866c320c3aebfc2bd5ba0e
--- /dev/null
+++ b/lib/python3.11/site-packages/idna/uts46data.py
@@ -0,0 +1,8598 @@
+# This file is automatically generated by tools/idna-data
+# vim: set fileencoding=utf-8 :
+
+from typing import List, Tuple, Union
+
+
+"""IDNA Mapping Table from UTS46."""
+
+
+__version__ = '15.1.0'
+def _seg_0() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x0, '3'),
+    (0x1, '3'),
+    (0x2, '3'),
+    (0x3, '3'),
+    (0x4, '3'),
+    (0x5, '3'),
+    (0x6, '3'),
+    (0x7, '3'),
+    (0x8, '3'),
+    (0x9, '3'),
+    (0xA, '3'),
+    (0xB, '3'),
+    (0xC, '3'),
+    (0xD, '3'),
+    (0xE, '3'),
+    (0xF, '3'),
+    (0x10, '3'),
+    (0x11, '3'),
+    (0x12, '3'),
+    (0x13, '3'),
+    (0x14, '3'),
+    (0x15, '3'),
+    (0x16, '3'),
+    (0x17, '3'),
+    (0x18, '3'),
+    (0x19, '3'),
+    (0x1A, '3'),
+    (0x1B, '3'),
+    (0x1C, '3'),
+    (0x1D, '3'),
+    (0x1E, '3'),
+    (0x1F, '3'),
+    (0x20, '3'),
+    (0x21, '3'),
+    (0x22, '3'),
+    (0x23, '3'),
+    (0x24, '3'),
+    (0x25, '3'),
+    (0x26, '3'),
+    (0x27, '3'),
+    (0x28, '3'),
+    (0x29, '3'),
+    (0x2A, '3'),
+    (0x2B, '3'),
+    (0x2C, '3'),
+    (0x2D, 'V'),
+    (0x2E, 'V'),
+    (0x2F, '3'),
+    (0x30, 'V'),
+    (0x31, 'V'),
+    (0x32, 'V'),
+    (0x33, 'V'),
+    (0x34, 'V'),
+    (0x35, 'V'),
+    (0x36, 'V'),
+    (0x37, 'V'),
+    (0x38, 'V'),
+    (0x39, 'V'),
+    (0x3A, '3'),
+    (0x3B, '3'),
+    (0x3C, '3'),
+    (0x3D, '3'),
+    (0x3E, '3'),
+    (0x3F, '3'),
+    (0x40, '3'),
+    (0x41, 'M', 'a'),
+    (0x42, 'M', 'b'),
+    (0x43, 'M', 'c'),
+    (0x44, 'M', 'd'),
+    (0x45, 'M', 'e'),
+    (0x46, 'M', 'f'),
+    (0x47, 'M', 'g'),
+    (0x48, 'M', 'h'),
+    (0x49, 'M', 'i'),
+    (0x4A, 'M', 'j'),
+    (0x4B, 'M', 'k'),
+    (0x4C, 'M', 'l'),
+    (0x4D, 'M', 'm'),
+    (0x4E, 'M', 'n'),
+    (0x4F, 'M', 'o'),
+    (0x50, 'M', 'p'),
+    (0x51, 'M', 'q'),
+    (0x52, 'M', 'r'),
+    (0x53, 'M', 's'),
+    (0x54, 'M', 't'),
+    (0x55, 'M', 'u'),
+    (0x56, 'M', 'v'),
+    (0x57, 'M', 'w'),
+    (0x58, 'M', 'x'),
+    (0x59, 'M', 'y'),
+    (0x5A, 'M', 'z'),
+    (0x5B, '3'),
+    (0x5C, '3'),
+    (0x5D, '3'),
+    (0x5E, '3'),
+    (0x5F, '3'),
+    (0x60, '3'),
+    (0x61, 'V'),
+    (0x62, 'V'),
+    (0x63, 'V'),
+    ]
+
+def _seg_1() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x64, 'V'),
+    (0x65, 'V'),
+    (0x66, 'V'),
+    (0x67, 'V'),
+    (0x68, 'V'),
+    (0x69, 'V'),
+    (0x6A, 'V'),
+    (0x6B, 'V'),
+    (0x6C, 'V'),
+    (0x6D, 'V'),
+    (0x6E, 'V'),
+    (0x6F, 'V'),
+    (0x70, 'V'),
+    (0x71, 'V'),
+    (0x72, 'V'),
+    (0x73, 'V'),
+    (0x74, 'V'),
+    (0x75, 'V'),
+    (0x76, 'V'),
+    (0x77, 'V'),
+    (0x78, 'V'),
+    (0x79, 'V'),
+    (0x7A, 'V'),
+    (0x7B, '3'),
+    (0x7C, '3'),
+    (0x7D, '3'),
+    (0x7E, '3'),
+    (0x7F, '3'),
+    (0x80, 'X'),
+    (0x81, 'X'),
+    (0x82, 'X'),
+    (0x83, 'X'),
+    (0x84, 'X'),
+    (0x85, 'X'),
+    (0x86, 'X'),
+    (0x87, 'X'),
+    (0x88, 'X'),
+    (0x89, 'X'),
+    (0x8A, 'X'),
+    (0x8B, 'X'),
+    (0x8C, 'X'),
+    (0x8D, 'X'),
+    (0x8E, 'X'),
+    (0x8F, 'X'),
+    (0x90, 'X'),
+    (0x91, 'X'),
+    (0x92, 'X'),
+    (0x93, 'X'),
+    (0x94, 'X'),
+    (0x95, 'X'),
+    (0x96, 'X'),
+    (0x97, 'X'),
+    (0x98, 'X'),
+    (0x99, 'X'),
+    (0x9A, 'X'),
+    (0x9B, 'X'),
+    (0x9C, 'X'),
+    (0x9D, 'X'),
+    (0x9E, 'X'),
+    (0x9F, 'X'),
+    (0xA0, '3', ' '),
+    (0xA1, 'V'),
+    (0xA2, 'V'),
+    (0xA3, 'V'),
+    (0xA4, 'V'),
+    (0xA5, 'V'),
+    (0xA6, 'V'),
+    (0xA7, 'V'),
+    (0xA8, '3', ' ̈'),
+    (0xA9, 'V'),
+    (0xAA, 'M', 'a'),
+    (0xAB, 'V'),
+    (0xAC, 'V'),
+    (0xAD, 'I'),
+    (0xAE, 'V'),
+    (0xAF, '3', ' ̄'),
+    (0xB0, 'V'),
+    (0xB1, 'V'),
+    (0xB2, 'M', '2'),
+    (0xB3, 'M', '3'),
+    (0xB4, '3', ' ́'),
+    (0xB5, 'M', 'μ'),
+    (0xB6, 'V'),
+    (0xB7, 'V'),
+    (0xB8, '3', ' ̧'),
+    (0xB9, 'M', '1'),
+    (0xBA, 'M', 'o'),
+    (0xBB, 'V'),
+    (0xBC, 'M', '1⁄4'),
+    (0xBD, 'M', '1⁄2'),
+    (0xBE, 'M', '3⁄4'),
+    (0xBF, 'V'),
+    (0xC0, 'M', 'à'),
+    (0xC1, 'M', 'á'),
+    (0xC2, 'M', 'â'),
+    (0xC3, 'M', 'ã'),
+    (0xC4, 'M', 'ä'),
+    (0xC5, 'M', 'å'),
+    (0xC6, 'M', 'æ'),
+    (0xC7, 'M', 'ç'),
+    ]
+
+def _seg_2() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xC8, 'M', 'è'),
+    (0xC9, 'M', 'é'),
+    (0xCA, 'M', 'ê'),
+    (0xCB, 'M', 'ë'),
+    (0xCC, 'M', 'ì'),
+    (0xCD, 'M', 'í'),
+    (0xCE, 'M', 'î'),
+    (0xCF, 'M', 'ï'),
+    (0xD0, 'M', 'ð'),
+    (0xD1, 'M', 'ñ'),
+    (0xD2, 'M', 'ò'),
+    (0xD3, 'M', 'ó'),
+    (0xD4, 'M', 'ô'),
+    (0xD5, 'M', 'õ'),
+    (0xD6, 'M', 'ö'),
+    (0xD7, 'V'),
+    (0xD8, 'M', 'ø'),
+    (0xD9, 'M', 'ù'),
+    (0xDA, 'M', 'ú'),
+    (0xDB, 'M', 'û'),
+    (0xDC, 'M', 'ü'),
+    (0xDD, 'M', 'ý'),
+    (0xDE, 'M', 'þ'),
+    (0xDF, 'D', 'ss'),
+    (0xE0, 'V'),
+    (0xE1, 'V'),
+    (0xE2, 'V'),
+    (0xE3, 'V'),
+    (0xE4, 'V'),
+    (0xE5, 'V'),
+    (0xE6, 'V'),
+    (0xE7, 'V'),
+    (0xE8, 'V'),
+    (0xE9, 'V'),
+    (0xEA, 'V'),
+    (0xEB, 'V'),
+    (0xEC, 'V'),
+    (0xED, 'V'),
+    (0xEE, 'V'),
+    (0xEF, 'V'),
+    (0xF0, 'V'),
+    (0xF1, 'V'),
+    (0xF2, 'V'),
+    (0xF3, 'V'),
+    (0xF4, 'V'),
+    (0xF5, 'V'),
+    (0xF6, 'V'),
+    (0xF7, 'V'),
+    (0xF8, 'V'),
+    (0xF9, 'V'),
+    (0xFA, 'V'),
+    (0xFB, 'V'),
+    (0xFC, 'V'),
+    (0xFD, 'V'),
+    (0xFE, 'V'),
+    (0xFF, 'V'),
+    (0x100, 'M', 'ā'),
+    (0x101, 'V'),
+    (0x102, 'M', 'ă'),
+    (0x103, 'V'),
+    (0x104, 'M', 'ą'),
+    (0x105, 'V'),
+    (0x106, 'M', 'ć'),
+    (0x107, 'V'),
+    (0x108, 'M', 'ĉ'),
+    (0x109, 'V'),
+    (0x10A, 'M', 'ċ'),
+    (0x10B, 'V'),
+    (0x10C, 'M', 'č'),
+    (0x10D, 'V'),
+    (0x10E, 'M', 'ď'),
+    (0x10F, 'V'),
+    (0x110, 'M', 'đ'),
+    (0x111, 'V'),
+    (0x112, 'M', 'ē'),
+    (0x113, 'V'),
+    (0x114, 'M', 'ĕ'),
+    (0x115, 'V'),
+    (0x116, 'M', 'ė'),
+    (0x117, 'V'),
+    (0x118, 'M', 'ę'),
+    (0x119, 'V'),
+    (0x11A, 'M', 'ě'),
+    (0x11B, 'V'),
+    (0x11C, 'M', 'ĝ'),
+    (0x11D, 'V'),
+    (0x11E, 'M', 'ğ'),
+    (0x11F, 'V'),
+    (0x120, 'M', 'ġ'),
+    (0x121, 'V'),
+    (0x122, 'M', 'ģ'),
+    (0x123, 'V'),
+    (0x124, 'M', 'ĥ'),
+    (0x125, 'V'),
+    (0x126, 'M', 'ħ'),
+    (0x127, 'V'),
+    (0x128, 'M', 'ĩ'),
+    (0x129, 'V'),
+    (0x12A, 'M', 'ī'),
+    (0x12B, 'V'),
+    ]
+
+def _seg_3() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x12C, 'M', 'ĭ'),
+    (0x12D, 'V'),
+    (0x12E, 'M', 'į'),
+    (0x12F, 'V'),
+    (0x130, 'M', 'i̇'),
+    (0x131, 'V'),
+    (0x132, 'M', 'ij'),
+    (0x134, 'M', 'ĵ'),
+    (0x135, 'V'),
+    (0x136, 'M', 'ķ'),
+    (0x137, 'V'),
+    (0x139, 'M', 'ĺ'),
+    (0x13A, 'V'),
+    (0x13B, 'M', 'ļ'),
+    (0x13C, 'V'),
+    (0x13D, 'M', 'ľ'),
+    (0x13E, 'V'),
+    (0x13F, 'M', 'l·'),
+    (0x141, 'M', 'ł'),
+    (0x142, 'V'),
+    (0x143, 'M', 'ń'),
+    (0x144, 'V'),
+    (0x145, 'M', 'ņ'),
+    (0x146, 'V'),
+    (0x147, 'M', 'ň'),
+    (0x148, 'V'),
+    (0x149, 'M', 'ʼn'),
+    (0x14A, 'M', 'ŋ'),
+    (0x14B, 'V'),
+    (0x14C, 'M', 'ō'),
+    (0x14D, 'V'),
+    (0x14E, 'M', 'ŏ'),
+    (0x14F, 'V'),
+    (0x150, 'M', 'ő'),
+    (0x151, 'V'),
+    (0x152, 'M', 'œ'),
+    (0x153, 'V'),
+    (0x154, 'M', 'ŕ'),
+    (0x155, 'V'),
+    (0x156, 'M', 'ŗ'),
+    (0x157, 'V'),
+    (0x158, 'M', 'ř'),
+    (0x159, 'V'),
+    (0x15A, 'M', 'ś'),
+    (0x15B, 'V'),
+    (0x15C, 'M', 'ŝ'),
+    (0x15D, 'V'),
+    (0x15E, 'M', 'ş'),
+    (0x15F, 'V'),
+    (0x160, 'M', 'š'),
+    (0x161, 'V'),
+    (0x162, 'M', 'ţ'),
+    (0x163, 'V'),
+    (0x164, 'M', 'ť'),
+    (0x165, 'V'),
+    (0x166, 'M', 'ŧ'),
+    (0x167, 'V'),
+    (0x168, 'M', 'ũ'),
+    (0x169, 'V'),
+    (0x16A, 'M', 'ū'),
+    (0x16B, 'V'),
+    (0x16C, 'M', 'ŭ'),
+    (0x16D, 'V'),
+    (0x16E, 'M', 'ů'),
+    (0x16F, 'V'),
+    (0x170, 'M', 'ű'),
+    (0x171, 'V'),
+    (0x172, 'M', 'ų'),
+    (0x173, 'V'),
+    (0x174, 'M', 'ŵ'),
+    (0x175, 'V'),
+    (0x176, 'M', 'ŷ'),
+    (0x177, 'V'),
+    (0x178, 'M', 'ÿ'),
+    (0x179, 'M', 'ź'),
+    (0x17A, 'V'),
+    (0x17B, 'M', 'ż'),
+    (0x17C, 'V'),
+    (0x17D, 'M', 'ž'),
+    (0x17E, 'V'),
+    (0x17F, 'M', 's'),
+    (0x180, 'V'),
+    (0x181, 'M', 'ɓ'),
+    (0x182, 'M', 'ƃ'),
+    (0x183, 'V'),
+    (0x184, 'M', 'ƅ'),
+    (0x185, 'V'),
+    (0x186, 'M', 'ɔ'),
+    (0x187, 'M', 'ƈ'),
+    (0x188, 'V'),
+    (0x189, 'M', 'ɖ'),
+    (0x18A, 'M', 'ɗ'),
+    (0x18B, 'M', 'ƌ'),
+    (0x18C, 'V'),
+    (0x18E, 'M', 'ǝ'),
+    (0x18F, 'M', 'ə'),
+    (0x190, 'M', 'ɛ'),
+    (0x191, 'M', 'ƒ'),
+    (0x192, 'V'),
+    (0x193, 'M', 'ɠ'),
+    ]
+
+def _seg_4() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x194, 'M', 'ɣ'),
+    (0x195, 'V'),
+    (0x196, 'M', 'ɩ'),
+    (0x197, 'M', 'ɨ'),
+    (0x198, 'M', 'ƙ'),
+    (0x199, 'V'),
+    (0x19C, 'M', 'ɯ'),
+    (0x19D, 'M', 'ɲ'),
+    (0x19E, 'V'),
+    (0x19F, 'M', 'ɵ'),
+    (0x1A0, 'M', 'ơ'),
+    (0x1A1, 'V'),
+    (0x1A2, 'M', 'ƣ'),
+    (0x1A3, 'V'),
+    (0x1A4, 'M', 'ƥ'),
+    (0x1A5, 'V'),
+    (0x1A6, 'M', 'ʀ'),
+    (0x1A7, 'M', 'ƨ'),
+    (0x1A8, 'V'),
+    (0x1A9, 'M', 'ʃ'),
+    (0x1AA, 'V'),
+    (0x1AC, 'M', 'ƭ'),
+    (0x1AD, 'V'),
+    (0x1AE, 'M', 'ʈ'),
+    (0x1AF, 'M', 'ư'),
+    (0x1B0, 'V'),
+    (0x1B1, 'M', 'ʊ'),
+    (0x1B2, 'M', 'ʋ'),
+    (0x1B3, 'M', 'ƴ'),
+    (0x1B4, 'V'),
+    (0x1B5, 'M', 'ƶ'),
+    (0x1B6, 'V'),
+    (0x1B7, 'M', 'ʒ'),
+    (0x1B8, 'M', 'ƹ'),
+    (0x1B9, 'V'),
+    (0x1BC, 'M', 'ƽ'),
+    (0x1BD, 'V'),
+    (0x1C4, 'M', 'dž'),
+    (0x1C7, 'M', 'lj'),
+    (0x1CA, 'M', 'nj'),
+    (0x1CD, 'M', 'ǎ'),
+    (0x1CE, 'V'),
+    (0x1CF, 'M', 'ǐ'),
+    (0x1D0, 'V'),
+    (0x1D1, 'M', 'ǒ'),
+    (0x1D2, 'V'),
+    (0x1D3, 'M', 'ǔ'),
+    (0x1D4, 'V'),
+    (0x1D5, 'M', 'ǖ'),
+    (0x1D6, 'V'),
+    (0x1D7, 'M', 'ǘ'),
+    (0x1D8, 'V'),
+    (0x1D9, 'M', 'ǚ'),
+    (0x1DA, 'V'),
+    (0x1DB, 'M', 'ǜ'),
+    (0x1DC, 'V'),
+    (0x1DE, 'M', 'ǟ'),
+    (0x1DF, 'V'),
+    (0x1E0, 'M', 'ǡ'),
+    (0x1E1, 'V'),
+    (0x1E2, 'M', 'ǣ'),
+    (0x1E3, 'V'),
+    (0x1E4, 'M', 'ǥ'),
+    (0x1E5, 'V'),
+    (0x1E6, 'M', 'ǧ'),
+    (0x1E7, 'V'),
+    (0x1E8, 'M', 'ǩ'),
+    (0x1E9, 'V'),
+    (0x1EA, 'M', 'ǫ'),
+    (0x1EB, 'V'),
+    (0x1EC, 'M', 'ǭ'),
+    (0x1ED, 'V'),
+    (0x1EE, 'M', 'ǯ'),
+    (0x1EF, 'V'),
+    (0x1F1, 'M', 'dz'),
+    (0x1F4, 'M', 'ǵ'),
+    (0x1F5, 'V'),
+    (0x1F6, 'M', 'ƕ'),
+    (0x1F7, 'M', 'ƿ'),
+    (0x1F8, 'M', 'ǹ'),
+    (0x1F9, 'V'),
+    (0x1FA, 'M', 'ǻ'),
+    (0x1FB, 'V'),
+    (0x1FC, 'M', 'ǽ'),
+    (0x1FD, 'V'),
+    (0x1FE, 'M', 'ǿ'),
+    (0x1FF, 'V'),
+    (0x200, 'M', 'ȁ'),
+    (0x201, 'V'),
+    (0x202, 'M', 'ȃ'),
+    (0x203, 'V'),
+    (0x204, 'M', 'ȅ'),
+    (0x205, 'V'),
+    (0x206, 'M', 'ȇ'),
+    (0x207, 'V'),
+    (0x208, 'M', 'ȉ'),
+    (0x209, 'V'),
+    (0x20A, 'M', 'ȋ'),
+    (0x20B, 'V'),
+    (0x20C, 'M', 'ȍ'),
+    ]
+
+def _seg_5() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x20D, 'V'),
+    (0x20E, 'M', 'ȏ'),
+    (0x20F, 'V'),
+    (0x210, 'M', 'ȑ'),
+    (0x211, 'V'),
+    (0x212, 'M', 'ȓ'),
+    (0x213, 'V'),
+    (0x214, 'M', 'ȕ'),
+    (0x215, 'V'),
+    (0x216, 'M', 'ȗ'),
+    (0x217, 'V'),
+    (0x218, 'M', 'ș'),
+    (0x219, 'V'),
+    (0x21A, 'M', 'ț'),
+    (0x21B, 'V'),
+    (0x21C, 'M', 'ȝ'),
+    (0x21D, 'V'),
+    (0x21E, 'M', 'ȟ'),
+    (0x21F, 'V'),
+    (0x220, 'M', 'ƞ'),
+    (0x221, 'V'),
+    (0x222, 'M', 'ȣ'),
+    (0x223, 'V'),
+    (0x224, 'M', 'ȥ'),
+    (0x225, 'V'),
+    (0x226, 'M', 'ȧ'),
+    (0x227, 'V'),
+    (0x228, 'M', 'ȩ'),
+    (0x229, 'V'),
+    (0x22A, 'M', 'ȫ'),
+    (0x22B, 'V'),
+    (0x22C, 'M', 'ȭ'),
+    (0x22D, 'V'),
+    (0x22E, 'M', 'ȯ'),
+    (0x22F, 'V'),
+    (0x230, 'M', 'ȱ'),
+    (0x231, 'V'),
+    (0x232, 'M', 'ȳ'),
+    (0x233, 'V'),
+    (0x23A, 'M', 'ⱥ'),
+    (0x23B, 'M', 'ȼ'),
+    (0x23C, 'V'),
+    (0x23D, 'M', 'ƚ'),
+    (0x23E, 'M', 'ⱦ'),
+    (0x23F, 'V'),
+    (0x241, 'M', 'ɂ'),
+    (0x242, 'V'),
+    (0x243, 'M', 'ƀ'),
+    (0x244, 'M', 'ʉ'),
+    (0x245, 'M', 'ʌ'),
+    (0x246, 'M', 'ɇ'),
+    (0x247, 'V'),
+    (0x248, 'M', 'ɉ'),
+    (0x249, 'V'),
+    (0x24A, 'M', 'ɋ'),
+    (0x24B, 'V'),
+    (0x24C, 'M', 'ɍ'),
+    (0x24D, 'V'),
+    (0x24E, 'M', 'ɏ'),
+    (0x24F, 'V'),
+    (0x2B0, 'M', 'h'),
+    (0x2B1, 'M', 'ɦ'),
+    (0x2B2, 'M', 'j'),
+    (0x2B3, 'M', 'r'),
+    (0x2B4, 'M', 'ɹ'),
+    (0x2B5, 'M', 'ɻ'),
+    (0x2B6, 'M', 'ʁ'),
+    (0x2B7, 'M', 'w'),
+    (0x2B8, 'M', 'y'),
+    (0x2B9, 'V'),
+    (0x2D8, '3', ' ̆'),
+    (0x2D9, '3', ' ̇'),
+    (0x2DA, '3', ' ̊'),
+    (0x2DB, '3', ' ̨'),
+    (0x2DC, '3', ' ̃'),
+    (0x2DD, '3', ' ̋'),
+    (0x2DE, 'V'),
+    (0x2E0, 'M', 'ɣ'),
+    (0x2E1, 'M', 'l'),
+    (0x2E2, 'M', 's'),
+    (0x2E3, 'M', 'x'),
+    (0x2E4, 'M', 'ʕ'),
+    (0x2E5, 'V'),
+    (0x340, 'M', '̀'),
+    (0x341, 'M', '́'),
+    (0x342, 'V'),
+    (0x343, 'M', '̓'),
+    (0x344, 'M', '̈́'),
+    (0x345, 'M', 'ι'),
+    (0x346, 'V'),
+    (0x34F, 'I'),
+    (0x350, 'V'),
+    (0x370, 'M', 'ͱ'),
+    (0x371, 'V'),
+    (0x372, 'M', 'ͳ'),
+    (0x373, 'V'),
+    (0x374, 'M', 'ʹ'),
+    (0x375, 'V'),
+    (0x376, 'M', 'ͷ'),
+    (0x377, 'V'),
+    ]
+
+def _seg_6() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x378, 'X'),
+    (0x37A, '3', ' ι'),
+    (0x37B, 'V'),
+    (0x37E, '3', ';'),
+    (0x37F, 'M', 'ϳ'),
+    (0x380, 'X'),
+    (0x384, '3', ' ́'),
+    (0x385, '3', ' ̈́'),
+    (0x386, 'M', 'ά'),
+    (0x387, 'M', '·'),
+    (0x388, 'M', 'έ'),
+    (0x389, 'M', 'ή'),
+    (0x38A, 'M', 'ί'),
+    (0x38B, 'X'),
+    (0x38C, 'M', 'ό'),
+    (0x38D, 'X'),
+    (0x38E, 'M', 'ύ'),
+    (0x38F, 'M', 'ώ'),
+    (0x390, 'V'),
+    (0x391, 'M', 'α'),
+    (0x392, 'M', 'β'),
+    (0x393, 'M', 'γ'),
+    (0x394, 'M', 'δ'),
+    (0x395, 'M', 'ε'),
+    (0x396, 'M', 'ζ'),
+    (0x397, 'M', 'η'),
+    (0x398, 'M', 'θ'),
+    (0x399, 'M', 'ι'),
+    (0x39A, 'M', 'κ'),
+    (0x39B, 'M', 'λ'),
+    (0x39C, 'M', 'μ'),
+    (0x39D, 'M', 'ν'),
+    (0x39E, 'M', 'ξ'),
+    (0x39F, 'M', 'ο'),
+    (0x3A0, 'M', 'π'),
+    (0x3A1, 'M', 'ρ'),
+    (0x3A2, 'X'),
+    (0x3A3, 'M', 'σ'),
+    (0x3A4, 'M', 'τ'),
+    (0x3A5, 'M', 'υ'),
+    (0x3A6, 'M', 'φ'),
+    (0x3A7, 'M', 'χ'),
+    (0x3A8, 'M', 'ψ'),
+    (0x3A9, 'M', 'ω'),
+    (0x3AA, 'M', 'ϊ'),
+    (0x3AB, 'M', 'ϋ'),
+    (0x3AC, 'V'),
+    (0x3C2, 'D', 'σ'),
+    (0x3C3, 'V'),
+    (0x3CF, 'M', 'ϗ'),
+    (0x3D0, 'M', 'β'),
+    (0x3D1, 'M', 'θ'),
+    (0x3D2, 'M', 'υ'),
+    (0x3D3, 'M', 'ύ'),
+    (0x3D4, 'M', 'ϋ'),
+    (0x3D5, 'M', 'φ'),
+    (0x3D6, 'M', 'π'),
+    (0x3D7, 'V'),
+    (0x3D8, 'M', 'ϙ'),
+    (0x3D9, 'V'),
+    (0x3DA, 'M', 'ϛ'),
+    (0x3DB, 'V'),
+    (0x3DC, 'M', 'ϝ'),
+    (0x3DD, 'V'),
+    (0x3DE, 'M', 'ϟ'),
+    (0x3DF, 'V'),
+    (0x3E0, 'M', 'ϡ'),
+    (0x3E1, 'V'),
+    (0x3E2, 'M', 'ϣ'),
+    (0x3E3, 'V'),
+    (0x3E4, 'M', 'ϥ'),
+    (0x3E5, 'V'),
+    (0x3E6, 'M', 'ϧ'),
+    (0x3E7, 'V'),
+    (0x3E8, 'M', 'ϩ'),
+    (0x3E9, 'V'),
+    (0x3EA, 'M', 'ϫ'),
+    (0x3EB, 'V'),
+    (0x3EC, 'M', 'ϭ'),
+    (0x3ED, 'V'),
+    (0x3EE, 'M', 'ϯ'),
+    (0x3EF, 'V'),
+    (0x3F0, 'M', 'κ'),
+    (0x3F1, 'M', 'ρ'),
+    (0x3F2, 'M', 'σ'),
+    (0x3F3, 'V'),
+    (0x3F4, 'M', 'θ'),
+    (0x3F5, 'M', 'ε'),
+    (0x3F6, 'V'),
+    (0x3F7, 'M', 'ϸ'),
+    (0x3F8, 'V'),
+    (0x3F9, 'M', 'σ'),
+    (0x3FA, 'M', 'ϻ'),
+    (0x3FB, 'V'),
+    (0x3FD, 'M', 'ͻ'),
+    (0x3FE, 'M', 'ͼ'),
+    (0x3FF, 'M', 'ͽ'),
+    (0x400, 'M', 'ѐ'),
+    (0x401, 'M', 'ё'),
+    (0x402, 'M', 'ђ'),
+    ]
+
+def _seg_7() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x403, 'M', 'ѓ'),
+    (0x404, 'M', 'є'),
+    (0x405, 'M', 'ѕ'),
+    (0x406, 'M', 'і'),
+    (0x407, 'M', 'ї'),
+    (0x408, 'M', 'ј'),
+    (0x409, 'M', 'љ'),
+    (0x40A, 'M', 'њ'),
+    (0x40B, 'M', 'ћ'),
+    (0x40C, 'M', 'ќ'),
+    (0x40D, 'M', 'ѝ'),
+    (0x40E, 'M', 'ў'),
+    (0x40F, 'M', 'џ'),
+    (0x410, 'M', 'а'),
+    (0x411, 'M', 'б'),
+    (0x412, 'M', 'в'),
+    (0x413, 'M', 'г'),
+    (0x414, 'M', 'д'),
+    (0x415, 'M', 'е'),
+    (0x416, 'M', 'ж'),
+    (0x417, 'M', 'з'),
+    (0x418, 'M', 'и'),
+    (0x419, 'M', 'й'),
+    (0x41A, 'M', 'к'),
+    (0x41B, 'M', 'л'),
+    (0x41C, 'M', 'м'),
+    (0x41D, 'M', 'н'),
+    (0x41E, 'M', 'о'),
+    (0x41F, 'M', 'п'),
+    (0x420, 'M', 'р'),
+    (0x421, 'M', 'с'),
+    (0x422, 'M', 'т'),
+    (0x423, 'M', 'у'),
+    (0x424, 'M', 'ф'),
+    (0x425, 'M', 'х'),
+    (0x426, 'M', 'ц'),
+    (0x427, 'M', 'ч'),
+    (0x428, 'M', 'ш'),
+    (0x429, 'M', 'щ'),
+    (0x42A, 'M', 'ъ'),
+    (0x42B, 'M', 'ы'),
+    (0x42C, 'M', 'ь'),
+    (0x42D, 'M', 'э'),
+    (0x42E, 'M', 'ю'),
+    (0x42F, 'M', 'я'),
+    (0x430, 'V'),
+    (0x460, 'M', 'ѡ'),
+    (0x461, 'V'),
+    (0x462, 'M', 'ѣ'),
+    (0x463, 'V'),
+    (0x464, 'M', 'ѥ'),
+    (0x465, 'V'),
+    (0x466, 'M', 'ѧ'),
+    (0x467, 'V'),
+    (0x468, 'M', 'ѩ'),
+    (0x469, 'V'),
+    (0x46A, 'M', 'ѫ'),
+    (0x46B, 'V'),
+    (0x46C, 'M', 'ѭ'),
+    (0x46D, 'V'),
+    (0x46E, 'M', 'ѯ'),
+    (0x46F, 'V'),
+    (0x470, 'M', 'ѱ'),
+    (0x471, 'V'),
+    (0x472, 'M', 'ѳ'),
+    (0x473, 'V'),
+    (0x474, 'M', 'ѵ'),
+    (0x475, 'V'),
+    (0x476, 'M', 'ѷ'),
+    (0x477, 'V'),
+    (0x478, 'M', 'ѹ'),
+    (0x479, 'V'),
+    (0x47A, 'M', 'ѻ'),
+    (0x47B, 'V'),
+    (0x47C, 'M', 'ѽ'),
+    (0x47D, 'V'),
+    (0x47E, 'M', 'ѿ'),
+    (0x47F, 'V'),
+    (0x480, 'M', 'ҁ'),
+    (0x481, 'V'),
+    (0x48A, 'M', 'ҋ'),
+    (0x48B, 'V'),
+    (0x48C, 'M', 'ҍ'),
+    (0x48D, 'V'),
+    (0x48E, 'M', 'ҏ'),
+    (0x48F, 'V'),
+    (0x490, 'M', 'ґ'),
+    (0x491, 'V'),
+    (0x492, 'M', 'ғ'),
+    (0x493, 'V'),
+    (0x494, 'M', 'ҕ'),
+    (0x495, 'V'),
+    (0x496, 'M', 'җ'),
+    (0x497, 'V'),
+    (0x498, 'M', 'ҙ'),
+    (0x499, 'V'),
+    (0x49A, 'M', 'қ'),
+    (0x49B, 'V'),
+    (0x49C, 'M', 'ҝ'),
+    (0x49D, 'V'),
+    ]
+
+def _seg_8() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x49E, 'M', 'ҟ'),
+    (0x49F, 'V'),
+    (0x4A0, 'M', 'ҡ'),
+    (0x4A1, 'V'),
+    (0x4A2, 'M', 'ң'),
+    (0x4A3, 'V'),
+    (0x4A4, 'M', 'ҥ'),
+    (0x4A5, 'V'),
+    (0x4A6, 'M', 'ҧ'),
+    (0x4A7, 'V'),
+    (0x4A8, 'M', 'ҩ'),
+    (0x4A9, 'V'),
+    (0x4AA, 'M', 'ҫ'),
+    (0x4AB, 'V'),
+    (0x4AC, 'M', 'ҭ'),
+    (0x4AD, 'V'),
+    (0x4AE, 'M', 'ү'),
+    (0x4AF, 'V'),
+    (0x4B0, 'M', 'ұ'),
+    (0x4B1, 'V'),
+    (0x4B2, 'M', 'ҳ'),
+    (0x4B3, 'V'),
+    (0x4B4, 'M', 'ҵ'),
+    (0x4B5, 'V'),
+    (0x4B6, 'M', 'ҷ'),
+    (0x4B7, 'V'),
+    (0x4B8, 'M', 'ҹ'),
+    (0x4B9, 'V'),
+    (0x4BA, 'M', 'һ'),
+    (0x4BB, 'V'),
+    (0x4BC, 'M', 'ҽ'),
+    (0x4BD, 'V'),
+    (0x4BE, 'M', 'ҿ'),
+    (0x4BF, 'V'),
+    (0x4C0, 'X'),
+    (0x4C1, 'M', 'ӂ'),
+    (0x4C2, 'V'),
+    (0x4C3, 'M', 'ӄ'),
+    (0x4C4, 'V'),
+    (0x4C5, 'M', 'ӆ'),
+    (0x4C6, 'V'),
+    (0x4C7, 'M', 'ӈ'),
+    (0x4C8, 'V'),
+    (0x4C9, 'M', 'ӊ'),
+    (0x4CA, 'V'),
+    (0x4CB, 'M', 'ӌ'),
+    (0x4CC, 'V'),
+    (0x4CD, 'M', 'ӎ'),
+    (0x4CE, 'V'),
+    (0x4D0, 'M', 'ӑ'),
+    (0x4D1, 'V'),
+    (0x4D2, 'M', 'ӓ'),
+    (0x4D3, 'V'),
+    (0x4D4, 'M', 'ӕ'),
+    (0x4D5, 'V'),
+    (0x4D6, 'M', 'ӗ'),
+    (0x4D7, 'V'),
+    (0x4D8, 'M', 'ә'),
+    (0x4D9, 'V'),
+    (0x4DA, 'M', 'ӛ'),
+    (0x4DB, 'V'),
+    (0x4DC, 'M', 'ӝ'),
+    (0x4DD, 'V'),
+    (0x4DE, 'M', 'ӟ'),
+    (0x4DF, 'V'),
+    (0x4E0, 'M', 'ӡ'),
+    (0x4E1, 'V'),
+    (0x4E2, 'M', 'ӣ'),
+    (0x4E3, 'V'),
+    (0x4E4, 'M', 'ӥ'),
+    (0x4E5, 'V'),
+    (0x4E6, 'M', 'ӧ'),
+    (0x4E7, 'V'),
+    (0x4E8, 'M', 'ө'),
+    (0x4E9, 'V'),
+    (0x4EA, 'M', 'ӫ'),
+    (0x4EB, 'V'),
+    (0x4EC, 'M', 'ӭ'),
+    (0x4ED, 'V'),
+    (0x4EE, 'M', 'ӯ'),
+    (0x4EF, 'V'),
+    (0x4F0, 'M', 'ӱ'),
+    (0x4F1, 'V'),
+    (0x4F2, 'M', 'ӳ'),
+    (0x4F3, 'V'),
+    (0x4F4, 'M', 'ӵ'),
+    (0x4F5, 'V'),
+    (0x4F6, 'M', 'ӷ'),
+    (0x4F7, 'V'),
+    (0x4F8, 'M', 'ӹ'),
+    (0x4F9, 'V'),
+    (0x4FA, 'M', 'ӻ'),
+    (0x4FB, 'V'),
+    (0x4FC, 'M', 'ӽ'),
+    (0x4FD, 'V'),
+    (0x4FE, 'M', 'ӿ'),
+    (0x4FF, 'V'),
+    (0x500, 'M', 'ԁ'),
+    (0x501, 'V'),
+    (0x502, 'M', 'ԃ'),
+    ]
+
+def _seg_9() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x503, 'V'),
+    (0x504, 'M', 'ԅ'),
+    (0x505, 'V'),
+    (0x506, 'M', 'ԇ'),
+    (0x507, 'V'),
+    (0x508, 'M', 'ԉ'),
+    (0x509, 'V'),
+    (0x50A, 'M', 'ԋ'),
+    (0x50B, 'V'),
+    (0x50C, 'M', 'ԍ'),
+    (0x50D, 'V'),
+    (0x50E, 'M', 'ԏ'),
+    (0x50F, 'V'),
+    (0x510, 'M', 'ԑ'),
+    (0x511, 'V'),
+    (0x512, 'M', 'ԓ'),
+    (0x513, 'V'),
+    (0x514, 'M', 'ԕ'),
+    (0x515, 'V'),
+    (0x516, 'M', 'ԗ'),
+    (0x517, 'V'),
+    (0x518, 'M', 'ԙ'),
+    (0x519, 'V'),
+    (0x51A, 'M', 'ԛ'),
+    (0x51B, 'V'),
+    (0x51C, 'M', 'ԝ'),
+    (0x51D, 'V'),
+    (0x51E, 'M', 'ԟ'),
+    (0x51F, 'V'),
+    (0x520, 'M', 'ԡ'),
+    (0x521, 'V'),
+    (0x522, 'M', 'ԣ'),
+    (0x523, 'V'),
+    (0x524, 'M', 'ԥ'),
+    (0x525, 'V'),
+    (0x526, 'M', 'ԧ'),
+    (0x527, 'V'),
+    (0x528, 'M', 'ԩ'),
+    (0x529, 'V'),
+    (0x52A, 'M', 'ԫ'),
+    (0x52B, 'V'),
+    (0x52C, 'M', 'ԭ'),
+    (0x52D, 'V'),
+    (0x52E, 'M', 'ԯ'),
+    (0x52F, 'V'),
+    (0x530, 'X'),
+    (0x531, 'M', 'ա'),
+    (0x532, 'M', 'բ'),
+    (0x533, 'M', 'գ'),
+    (0x534, 'M', 'դ'),
+    (0x535, 'M', 'ե'),
+    (0x536, 'M', 'զ'),
+    (0x537, 'M', 'է'),
+    (0x538, 'M', 'ը'),
+    (0x539, 'M', 'թ'),
+    (0x53A, 'M', 'ժ'),
+    (0x53B, 'M', 'ի'),
+    (0x53C, 'M', 'լ'),
+    (0x53D, 'M', 'խ'),
+    (0x53E, 'M', 'ծ'),
+    (0x53F, 'M', 'կ'),
+    (0x540, 'M', 'հ'),
+    (0x541, 'M', 'ձ'),
+    (0x542, 'M', 'ղ'),
+    (0x543, 'M', 'ճ'),
+    (0x544, 'M', 'մ'),
+    (0x545, 'M', 'յ'),
+    (0x546, 'M', 'ն'),
+    (0x547, 'M', 'շ'),
+    (0x548, 'M', 'ո'),
+    (0x549, 'M', 'չ'),
+    (0x54A, 'M', 'պ'),
+    (0x54B, 'M', 'ջ'),
+    (0x54C, 'M', 'ռ'),
+    (0x54D, 'M', 'ս'),
+    (0x54E, 'M', 'վ'),
+    (0x54F, 'M', 'տ'),
+    (0x550, 'M', 'ր'),
+    (0x551, 'M', 'ց'),
+    (0x552, 'M', 'ւ'),
+    (0x553, 'M', 'փ'),
+    (0x554, 'M', 'ք'),
+    (0x555, 'M', 'օ'),
+    (0x556, 'M', 'ֆ'),
+    (0x557, 'X'),
+    (0x559, 'V'),
+    (0x587, 'M', 'եւ'),
+    (0x588, 'V'),
+    (0x58B, 'X'),
+    (0x58D, 'V'),
+    (0x590, 'X'),
+    (0x591, 'V'),
+    (0x5C8, 'X'),
+    (0x5D0, 'V'),
+    (0x5EB, 'X'),
+    (0x5EF, 'V'),
+    (0x5F5, 'X'),
+    (0x606, 'V'),
+    (0x61C, 'X'),
+    (0x61D, 'V'),
+    ]
+
+def _seg_10() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x675, 'M', 'اٴ'),
+    (0x676, 'M', 'وٴ'),
+    (0x677, 'M', 'ۇٴ'),
+    (0x678, 'M', 'يٴ'),
+    (0x679, 'V'),
+    (0x6DD, 'X'),
+    (0x6DE, 'V'),
+    (0x70E, 'X'),
+    (0x710, 'V'),
+    (0x74B, 'X'),
+    (0x74D, 'V'),
+    (0x7B2, 'X'),
+    (0x7C0, 'V'),
+    (0x7FB, 'X'),
+    (0x7FD, 'V'),
+    (0x82E, 'X'),
+    (0x830, 'V'),
+    (0x83F, 'X'),
+    (0x840, 'V'),
+    (0x85C, 'X'),
+    (0x85E, 'V'),
+    (0x85F, 'X'),
+    (0x860, 'V'),
+    (0x86B, 'X'),
+    (0x870, 'V'),
+    (0x88F, 'X'),
+    (0x898, 'V'),
+    (0x8E2, 'X'),
+    (0x8E3, 'V'),
+    (0x958, 'M', 'क़'),
+    (0x959, 'M', 'ख़'),
+    (0x95A, 'M', 'ग़'),
+    (0x95B, 'M', 'ज़'),
+    (0x95C, 'M', 'ड़'),
+    (0x95D, 'M', 'ढ़'),
+    (0x95E, 'M', 'फ़'),
+    (0x95F, 'M', 'य़'),
+    (0x960, 'V'),
+    (0x984, 'X'),
+    (0x985, 'V'),
+    (0x98D, 'X'),
+    (0x98F, 'V'),
+    (0x991, 'X'),
+    (0x993, 'V'),
+    (0x9A9, 'X'),
+    (0x9AA, 'V'),
+    (0x9B1, 'X'),
+    (0x9B2, 'V'),
+    (0x9B3, 'X'),
+    (0x9B6, 'V'),
+    (0x9BA, 'X'),
+    (0x9BC, 'V'),
+    (0x9C5, 'X'),
+    (0x9C7, 'V'),
+    (0x9C9, 'X'),
+    (0x9CB, 'V'),
+    (0x9CF, 'X'),
+    (0x9D7, 'V'),
+    (0x9D8, 'X'),
+    (0x9DC, 'M', 'ড়'),
+    (0x9DD, 'M', 'ঢ়'),
+    (0x9DE, 'X'),
+    (0x9DF, 'M', 'য়'),
+    (0x9E0, 'V'),
+    (0x9E4, 'X'),
+    (0x9E6, 'V'),
+    (0x9FF, 'X'),
+    (0xA01, 'V'),
+    (0xA04, 'X'),
+    (0xA05, 'V'),
+    (0xA0B, 'X'),
+    (0xA0F, 'V'),
+    (0xA11, 'X'),
+    (0xA13, 'V'),
+    (0xA29, 'X'),
+    (0xA2A, 'V'),
+    (0xA31, 'X'),
+    (0xA32, 'V'),
+    (0xA33, 'M', 'ਲ਼'),
+    (0xA34, 'X'),
+    (0xA35, 'V'),
+    (0xA36, 'M', 'ਸ਼'),
+    (0xA37, 'X'),
+    (0xA38, 'V'),
+    (0xA3A, 'X'),
+    (0xA3C, 'V'),
+    (0xA3D, 'X'),
+    (0xA3E, 'V'),
+    (0xA43, 'X'),
+    (0xA47, 'V'),
+    (0xA49, 'X'),
+    (0xA4B, 'V'),
+    (0xA4E, 'X'),
+    (0xA51, 'V'),
+    (0xA52, 'X'),
+    (0xA59, 'M', 'ਖ਼'),
+    (0xA5A, 'M', 'ਗ਼'),
+    (0xA5B, 'M', 'ਜ਼'),
+    (0xA5C, 'V'),
+    (0xA5D, 'X'),
+    ]
+
+def _seg_11() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA5E, 'M', 'ਫ਼'),
+    (0xA5F, 'X'),
+    (0xA66, 'V'),
+    (0xA77, 'X'),
+    (0xA81, 'V'),
+    (0xA84, 'X'),
+    (0xA85, 'V'),
+    (0xA8E, 'X'),
+    (0xA8F, 'V'),
+    (0xA92, 'X'),
+    (0xA93, 'V'),
+    (0xAA9, 'X'),
+    (0xAAA, 'V'),
+    (0xAB1, 'X'),
+    (0xAB2, 'V'),
+    (0xAB4, 'X'),
+    (0xAB5, 'V'),
+    (0xABA, 'X'),
+    (0xABC, 'V'),
+    (0xAC6, 'X'),
+    (0xAC7, 'V'),
+    (0xACA, 'X'),
+    (0xACB, 'V'),
+    (0xACE, 'X'),
+    (0xAD0, 'V'),
+    (0xAD1, 'X'),
+    (0xAE0, 'V'),
+    (0xAE4, 'X'),
+    (0xAE6, 'V'),
+    (0xAF2, 'X'),
+    (0xAF9, 'V'),
+    (0xB00, 'X'),
+    (0xB01, 'V'),
+    (0xB04, 'X'),
+    (0xB05, 'V'),
+    (0xB0D, 'X'),
+    (0xB0F, 'V'),
+    (0xB11, 'X'),
+    (0xB13, 'V'),
+    (0xB29, 'X'),
+    (0xB2A, 'V'),
+    (0xB31, 'X'),
+    (0xB32, 'V'),
+    (0xB34, 'X'),
+    (0xB35, 'V'),
+    (0xB3A, 'X'),
+    (0xB3C, 'V'),
+    (0xB45, 'X'),
+    (0xB47, 'V'),
+    (0xB49, 'X'),
+    (0xB4B, 'V'),
+    (0xB4E, 'X'),
+    (0xB55, 'V'),
+    (0xB58, 'X'),
+    (0xB5C, 'M', 'ଡ଼'),
+    (0xB5D, 'M', 'ଢ଼'),
+    (0xB5E, 'X'),
+    (0xB5F, 'V'),
+    (0xB64, 'X'),
+    (0xB66, 'V'),
+    (0xB78, 'X'),
+    (0xB82, 'V'),
+    (0xB84, 'X'),
+    (0xB85, 'V'),
+    (0xB8B, 'X'),
+    (0xB8E, 'V'),
+    (0xB91, 'X'),
+    (0xB92, 'V'),
+    (0xB96, 'X'),
+    (0xB99, 'V'),
+    (0xB9B, 'X'),
+    (0xB9C, 'V'),
+    (0xB9D, 'X'),
+    (0xB9E, 'V'),
+    (0xBA0, 'X'),
+    (0xBA3, 'V'),
+    (0xBA5, 'X'),
+    (0xBA8, 'V'),
+    (0xBAB, 'X'),
+    (0xBAE, 'V'),
+    (0xBBA, 'X'),
+    (0xBBE, 'V'),
+    (0xBC3, 'X'),
+    (0xBC6, 'V'),
+    (0xBC9, 'X'),
+    (0xBCA, 'V'),
+    (0xBCE, 'X'),
+    (0xBD0, 'V'),
+    (0xBD1, 'X'),
+    (0xBD7, 'V'),
+    (0xBD8, 'X'),
+    (0xBE6, 'V'),
+    (0xBFB, 'X'),
+    (0xC00, 'V'),
+    (0xC0D, 'X'),
+    (0xC0E, 'V'),
+    (0xC11, 'X'),
+    (0xC12, 'V'),
+    (0xC29, 'X'),
+    (0xC2A, 'V'),
+    ]
+
+def _seg_12() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xC3A, 'X'),
+    (0xC3C, 'V'),
+    (0xC45, 'X'),
+    (0xC46, 'V'),
+    (0xC49, 'X'),
+    (0xC4A, 'V'),
+    (0xC4E, 'X'),
+    (0xC55, 'V'),
+    (0xC57, 'X'),
+    (0xC58, 'V'),
+    (0xC5B, 'X'),
+    (0xC5D, 'V'),
+    (0xC5E, 'X'),
+    (0xC60, 'V'),
+    (0xC64, 'X'),
+    (0xC66, 'V'),
+    (0xC70, 'X'),
+    (0xC77, 'V'),
+    (0xC8D, 'X'),
+    (0xC8E, 'V'),
+    (0xC91, 'X'),
+    (0xC92, 'V'),
+    (0xCA9, 'X'),
+    (0xCAA, 'V'),
+    (0xCB4, 'X'),
+    (0xCB5, 'V'),
+    (0xCBA, 'X'),
+    (0xCBC, 'V'),
+    (0xCC5, 'X'),
+    (0xCC6, 'V'),
+    (0xCC9, 'X'),
+    (0xCCA, 'V'),
+    (0xCCE, 'X'),
+    (0xCD5, 'V'),
+    (0xCD7, 'X'),
+    (0xCDD, 'V'),
+    (0xCDF, 'X'),
+    (0xCE0, 'V'),
+    (0xCE4, 'X'),
+    (0xCE6, 'V'),
+    (0xCF0, 'X'),
+    (0xCF1, 'V'),
+    (0xCF4, 'X'),
+    (0xD00, 'V'),
+    (0xD0D, 'X'),
+    (0xD0E, 'V'),
+    (0xD11, 'X'),
+    (0xD12, 'V'),
+    (0xD45, 'X'),
+    (0xD46, 'V'),
+    (0xD49, 'X'),
+    (0xD4A, 'V'),
+    (0xD50, 'X'),
+    (0xD54, 'V'),
+    (0xD64, 'X'),
+    (0xD66, 'V'),
+    (0xD80, 'X'),
+    (0xD81, 'V'),
+    (0xD84, 'X'),
+    (0xD85, 'V'),
+    (0xD97, 'X'),
+    (0xD9A, 'V'),
+    (0xDB2, 'X'),
+    (0xDB3, 'V'),
+    (0xDBC, 'X'),
+    (0xDBD, 'V'),
+    (0xDBE, 'X'),
+    (0xDC0, 'V'),
+    (0xDC7, 'X'),
+    (0xDCA, 'V'),
+    (0xDCB, 'X'),
+    (0xDCF, 'V'),
+    (0xDD5, 'X'),
+    (0xDD6, 'V'),
+    (0xDD7, 'X'),
+    (0xDD8, 'V'),
+    (0xDE0, 'X'),
+    (0xDE6, 'V'),
+    (0xDF0, 'X'),
+    (0xDF2, 'V'),
+    (0xDF5, 'X'),
+    (0xE01, 'V'),
+    (0xE33, 'M', 'ํา'),
+    (0xE34, 'V'),
+    (0xE3B, 'X'),
+    (0xE3F, 'V'),
+    (0xE5C, 'X'),
+    (0xE81, 'V'),
+    (0xE83, 'X'),
+    (0xE84, 'V'),
+    (0xE85, 'X'),
+    (0xE86, 'V'),
+    (0xE8B, 'X'),
+    (0xE8C, 'V'),
+    (0xEA4, 'X'),
+    (0xEA5, 'V'),
+    (0xEA6, 'X'),
+    (0xEA7, 'V'),
+    (0xEB3, 'M', 'ໍາ'),
+    (0xEB4, 'V'),
+    ]
+
+def _seg_13() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xEBE, 'X'),
+    (0xEC0, 'V'),
+    (0xEC5, 'X'),
+    (0xEC6, 'V'),
+    (0xEC7, 'X'),
+    (0xEC8, 'V'),
+    (0xECF, 'X'),
+    (0xED0, 'V'),
+    (0xEDA, 'X'),
+    (0xEDC, 'M', 'ຫນ'),
+    (0xEDD, 'M', 'ຫມ'),
+    (0xEDE, 'V'),
+    (0xEE0, 'X'),
+    (0xF00, 'V'),
+    (0xF0C, 'M', '་'),
+    (0xF0D, 'V'),
+    (0xF43, 'M', 'གྷ'),
+    (0xF44, 'V'),
+    (0xF48, 'X'),
+    (0xF49, 'V'),
+    (0xF4D, 'M', 'ཌྷ'),
+    (0xF4E, 'V'),
+    (0xF52, 'M', 'དྷ'),
+    (0xF53, 'V'),
+    (0xF57, 'M', 'བྷ'),
+    (0xF58, 'V'),
+    (0xF5C, 'M', 'ཛྷ'),
+    (0xF5D, 'V'),
+    (0xF69, 'M', 'ཀྵ'),
+    (0xF6A, 'V'),
+    (0xF6D, 'X'),
+    (0xF71, 'V'),
+    (0xF73, 'M', 'ཱི'),
+    (0xF74, 'V'),
+    (0xF75, 'M', 'ཱུ'),
+    (0xF76, 'M', 'ྲྀ'),
+    (0xF77, 'M', 'ྲཱྀ'),
+    (0xF78, 'M', 'ླྀ'),
+    (0xF79, 'M', 'ླཱྀ'),
+    (0xF7A, 'V'),
+    (0xF81, 'M', 'ཱྀ'),
+    (0xF82, 'V'),
+    (0xF93, 'M', 'ྒྷ'),
+    (0xF94, 'V'),
+    (0xF98, 'X'),
+    (0xF99, 'V'),
+    (0xF9D, 'M', 'ྜྷ'),
+    (0xF9E, 'V'),
+    (0xFA2, 'M', 'ྡྷ'),
+    (0xFA3, 'V'),
+    (0xFA7, 'M', 'ྦྷ'),
+    (0xFA8, 'V'),
+    (0xFAC, 'M', 'ྫྷ'),
+    (0xFAD, 'V'),
+    (0xFB9, 'M', 'ྐྵ'),
+    (0xFBA, 'V'),
+    (0xFBD, 'X'),
+    (0xFBE, 'V'),
+    (0xFCD, 'X'),
+    (0xFCE, 'V'),
+    (0xFDB, 'X'),
+    (0x1000, 'V'),
+    (0x10A0, 'X'),
+    (0x10C7, 'M', 'ⴧ'),
+    (0x10C8, 'X'),
+    (0x10CD, 'M', 'ⴭ'),
+    (0x10CE, 'X'),
+    (0x10D0, 'V'),
+    (0x10FC, 'M', 'ნ'),
+    (0x10FD, 'V'),
+    (0x115F, 'X'),
+    (0x1161, 'V'),
+    (0x1249, 'X'),
+    (0x124A, 'V'),
+    (0x124E, 'X'),
+    (0x1250, 'V'),
+    (0x1257, 'X'),
+    (0x1258, 'V'),
+    (0x1259, 'X'),
+    (0x125A, 'V'),
+    (0x125E, 'X'),
+    (0x1260, 'V'),
+    (0x1289, 'X'),
+    (0x128A, 'V'),
+    (0x128E, 'X'),
+    (0x1290, 'V'),
+    (0x12B1, 'X'),
+    (0x12B2, 'V'),
+    (0x12B6, 'X'),
+    (0x12B8, 'V'),
+    (0x12BF, 'X'),
+    (0x12C0, 'V'),
+    (0x12C1, 'X'),
+    (0x12C2, 'V'),
+    (0x12C6, 'X'),
+    (0x12C8, 'V'),
+    (0x12D7, 'X'),
+    (0x12D8, 'V'),
+    (0x1311, 'X'),
+    (0x1312, 'V'),
+    ]
+
+def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1316, 'X'),
+    (0x1318, 'V'),
+    (0x135B, 'X'),
+    (0x135D, 'V'),
+    (0x137D, 'X'),
+    (0x1380, 'V'),
+    (0x139A, 'X'),
+    (0x13A0, 'V'),
+    (0x13F6, 'X'),
+    (0x13F8, 'M', 'Ᏸ'),
+    (0x13F9, 'M', 'Ᏹ'),
+    (0x13FA, 'M', 'Ᏺ'),
+    (0x13FB, 'M', 'Ᏻ'),
+    (0x13FC, 'M', 'Ᏼ'),
+    (0x13FD, 'M', 'Ᏽ'),
+    (0x13FE, 'X'),
+    (0x1400, 'V'),
+    (0x1680, 'X'),
+    (0x1681, 'V'),
+    (0x169D, 'X'),
+    (0x16A0, 'V'),
+    (0x16F9, 'X'),
+    (0x1700, 'V'),
+    (0x1716, 'X'),
+    (0x171F, 'V'),
+    (0x1737, 'X'),
+    (0x1740, 'V'),
+    (0x1754, 'X'),
+    (0x1760, 'V'),
+    (0x176D, 'X'),
+    (0x176E, 'V'),
+    (0x1771, 'X'),
+    (0x1772, 'V'),
+    (0x1774, 'X'),
+    (0x1780, 'V'),
+    (0x17B4, 'X'),
+    (0x17B6, 'V'),
+    (0x17DE, 'X'),
+    (0x17E0, 'V'),
+    (0x17EA, 'X'),
+    (0x17F0, 'V'),
+    (0x17FA, 'X'),
+    (0x1800, 'V'),
+    (0x1806, 'X'),
+    (0x1807, 'V'),
+    (0x180B, 'I'),
+    (0x180E, 'X'),
+    (0x180F, 'I'),
+    (0x1810, 'V'),
+    (0x181A, 'X'),
+    (0x1820, 'V'),
+    (0x1879, 'X'),
+    (0x1880, 'V'),
+    (0x18AB, 'X'),
+    (0x18B0, 'V'),
+    (0x18F6, 'X'),
+    (0x1900, 'V'),
+    (0x191F, 'X'),
+    (0x1920, 'V'),
+    (0x192C, 'X'),
+    (0x1930, 'V'),
+    (0x193C, 'X'),
+    (0x1940, 'V'),
+    (0x1941, 'X'),
+    (0x1944, 'V'),
+    (0x196E, 'X'),
+    (0x1970, 'V'),
+    (0x1975, 'X'),
+    (0x1980, 'V'),
+    (0x19AC, 'X'),
+    (0x19B0, 'V'),
+    (0x19CA, 'X'),
+    (0x19D0, 'V'),
+    (0x19DB, 'X'),
+    (0x19DE, 'V'),
+    (0x1A1C, 'X'),
+    (0x1A1E, 'V'),
+    (0x1A5F, 'X'),
+    (0x1A60, 'V'),
+    (0x1A7D, 'X'),
+    (0x1A7F, 'V'),
+    (0x1A8A, 'X'),
+    (0x1A90, 'V'),
+    (0x1A9A, 'X'),
+    (0x1AA0, 'V'),
+    (0x1AAE, 'X'),
+    (0x1AB0, 'V'),
+    (0x1ACF, 'X'),
+    (0x1B00, 'V'),
+    (0x1B4D, 'X'),
+    (0x1B50, 'V'),
+    (0x1B7F, 'X'),
+    (0x1B80, 'V'),
+    (0x1BF4, 'X'),
+    (0x1BFC, 'V'),
+    (0x1C38, 'X'),
+    (0x1C3B, 'V'),
+    (0x1C4A, 'X'),
+    (0x1C4D, 'V'),
+    (0x1C80, 'M', 'в'),
+    ]
+
+def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1C81, 'M', 'д'),
+    (0x1C82, 'M', 'о'),
+    (0x1C83, 'M', 'с'),
+    (0x1C84, 'M', 'т'),
+    (0x1C86, 'M', 'ъ'),
+    (0x1C87, 'M', 'ѣ'),
+    (0x1C88, 'M', 'ꙋ'),
+    (0x1C89, 'X'),
+    (0x1C90, 'M', 'ა'),
+    (0x1C91, 'M', 'ბ'),
+    (0x1C92, 'M', 'გ'),
+    (0x1C93, 'M', 'დ'),
+    (0x1C94, 'M', 'ე'),
+    (0x1C95, 'M', 'ვ'),
+    (0x1C96, 'M', 'ზ'),
+    (0x1C97, 'M', 'თ'),
+    (0x1C98, 'M', 'ი'),
+    (0x1C99, 'M', 'კ'),
+    (0x1C9A, 'M', 'ლ'),
+    (0x1C9B, 'M', 'მ'),
+    (0x1C9C, 'M', 'ნ'),
+    (0x1C9D, 'M', 'ო'),
+    (0x1C9E, 'M', 'პ'),
+    (0x1C9F, 'M', 'ჟ'),
+    (0x1CA0, 'M', 'რ'),
+    (0x1CA1, 'M', 'ს'),
+    (0x1CA2, 'M', 'ტ'),
+    (0x1CA3, 'M', 'უ'),
+    (0x1CA4, 'M', 'ფ'),
+    (0x1CA5, 'M', 'ქ'),
+    (0x1CA6, 'M', 'ღ'),
+    (0x1CA7, 'M', 'ყ'),
+    (0x1CA8, 'M', 'შ'),
+    (0x1CA9, 'M', 'ჩ'),
+    (0x1CAA, 'M', 'ც'),
+    (0x1CAB, 'M', 'ძ'),
+    (0x1CAC, 'M', 'წ'),
+    (0x1CAD, 'M', 'ჭ'),
+    (0x1CAE, 'M', 'ხ'),
+    (0x1CAF, 'M', 'ჯ'),
+    (0x1CB0, 'M', 'ჰ'),
+    (0x1CB1, 'M', 'ჱ'),
+    (0x1CB2, 'M', 'ჲ'),
+    (0x1CB3, 'M', 'ჳ'),
+    (0x1CB4, 'M', 'ჴ'),
+    (0x1CB5, 'M', 'ჵ'),
+    (0x1CB6, 'M', 'ჶ'),
+    (0x1CB7, 'M', 'ჷ'),
+    (0x1CB8, 'M', 'ჸ'),
+    (0x1CB9, 'M', 'ჹ'),
+    (0x1CBA, 'M', 'ჺ'),
+    (0x1CBB, 'X'),
+    (0x1CBD, 'M', 'ჽ'),
+    (0x1CBE, 'M', 'ჾ'),
+    (0x1CBF, 'M', 'ჿ'),
+    (0x1CC0, 'V'),
+    (0x1CC8, 'X'),
+    (0x1CD0, 'V'),
+    (0x1CFB, 'X'),
+    (0x1D00, 'V'),
+    (0x1D2C, 'M', 'a'),
+    (0x1D2D, 'M', 'æ'),
+    (0x1D2E, 'M', 'b'),
+    (0x1D2F, 'V'),
+    (0x1D30, 'M', 'd'),
+    (0x1D31, 'M', 'e'),
+    (0x1D32, 'M', 'ǝ'),
+    (0x1D33, 'M', 'g'),
+    (0x1D34, 'M', 'h'),
+    (0x1D35, 'M', 'i'),
+    (0x1D36, 'M', 'j'),
+    (0x1D37, 'M', 'k'),
+    (0x1D38, 'M', 'l'),
+    (0x1D39, 'M', 'm'),
+    (0x1D3A, 'M', 'n'),
+    (0x1D3B, 'V'),
+    (0x1D3C, 'M', 'o'),
+    (0x1D3D, 'M', 'ȣ'),
+    (0x1D3E, 'M', 'p'),
+    (0x1D3F, 'M', 'r'),
+    (0x1D40, 'M', 't'),
+    (0x1D41, 'M', 'u'),
+    (0x1D42, 'M', 'w'),
+    (0x1D43, 'M', 'a'),
+    (0x1D44, 'M', 'ɐ'),
+    (0x1D45, 'M', 'ɑ'),
+    (0x1D46, 'M', 'ᴂ'),
+    (0x1D47, 'M', 'b'),
+    (0x1D48, 'M', 'd'),
+    (0x1D49, 'M', 'e'),
+    (0x1D4A, 'M', 'ə'),
+    (0x1D4B, 'M', 'ɛ'),
+    (0x1D4C, 'M', 'ɜ'),
+    (0x1D4D, 'M', 'g'),
+    (0x1D4E, 'V'),
+    (0x1D4F, 'M', 'k'),
+    (0x1D50, 'M', 'm'),
+    (0x1D51, 'M', 'ŋ'),
+    (0x1D52, 'M', 'o'),
+    (0x1D53, 'M', 'ɔ'),
+    ]
+
+def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D54, 'M', 'ᴖ'),
+    (0x1D55, 'M', 'ᴗ'),
+    (0x1D56, 'M', 'p'),
+    (0x1D57, 'M', 't'),
+    (0x1D58, 'M', 'u'),
+    (0x1D59, 'M', 'ᴝ'),
+    (0x1D5A, 'M', 'ɯ'),
+    (0x1D5B, 'M', 'v'),
+    (0x1D5C, 'M', 'ᴥ'),
+    (0x1D5D, 'M', 'β'),
+    (0x1D5E, 'M', 'γ'),
+    (0x1D5F, 'M', 'δ'),
+    (0x1D60, 'M', 'φ'),
+    (0x1D61, 'M', 'χ'),
+    (0x1D62, 'M', 'i'),
+    (0x1D63, 'M', 'r'),
+    (0x1D64, 'M', 'u'),
+    (0x1D65, 'M', 'v'),
+    (0x1D66, 'M', 'β'),
+    (0x1D67, 'M', 'γ'),
+    (0x1D68, 'M', 'ρ'),
+    (0x1D69, 'M', 'φ'),
+    (0x1D6A, 'M', 'χ'),
+    (0x1D6B, 'V'),
+    (0x1D78, 'M', 'н'),
+    (0x1D79, 'V'),
+    (0x1D9B, 'M', 'ɒ'),
+    (0x1D9C, 'M', 'c'),
+    (0x1D9D, 'M', 'ɕ'),
+    (0x1D9E, 'M', 'ð'),
+    (0x1D9F, 'M', 'ɜ'),
+    (0x1DA0, 'M', 'f'),
+    (0x1DA1, 'M', 'ɟ'),
+    (0x1DA2, 'M', 'ɡ'),
+    (0x1DA3, 'M', 'ɥ'),
+    (0x1DA4, 'M', 'ɨ'),
+    (0x1DA5, 'M', 'ɩ'),
+    (0x1DA6, 'M', 'ɪ'),
+    (0x1DA7, 'M', 'ᵻ'),
+    (0x1DA8, 'M', 'ʝ'),
+    (0x1DA9, 'M', 'ɭ'),
+    (0x1DAA, 'M', 'ᶅ'),
+    (0x1DAB, 'M', 'ʟ'),
+    (0x1DAC, 'M', 'ɱ'),
+    (0x1DAD, 'M', 'ɰ'),
+    (0x1DAE, 'M', 'ɲ'),
+    (0x1DAF, 'M', 'ɳ'),
+    (0x1DB0, 'M', 'ɴ'),
+    (0x1DB1, 'M', 'ɵ'),
+    (0x1DB2, 'M', 'ɸ'),
+    (0x1DB3, 'M', 'ʂ'),
+    (0x1DB4, 'M', 'ʃ'),
+    (0x1DB5, 'M', 'ƫ'),
+    (0x1DB6, 'M', 'ʉ'),
+    (0x1DB7, 'M', 'ʊ'),
+    (0x1DB8, 'M', 'ᴜ'),
+    (0x1DB9, 'M', 'ʋ'),
+    (0x1DBA, 'M', 'ʌ'),
+    (0x1DBB, 'M', 'z'),
+    (0x1DBC, 'M', 'ʐ'),
+    (0x1DBD, 'M', 'ʑ'),
+    (0x1DBE, 'M', 'ʒ'),
+    (0x1DBF, 'M', 'θ'),
+    (0x1DC0, 'V'),
+    (0x1E00, 'M', 'ḁ'),
+    (0x1E01, 'V'),
+    (0x1E02, 'M', 'ḃ'),
+    (0x1E03, 'V'),
+    (0x1E04, 'M', 'ḅ'),
+    (0x1E05, 'V'),
+    (0x1E06, 'M', 'ḇ'),
+    (0x1E07, 'V'),
+    (0x1E08, 'M', 'ḉ'),
+    (0x1E09, 'V'),
+    (0x1E0A, 'M', 'ḋ'),
+    (0x1E0B, 'V'),
+    (0x1E0C, 'M', 'ḍ'),
+    (0x1E0D, 'V'),
+    (0x1E0E, 'M', 'ḏ'),
+    (0x1E0F, 'V'),
+    (0x1E10, 'M', 'ḑ'),
+    (0x1E11, 'V'),
+    (0x1E12, 'M', 'ḓ'),
+    (0x1E13, 'V'),
+    (0x1E14, 'M', 'ḕ'),
+    (0x1E15, 'V'),
+    (0x1E16, 'M', 'ḗ'),
+    (0x1E17, 'V'),
+    (0x1E18, 'M', 'ḙ'),
+    (0x1E19, 'V'),
+    (0x1E1A, 'M', 'ḛ'),
+    (0x1E1B, 'V'),
+    (0x1E1C, 'M', 'ḝ'),
+    (0x1E1D, 'V'),
+    (0x1E1E, 'M', 'ḟ'),
+    (0x1E1F, 'V'),
+    (0x1E20, 'M', 'ḡ'),
+    (0x1E21, 'V'),
+    (0x1E22, 'M', 'ḣ'),
+    (0x1E23, 'V'),
+    ]
+
+def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E24, 'M', 'ḥ'),
+    (0x1E25, 'V'),
+    (0x1E26, 'M', 'ḧ'),
+    (0x1E27, 'V'),
+    (0x1E28, 'M', 'ḩ'),
+    (0x1E29, 'V'),
+    (0x1E2A, 'M', 'ḫ'),
+    (0x1E2B, 'V'),
+    (0x1E2C, 'M', 'ḭ'),
+    (0x1E2D, 'V'),
+    (0x1E2E, 'M', 'ḯ'),
+    (0x1E2F, 'V'),
+    (0x1E30, 'M', 'ḱ'),
+    (0x1E31, 'V'),
+    (0x1E32, 'M', 'ḳ'),
+    (0x1E33, 'V'),
+    (0x1E34, 'M', 'ḵ'),
+    (0x1E35, 'V'),
+    (0x1E36, 'M', 'ḷ'),
+    (0x1E37, 'V'),
+    (0x1E38, 'M', 'ḹ'),
+    (0x1E39, 'V'),
+    (0x1E3A, 'M', 'ḻ'),
+    (0x1E3B, 'V'),
+    (0x1E3C, 'M', 'ḽ'),
+    (0x1E3D, 'V'),
+    (0x1E3E, 'M', 'ḿ'),
+    (0x1E3F, 'V'),
+    (0x1E40, 'M', 'ṁ'),
+    (0x1E41, 'V'),
+    (0x1E42, 'M', 'ṃ'),
+    (0x1E43, 'V'),
+    (0x1E44, 'M', 'ṅ'),
+    (0x1E45, 'V'),
+    (0x1E46, 'M', 'ṇ'),
+    (0x1E47, 'V'),
+    (0x1E48, 'M', 'ṉ'),
+    (0x1E49, 'V'),
+    (0x1E4A, 'M', 'ṋ'),
+    (0x1E4B, 'V'),
+    (0x1E4C, 'M', 'ṍ'),
+    (0x1E4D, 'V'),
+    (0x1E4E, 'M', 'ṏ'),
+    (0x1E4F, 'V'),
+    (0x1E50, 'M', 'ṑ'),
+    (0x1E51, 'V'),
+    (0x1E52, 'M', 'ṓ'),
+    (0x1E53, 'V'),
+    (0x1E54, 'M', 'ṕ'),
+    (0x1E55, 'V'),
+    (0x1E56, 'M', 'ṗ'),
+    (0x1E57, 'V'),
+    (0x1E58, 'M', 'ṙ'),
+    (0x1E59, 'V'),
+    (0x1E5A, 'M', 'ṛ'),
+    (0x1E5B, 'V'),
+    (0x1E5C, 'M', 'ṝ'),
+    (0x1E5D, 'V'),
+    (0x1E5E, 'M', 'ṟ'),
+    (0x1E5F, 'V'),
+    (0x1E60, 'M', 'ṡ'),
+    (0x1E61, 'V'),
+    (0x1E62, 'M', 'ṣ'),
+    (0x1E63, 'V'),
+    (0x1E64, 'M', 'ṥ'),
+    (0x1E65, 'V'),
+    (0x1E66, 'M', 'ṧ'),
+    (0x1E67, 'V'),
+    (0x1E68, 'M', 'ṩ'),
+    (0x1E69, 'V'),
+    (0x1E6A, 'M', 'ṫ'),
+    (0x1E6B, 'V'),
+    (0x1E6C, 'M', 'ṭ'),
+    (0x1E6D, 'V'),
+    (0x1E6E, 'M', 'ṯ'),
+    (0x1E6F, 'V'),
+    (0x1E70, 'M', 'ṱ'),
+    (0x1E71, 'V'),
+    (0x1E72, 'M', 'ṳ'),
+    (0x1E73, 'V'),
+    (0x1E74, 'M', 'ṵ'),
+    (0x1E75, 'V'),
+    (0x1E76, 'M', 'ṷ'),
+    (0x1E77, 'V'),
+    (0x1E78, 'M', 'ṹ'),
+    (0x1E79, 'V'),
+    (0x1E7A, 'M', 'ṻ'),
+    (0x1E7B, 'V'),
+    (0x1E7C, 'M', 'ṽ'),
+    (0x1E7D, 'V'),
+    (0x1E7E, 'M', 'ṿ'),
+    (0x1E7F, 'V'),
+    (0x1E80, 'M', 'ẁ'),
+    (0x1E81, 'V'),
+    (0x1E82, 'M', 'ẃ'),
+    (0x1E83, 'V'),
+    (0x1E84, 'M', 'ẅ'),
+    (0x1E85, 'V'),
+    (0x1E86, 'M', 'ẇ'),
+    (0x1E87, 'V'),
+    ]
+
+def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E88, 'M', 'ẉ'),
+    (0x1E89, 'V'),
+    (0x1E8A, 'M', 'ẋ'),
+    (0x1E8B, 'V'),
+    (0x1E8C, 'M', 'ẍ'),
+    (0x1E8D, 'V'),
+    (0x1E8E, 'M', 'ẏ'),
+    (0x1E8F, 'V'),
+    (0x1E90, 'M', 'ẑ'),
+    (0x1E91, 'V'),
+    (0x1E92, 'M', 'ẓ'),
+    (0x1E93, 'V'),
+    (0x1E94, 'M', 'ẕ'),
+    (0x1E95, 'V'),
+    (0x1E9A, 'M', 'aʾ'),
+    (0x1E9B, 'M', 'ṡ'),
+    (0x1E9C, 'V'),
+    (0x1E9E, 'M', 'ß'),
+    (0x1E9F, 'V'),
+    (0x1EA0, 'M', 'ạ'),
+    (0x1EA1, 'V'),
+    (0x1EA2, 'M', 'ả'),
+    (0x1EA3, 'V'),
+    (0x1EA4, 'M', 'ấ'),
+    (0x1EA5, 'V'),
+    (0x1EA6, 'M', 'ầ'),
+    (0x1EA7, 'V'),
+    (0x1EA8, 'M', 'ẩ'),
+    (0x1EA9, 'V'),
+    (0x1EAA, 'M', 'ẫ'),
+    (0x1EAB, 'V'),
+    (0x1EAC, 'M', 'ậ'),
+    (0x1EAD, 'V'),
+    (0x1EAE, 'M', 'ắ'),
+    (0x1EAF, 'V'),
+    (0x1EB0, 'M', 'ằ'),
+    (0x1EB1, 'V'),
+    (0x1EB2, 'M', 'ẳ'),
+    (0x1EB3, 'V'),
+    (0x1EB4, 'M', 'ẵ'),
+    (0x1EB5, 'V'),
+    (0x1EB6, 'M', 'ặ'),
+    (0x1EB7, 'V'),
+    (0x1EB8, 'M', 'ẹ'),
+    (0x1EB9, 'V'),
+    (0x1EBA, 'M', 'ẻ'),
+    (0x1EBB, 'V'),
+    (0x1EBC, 'M', 'ẽ'),
+    (0x1EBD, 'V'),
+    (0x1EBE, 'M', 'ế'),
+    (0x1EBF, 'V'),
+    (0x1EC0, 'M', 'ề'),
+    (0x1EC1, 'V'),
+    (0x1EC2, 'M', 'ể'),
+    (0x1EC3, 'V'),
+    (0x1EC4, 'M', 'ễ'),
+    (0x1EC5, 'V'),
+    (0x1EC6, 'M', 'ệ'),
+    (0x1EC7, 'V'),
+    (0x1EC8, 'M', 'ỉ'),
+    (0x1EC9, 'V'),
+    (0x1ECA, 'M', 'ị'),
+    (0x1ECB, 'V'),
+    (0x1ECC, 'M', 'ọ'),
+    (0x1ECD, 'V'),
+    (0x1ECE, 'M', 'ỏ'),
+    (0x1ECF, 'V'),
+    (0x1ED0, 'M', 'ố'),
+    (0x1ED1, 'V'),
+    (0x1ED2, 'M', 'ồ'),
+    (0x1ED3, 'V'),
+    (0x1ED4, 'M', 'ổ'),
+    (0x1ED5, 'V'),
+    (0x1ED6, 'M', 'ỗ'),
+    (0x1ED7, 'V'),
+    (0x1ED8, 'M', 'ộ'),
+    (0x1ED9, 'V'),
+    (0x1EDA, 'M', 'ớ'),
+    (0x1EDB, 'V'),
+    (0x1EDC, 'M', 'ờ'),
+    (0x1EDD, 'V'),
+    (0x1EDE, 'M', 'ở'),
+    (0x1EDF, 'V'),
+    (0x1EE0, 'M', 'ỡ'),
+    (0x1EE1, 'V'),
+    (0x1EE2, 'M', 'ợ'),
+    (0x1EE3, 'V'),
+    (0x1EE4, 'M', 'ụ'),
+    (0x1EE5, 'V'),
+    (0x1EE6, 'M', 'ủ'),
+    (0x1EE7, 'V'),
+    (0x1EE8, 'M', 'ứ'),
+    (0x1EE9, 'V'),
+    (0x1EEA, 'M', 'ừ'),
+    (0x1EEB, 'V'),
+    (0x1EEC, 'M', 'ử'),
+    (0x1EED, 'V'),
+    (0x1EEE, 'M', 'ữ'),
+    (0x1EEF, 'V'),
+    (0x1EF0, 'M', 'ự'),
+    ]
+
+def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EF1, 'V'),
+    (0x1EF2, 'M', 'ỳ'),
+    (0x1EF3, 'V'),
+    (0x1EF4, 'M', 'ỵ'),
+    (0x1EF5, 'V'),
+    (0x1EF6, 'M', 'ỷ'),
+    (0x1EF7, 'V'),
+    (0x1EF8, 'M', 'ỹ'),
+    (0x1EF9, 'V'),
+    (0x1EFA, 'M', 'ỻ'),
+    (0x1EFB, 'V'),
+    (0x1EFC, 'M', 'ỽ'),
+    (0x1EFD, 'V'),
+    (0x1EFE, 'M', 'ỿ'),
+    (0x1EFF, 'V'),
+    (0x1F08, 'M', 'ἀ'),
+    (0x1F09, 'M', 'ἁ'),
+    (0x1F0A, 'M', 'ἂ'),
+    (0x1F0B, 'M', 'ἃ'),
+    (0x1F0C, 'M', 'ἄ'),
+    (0x1F0D, 'M', 'ἅ'),
+    (0x1F0E, 'M', 'ἆ'),
+    (0x1F0F, 'M', 'ἇ'),
+    (0x1F10, 'V'),
+    (0x1F16, 'X'),
+    (0x1F18, 'M', 'ἐ'),
+    (0x1F19, 'M', 'ἑ'),
+    (0x1F1A, 'M', 'ἒ'),
+    (0x1F1B, 'M', 'ἓ'),
+    (0x1F1C, 'M', 'ἔ'),
+    (0x1F1D, 'M', 'ἕ'),
+    (0x1F1E, 'X'),
+    (0x1F20, 'V'),
+    (0x1F28, 'M', 'ἠ'),
+    (0x1F29, 'M', 'ἡ'),
+    (0x1F2A, 'M', 'ἢ'),
+    (0x1F2B, 'M', 'ἣ'),
+    (0x1F2C, 'M', 'ἤ'),
+    (0x1F2D, 'M', 'ἥ'),
+    (0x1F2E, 'M', 'ἦ'),
+    (0x1F2F, 'M', 'ἧ'),
+    (0x1F30, 'V'),
+    (0x1F38, 'M', 'ἰ'),
+    (0x1F39, 'M', 'ἱ'),
+    (0x1F3A, 'M', 'ἲ'),
+    (0x1F3B, 'M', 'ἳ'),
+    (0x1F3C, 'M', 'ἴ'),
+    (0x1F3D, 'M', 'ἵ'),
+    (0x1F3E, 'M', 'ἶ'),
+    (0x1F3F, 'M', 'ἷ'),
+    (0x1F40, 'V'),
+    (0x1F46, 'X'),
+    (0x1F48, 'M', 'ὀ'),
+    (0x1F49, 'M', 'ὁ'),
+    (0x1F4A, 'M', 'ὂ'),
+    (0x1F4B, 'M', 'ὃ'),
+    (0x1F4C, 'M', 'ὄ'),
+    (0x1F4D, 'M', 'ὅ'),
+    (0x1F4E, 'X'),
+    (0x1F50, 'V'),
+    (0x1F58, 'X'),
+    (0x1F59, 'M', 'ὑ'),
+    (0x1F5A, 'X'),
+    (0x1F5B, 'M', 'ὓ'),
+    (0x1F5C, 'X'),
+    (0x1F5D, 'M', 'ὕ'),
+    (0x1F5E, 'X'),
+    (0x1F5F, 'M', 'ὗ'),
+    (0x1F60, 'V'),
+    (0x1F68, 'M', 'ὠ'),
+    (0x1F69, 'M', 'ὡ'),
+    (0x1F6A, 'M', 'ὢ'),
+    (0x1F6B, 'M', 'ὣ'),
+    (0x1F6C, 'M', 'ὤ'),
+    (0x1F6D, 'M', 'ὥ'),
+    (0x1F6E, 'M', 'ὦ'),
+    (0x1F6F, 'M', 'ὧ'),
+    (0x1F70, 'V'),
+    (0x1F71, 'M', 'ά'),
+    (0x1F72, 'V'),
+    (0x1F73, 'M', 'έ'),
+    (0x1F74, 'V'),
+    (0x1F75, 'M', 'ή'),
+    (0x1F76, 'V'),
+    (0x1F77, 'M', 'ί'),
+    (0x1F78, 'V'),
+    (0x1F79, 'M', 'ό'),
+    (0x1F7A, 'V'),
+    (0x1F7B, 'M', 'ύ'),
+    (0x1F7C, 'V'),
+    (0x1F7D, 'M', 'ώ'),
+    (0x1F7E, 'X'),
+    (0x1F80, 'M', 'ἀι'),
+    (0x1F81, 'M', 'ἁι'),
+    (0x1F82, 'M', 'ἂι'),
+    (0x1F83, 'M', 'ἃι'),
+    (0x1F84, 'M', 'ἄι'),
+    (0x1F85, 'M', 'ἅι'),
+    (0x1F86, 'M', 'ἆι'),
+    (0x1F87, 'M', 'ἇι'),
+    ]
+
+def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1F88, 'M', 'ἀι'),
+    (0x1F89, 'M', 'ἁι'),
+    (0x1F8A, 'M', 'ἂι'),
+    (0x1F8B, 'M', 'ἃι'),
+    (0x1F8C, 'M', 'ἄι'),
+    (0x1F8D, 'M', 'ἅι'),
+    (0x1F8E, 'M', 'ἆι'),
+    (0x1F8F, 'M', 'ἇι'),
+    (0x1F90, 'M', 'ἠι'),
+    (0x1F91, 'M', 'ἡι'),
+    (0x1F92, 'M', 'ἢι'),
+    (0x1F93, 'M', 'ἣι'),
+    (0x1F94, 'M', 'ἤι'),
+    (0x1F95, 'M', 'ἥι'),
+    (0x1F96, 'M', 'ἦι'),
+    (0x1F97, 'M', 'ἧι'),
+    (0x1F98, 'M', 'ἠι'),
+    (0x1F99, 'M', 'ἡι'),
+    (0x1F9A, 'M', 'ἢι'),
+    (0x1F9B, 'M', 'ἣι'),
+    (0x1F9C, 'M', 'ἤι'),
+    (0x1F9D, 'M', 'ἥι'),
+    (0x1F9E, 'M', 'ἦι'),
+    (0x1F9F, 'M', 'ἧι'),
+    (0x1FA0, 'M', 'ὠι'),
+    (0x1FA1, 'M', 'ὡι'),
+    (0x1FA2, 'M', 'ὢι'),
+    (0x1FA3, 'M', 'ὣι'),
+    (0x1FA4, 'M', 'ὤι'),
+    (0x1FA5, 'M', 'ὥι'),
+    (0x1FA6, 'M', 'ὦι'),
+    (0x1FA7, 'M', 'ὧι'),
+    (0x1FA8, 'M', 'ὠι'),
+    (0x1FA9, 'M', 'ὡι'),
+    (0x1FAA, 'M', 'ὢι'),
+    (0x1FAB, 'M', 'ὣι'),
+    (0x1FAC, 'M', 'ὤι'),
+    (0x1FAD, 'M', 'ὥι'),
+    (0x1FAE, 'M', 'ὦι'),
+    (0x1FAF, 'M', 'ὧι'),
+    (0x1FB0, 'V'),
+    (0x1FB2, 'M', 'ὰι'),
+    (0x1FB3, 'M', 'αι'),
+    (0x1FB4, 'M', 'άι'),
+    (0x1FB5, 'X'),
+    (0x1FB6, 'V'),
+    (0x1FB7, 'M', 'ᾶι'),
+    (0x1FB8, 'M', 'ᾰ'),
+    (0x1FB9, 'M', 'ᾱ'),
+    (0x1FBA, 'M', 'ὰ'),
+    (0x1FBB, 'M', 'ά'),
+    (0x1FBC, 'M', 'αι'),
+    (0x1FBD, '3', ' ̓'),
+    (0x1FBE, 'M', 'ι'),
+    (0x1FBF, '3', ' ̓'),
+    (0x1FC0, '3', ' ͂'),
+    (0x1FC1, '3', ' ̈͂'),
+    (0x1FC2, 'M', 'ὴι'),
+    (0x1FC3, 'M', 'ηι'),
+    (0x1FC4, 'M', 'ήι'),
+    (0x1FC5, 'X'),
+    (0x1FC6, 'V'),
+    (0x1FC7, 'M', 'ῆι'),
+    (0x1FC8, 'M', 'ὲ'),
+    (0x1FC9, 'M', 'έ'),
+    (0x1FCA, 'M', 'ὴ'),
+    (0x1FCB, 'M', 'ή'),
+    (0x1FCC, 'M', 'ηι'),
+    (0x1FCD, '3', ' ̓̀'),
+    (0x1FCE, '3', ' ̓́'),
+    (0x1FCF, '3', ' ̓͂'),
+    (0x1FD0, 'V'),
+    (0x1FD3, 'M', 'ΐ'),
+    (0x1FD4, 'X'),
+    (0x1FD6, 'V'),
+    (0x1FD8, 'M', 'ῐ'),
+    (0x1FD9, 'M', 'ῑ'),
+    (0x1FDA, 'M', 'ὶ'),
+    (0x1FDB, 'M', 'ί'),
+    (0x1FDC, 'X'),
+    (0x1FDD, '3', ' ̔̀'),
+    (0x1FDE, '3', ' ̔́'),
+    (0x1FDF, '3', ' ̔͂'),
+    (0x1FE0, 'V'),
+    (0x1FE3, 'M', 'ΰ'),
+    (0x1FE4, 'V'),
+    (0x1FE8, 'M', 'ῠ'),
+    (0x1FE9, 'M', 'ῡ'),
+    (0x1FEA, 'M', 'ὺ'),
+    (0x1FEB, 'M', 'ύ'),
+    (0x1FEC, 'M', 'ῥ'),
+    (0x1FED, '3', ' ̈̀'),
+    (0x1FEE, '3', ' ̈́'),
+    (0x1FEF, '3', '`'),
+    (0x1FF0, 'X'),
+    (0x1FF2, 'M', 'ὼι'),
+    (0x1FF3, 'M', 'ωι'),
+    (0x1FF4, 'M', 'ώι'),
+    (0x1FF5, 'X'),
+    (0x1FF6, 'V'),
+    ]
+
+def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1FF7, 'M', 'ῶι'),
+    (0x1FF8, 'M', 'ὸ'),
+    (0x1FF9, 'M', 'ό'),
+    (0x1FFA, 'M', 'ὼ'),
+    (0x1FFB, 'M', 'ώ'),
+    (0x1FFC, 'M', 'ωι'),
+    (0x1FFD, '3', ' ́'),
+    (0x1FFE, '3', ' ̔'),
+    (0x1FFF, 'X'),
+    (0x2000, '3', ' '),
+    (0x200B, 'I'),
+    (0x200C, 'D', ''),
+    (0x200E, 'X'),
+    (0x2010, 'V'),
+    (0x2011, 'M', '‐'),
+    (0x2012, 'V'),
+    (0x2017, '3', ' ̳'),
+    (0x2018, 'V'),
+    (0x2024, 'X'),
+    (0x2027, 'V'),
+    (0x2028, 'X'),
+    (0x202F, '3', ' '),
+    (0x2030, 'V'),
+    (0x2033, 'M', '′′'),
+    (0x2034, 'M', '′′′'),
+    (0x2035, 'V'),
+    (0x2036, 'M', '‵‵'),
+    (0x2037, 'M', '‵‵‵'),
+    (0x2038, 'V'),
+    (0x203C, '3', '!!'),
+    (0x203D, 'V'),
+    (0x203E, '3', ' ̅'),
+    (0x203F, 'V'),
+    (0x2047, '3', '??'),
+    (0x2048, '3', '?!'),
+    (0x2049, '3', '!?'),
+    (0x204A, 'V'),
+    (0x2057, 'M', '′′′′'),
+    (0x2058, 'V'),
+    (0x205F, '3', ' '),
+    (0x2060, 'I'),
+    (0x2061, 'X'),
+    (0x2064, 'I'),
+    (0x2065, 'X'),
+    (0x2070, 'M', '0'),
+    (0x2071, 'M', 'i'),
+    (0x2072, 'X'),
+    (0x2074, 'M', '4'),
+    (0x2075, 'M', '5'),
+    (0x2076, 'M', '6'),
+    (0x2077, 'M', '7'),
+    (0x2078, 'M', '8'),
+    (0x2079, 'M', '9'),
+    (0x207A, '3', '+'),
+    (0x207B, 'M', '−'),
+    (0x207C, '3', '='),
+    (0x207D, '3', '('),
+    (0x207E, '3', ')'),
+    (0x207F, 'M', 'n'),
+    (0x2080, 'M', '0'),
+    (0x2081, 'M', '1'),
+    (0x2082, 'M', '2'),
+    (0x2083, 'M', '3'),
+    (0x2084, 'M', '4'),
+    (0x2085, 'M', '5'),
+    (0x2086, 'M', '6'),
+    (0x2087, 'M', '7'),
+    (0x2088, 'M', '8'),
+    (0x2089, 'M', '9'),
+    (0x208A, '3', '+'),
+    (0x208B, 'M', '−'),
+    (0x208C, '3', '='),
+    (0x208D, '3', '('),
+    (0x208E, '3', ')'),
+    (0x208F, 'X'),
+    (0x2090, 'M', 'a'),
+    (0x2091, 'M', 'e'),
+    (0x2092, 'M', 'o'),
+    (0x2093, 'M', 'x'),
+    (0x2094, 'M', 'ə'),
+    (0x2095, 'M', 'h'),
+    (0x2096, 'M', 'k'),
+    (0x2097, 'M', 'l'),
+    (0x2098, 'M', 'm'),
+    (0x2099, 'M', 'n'),
+    (0x209A, 'M', 'p'),
+    (0x209B, 'M', 's'),
+    (0x209C, 'M', 't'),
+    (0x209D, 'X'),
+    (0x20A0, 'V'),
+    (0x20A8, 'M', 'rs'),
+    (0x20A9, 'V'),
+    (0x20C1, 'X'),
+    (0x20D0, 'V'),
+    (0x20F1, 'X'),
+    (0x2100, '3', 'a/c'),
+    (0x2101, '3', 'a/s'),
+    (0x2102, 'M', 'c'),
+    (0x2103, 'M', '°c'),
+    (0x2104, 'V'),
+    ]
+
+def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2105, '3', 'c/o'),
+    (0x2106, '3', 'c/u'),
+    (0x2107, 'M', 'ɛ'),
+    (0x2108, 'V'),
+    (0x2109, 'M', '°f'),
+    (0x210A, 'M', 'g'),
+    (0x210B, 'M', 'h'),
+    (0x210F, 'M', 'ħ'),
+    (0x2110, 'M', 'i'),
+    (0x2112, 'M', 'l'),
+    (0x2114, 'V'),
+    (0x2115, 'M', 'n'),
+    (0x2116, 'M', 'no'),
+    (0x2117, 'V'),
+    (0x2119, 'M', 'p'),
+    (0x211A, 'M', 'q'),
+    (0x211B, 'M', 'r'),
+    (0x211E, 'V'),
+    (0x2120, 'M', 'sm'),
+    (0x2121, 'M', 'tel'),
+    (0x2122, 'M', 'tm'),
+    (0x2123, 'V'),
+    (0x2124, 'M', 'z'),
+    (0x2125, 'V'),
+    (0x2126, 'M', 'ω'),
+    (0x2127, 'V'),
+    (0x2128, 'M', 'z'),
+    (0x2129, 'V'),
+    (0x212A, 'M', 'k'),
+    (0x212B, 'M', 'å'),
+    (0x212C, 'M', 'b'),
+    (0x212D, 'M', 'c'),
+    (0x212E, 'V'),
+    (0x212F, 'M', 'e'),
+    (0x2131, 'M', 'f'),
+    (0x2132, 'X'),
+    (0x2133, 'M', 'm'),
+    (0x2134, 'M', 'o'),
+    (0x2135, 'M', 'א'),
+    (0x2136, 'M', 'ב'),
+    (0x2137, 'M', 'ג'),
+    (0x2138, 'M', 'ד'),
+    (0x2139, 'M', 'i'),
+    (0x213A, 'V'),
+    (0x213B, 'M', 'fax'),
+    (0x213C, 'M', 'π'),
+    (0x213D, 'M', 'γ'),
+    (0x213F, 'M', 'π'),
+    (0x2140, 'M', '∑'),
+    (0x2141, 'V'),
+    (0x2145, 'M', 'd'),
+    (0x2147, 'M', 'e'),
+    (0x2148, 'M', 'i'),
+    (0x2149, 'M', 'j'),
+    (0x214A, 'V'),
+    (0x2150, 'M', '1⁄7'),
+    (0x2151, 'M', '1⁄9'),
+    (0x2152, 'M', '1⁄10'),
+    (0x2153, 'M', '1⁄3'),
+    (0x2154, 'M', '2⁄3'),
+    (0x2155, 'M', '1⁄5'),
+    (0x2156, 'M', '2⁄5'),
+    (0x2157, 'M', '3⁄5'),
+    (0x2158, 'M', '4⁄5'),
+    (0x2159, 'M', '1⁄6'),
+    (0x215A, 'M', '5⁄6'),
+    (0x215B, 'M', '1⁄8'),
+    (0x215C, 'M', '3⁄8'),
+    (0x215D, 'M', '5⁄8'),
+    (0x215E, 'M', '7⁄8'),
+    (0x215F, 'M', '1⁄'),
+    (0x2160, 'M', 'i'),
+    (0x2161, 'M', 'ii'),
+    (0x2162, 'M', 'iii'),
+    (0x2163, 'M', 'iv'),
+    (0x2164, 'M', 'v'),
+    (0x2165, 'M', 'vi'),
+    (0x2166, 'M', 'vii'),
+    (0x2167, 'M', 'viii'),
+    (0x2168, 'M', 'ix'),
+    (0x2169, 'M', 'x'),
+    (0x216A, 'M', 'xi'),
+    (0x216B, 'M', 'xii'),
+    (0x216C, 'M', 'l'),
+    (0x216D, 'M', 'c'),
+    (0x216E, 'M', 'd'),
+    (0x216F, 'M', 'm'),
+    (0x2170, 'M', 'i'),
+    (0x2171, 'M', 'ii'),
+    (0x2172, 'M', 'iii'),
+    (0x2173, 'M', 'iv'),
+    (0x2174, 'M', 'v'),
+    (0x2175, 'M', 'vi'),
+    (0x2176, 'M', 'vii'),
+    (0x2177, 'M', 'viii'),
+    (0x2178, 'M', 'ix'),
+    (0x2179, 'M', 'x'),
+    (0x217A, 'M', 'xi'),
+    (0x217B, 'M', 'xii'),
+    (0x217C, 'M', 'l'),
+    ]
+
+def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x217D, 'M', 'c'),
+    (0x217E, 'M', 'd'),
+    (0x217F, 'M', 'm'),
+    (0x2180, 'V'),
+    (0x2183, 'X'),
+    (0x2184, 'V'),
+    (0x2189, 'M', '0⁄3'),
+    (0x218A, 'V'),
+    (0x218C, 'X'),
+    (0x2190, 'V'),
+    (0x222C, 'M', '∫∫'),
+    (0x222D, 'M', '∫∫∫'),
+    (0x222E, 'V'),
+    (0x222F, 'M', '∮∮'),
+    (0x2230, 'M', '∮∮∮'),
+    (0x2231, 'V'),
+    (0x2329, 'M', '〈'),
+    (0x232A, 'M', '〉'),
+    (0x232B, 'V'),
+    (0x2427, 'X'),
+    (0x2440, 'V'),
+    (0x244B, 'X'),
+    (0x2460, 'M', '1'),
+    (0x2461, 'M', '2'),
+    (0x2462, 'M', '3'),
+    (0x2463, 'M', '4'),
+    (0x2464, 'M', '5'),
+    (0x2465, 'M', '6'),
+    (0x2466, 'M', '7'),
+    (0x2467, 'M', '8'),
+    (0x2468, 'M', '9'),
+    (0x2469, 'M', '10'),
+    (0x246A, 'M', '11'),
+    (0x246B, 'M', '12'),
+    (0x246C, 'M', '13'),
+    (0x246D, 'M', '14'),
+    (0x246E, 'M', '15'),
+    (0x246F, 'M', '16'),
+    (0x2470, 'M', '17'),
+    (0x2471, 'M', '18'),
+    (0x2472, 'M', '19'),
+    (0x2473, 'M', '20'),
+    (0x2474, '3', '(1)'),
+    (0x2475, '3', '(2)'),
+    (0x2476, '3', '(3)'),
+    (0x2477, '3', '(4)'),
+    (0x2478, '3', '(5)'),
+    (0x2479, '3', '(6)'),
+    (0x247A, '3', '(7)'),
+    (0x247B, '3', '(8)'),
+    (0x247C, '3', '(9)'),
+    (0x247D, '3', '(10)'),
+    (0x247E, '3', '(11)'),
+    (0x247F, '3', '(12)'),
+    (0x2480, '3', '(13)'),
+    (0x2481, '3', '(14)'),
+    (0x2482, '3', '(15)'),
+    (0x2483, '3', '(16)'),
+    (0x2484, '3', '(17)'),
+    (0x2485, '3', '(18)'),
+    (0x2486, '3', '(19)'),
+    (0x2487, '3', '(20)'),
+    (0x2488, 'X'),
+    (0x249C, '3', '(a)'),
+    (0x249D, '3', '(b)'),
+    (0x249E, '3', '(c)'),
+    (0x249F, '3', '(d)'),
+    (0x24A0, '3', '(e)'),
+    (0x24A1, '3', '(f)'),
+    (0x24A2, '3', '(g)'),
+    (0x24A3, '3', '(h)'),
+    (0x24A4, '3', '(i)'),
+    (0x24A5, '3', '(j)'),
+    (0x24A6, '3', '(k)'),
+    (0x24A7, '3', '(l)'),
+    (0x24A8, '3', '(m)'),
+    (0x24A9, '3', '(n)'),
+    (0x24AA, '3', '(o)'),
+    (0x24AB, '3', '(p)'),
+    (0x24AC, '3', '(q)'),
+    (0x24AD, '3', '(r)'),
+    (0x24AE, '3', '(s)'),
+    (0x24AF, '3', '(t)'),
+    (0x24B0, '3', '(u)'),
+    (0x24B1, '3', '(v)'),
+    (0x24B2, '3', '(w)'),
+    (0x24B3, '3', '(x)'),
+    (0x24B4, '3', '(y)'),
+    (0x24B5, '3', '(z)'),
+    (0x24B6, 'M', 'a'),
+    (0x24B7, 'M', 'b'),
+    (0x24B8, 'M', 'c'),
+    (0x24B9, 'M', 'd'),
+    (0x24BA, 'M', 'e'),
+    (0x24BB, 'M', 'f'),
+    (0x24BC, 'M', 'g'),
+    (0x24BD, 'M', 'h'),
+    (0x24BE, 'M', 'i'),
+    (0x24BF, 'M', 'j'),
+    (0x24C0, 'M', 'k'),
+    ]
+
+def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x24C1, 'M', 'l'),
+    (0x24C2, 'M', 'm'),
+    (0x24C3, 'M', 'n'),
+    (0x24C4, 'M', 'o'),
+    (0x24C5, 'M', 'p'),
+    (0x24C6, 'M', 'q'),
+    (0x24C7, 'M', 'r'),
+    (0x24C8, 'M', 's'),
+    (0x24C9, 'M', 't'),
+    (0x24CA, 'M', 'u'),
+    (0x24CB, 'M', 'v'),
+    (0x24CC, 'M', 'w'),
+    (0x24CD, 'M', 'x'),
+    (0x24CE, 'M', 'y'),
+    (0x24CF, 'M', 'z'),
+    (0x24D0, 'M', 'a'),
+    (0x24D1, 'M', 'b'),
+    (0x24D2, 'M', 'c'),
+    (0x24D3, 'M', 'd'),
+    (0x24D4, 'M', 'e'),
+    (0x24D5, 'M', 'f'),
+    (0x24D6, 'M', 'g'),
+    (0x24D7, 'M', 'h'),
+    (0x24D8, 'M', 'i'),
+    (0x24D9, 'M', 'j'),
+    (0x24DA, 'M', 'k'),
+    (0x24DB, 'M', 'l'),
+    (0x24DC, 'M', 'm'),
+    (0x24DD, 'M', 'n'),
+    (0x24DE, 'M', 'o'),
+    (0x24DF, 'M', 'p'),
+    (0x24E0, 'M', 'q'),
+    (0x24E1, 'M', 'r'),
+    (0x24E2, 'M', 's'),
+    (0x24E3, 'M', 't'),
+    (0x24E4, 'M', 'u'),
+    (0x24E5, 'M', 'v'),
+    (0x24E6, 'M', 'w'),
+    (0x24E7, 'M', 'x'),
+    (0x24E8, 'M', 'y'),
+    (0x24E9, 'M', 'z'),
+    (0x24EA, 'M', '0'),
+    (0x24EB, 'V'),
+    (0x2A0C, 'M', '∫∫∫∫'),
+    (0x2A0D, 'V'),
+    (0x2A74, '3', '::='),
+    (0x2A75, '3', '=='),
+    (0x2A76, '3', '==='),
+    (0x2A77, 'V'),
+    (0x2ADC, 'M', '⫝̸'),
+    (0x2ADD, 'V'),
+    (0x2B74, 'X'),
+    (0x2B76, 'V'),
+    (0x2B96, 'X'),
+    (0x2B97, 'V'),
+    (0x2C00, 'M', 'ⰰ'),
+    (0x2C01, 'M', 'ⰱ'),
+    (0x2C02, 'M', 'ⰲ'),
+    (0x2C03, 'M', 'ⰳ'),
+    (0x2C04, 'M', 'ⰴ'),
+    (0x2C05, 'M', 'ⰵ'),
+    (0x2C06, 'M', 'ⰶ'),
+    (0x2C07, 'M', 'ⰷ'),
+    (0x2C08, 'M', 'ⰸ'),
+    (0x2C09, 'M', 'ⰹ'),
+    (0x2C0A, 'M', 'ⰺ'),
+    (0x2C0B, 'M', 'ⰻ'),
+    (0x2C0C, 'M', 'ⰼ'),
+    (0x2C0D, 'M', 'ⰽ'),
+    (0x2C0E, 'M', 'ⰾ'),
+    (0x2C0F, 'M', 'ⰿ'),
+    (0x2C10, 'M', 'ⱀ'),
+    (0x2C11, 'M', 'ⱁ'),
+    (0x2C12, 'M', 'ⱂ'),
+    (0x2C13, 'M', 'ⱃ'),
+    (0x2C14, 'M', 'ⱄ'),
+    (0x2C15, 'M', 'ⱅ'),
+    (0x2C16, 'M', 'ⱆ'),
+    (0x2C17, 'M', 'ⱇ'),
+    (0x2C18, 'M', 'ⱈ'),
+    (0x2C19, 'M', 'ⱉ'),
+    (0x2C1A, 'M', 'ⱊ'),
+    (0x2C1B, 'M', 'ⱋ'),
+    (0x2C1C, 'M', 'ⱌ'),
+    (0x2C1D, 'M', 'ⱍ'),
+    (0x2C1E, 'M', 'ⱎ'),
+    (0x2C1F, 'M', 'ⱏ'),
+    (0x2C20, 'M', 'ⱐ'),
+    (0x2C21, 'M', 'ⱑ'),
+    (0x2C22, 'M', 'ⱒ'),
+    (0x2C23, 'M', 'ⱓ'),
+    (0x2C24, 'M', 'ⱔ'),
+    (0x2C25, 'M', 'ⱕ'),
+    (0x2C26, 'M', 'ⱖ'),
+    (0x2C27, 'M', 'ⱗ'),
+    (0x2C28, 'M', 'ⱘ'),
+    (0x2C29, 'M', 'ⱙ'),
+    (0x2C2A, 'M', 'ⱚ'),
+    (0x2C2B, 'M', 'ⱛ'),
+    (0x2C2C, 'M', 'ⱜ'),
+    ]
+
+def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2C2D, 'M', 'ⱝ'),
+    (0x2C2E, 'M', 'ⱞ'),
+    (0x2C2F, 'M', 'ⱟ'),
+    (0x2C30, 'V'),
+    (0x2C60, 'M', 'ⱡ'),
+    (0x2C61, 'V'),
+    (0x2C62, 'M', 'ɫ'),
+    (0x2C63, 'M', 'ᵽ'),
+    (0x2C64, 'M', 'ɽ'),
+    (0x2C65, 'V'),
+    (0x2C67, 'M', 'ⱨ'),
+    (0x2C68, 'V'),
+    (0x2C69, 'M', 'ⱪ'),
+    (0x2C6A, 'V'),
+    (0x2C6B, 'M', 'ⱬ'),
+    (0x2C6C, 'V'),
+    (0x2C6D, 'M', 'ɑ'),
+    (0x2C6E, 'M', 'ɱ'),
+    (0x2C6F, 'M', 'ɐ'),
+    (0x2C70, 'M', 'ɒ'),
+    (0x2C71, 'V'),
+    (0x2C72, 'M', 'ⱳ'),
+    (0x2C73, 'V'),
+    (0x2C75, 'M', 'ⱶ'),
+    (0x2C76, 'V'),
+    (0x2C7C, 'M', 'j'),
+    (0x2C7D, 'M', 'v'),
+    (0x2C7E, 'M', 'ȿ'),
+    (0x2C7F, 'M', 'ɀ'),
+    (0x2C80, 'M', 'ⲁ'),
+    (0x2C81, 'V'),
+    (0x2C82, 'M', 'ⲃ'),
+    (0x2C83, 'V'),
+    (0x2C84, 'M', 'ⲅ'),
+    (0x2C85, 'V'),
+    (0x2C86, 'M', 'ⲇ'),
+    (0x2C87, 'V'),
+    (0x2C88, 'M', 'ⲉ'),
+    (0x2C89, 'V'),
+    (0x2C8A, 'M', 'ⲋ'),
+    (0x2C8B, 'V'),
+    (0x2C8C, 'M', 'ⲍ'),
+    (0x2C8D, 'V'),
+    (0x2C8E, 'M', 'ⲏ'),
+    (0x2C8F, 'V'),
+    (0x2C90, 'M', 'ⲑ'),
+    (0x2C91, 'V'),
+    (0x2C92, 'M', 'ⲓ'),
+    (0x2C93, 'V'),
+    (0x2C94, 'M', 'ⲕ'),
+    (0x2C95, 'V'),
+    (0x2C96, 'M', 'ⲗ'),
+    (0x2C97, 'V'),
+    (0x2C98, 'M', 'ⲙ'),
+    (0x2C99, 'V'),
+    (0x2C9A, 'M', 'ⲛ'),
+    (0x2C9B, 'V'),
+    (0x2C9C, 'M', 'ⲝ'),
+    (0x2C9D, 'V'),
+    (0x2C9E, 'M', 'ⲟ'),
+    (0x2C9F, 'V'),
+    (0x2CA0, 'M', 'ⲡ'),
+    (0x2CA1, 'V'),
+    (0x2CA2, 'M', 'ⲣ'),
+    (0x2CA3, 'V'),
+    (0x2CA4, 'M', 'ⲥ'),
+    (0x2CA5, 'V'),
+    (0x2CA6, 'M', 'ⲧ'),
+    (0x2CA7, 'V'),
+    (0x2CA8, 'M', 'ⲩ'),
+    (0x2CA9, 'V'),
+    (0x2CAA, 'M', 'ⲫ'),
+    (0x2CAB, 'V'),
+    (0x2CAC, 'M', 'ⲭ'),
+    (0x2CAD, 'V'),
+    (0x2CAE, 'M', 'ⲯ'),
+    (0x2CAF, 'V'),
+    (0x2CB0, 'M', 'ⲱ'),
+    (0x2CB1, 'V'),
+    (0x2CB2, 'M', 'ⲳ'),
+    (0x2CB3, 'V'),
+    (0x2CB4, 'M', 'ⲵ'),
+    (0x2CB5, 'V'),
+    (0x2CB6, 'M', 'ⲷ'),
+    (0x2CB7, 'V'),
+    (0x2CB8, 'M', 'ⲹ'),
+    (0x2CB9, 'V'),
+    (0x2CBA, 'M', 'ⲻ'),
+    (0x2CBB, 'V'),
+    (0x2CBC, 'M', 'ⲽ'),
+    (0x2CBD, 'V'),
+    (0x2CBE, 'M', 'ⲿ'),
+    (0x2CBF, 'V'),
+    (0x2CC0, 'M', 'ⳁ'),
+    (0x2CC1, 'V'),
+    (0x2CC2, 'M', 'ⳃ'),
+    (0x2CC3, 'V'),
+    (0x2CC4, 'M', 'ⳅ'),
+    (0x2CC5, 'V'),
+    (0x2CC6, 'M', 'ⳇ'),
+    ]
+
+def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2CC7, 'V'),
+    (0x2CC8, 'M', 'ⳉ'),
+    (0x2CC9, 'V'),
+    (0x2CCA, 'M', 'ⳋ'),
+    (0x2CCB, 'V'),
+    (0x2CCC, 'M', 'ⳍ'),
+    (0x2CCD, 'V'),
+    (0x2CCE, 'M', 'ⳏ'),
+    (0x2CCF, 'V'),
+    (0x2CD0, 'M', 'ⳑ'),
+    (0x2CD1, 'V'),
+    (0x2CD2, 'M', 'ⳓ'),
+    (0x2CD3, 'V'),
+    (0x2CD4, 'M', 'ⳕ'),
+    (0x2CD5, 'V'),
+    (0x2CD6, 'M', 'ⳗ'),
+    (0x2CD7, 'V'),
+    (0x2CD8, 'M', 'ⳙ'),
+    (0x2CD9, 'V'),
+    (0x2CDA, 'M', 'ⳛ'),
+    (0x2CDB, 'V'),
+    (0x2CDC, 'M', 'ⳝ'),
+    (0x2CDD, 'V'),
+    (0x2CDE, 'M', 'ⳟ'),
+    (0x2CDF, 'V'),
+    (0x2CE0, 'M', 'ⳡ'),
+    (0x2CE1, 'V'),
+    (0x2CE2, 'M', 'ⳣ'),
+    (0x2CE3, 'V'),
+    (0x2CEB, 'M', 'ⳬ'),
+    (0x2CEC, 'V'),
+    (0x2CED, 'M', 'ⳮ'),
+    (0x2CEE, 'V'),
+    (0x2CF2, 'M', 'ⳳ'),
+    (0x2CF3, 'V'),
+    (0x2CF4, 'X'),
+    (0x2CF9, 'V'),
+    (0x2D26, 'X'),
+    (0x2D27, 'V'),
+    (0x2D28, 'X'),
+    (0x2D2D, 'V'),
+    (0x2D2E, 'X'),
+    (0x2D30, 'V'),
+    (0x2D68, 'X'),
+    (0x2D6F, 'M', 'ⵡ'),
+    (0x2D70, 'V'),
+    (0x2D71, 'X'),
+    (0x2D7F, 'V'),
+    (0x2D97, 'X'),
+    (0x2DA0, 'V'),
+    (0x2DA7, 'X'),
+    (0x2DA8, 'V'),
+    (0x2DAF, 'X'),
+    (0x2DB0, 'V'),
+    (0x2DB7, 'X'),
+    (0x2DB8, 'V'),
+    (0x2DBF, 'X'),
+    (0x2DC0, 'V'),
+    (0x2DC7, 'X'),
+    (0x2DC8, 'V'),
+    (0x2DCF, 'X'),
+    (0x2DD0, 'V'),
+    (0x2DD7, 'X'),
+    (0x2DD8, 'V'),
+    (0x2DDF, 'X'),
+    (0x2DE0, 'V'),
+    (0x2E5E, 'X'),
+    (0x2E80, 'V'),
+    (0x2E9A, 'X'),
+    (0x2E9B, 'V'),
+    (0x2E9F, 'M', '母'),
+    (0x2EA0, 'V'),
+    (0x2EF3, 'M', '龟'),
+    (0x2EF4, 'X'),
+    (0x2F00, 'M', '一'),
+    (0x2F01, 'M', '丨'),
+    (0x2F02, 'M', '丶'),
+    (0x2F03, 'M', '丿'),
+    (0x2F04, 'M', '乙'),
+    (0x2F05, 'M', '亅'),
+    (0x2F06, 'M', '二'),
+    (0x2F07, 'M', '亠'),
+    (0x2F08, 'M', '人'),
+    (0x2F09, 'M', '儿'),
+    (0x2F0A, 'M', '入'),
+    (0x2F0B, 'M', '八'),
+    (0x2F0C, 'M', '冂'),
+    (0x2F0D, 'M', '冖'),
+    (0x2F0E, 'M', '冫'),
+    (0x2F0F, 'M', '几'),
+    (0x2F10, 'M', '凵'),
+    (0x2F11, 'M', '刀'),
+    (0x2F12, 'M', '力'),
+    (0x2F13, 'M', '勹'),
+    (0x2F14, 'M', '匕'),
+    (0x2F15, 'M', '匚'),
+    (0x2F16, 'M', '匸'),
+    (0x2F17, 'M', '十'),
+    (0x2F18, 'M', '卜'),
+    (0x2F19, 'M', '卩'),
+    ]
+
+def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F1A, 'M', '厂'),
+    (0x2F1B, 'M', '厶'),
+    (0x2F1C, 'M', '又'),
+    (0x2F1D, 'M', '口'),
+    (0x2F1E, 'M', '囗'),
+    (0x2F1F, 'M', '土'),
+    (0x2F20, 'M', '士'),
+    (0x2F21, 'M', '夂'),
+    (0x2F22, 'M', '夊'),
+    (0x2F23, 'M', '夕'),
+    (0x2F24, 'M', '大'),
+    (0x2F25, 'M', '女'),
+    (0x2F26, 'M', '子'),
+    (0x2F27, 'M', '宀'),
+    (0x2F28, 'M', '寸'),
+    (0x2F29, 'M', '小'),
+    (0x2F2A, 'M', '尢'),
+    (0x2F2B, 'M', '尸'),
+    (0x2F2C, 'M', '屮'),
+    (0x2F2D, 'M', '山'),
+    (0x2F2E, 'M', '巛'),
+    (0x2F2F, 'M', '工'),
+    (0x2F30, 'M', '己'),
+    (0x2F31, 'M', '巾'),
+    (0x2F32, 'M', '干'),
+    (0x2F33, 'M', '幺'),
+    (0x2F34, 'M', '广'),
+    (0x2F35, 'M', '廴'),
+    (0x2F36, 'M', '廾'),
+    (0x2F37, 'M', '弋'),
+    (0x2F38, 'M', '弓'),
+    (0x2F39, 'M', '彐'),
+    (0x2F3A, 'M', '彡'),
+    (0x2F3B, 'M', '彳'),
+    (0x2F3C, 'M', '心'),
+    (0x2F3D, 'M', '戈'),
+    (0x2F3E, 'M', '戶'),
+    (0x2F3F, 'M', '手'),
+    (0x2F40, 'M', '支'),
+    (0x2F41, 'M', '攴'),
+    (0x2F42, 'M', '文'),
+    (0x2F43, 'M', '斗'),
+    (0x2F44, 'M', '斤'),
+    (0x2F45, 'M', '方'),
+    (0x2F46, 'M', '无'),
+    (0x2F47, 'M', '日'),
+    (0x2F48, 'M', '曰'),
+    (0x2F49, 'M', '月'),
+    (0x2F4A, 'M', '木'),
+    (0x2F4B, 'M', '欠'),
+    (0x2F4C, 'M', '止'),
+    (0x2F4D, 'M', '歹'),
+    (0x2F4E, 'M', '殳'),
+    (0x2F4F, 'M', '毋'),
+    (0x2F50, 'M', '比'),
+    (0x2F51, 'M', '毛'),
+    (0x2F52, 'M', '氏'),
+    (0x2F53, 'M', '气'),
+    (0x2F54, 'M', '水'),
+    (0x2F55, 'M', '火'),
+    (0x2F56, 'M', '爪'),
+    (0x2F57, 'M', '父'),
+    (0x2F58, 'M', '爻'),
+    (0x2F59, 'M', '爿'),
+    (0x2F5A, 'M', '片'),
+    (0x2F5B, 'M', '牙'),
+    (0x2F5C, 'M', '牛'),
+    (0x2F5D, 'M', '犬'),
+    (0x2F5E, 'M', '玄'),
+    (0x2F5F, 'M', '玉'),
+    (0x2F60, 'M', '瓜'),
+    (0x2F61, 'M', '瓦'),
+    (0x2F62, 'M', '甘'),
+    (0x2F63, 'M', '生'),
+    (0x2F64, 'M', '用'),
+    (0x2F65, 'M', '田'),
+    (0x2F66, 'M', '疋'),
+    (0x2F67, 'M', '疒'),
+    (0x2F68, 'M', '癶'),
+    (0x2F69, 'M', '白'),
+    (0x2F6A, 'M', '皮'),
+    (0x2F6B, 'M', '皿'),
+    (0x2F6C, 'M', '目'),
+    (0x2F6D, 'M', '矛'),
+    (0x2F6E, 'M', '矢'),
+    (0x2F6F, 'M', '石'),
+    (0x2F70, 'M', '示'),
+    (0x2F71, 'M', '禸'),
+    (0x2F72, 'M', '禾'),
+    (0x2F73, 'M', '穴'),
+    (0x2F74, 'M', '立'),
+    (0x2F75, 'M', '竹'),
+    (0x2F76, 'M', '米'),
+    (0x2F77, 'M', '糸'),
+    (0x2F78, 'M', '缶'),
+    (0x2F79, 'M', '网'),
+    (0x2F7A, 'M', '羊'),
+    (0x2F7B, 'M', '羽'),
+    (0x2F7C, 'M', '老'),
+    (0x2F7D, 'M', '而'),
+    ]
+
+def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F7E, 'M', '耒'),
+    (0x2F7F, 'M', '耳'),
+    (0x2F80, 'M', '聿'),
+    (0x2F81, 'M', '肉'),
+    (0x2F82, 'M', '臣'),
+    (0x2F83, 'M', '自'),
+    (0x2F84, 'M', '至'),
+    (0x2F85, 'M', '臼'),
+    (0x2F86, 'M', '舌'),
+    (0x2F87, 'M', '舛'),
+    (0x2F88, 'M', '舟'),
+    (0x2F89, 'M', '艮'),
+    (0x2F8A, 'M', '色'),
+    (0x2F8B, 'M', '艸'),
+    (0x2F8C, 'M', '虍'),
+    (0x2F8D, 'M', '虫'),
+    (0x2F8E, 'M', '血'),
+    (0x2F8F, 'M', '行'),
+    (0x2F90, 'M', '衣'),
+    (0x2F91, 'M', '襾'),
+    (0x2F92, 'M', '見'),
+    (0x2F93, 'M', '角'),
+    (0x2F94, 'M', '言'),
+    (0x2F95, 'M', '谷'),
+    (0x2F96, 'M', '豆'),
+    (0x2F97, 'M', '豕'),
+    (0x2F98, 'M', '豸'),
+    (0x2F99, 'M', '貝'),
+    (0x2F9A, 'M', '赤'),
+    (0x2F9B, 'M', '走'),
+    (0x2F9C, 'M', '足'),
+    (0x2F9D, 'M', '身'),
+    (0x2F9E, 'M', '車'),
+    (0x2F9F, 'M', '辛'),
+    (0x2FA0, 'M', '辰'),
+    (0x2FA1, 'M', '辵'),
+    (0x2FA2, 'M', '邑'),
+    (0x2FA3, 'M', '酉'),
+    (0x2FA4, 'M', '釆'),
+    (0x2FA5, 'M', '里'),
+    (0x2FA6, 'M', '金'),
+    (0x2FA7, 'M', '長'),
+    (0x2FA8, 'M', '門'),
+    (0x2FA9, 'M', '阜'),
+    (0x2FAA, 'M', '隶'),
+    (0x2FAB, 'M', '隹'),
+    (0x2FAC, 'M', '雨'),
+    (0x2FAD, 'M', '靑'),
+    (0x2FAE, 'M', '非'),
+    (0x2FAF, 'M', '面'),
+    (0x2FB0, 'M', '革'),
+    (0x2FB1, 'M', '韋'),
+    (0x2FB2, 'M', '韭'),
+    (0x2FB3, 'M', '音'),
+    (0x2FB4, 'M', '頁'),
+    (0x2FB5, 'M', '風'),
+    (0x2FB6, 'M', '飛'),
+    (0x2FB7, 'M', '食'),
+    (0x2FB8, 'M', '首'),
+    (0x2FB9, 'M', '香'),
+    (0x2FBA, 'M', '馬'),
+    (0x2FBB, 'M', '骨'),
+    (0x2FBC, 'M', '高'),
+    (0x2FBD, 'M', '髟'),
+    (0x2FBE, 'M', '鬥'),
+    (0x2FBF, 'M', '鬯'),
+    (0x2FC0, 'M', '鬲'),
+    (0x2FC1, 'M', '鬼'),
+    (0x2FC2, 'M', '魚'),
+    (0x2FC3, 'M', '鳥'),
+    (0x2FC4, 'M', '鹵'),
+    (0x2FC5, 'M', '鹿'),
+    (0x2FC6, 'M', '麥'),
+    (0x2FC7, 'M', '麻'),
+    (0x2FC8, 'M', '黃'),
+    (0x2FC9, 'M', '黍'),
+    (0x2FCA, 'M', '黑'),
+    (0x2FCB, 'M', '黹'),
+    (0x2FCC, 'M', '黽'),
+    (0x2FCD, 'M', '鼎'),
+    (0x2FCE, 'M', '鼓'),
+    (0x2FCF, 'M', '鼠'),
+    (0x2FD0, 'M', '鼻'),
+    (0x2FD1, 'M', '齊'),
+    (0x2FD2, 'M', '齒'),
+    (0x2FD3, 'M', '龍'),
+    (0x2FD4, 'M', '龜'),
+    (0x2FD5, 'M', '龠'),
+    (0x2FD6, 'X'),
+    (0x3000, '3', ' '),
+    (0x3001, 'V'),
+    (0x3002, 'M', '.'),
+    (0x3003, 'V'),
+    (0x3036, 'M', '〒'),
+    (0x3037, 'V'),
+    (0x3038, 'M', '十'),
+    (0x3039, 'M', '卄'),
+    (0x303A, 'M', '卅'),
+    (0x303B, 'V'),
+    (0x3040, 'X'),
+    ]
+
+def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3041, 'V'),
+    (0x3097, 'X'),
+    (0x3099, 'V'),
+    (0x309B, '3', ' ゙'),
+    (0x309C, '3', ' ゚'),
+    (0x309D, 'V'),
+    (0x309F, 'M', 'より'),
+    (0x30A0, 'V'),
+    (0x30FF, 'M', 'コト'),
+    (0x3100, 'X'),
+    (0x3105, 'V'),
+    (0x3130, 'X'),
+    (0x3131, 'M', 'ᄀ'),
+    (0x3132, 'M', 'ᄁ'),
+    (0x3133, 'M', 'ᆪ'),
+    (0x3134, 'M', 'ᄂ'),
+    (0x3135, 'M', 'ᆬ'),
+    (0x3136, 'M', 'ᆭ'),
+    (0x3137, 'M', 'ᄃ'),
+    (0x3138, 'M', 'ᄄ'),
+    (0x3139, 'M', 'ᄅ'),
+    (0x313A, 'M', 'ᆰ'),
+    (0x313B, 'M', 'ᆱ'),
+    (0x313C, 'M', 'ᆲ'),
+    (0x313D, 'M', 'ᆳ'),
+    (0x313E, 'M', 'ᆴ'),
+    (0x313F, 'M', 'ᆵ'),
+    (0x3140, 'M', 'ᄚ'),
+    (0x3141, 'M', 'ᄆ'),
+    (0x3142, 'M', 'ᄇ'),
+    (0x3143, 'M', 'ᄈ'),
+    (0x3144, 'M', 'ᄡ'),
+    (0x3145, 'M', 'ᄉ'),
+    (0x3146, 'M', 'ᄊ'),
+    (0x3147, 'M', 'ᄋ'),
+    (0x3148, 'M', 'ᄌ'),
+    (0x3149, 'M', 'ᄍ'),
+    (0x314A, 'M', 'ᄎ'),
+    (0x314B, 'M', 'ᄏ'),
+    (0x314C, 'M', 'ᄐ'),
+    (0x314D, 'M', 'ᄑ'),
+    (0x314E, 'M', 'ᄒ'),
+    (0x314F, 'M', 'ᅡ'),
+    (0x3150, 'M', 'ᅢ'),
+    (0x3151, 'M', 'ᅣ'),
+    (0x3152, 'M', 'ᅤ'),
+    (0x3153, 'M', 'ᅥ'),
+    (0x3154, 'M', 'ᅦ'),
+    (0x3155, 'M', 'ᅧ'),
+    (0x3156, 'M', 'ᅨ'),
+    (0x3157, 'M', 'ᅩ'),
+    (0x3158, 'M', 'ᅪ'),
+    (0x3159, 'M', 'ᅫ'),
+    (0x315A, 'M', 'ᅬ'),
+    (0x315B, 'M', 'ᅭ'),
+    (0x315C, 'M', 'ᅮ'),
+    (0x315D, 'M', 'ᅯ'),
+    (0x315E, 'M', 'ᅰ'),
+    (0x315F, 'M', 'ᅱ'),
+    (0x3160, 'M', 'ᅲ'),
+    (0x3161, 'M', 'ᅳ'),
+    (0x3162, 'M', 'ᅴ'),
+    (0x3163, 'M', 'ᅵ'),
+    (0x3164, 'X'),
+    (0x3165, 'M', 'ᄔ'),
+    (0x3166, 'M', 'ᄕ'),
+    (0x3167, 'M', 'ᇇ'),
+    (0x3168, 'M', 'ᇈ'),
+    (0x3169, 'M', 'ᇌ'),
+    (0x316A, 'M', 'ᇎ'),
+    (0x316B, 'M', 'ᇓ'),
+    (0x316C, 'M', 'ᇗ'),
+    (0x316D, 'M', 'ᇙ'),
+    (0x316E, 'M', 'ᄜ'),
+    (0x316F, 'M', 'ᇝ'),
+    (0x3170, 'M', 'ᇟ'),
+    (0x3171, 'M', 'ᄝ'),
+    (0x3172, 'M', 'ᄞ'),
+    (0x3173, 'M', 'ᄠ'),
+    (0x3174, 'M', 'ᄢ'),
+    (0x3175, 'M', 'ᄣ'),
+    (0x3176, 'M', 'ᄧ'),
+    (0x3177, 'M', 'ᄩ'),
+    (0x3178, 'M', 'ᄫ'),
+    (0x3179, 'M', 'ᄬ'),
+    (0x317A, 'M', 'ᄭ'),
+    (0x317B, 'M', 'ᄮ'),
+    (0x317C, 'M', 'ᄯ'),
+    (0x317D, 'M', 'ᄲ'),
+    (0x317E, 'M', 'ᄶ'),
+    (0x317F, 'M', 'ᅀ'),
+    (0x3180, 'M', 'ᅇ'),
+    (0x3181, 'M', 'ᅌ'),
+    (0x3182, 'M', 'ᇱ'),
+    (0x3183, 'M', 'ᇲ'),
+    (0x3184, 'M', 'ᅗ'),
+    (0x3185, 'M', 'ᅘ'),
+    (0x3186, 'M', 'ᅙ'),
+    (0x3187, 'M', 'ᆄ'),
+    (0x3188, 'M', 'ᆅ'),
+    ]
+
+def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3189, 'M', 'ᆈ'),
+    (0x318A, 'M', 'ᆑ'),
+    (0x318B, 'M', 'ᆒ'),
+    (0x318C, 'M', 'ᆔ'),
+    (0x318D, 'M', 'ᆞ'),
+    (0x318E, 'M', 'ᆡ'),
+    (0x318F, 'X'),
+    (0x3190, 'V'),
+    (0x3192, 'M', '一'),
+    (0x3193, 'M', '二'),
+    (0x3194, 'M', '三'),
+    (0x3195, 'M', '四'),
+    (0x3196, 'M', '上'),
+    (0x3197, 'M', '中'),
+    (0x3198, 'M', '下'),
+    (0x3199, 'M', '甲'),
+    (0x319A, 'M', '乙'),
+    (0x319B, 'M', '丙'),
+    (0x319C, 'M', '丁'),
+    (0x319D, 'M', '天'),
+    (0x319E, 'M', '地'),
+    (0x319F, 'M', '人'),
+    (0x31A0, 'V'),
+    (0x31E4, 'X'),
+    (0x31F0, 'V'),
+    (0x3200, '3', '(ᄀ)'),
+    (0x3201, '3', '(ᄂ)'),
+    (0x3202, '3', '(ᄃ)'),
+    (0x3203, '3', '(ᄅ)'),
+    (0x3204, '3', '(ᄆ)'),
+    (0x3205, '3', '(ᄇ)'),
+    (0x3206, '3', '(ᄉ)'),
+    (0x3207, '3', '(ᄋ)'),
+    (0x3208, '3', '(ᄌ)'),
+    (0x3209, '3', '(ᄎ)'),
+    (0x320A, '3', '(ᄏ)'),
+    (0x320B, '3', '(ᄐ)'),
+    (0x320C, '3', '(ᄑ)'),
+    (0x320D, '3', '(ᄒ)'),
+    (0x320E, '3', '(가)'),
+    (0x320F, '3', '(나)'),
+    (0x3210, '3', '(다)'),
+    (0x3211, '3', '(라)'),
+    (0x3212, '3', '(마)'),
+    (0x3213, '3', '(바)'),
+    (0x3214, '3', '(사)'),
+    (0x3215, '3', '(아)'),
+    (0x3216, '3', '(자)'),
+    (0x3217, '3', '(차)'),
+    (0x3218, '3', '(카)'),
+    (0x3219, '3', '(타)'),
+    (0x321A, '3', '(파)'),
+    (0x321B, '3', '(하)'),
+    (0x321C, '3', '(주)'),
+    (0x321D, '3', '(오전)'),
+    (0x321E, '3', '(오후)'),
+    (0x321F, 'X'),
+    (0x3220, '3', '(一)'),
+    (0x3221, '3', '(二)'),
+    (0x3222, '3', '(三)'),
+    (0x3223, '3', '(四)'),
+    (0x3224, '3', '(五)'),
+    (0x3225, '3', '(六)'),
+    (0x3226, '3', '(七)'),
+    (0x3227, '3', '(八)'),
+    (0x3228, '3', '(九)'),
+    (0x3229, '3', '(十)'),
+    (0x322A, '3', '(月)'),
+    (0x322B, '3', '(火)'),
+    (0x322C, '3', '(水)'),
+    (0x322D, '3', '(木)'),
+    (0x322E, '3', '(金)'),
+    (0x322F, '3', '(土)'),
+    (0x3230, '3', '(日)'),
+    (0x3231, '3', '(株)'),
+    (0x3232, '3', '(有)'),
+    (0x3233, '3', '(社)'),
+    (0x3234, '3', '(名)'),
+    (0x3235, '3', '(特)'),
+    (0x3236, '3', '(財)'),
+    (0x3237, '3', '(祝)'),
+    (0x3238, '3', '(労)'),
+    (0x3239, '3', '(代)'),
+    (0x323A, '3', '(呼)'),
+    (0x323B, '3', '(学)'),
+    (0x323C, '3', '(監)'),
+    (0x323D, '3', '(企)'),
+    (0x323E, '3', '(資)'),
+    (0x323F, '3', '(協)'),
+    (0x3240, '3', '(祭)'),
+    (0x3241, '3', '(休)'),
+    (0x3242, '3', '(自)'),
+    (0x3243, '3', '(至)'),
+    (0x3244, 'M', '問'),
+    (0x3245, 'M', '幼'),
+    (0x3246, 'M', '文'),
+    (0x3247, 'M', '箏'),
+    (0x3248, 'V'),
+    (0x3250, 'M', 'pte'),
+    (0x3251, 'M', '21'),
+    ]
+
+def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3252, 'M', '22'),
+    (0x3253, 'M', '23'),
+    (0x3254, 'M', '24'),
+    (0x3255, 'M', '25'),
+    (0x3256, 'M', '26'),
+    (0x3257, 'M', '27'),
+    (0x3258, 'M', '28'),
+    (0x3259, 'M', '29'),
+    (0x325A, 'M', '30'),
+    (0x325B, 'M', '31'),
+    (0x325C, 'M', '32'),
+    (0x325D, 'M', '33'),
+    (0x325E, 'M', '34'),
+    (0x325F, 'M', '35'),
+    (0x3260, 'M', 'ᄀ'),
+    (0x3261, 'M', 'ᄂ'),
+    (0x3262, 'M', 'ᄃ'),
+    (0x3263, 'M', 'ᄅ'),
+    (0x3264, 'M', 'ᄆ'),
+    (0x3265, 'M', 'ᄇ'),
+    (0x3266, 'M', 'ᄉ'),
+    (0x3267, 'M', 'ᄋ'),
+    (0x3268, 'M', 'ᄌ'),
+    (0x3269, 'M', 'ᄎ'),
+    (0x326A, 'M', 'ᄏ'),
+    (0x326B, 'M', 'ᄐ'),
+    (0x326C, 'M', 'ᄑ'),
+    (0x326D, 'M', 'ᄒ'),
+    (0x326E, 'M', '가'),
+    (0x326F, 'M', '나'),
+    (0x3270, 'M', '다'),
+    (0x3271, 'M', '라'),
+    (0x3272, 'M', '마'),
+    (0x3273, 'M', '바'),
+    (0x3274, 'M', '사'),
+    (0x3275, 'M', '아'),
+    (0x3276, 'M', '자'),
+    (0x3277, 'M', '차'),
+    (0x3278, 'M', '카'),
+    (0x3279, 'M', '타'),
+    (0x327A, 'M', '파'),
+    (0x327B, 'M', '하'),
+    (0x327C, 'M', '참고'),
+    (0x327D, 'M', '주의'),
+    (0x327E, 'M', '우'),
+    (0x327F, 'V'),
+    (0x3280, 'M', '一'),
+    (0x3281, 'M', '二'),
+    (0x3282, 'M', '三'),
+    (0x3283, 'M', '四'),
+    (0x3284, 'M', '五'),
+    (0x3285, 'M', '六'),
+    (0x3286, 'M', '七'),
+    (0x3287, 'M', '八'),
+    (0x3288, 'M', '九'),
+    (0x3289, 'M', '十'),
+    (0x328A, 'M', '月'),
+    (0x328B, 'M', '火'),
+    (0x328C, 'M', '水'),
+    (0x328D, 'M', '木'),
+    (0x328E, 'M', '金'),
+    (0x328F, 'M', '土'),
+    (0x3290, 'M', '日'),
+    (0x3291, 'M', '株'),
+    (0x3292, 'M', '有'),
+    (0x3293, 'M', '社'),
+    (0x3294, 'M', '名'),
+    (0x3295, 'M', '特'),
+    (0x3296, 'M', '財'),
+    (0x3297, 'M', '祝'),
+    (0x3298, 'M', '労'),
+    (0x3299, 'M', '秘'),
+    (0x329A, 'M', '男'),
+    (0x329B, 'M', '女'),
+    (0x329C, 'M', '適'),
+    (0x329D, 'M', '優'),
+    (0x329E, 'M', '印'),
+    (0x329F, 'M', '注'),
+    (0x32A0, 'M', '項'),
+    (0x32A1, 'M', '休'),
+    (0x32A2, 'M', '写'),
+    (0x32A3, 'M', '正'),
+    (0x32A4, 'M', '上'),
+    (0x32A5, 'M', '中'),
+    (0x32A6, 'M', '下'),
+    (0x32A7, 'M', '左'),
+    (0x32A8, 'M', '右'),
+    (0x32A9, 'M', '医'),
+    (0x32AA, 'M', '宗'),
+    (0x32AB, 'M', '学'),
+    (0x32AC, 'M', '監'),
+    (0x32AD, 'M', '企'),
+    (0x32AE, 'M', '資'),
+    (0x32AF, 'M', '協'),
+    (0x32B0, 'M', '夜'),
+    (0x32B1, 'M', '36'),
+    (0x32B2, 'M', '37'),
+    (0x32B3, 'M', '38'),
+    (0x32B4, 'M', '39'),
+    (0x32B5, 'M', '40'),
+    ]
+
+def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x32B6, 'M', '41'),
+    (0x32B7, 'M', '42'),
+    (0x32B8, 'M', '43'),
+    (0x32B9, 'M', '44'),
+    (0x32BA, 'M', '45'),
+    (0x32BB, 'M', '46'),
+    (0x32BC, 'M', '47'),
+    (0x32BD, 'M', '48'),
+    (0x32BE, 'M', '49'),
+    (0x32BF, 'M', '50'),
+    (0x32C0, 'M', '1月'),
+    (0x32C1, 'M', '2月'),
+    (0x32C2, 'M', '3月'),
+    (0x32C3, 'M', '4月'),
+    (0x32C4, 'M', '5月'),
+    (0x32C5, 'M', '6月'),
+    (0x32C6, 'M', '7月'),
+    (0x32C7, 'M', '8月'),
+    (0x32C8, 'M', '9月'),
+    (0x32C9, 'M', '10月'),
+    (0x32CA, 'M', '11月'),
+    (0x32CB, 'M', '12月'),
+    (0x32CC, 'M', 'hg'),
+    (0x32CD, 'M', 'erg'),
+    (0x32CE, 'M', 'ev'),
+    (0x32CF, 'M', 'ltd'),
+    (0x32D0, 'M', 'ア'),
+    (0x32D1, 'M', 'イ'),
+    (0x32D2, 'M', 'ウ'),
+    (0x32D3, 'M', 'エ'),
+    (0x32D4, 'M', 'オ'),
+    (0x32D5, 'M', 'カ'),
+    (0x32D6, 'M', 'キ'),
+    (0x32D7, 'M', 'ク'),
+    (0x32D8, 'M', 'ケ'),
+    (0x32D9, 'M', 'コ'),
+    (0x32DA, 'M', 'サ'),
+    (0x32DB, 'M', 'シ'),
+    (0x32DC, 'M', 'ス'),
+    (0x32DD, 'M', 'セ'),
+    (0x32DE, 'M', 'ソ'),
+    (0x32DF, 'M', 'タ'),
+    (0x32E0, 'M', 'チ'),
+    (0x32E1, 'M', 'ツ'),
+    (0x32E2, 'M', 'テ'),
+    (0x32E3, 'M', 'ト'),
+    (0x32E4, 'M', 'ナ'),
+    (0x32E5, 'M', 'ニ'),
+    (0x32E6, 'M', 'ヌ'),
+    (0x32E7, 'M', 'ネ'),
+    (0x32E8, 'M', 'ノ'),
+    (0x32E9, 'M', 'ハ'),
+    (0x32EA, 'M', 'ヒ'),
+    (0x32EB, 'M', 'フ'),
+    (0x32EC, 'M', 'ヘ'),
+    (0x32ED, 'M', 'ホ'),
+    (0x32EE, 'M', 'マ'),
+    (0x32EF, 'M', 'ミ'),
+    (0x32F0, 'M', 'ム'),
+    (0x32F1, 'M', 'メ'),
+    (0x32F2, 'M', 'モ'),
+    (0x32F3, 'M', 'ヤ'),
+    (0x32F4, 'M', 'ユ'),
+    (0x32F5, 'M', 'ヨ'),
+    (0x32F6, 'M', 'ラ'),
+    (0x32F7, 'M', 'リ'),
+    (0x32F8, 'M', 'ル'),
+    (0x32F9, 'M', 'レ'),
+    (0x32FA, 'M', 'ロ'),
+    (0x32FB, 'M', 'ワ'),
+    (0x32FC, 'M', 'ヰ'),
+    (0x32FD, 'M', 'ヱ'),
+    (0x32FE, 'M', 'ヲ'),
+    (0x32FF, 'M', '令和'),
+    (0x3300, 'M', 'アパート'),
+    (0x3301, 'M', 'アルファ'),
+    (0x3302, 'M', 'アンペア'),
+    (0x3303, 'M', 'アール'),
+    (0x3304, 'M', 'イニング'),
+    (0x3305, 'M', 'インチ'),
+    (0x3306, 'M', 'ウォン'),
+    (0x3307, 'M', 'エスクード'),
+    (0x3308, 'M', 'エーカー'),
+    (0x3309, 'M', 'オンス'),
+    (0x330A, 'M', 'オーム'),
+    (0x330B, 'M', 'カイリ'),
+    (0x330C, 'M', 'カラット'),
+    (0x330D, 'M', 'カロリー'),
+    (0x330E, 'M', 'ガロン'),
+    (0x330F, 'M', 'ガンマ'),
+    (0x3310, 'M', 'ギガ'),
+    (0x3311, 'M', 'ギニー'),
+    (0x3312, 'M', 'キュリー'),
+    (0x3313, 'M', 'ギルダー'),
+    (0x3314, 'M', 'キロ'),
+    (0x3315, 'M', 'キログラム'),
+    (0x3316, 'M', 'キロメートル'),
+    (0x3317, 'M', 'キロワット'),
+    (0x3318, 'M', 'グラム'),
+    (0x3319, 'M', 'グラムトン'),
+    ]
+
+def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x331A, 'M', 'クルゼイロ'),
+    (0x331B, 'M', 'クローネ'),
+    (0x331C, 'M', 'ケース'),
+    (0x331D, 'M', 'コルナ'),
+    (0x331E, 'M', 'コーポ'),
+    (0x331F, 'M', 'サイクル'),
+    (0x3320, 'M', 'サンチーム'),
+    (0x3321, 'M', 'シリング'),
+    (0x3322, 'M', 'センチ'),
+    (0x3323, 'M', 'セント'),
+    (0x3324, 'M', 'ダース'),
+    (0x3325, 'M', 'デシ'),
+    (0x3326, 'M', 'ドル'),
+    (0x3327, 'M', 'トン'),
+    (0x3328, 'M', 'ナノ'),
+    (0x3329, 'M', 'ノット'),
+    (0x332A, 'M', 'ハイツ'),
+    (0x332B, 'M', 'パーセント'),
+    (0x332C, 'M', 'パーツ'),
+    (0x332D, 'M', 'バーレル'),
+    (0x332E, 'M', 'ピアストル'),
+    (0x332F, 'M', 'ピクル'),
+    (0x3330, 'M', 'ピコ'),
+    (0x3331, 'M', 'ビル'),
+    (0x3332, 'M', 'ファラッド'),
+    (0x3333, 'M', 'フィート'),
+    (0x3334, 'M', 'ブッシェル'),
+    (0x3335, 'M', 'フラン'),
+    (0x3336, 'M', 'ヘクタール'),
+    (0x3337, 'M', 'ペソ'),
+    (0x3338, 'M', 'ペニヒ'),
+    (0x3339, 'M', 'ヘルツ'),
+    (0x333A, 'M', 'ペンス'),
+    (0x333B, 'M', 'ページ'),
+    (0x333C, 'M', 'ベータ'),
+    (0x333D, 'M', 'ポイント'),
+    (0x333E, 'M', 'ボルト'),
+    (0x333F, 'M', 'ホン'),
+    (0x3340, 'M', 'ポンド'),
+    (0x3341, 'M', 'ホール'),
+    (0x3342, 'M', 'ホーン'),
+    (0x3343, 'M', 'マイクロ'),
+    (0x3344, 'M', 'マイル'),
+    (0x3345, 'M', 'マッハ'),
+    (0x3346, 'M', 'マルク'),
+    (0x3347, 'M', 'マンション'),
+    (0x3348, 'M', 'ミクロン'),
+    (0x3349, 'M', 'ミリ'),
+    (0x334A, 'M', 'ミリバール'),
+    (0x334B, 'M', 'メガ'),
+    (0x334C, 'M', 'メガトン'),
+    (0x334D, 'M', 'メートル'),
+    (0x334E, 'M', 'ヤード'),
+    (0x334F, 'M', 'ヤール'),
+    (0x3350, 'M', 'ユアン'),
+    (0x3351, 'M', 'リットル'),
+    (0x3352, 'M', 'リラ'),
+    (0x3353, 'M', 'ルピー'),
+    (0x3354, 'M', 'ルーブル'),
+    (0x3355, 'M', 'レム'),
+    (0x3356, 'M', 'レントゲン'),
+    (0x3357, 'M', 'ワット'),
+    (0x3358, 'M', '0点'),
+    (0x3359, 'M', '1点'),
+    (0x335A, 'M', '2点'),
+    (0x335B, 'M', '3点'),
+    (0x335C, 'M', '4点'),
+    (0x335D, 'M', '5点'),
+    (0x335E, 'M', '6点'),
+    (0x335F, 'M', '7点'),
+    (0x3360, 'M', '8点'),
+    (0x3361, 'M', '9点'),
+    (0x3362, 'M', '10点'),
+    (0x3363, 'M', '11点'),
+    (0x3364, 'M', '12点'),
+    (0x3365, 'M', '13点'),
+    (0x3366, 'M', '14点'),
+    (0x3367, 'M', '15点'),
+    (0x3368, 'M', '16点'),
+    (0x3369, 'M', '17点'),
+    (0x336A, 'M', '18点'),
+    (0x336B, 'M', '19点'),
+    (0x336C, 'M', '20点'),
+    (0x336D, 'M', '21点'),
+    (0x336E, 'M', '22点'),
+    (0x336F, 'M', '23点'),
+    (0x3370, 'M', '24点'),
+    (0x3371, 'M', 'hpa'),
+    (0x3372, 'M', 'da'),
+    (0x3373, 'M', 'au'),
+    (0x3374, 'M', 'bar'),
+    (0x3375, 'M', 'ov'),
+    (0x3376, 'M', 'pc'),
+    (0x3377, 'M', 'dm'),
+    (0x3378, 'M', 'dm2'),
+    (0x3379, 'M', 'dm3'),
+    (0x337A, 'M', 'iu'),
+    (0x337B, 'M', '平成'),
+    (0x337C, 'M', '昭和'),
+    (0x337D, 'M', '大正'),
+    ]
+
+def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x337E, 'M', '明治'),
+    (0x337F, 'M', '株式会社'),
+    (0x3380, 'M', 'pa'),
+    (0x3381, 'M', 'na'),
+    (0x3382, 'M', 'μa'),
+    (0x3383, 'M', 'ma'),
+    (0x3384, 'M', 'ka'),
+    (0x3385, 'M', 'kb'),
+    (0x3386, 'M', 'mb'),
+    (0x3387, 'M', 'gb'),
+    (0x3388, 'M', 'cal'),
+    (0x3389, 'M', 'kcal'),
+    (0x338A, 'M', 'pf'),
+    (0x338B, 'M', 'nf'),
+    (0x338C, 'M', 'μf'),
+    (0x338D, 'M', 'μg'),
+    (0x338E, 'M', 'mg'),
+    (0x338F, 'M', 'kg'),
+    (0x3390, 'M', 'hz'),
+    (0x3391, 'M', 'khz'),
+    (0x3392, 'M', 'mhz'),
+    (0x3393, 'M', 'ghz'),
+    (0x3394, 'M', 'thz'),
+    (0x3395, 'M', 'μl'),
+    (0x3396, 'M', 'ml'),
+    (0x3397, 'M', 'dl'),
+    (0x3398, 'M', 'kl'),
+    (0x3399, 'M', 'fm'),
+    (0x339A, 'M', 'nm'),
+    (0x339B, 'M', 'μm'),
+    (0x339C, 'M', 'mm'),
+    (0x339D, 'M', 'cm'),
+    (0x339E, 'M', 'km'),
+    (0x339F, 'M', 'mm2'),
+    (0x33A0, 'M', 'cm2'),
+    (0x33A1, 'M', 'm2'),
+    (0x33A2, 'M', 'km2'),
+    (0x33A3, 'M', 'mm3'),
+    (0x33A4, 'M', 'cm3'),
+    (0x33A5, 'M', 'm3'),
+    (0x33A6, 'M', 'km3'),
+    (0x33A7, 'M', 'm∕s'),
+    (0x33A8, 'M', 'm∕s2'),
+    (0x33A9, 'M', 'pa'),
+    (0x33AA, 'M', 'kpa'),
+    (0x33AB, 'M', 'mpa'),
+    (0x33AC, 'M', 'gpa'),
+    (0x33AD, 'M', 'rad'),
+    (0x33AE, 'M', 'rad∕s'),
+    (0x33AF, 'M', 'rad∕s2'),
+    (0x33B0, 'M', 'ps'),
+    (0x33B1, 'M', 'ns'),
+    (0x33B2, 'M', 'μs'),
+    (0x33B3, 'M', 'ms'),
+    (0x33B4, 'M', 'pv'),
+    (0x33B5, 'M', 'nv'),
+    (0x33B6, 'M', 'μv'),
+    (0x33B7, 'M', 'mv'),
+    (0x33B8, 'M', 'kv'),
+    (0x33B9, 'M', 'mv'),
+    (0x33BA, 'M', 'pw'),
+    (0x33BB, 'M', 'nw'),
+    (0x33BC, 'M', 'μw'),
+    (0x33BD, 'M', 'mw'),
+    (0x33BE, 'M', 'kw'),
+    (0x33BF, 'M', 'mw'),
+    (0x33C0, 'M', 'kω'),
+    (0x33C1, 'M', 'mω'),
+    (0x33C2, 'X'),
+    (0x33C3, 'M', 'bq'),
+    (0x33C4, 'M', 'cc'),
+    (0x33C5, 'M', 'cd'),
+    (0x33C6, 'M', 'c∕kg'),
+    (0x33C7, 'X'),
+    (0x33C8, 'M', 'db'),
+    (0x33C9, 'M', 'gy'),
+    (0x33CA, 'M', 'ha'),
+    (0x33CB, 'M', 'hp'),
+    (0x33CC, 'M', 'in'),
+    (0x33CD, 'M', 'kk'),
+    (0x33CE, 'M', 'km'),
+    (0x33CF, 'M', 'kt'),
+    (0x33D0, 'M', 'lm'),
+    (0x33D1, 'M', 'ln'),
+    (0x33D2, 'M', 'log'),
+    (0x33D3, 'M', 'lx'),
+    (0x33D4, 'M', 'mb'),
+    (0x33D5, 'M', 'mil'),
+    (0x33D6, 'M', 'mol'),
+    (0x33D7, 'M', 'ph'),
+    (0x33D8, 'X'),
+    (0x33D9, 'M', 'ppm'),
+    (0x33DA, 'M', 'pr'),
+    (0x33DB, 'M', 'sr'),
+    (0x33DC, 'M', 'sv'),
+    (0x33DD, 'M', 'wb'),
+    (0x33DE, 'M', 'v∕m'),
+    (0x33DF, 'M', 'a∕m'),
+    (0x33E0, 'M', '1日'),
+    (0x33E1, 'M', '2日'),
+    ]
+
+def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x33E2, 'M', '3日'),
+    (0x33E3, 'M', '4日'),
+    (0x33E4, 'M', '5日'),
+    (0x33E5, 'M', '6日'),
+    (0x33E6, 'M', '7日'),
+    (0x33E7, 'M', '8日'),
+    (0x33E8, 'M', '9日'),
+    (0x33E9, 'M', '10日'),
+    (0x33EA, 'M', '11日'),
+    (0x33EB, 'M', '12日'),
+    (0x33EC, 'M', '13日'),
+    (0x33ED, 'M', '14日'),
+    (0x33EE, 'M', '15日'),
+    (0x33EF, 'M', '16日'),
+    (0x33F0, 'M', '17日'),
+    (0x33F1, 'M', '18日'),
+    (0x33F2, 'M', '19日'),
+    (0x33F3, 'M', '20日'),
+    (0x33F4, 'M', '21日'),
+    (0x33F5, 'M', '22日'),
+    (0x33F6, 'M', '23日'),
+    (0x33F7, 'M', '24日'),
+    (0x33F8, 'M', '25日'),
+    (0x33F9, 'M', '26日'),
+    (0x33FA, 'M', '27日'),
+    (0x33FB, 'M', '28日'),
+    (0x33FC, 'M', '29日'),
+    (0x33FD, 'M', '30日'),
+    (0x33FE, 'M', '31日'),
+    (0x33FF, 'M', 'gal'),
+    (0x3400, 'V'),
+    (0xA48D, 'X'),
+    (0xA490, 'V'),
+    (0xA4C7, 'X'),
+    (0xA4D0, 'V'),
+    (0xA62C, 'X'),
+    (0xA640, 'M', 'ꙁ'),
+    (0xA641, 'V'),
+    (0xA642, 'M', 'ꙃ'),
+    (0xA643, 'V'),
+    (0xA644, 'M', 'ꙅ'),
+    (0xA645, 'V'),
+    (0xA646, 'M', 'ꙇ'),
+    (0xA647, 'V'),
+    (0xA648, 'M', 'ꙉ'),
+    (0xA649, 'V'),
+    (0xA64A, 'M', 'ꙋ'),
+    (0xA64B, 'V'),
+    (0xA64C, 'M', 'ꙍ'),
+    (0xA64D, 'V'),
+    (0xA64E, 'M', 'ꙏ'),
+    (0xA64F, 'V'),
+    (0xA650, 'M', 'ꙑ'),
+    (0xA651, 'V'),
+    (0xA652, 'M', 'ꙓ'),
+    (0xA653, 'V'),
+    (0xA654, 'M', 'ꙕ'),
+    (0xA655, 'V'),
+    (0xA656, 'M', 'ꙗ'),
+    (0xA657, 'V'),
+    (0xA658, 'M', 'ꙙ'),
+    (0xA659, 'V'),
+    (0xA65A, 'M', 'ꙛ'),
+    (0xA65B, 'V'),
+    (0xA65C, 'M', 'ꙝ'),
+    (0xA65D, 'V'),
+    (0xA65E, 'M', 'ꙟ'),
+    (0xA65F, 'V'),
+    (0xA660, 'M', 'ꙡ'),
+    (0xA661, 'V'),
+    (0xA662, 'M', 'ꙣ'),
+    (0xA663, 'V'),
+    (0xA664, 'M', 'ꙥ'),
+    (0xA665, 'V'),
+    (0xA666, 'M', 'ꙧ'),
+    (0xA667, 'V'),
+    (0xA668, 'M', 'ꙩ'),
+    (0xA669, 'V'),
+    (0xA66A, 'M', 'ꙫ'),
+    (0xA66B, 'V'),
+    (0xA66C, 'M', 'ꙭ'),
+    (0xA66D, 'V'),
+    (0xA680, 'M', 'ꚁ'),
+    (0xA681, 'V'),
+    (0xA682, 'M', 'ꚃ'),
+    (0xA683, 'V'),
+    (0xA684, 'M', 'ꚅ'),
+    (0xA685, 'V'),
+    (0xA686, 'M', 'ꚇ'),
+    (0xA687, 'V'),
+    (0xA688, 'M', 'ꚉ'),
+    (0xA689, 'V'),
+    (0xA68A, 'M', 'ꚋ'),
+    (0xA68B, 'V'),
+    (0xA68C, 'M', 'ꚍ'),
+    (0xA68D, 'V'),
+    (0xA68E, 'M', 'ꚏ'),
+    (0xA68F, 'V'),
+    (0xA690, 'M', 'ꚑ'),
+    (0xA691, 'V'),
+    ]
+
+def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA692, 'M', 'ꚓ'),
+    (0xA693, 'V'),
+    (0xA694, 'M', 'ꚕ'),
+    (0xA695, 'V'),
+    (0xA696, 'M', 'ꚗ'),
+    (0xA697, 'V'),
+    (0xA698, 'M', 'ꚙ'),
+    (0xA699, 'V'),
+    (0xA69A, 'M', 'ꚛ'),
+    (0xA69B, 'V'),
+    (0xA69C, 'M', 'ъ'),
+    (0xA69D, 'M', 'ь'),
+    (0xA69E, 'V'),
+    (0xA6F8, 'X'),
+    (0xA700, 'V'),
+    (0xA722, 'M', 'ꜣ'),
+    (0xA723, 'V'),
+    (0xA724, 'M', 'ꜥ'),
+    (0xA725, 'V'),
+    (0xA726, 'M', 'ꜧ'),
+    (0xA727, 'V'),
+    (0xA728, 'M', 'ꜩ'),
+    (0xA729, 'V'),
+    (0xA72A, 'M', 'ꜫ'),
+    (0xA72B, 'V'),
+    (0xA72C, 'M', 'ꜭ'),
+    (0xA72D, 'V'),
+    (0xA72E, 'M', 'ꜯ'),
+    (0xA72F, 'V'),
+    (0xA732, 'M', 'ꜳ'),
+    (0xA733, 'V'),
+    (0xA734, 'M', 'ꜵ'),
+    (0xA735, 'V'),
+    (0xA736, 'M', 'ꜷ'),
+    (0xA737, 'V'),
+    (0xA738, 'M', 'ꜹ'),
+    (0xA739, 'V'),
+    (0xA73A, 'M', 'ꜻ'),
+    (0xA73B, 'V'),
+    (0xA73C, 'M', 'ꜽ'),
+    (0xA73D, 'V'),
+    (0xA73E, 'M', 'ꜿ'),
+    (0xA73F, 'V'),
+    (0xA740, 'M', 'ꝁ'),
+    (0xA741, 'V'),
+    (0xA742, 'M', 'ꝃ'),
+    (0xA743, 'V'),
+    (0xA744, 'M', 'ꝅ'),
+    (0xA745, 'V'),
+    (0xA746, 'M', 'ꝇ'),
+    (0xA747, 'V'),
+    (0xA748, 'M', 'ꝉ'),
+    (0xA749, 'V'),
+    (0xA74A, 'M', 'ꝋ'),
+    (0xA74B, 'V'),
+    (0xA74C, 'M', 'ꝍ'),
+    (0xA74D, 'V'),
+    (0xA74E, 'M', 'ꝏ'),
+    (0xA74F, 'V'),
+    (0xA750, 'M', 'ꝑ'),
+    (0xA751, 'V'),
+    (0xA752, 'M', 'ꝓ'),
+    (0xA753, 'V'),
+    (0xA754, 'M', 'ꝕ'),
+    (0xA755, 'V'),
+    (0xA756, 'M', 'ꝗ'),
+    (0xA757, 'V'),
+    (0xA758, 'M', 'ꝙ'),
+    (0xA759, 'V'),
+    (0xA75A, 'M', 'ꝛ'),
+    (0xA75B, 'V'),
+    (0xA75C, 'M', 'ꝝ'),
+    (0xA75D, 'V'),
+    (0xA75E, 'M', 'ꝟ'),
+    (0xA75F, 'V'),
+    (0xA760, 'M', 'ꝡ'),
+    (0xA761, 'V'),
+    (0xA762, 'M', 'ꝣ'),
+    (0xA763, 'V'),
+    (0xA764, 'M', 'ꝥ'),
+    (0xA765, 'V'),
+    (0xA766, 'M', 'ꝧ'),
+    (0xA767, 'V'),
+    (0xA768, 'M', 'ꝩ'),
+    (0xA769, 'V'),
+    (0xA76A, 'M', 'ꝫ'),
+    (0xA76B, 'V'),
+    (0xA76C, 'M', 'ꝭ'),
+    (0xA76D, 'V'),
+    (0xA76E, 'M', 'ꝯ'),
+    (0xA76F, 'V'),
+    (0xA770, 'M', 'ꝯ'),
+    (0xA771, 'V'),
+    (0xA779, 'M', 'ꝺ'),
+    (0xA77A, 'V'),
+    (0xA77B, 'M', 'ꝼ'),
+    (0xA77C, 'V'),
+    (0xA77D, 'M', 'ᵹ'),
+    (0xA77E, 'M', 'ꝿ'),
+    (0xA77F, 'V'),
+    ]
+
+def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA780, 'M', 'ꞁ'),
+    (0xA781, 'V'),
+    (0xA782, 'M', 'ꞃ'),
+    (0xA783, 'V'),
+    (0xA784, 'M', 'ꞅ'),
+    (0xA785, 'V'),
+    (0xA786, 'M', 'ꞇ'),
+    (0xA787, 'V'),
+    (0xA78B, 'M', 'ꞌ'),
+    (0xA78C, 'V'),
+    (0xA78D, 'M', 'ɥ'),
+    (0xA78E, 'V'),
+    (0xA790, 'M', 'ꞑ'),
+    (0xA791, 'V'),
+    (0xA792, 'M', 'ꞓ'),
+    (0xA793, 'V'),
+    (0xA796, 'M', 'ꞗ'),
+    (0xA797, 'V'),
+    (0xA798, 'M', 'ꞙ'),
+    (0xA799, 'V'),
+    (0xA79A, 'M', 'ꞛ'),
+    (0xA79B, 'V'),
+    (0xA79C, 'M', 'ꞝ'),
+    (0xA79D, 'V'),
+    (0xA79E, 'M', 'ꞟ'),
+    (0xA79F, 'V'),
+    (0xA7A0, 'M', 'ꞡ'),
+    (0xA7A1, 'V'),
+    (0xA7A2, 'M', 'ꞣ'),
+    (0xA7A3, 'V'),
+    (0xA7A4, 'M', 'ꞥ'),
+    (0xA7A5, 'V'),
+    (0xA7A6, 'M', 'ꞧ'),
+    (0xA7A7, 'V'),
+    (0xA7A8, 'M', 'ꞩ'),
+    (0xA7A9, 'V'),
+    (0xA7AA, 'M', 'ɦ'),
+    (0xA7AB, 'M', 'ɜ'),
+    (0xA7AC, 'M', 'ɡ'),
+    (0xA7AD, 'M', 'ɬ'),
+    (0xA7AE, 'M', 'ɪ'),
+    (0xA7AF, 'V'),
+    (0xA7B0, 'M', 'ʞ'),
+    (0xA7B1, 'M', 'ʇ'),
+    (0xA7B2, 'M', 'ʝ'),
+    (0xA7B3, 'M', 'ꭓ'),
+    (0xA7B4, 'M', 'ꞵ'),
+    (0xA7B5, 'V'),
+    (0xA7B6, 'M', 'ꞷ'),
+    (0xA7B7, 'V'),
+    (0xA7B8, 'M', 'ꞹ'),
+    (0xA7B9, 'V'),
+    (0xA7BA, 'M', 'ꞻ'),
+    (0xA7BB, 'V'),
+    (0xA7BC, 'M', 'ꞽ'),
+    (0xA7BD, 'V'),
+    (0xA7BE, 'M', 'ꞿ'),
+    (0xA7BF, 'V'),
+    (0xA7C0, 'M', 'ꟁ'),
+    (0xA7C1, 'V'),
+    (0xA7C2, 'M', 'ꟃ'),
+    (0xA7C3, 'V'),
+    (0xA7C4, 'M', 'ꞔ'),
+    (0xA7C5, 'M', 'ʂ'),
+    (0xA7C6, 'M', 'ᶎ'),
+    (0xA7C7, 'M', 'ꟈ'),
+    (0xA7C8, 'V'),
+    (0xA7C9, 'M', 'ꟊ'),
+    (0xA7CA, 'V'),
+    (0xA7CB, 'X'),
+    (0xA7D0, 'M', 'ꟑ'),
+    (0xA7D1, 'V'),
+    (0xA7D2, 'X'),
+    (0xA7D3, 'V'),
+    (0xA7D4, 'X'),
+    (0xA7D5, 'V'),
+    (0xA7D6, 'M', 'ꟗ'),
+    (0xA7D7, 'V'),
+    (0xA7D8, 'M', 'ꟙ'),
+    (0xA7D9, 'V'),
+    (0xA7DA, 'X'),
+    (0xA7F2, 'M', 'c'),
+    (0xA7F3, 'M', 'f'),
+    (0xA7F4, 'M', 'q'),
+    (0xA7F5, 'M', 'ꟶ'),
+    (0xA7F6, 'V'),
+    (0xA7F8, 'M', 'ħ'),
+    (0xA7F9, 'M', 'œ'),
+    (0xA7FA, 'V'),
+    (0xA82D, 'X'),
+    (0xA830, 'V'),
+    (0xA83A, 'X'),
+    (0xA840, 'V'),
+    (0xA878, 'X'),
+    (0xA880, 'V'),
+    (0xA8C6, 'X'),
+    (0xA8CE, 'V'),
+    (0xA8DA, 'X'),
+    (0xA8E0, 'V'),
+    (0xA954, 'X'),
+    ]
+
+def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA95F, 'V'),
+    (0xA97D, 'X'),
+    (0xA980, 'V'),
+    (0xA9CE, 'X'),
+    (0xA9CF, 'V'),
+    (0xA9DA, 'X'),
+    (0xA9DE, 'V'),
+    (0xA9FF, 'X'),
+    (0xAA00, 'V'),
+    (0xAA37, 'X'),
+    (0xAA40, 'V'),
+    (0xAA4E, 'X'),
+    (0xAA50, 'V'),
+    (0xAA5A, 'X'),
+    (0xAA5C, 'V'),
+    (0xAAC3, 'X'),
+    (0xAADB, 'V'),
+    (0xAAF7, 'X'),
+    (0xAB01, 'V'),
+    (0xAB07, 'X'),
+    (0xAB09, 'V'),
+    (0xAB0F, 'X'),
+    (0xAB11, 'V'),
+    (0xAB17, 'X'),
+    (0xAB20, 'V'),
+    (0xAB27, 'X'),
+    (0xAB28, 'V'),
+    (0xAB2F, 'X'),
+    (0xAB30, 'V'),
+    (0xAB5C, 'M', 'ꜧ'),
+    (0xAB5D, 'M', 'ꬷ'),
+    (0xAB5E, 'M', 'ɫ'),
+    (0xAB5F, 'M', 'ꭒ'),
+    (0xAB60, 'V'),
+    (0xAB69, 'M', 'ʍ'),
+    (0xAB6A, 'V'),
+    (0xAB6C, 'X'),
+    (0xAB70, 'M', 'Ꭰ'),
+    (0xAB71, 'M', 'Ꭱ'),
+    (0xAB72, 'M', 'Ꭲ'),
+    (0xAB73, 'M', 'Ꭳ'),
+    (0xAB74, 'M', 'Ꭴ'),
+    (0xAB75, 'M', 'Ꭵ'),
+    (0xAB76, 'M', 'Ꭶ'),
+    (0xAB77, 'M', 'Ꭷ'),
+    (0xAB78, 'M', 'Ꭸ'),
+    (0xAB79, 'M', 'Ꭹ'),
+    (0xAB7A, 'M', 'Ꭺ'),
+    (0xAB7B, 'M', 'Ꭻ'),
+    (0xAB7C, 'M', 'Ꭼ'),
+    (0xAB7D, 'M', 'Ꭽ'),
+    (0xAB7E, 'M', 'Ꭾ'),
+    (0xAB7F, 'M', 'Ꭿ'),
+    (0xAB80, 'M', 'Ꮀ'),
+    (0xAB81, 'M', 'Ꮁ'),
+    (0xAB82, 'M', 'Ꮂ'),
+    (0xAB83, 'M', 'Ꮃ'),
+    (0xAB84, 'M', 'Ꮄ'),
+    (0xAB85, 'M', 'Ꮅ'),
+    (0xAB86, 'M', 'Ꮆ'),
+    (0xAB87, 'M', 'Ꮇ'),
+    (0xAB88, 'M', 'Ꮈ'),
+    (0xAB89, 'M', 'Ꮉ'),
+    (0xAB8A, 'M', 'Ꮊ'),
+    (0xAB8B, 'M', 'Ꮋ'),
+    (0xAB8C, 'M', 'Ꮌ'),
+    (0xAB8D, 'M', 'Ꮍ'),
+    (0xAB8E, 'M', 'Ꮎ'),
+    (0xAB8F, 'M', 'Ꮏ'),
+    (0xAB90, 'M', 'Ꮐ'),
+    (0xAB91, 'M', 'Ꮑ'),
+    (0xAB92, 'M', 'Ꮒ'),
+    (0xAB93, 'M', 'Ꮓ'),
+    (0xAB94, 'M', 'Ꮔ'),
+    (0xAB95, 'M', 'Ꮕ'),
+    (0xAB96, 'M', 'Ꮖ'),
+    (0xAB97, 'M', 'Ꮗ'),
+    (0xAB98, 'M', 'Ꮘ'),
+    (0xAB99, 'M', 'Ꮙ'),
+    (0xAB9A, 'M', 'Ꮚ'),
+    (0xAB9B, 'M', 'Ꮛ'),
+    (0xAB9C, 'M', 'Ꮜ'),
+    (0xAB9D, 'M', 'Ꮝ'),
+    (0xAB9E, 'M', 'Ꮞ'),
+    (0xAB9F, 'M', 'Ꮟ'),
+    (0xABA0, 'M', 'Ꮠ'),
+    (0xABA1, 'M', 'Ꮡ'),
+    (0xABA2, 'M', 'Ꮢ'),
+    (0xABA3, 'M', 'Ꮣ'),
+    (0xABA4, 'M', 'Ꮤ'),
+    (0xABA5, 'M', 'Ꮥ'),
+    (0xABA6, 'M', 'Ꮦ'),
+    (0xABA7, 'M', 'Ꮧ'),
+    (0xABA8, 'M', 'Ꮨ'),
+    (0xABA9, 'M', 'Ꮩ'),
+    (0xABAA, 'M', 'Ꮪ'),
+    (0xABAB, 'M', 'Ꮫ'),
+    (0xABAC, 'M', 'Ꮬ'),
+    (0xABAD, 'M', 'Ꮭ'),
+    (0xABAE, 'M', 'Ꮮ'),
+    ]
+
+def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xABAF, 'M', 'Ꮯ'),
+    (0xABB0, 'M', 'Ꮰ'),
+    (0xABB1, 'M', 'Ꮱ'),
+    (0xABB2, 'M', 'Ꮲ'),
+    (0xABB3, 'M', 'Ꮳ'),
+    (0xABB4, 'M', 'Ꮴ'),
+    (0xABB5, 'M', 'Ꮵ'),
+    (0xABB6, 'M', 'Ꮶ'),
+    (0xABB7, 'M', 'Ꮷ'),
+    (0xABB8, 'M', 'Ꮸ'),
+    (0xABB9, 'M', 'Ꮹ'),
+    (0xABBA, 'M', 'Ꮺ'),
+    (0xABBB, 'M', 'Ꮻ'),
+    (0xABBC, 'M', 'Ꮼ'),
+    (0xABBD, 'M', 'Ꮽ'),
+    (0xABBE, 'M', 'Ꮾ'),
+    (0xABBF, 'M', 'Ꮿ'),
+    (0xABC0, 'V'),
+    (0xABEE, 'X'),
+    (0xABF0, 'V'),
+    (0xABFA, 'X'),
+    (0xAC00, 'V'),
+    (0xD7A4, 'X'),
+    (0xD7B0, 'V'),
+    (0xD7C7, 'X'),
+    (0xD7CB, 'V'),
+    (0xD7FC, 'X'),
+    (0xF900, 'M', '豈'),
+    (0xF901, 'M', '更'),
+    (0xF902, 'M', '車'),
+    (0xF903, 'M', '賈'),
+    (0xF904, 'M', '滑'),
+    (0xF905, 'M', '串'),
+    (0xF906, 'M', '句'),
+    (0xF907, 'M', '龜'),
+    (0xF909, 'M', '契'),
+    (0xF90A, 'M', '金'),
+    (0xF90B, 'M', '喇'),
+    (0xF90C, 'M', '奈'),
+    (0xF90D, 'M', '懶'),
+    (0xF90E, 'M', '癩'),
+    (0xF90F, 'M', '羅'),
+    (0xF910, 'M', '蘿'),
+    (0xF911, 'M', '螺'),
+    (0xF912, 'M', '裸'),
+    (0xF913, 'M', '邏'),
+    (0xF914, 'M', '樂'),
+    (0xF915, 'M', '洛'),
+    (0xF916, 'M', '烙'),
+    (0xF917, 'M', '珞'),
+    (0xF918, 'M', '落'),
+    (0xF919, 'M', '酪'),
+    (0xF91A, 'M', '駱'),
+    (0xF91B, 'M', '亂'),
+    (0xF91C, 'M', '卵'),
+    (0xF91D, 'M', '欄'),
+    (0xF91E, 'M', '爛'),
+    (0xF91F, 'M', '蘭'),
+    (0xF920, 'M', '鸞'),
+    (0xF921, 'M', '嵐'),
+    (0xF922, 'M', '濫'),
+    (0xF923, 'M', '藍'),
+    (0xF924, 'M', '襤'),
+    (0xF925, 'M', '拉'),
+    (0xF926, 'M', '臘'),
+    (0xF927, 'M', '蠟'),
+    (0xF928, 'M', '廊'),
+    (0xF929, 'M', '朗'),
+    (0xF92A, 'M', '浪'),
+    (0xF92B, 'M', '狼'),
+    (0xF92C, 'M', '郎'),
+    (0xF92D, 'M', '來'),
+    (0xF92E, 'M', '冷'),
+    (0xF92F, 'M', '勞'),
+    (0xF930, 'M', '擄'),
+    (0xF931, 'M', '櫓'),
+    (0xF932, 'M', '爐'),
+    (0xF933, 'M', '盧'),
+    (0xF934, 'M', '老'),
+    (0xF935, 'M', '蘆'),
+    (0xF936, 'M', '虜'),
+    (0xF937, 'M', '路'),
+    (0xF938, 'M', '露'),
+    (0xF939, 'M', '魯'),
+    (0xF93A, 'M', '鷺'),
+    (0xF93B, 'M', '碌'),
+    (0xF93C, 'M', '祿'),
+    (0xF93D, 'M', '綠'),
+    (0xF93E, 'M', '菉'),
+    (0xF93F, 'M', '錄'),
+    (0xF940, 'M', '鹿'),
+    (0xF941, 'M', '論'),
+    (0xF942, 'M', '壟'),
+    (0xF943, 'M', '弄'),
+    (0xF944, 'M', '籠'),
+    (0xF945, 'M', '聾'),
+    (0xF946, 'M', '牢'),
+    (0xF947, 'M', '磊'),
+    (0xF948, 'M', '賂'),
+    (0xF949, 'M', '雷'),
+    ]
+
+def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xF94A, 'M', '壘'),
+    (0xF94B, 'M', '屢'),
+    (0xF94C, 'M', '樓'),
+    (0xF94D, 'M', '淚'),
+    (0xF94E, 'M', '漏'),
+    (0xF94F, 'M', '累'),
+    (0xF950, 'M', '縷'),
+    (0xF951, 'M', '陋'),
+    (0xF952, 'M', '勒'),
+    (0xF953, 'M', '肋'),
+    (0xF954, 'M', '凜'),
+    (0xF955, 'M', '凌'),
+    (0xF956, 'M', '稜'),
+    (0xF957, 'M', '綾'),
+    (0xF958, 'M', '菱'),
+    (0xF959, 'M', '陵'),
+    (0xF95A, 'M', '讀'),
+    (0xF95B, 'M', '拏'),
+    (0xF95C, 'M', '樂'),
+    (0xF95D, 'M', '諾'),
+    (0xF95E, 'M', '丹'),
+    (0xF95F, 'M', '寧'),
+    (0xF960, 'M', '怒'),
+    (0xF961, 'M', '率'),
+    (0xF962, 'M', '異'),
+    (0xF963, 'M', '北'),
+    (0xF964, 'M', '磻'),
+    (0xF965, 'M', '便'),
+    (0xF966, 'M', '復'),
+    (0xF967, 'M', '不'),
+    (0xF968, 'M', '泌'),
+    (0xF969, 'M', '數'),
+    (0xF96A, 'M', '索'),
+    (0xF96B, 'M', '參'),
+    (0xF96C, 'M', '塞'),
+    (0xF96D, 'M', '省'),
+    (0xF96E, 'M', '葉'),
+    (0xF96F, 'M', '說'),
+    (0xF970, 'M', '殺'),
+    (0xF971, 'M', '辰'),
+    (0xF972, 'M', '沈'),
+    (0xF973, 'M', '拾'),
+    (0xF974, 'M', '若'),
+    (0xF975, 'M', '掠'),
+    (0xF976, 'M', '略'),
+    (0xF977, 'M', '亮'),
+    (0xF978, 'M', '兩'),
+    (0xF979, 'M', '凉'),
+    (0xF97A, 'M', '梁'),
+    (0xF97B, 'M', '糧'),
+    (0xF97C, 'M', '良'),
+    (0xF97D, 'M', '諒'),
+    (0xF97E, 'M', '量'),
+    (0xF97F, 'M', '勵'),
+    (0xF980, 'M', '呂'),
+    (0xF981, 'M', '女'),
+    (0xF982, 'M', '廬'),
+    (0xF983, 'M', '旅'),
+    (0xF984, 'M', '濾'),
+    (0xF985, 'M', '礪'),
+    (0xF986, 'M', '閭'),
+    (0xF987, 'M', '驪'),
+    (0xF988, 'M', '麗'),
+    (0xF989, 'M', '黎'),
+    (0xF98A, 'M', '力'),
+    (0xF98B, 'M', '曆'),
+    (0xF98C, 'M', '歷'),
+    (0xF98D, 'M', '轢'),
+    (0xF98E, 'M', '年'),
+    (0xF98F, 'M', '憐'),
+    (0xF990, 'M', '戀'),
+    (0xF991, 'M', '撚'),
+    (0xF992, 'M', '漣'),
+    (0xF993, 'M', '煉'),
+    (0xF994, 'M', '璉'),
+    (0xF995, 'M', '秊'),
+    (0xF996, 'M', '練'),
+    (0xF997, 'M', '聯'),
+    (0xF998, 'M', '輦'),
+    (0xF999, 'M', '蓮'),
+    (0xF99A, 'M', '連'),
+    (0xF99B, 'M', '鍊'),
+    (0xF99C, 'M', '列'),
+    (0xF99D, 'M', '劣'),
+    (0xF99E, 'M', '咽'),
+    (0xF99F, 'M', '烈'),
+    (0xF9A0, 'M', '裂'),
+    (0xF9A1, 'M', '說'),
+    (0xF9A2, 'M', '廉'),
+    (0xF9A3, 'M', '念'),
+    (0xF9A4, 'M', '捻'),
+    (0xF9A5, 'M', '殮'),
+    (0xF9A6, 'M', '簾'),
+    (0xF9A7, 'M', '獵'),
+    (0xF9A8, 'M', '令'),
+    (0xF9A9, 'M', '囹'),
+    (0xF9AA, 'M', '寧'),
+    (0xF9AB, 'M', '嶺'),
+    (0xF9AC, 'M', '怜'),
+    (0xF9AD, 'M', '玲'),
+    ]
+
+def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xF9AE, 'M', '瑩'),
+    (0xF9AF, 'M', '羚'),
+    (0xF9B0, 'M', '聆'),
+    (0xF9B1, 'M', '鈴'),
+    (0xF9B2, 'M', '零'),
+    (0xF9B3, 'M', '靈'),
+    (0xF9B4, 'M', '領'),
+    (0xF9B5, 'M', '例'),
+    (0xF9B6, 'M', '禮'),
+    (0xF9B7, 'M', '醴'),
+    (0xF9B8, 'M', '隸'),
+    (0xF9B9, 'M', '惡'),
+    (0xF9BA, 'M', '了'),
+    (0xF9BB, 'M', '僚'),
+    (0xF9BC, 'M', '寮'),
+    (0xF9BD, 'M', '尿'),
+    (0xF9BE, 'M', '料'),
+    (0xF9BF, 'M', '樂'),
+    (0xF9C0, 'M', '燎'),
+    (0xF9C1, 'M', '療'),
+    (0xF9C2, 'M', '蓼'),
+    (0xF9C3, 'M', '遼'),
+    (0xF9C4, 'M', '龍'),
+    (0xF9C5, 'M', '暈'),
+    (0xF9C6, 'M', '阮'),
+    (0xF9C7, 'M', '劉'),
+    (0xF9C8, 'M', '杻'),
+    (0xF9C9, 'M', '柳'),
+    (0xF9CA, 'M', '流'),
+    (0xF9CB, 'M', '溜'),
+    (0xF9CC, 'M', '琉'),
+    (0xF9CD, 'M', '留'),
+    (0xF9CE, 'M', '硫'),
+    (0xF9CF, 'M', '紐'),
+    (0xF9D0, 'M', '類'),
+    (0xF9D1, 'M', '六'),
+    (0xF9D2, 'M', '戮'),
+    (0xF9D3, 'M', '陸'),
+    (0xF9D4, 'M', '倫'),
+    (0xF9D5, 'M', '崙'),
+    (0xF9D6, 'M', '淪'),
+    (0xF9D7, 'M', '輪'),
+    (0xF9D8, 'M', '律'),
+    (0xF9D9, 'M', '慄'),
+    (0xF9DA, 'M', '栗'),
+    (0xF9DB, 'M', '率'),
+    (0xF9DC, 'M', '隆'),
+    (0xF9DD, 'M', '利'),
+    (0xF9DE, 'M', '吏'),
+    (0xF9DF, 'M', '履'),
+    (0xF9E0, 'M', '易'),
+    (0xF9E1, 'M', '李'),
+    (0xF9E2, 'M', '梨'),
+    (0xF9E3, 'M', '泥'),
+    (0xF9E4, 'M', '理'),
+    (0xF9E5, 'M', '痢'),
+    (0xF9E6, 'M', '罹'),
+    (0xF9E7, 'M', '裏'),
+    (0xF9E8, 'M', '裡'),
+    (0xF9E9, 'M', '里'),
+    (0xF9EA, 'M', '離'),
+    (0xF9EB, 'M', '匿'),
+    (0xF9EC, 'M', '溺'),
+    (0xF9ED, 'M', '吝'),
+    (0xF9EE, 'M', '燐'),
+    (0xF9EF, 'M', '璘'),
+    (0xF9F0, 'M', '藺'),
+    (0xF9F1, 'M', '隣'),
+    (0xF9F2, 'M', '鱗'),
+    (0xF9F3, 'M', '麟'),
+    (0xF9F4, 'M', '林'),
+    (0xF9F5, 'M', '淋'),
+    (0xF9F6, 'M', '臨'),
+    (0xF9F7, 'M', '立'),
+    (0xF9F8, 'M', '笠'),
+    (0xF9F9, 'M', '粒'),
+    (0xF9FA, 'M', '狀'),
+    (0xF9FB, 'M', '炙'),
+    (0xF9FC, 'M', '識'),
+    (0xF9FD, 'M', '什'),
+    (0xF9FE, 'M', '茶'),
+    (0xF9FF, 'M', '刺'),
+    (0xFA00, 'M', '切'),
+    (0xFA01, 'M', '度'),
+    (0xFA02, 'M', '拓'),
+    (0xFA03, 'M', '糖'),
+    (0xFA04, 'M', '宅'),
+    (0xFA05, 'M', '洞'),
+    (0xFA06, 'M', '暴'),
+    (0xFA07, 'M', '輻'),
+    (0xFA08, 'M', '行'),
+    (0xFA09, 'M', '降'),
+    (0xFA0A, 'M', '見'),
+    (0xFA0B, 'M', '廓'),
+    (0xFA0C, 'M', '兀'),
+    (0xFA0D, 'M', '嗀'),
+    (0xFA0E, 'V'),
+    (0xFA10, 'M', '塚'),
+    (0xFA11, 'V'),
+    (0xFA12, 'M', '晴'),
+    ]
+
+def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFA13, 'V'),
+    (0xFA15, 'M', '凞'),
+    (0xFA16, 'M', '猪'),
+    (0xFA17, 'M', '益'),
+    (0xFA18, 'M', '礼'),
+    (0xFA19, 'M', '神'),
+    (0xFA1A, 'M', '祥'),
+    (0xFA1B, 'M', '福'),
+    (0xFA1C, 'M', '靖'),
+    (0xFA1D, 'M', '精'),
+    (0xFA1E, 'M', '羽'),
+    (0xFA1F, 'V'),
+    (0xFA20, 'M', '蘒'),
+    (0xFA21, 'V'),
+    (0xFA22, 'M', '諸'),
+    (0xFA23, 'V'),
+    (0xFA25, 'M', '逸'),
+    (0xFA26, 'M', '都'),
+    (0xFA27, 'V'),
+    (0xFA2A, 'M', '飯'),
+    (0xFA2B, 'M', '飼'),
+    (0xFA2C, 'M', '館'),
+    (0xFA2D, 'M', '鶴'),
+    (0xFA2E, 'M', '郞'),
+    (0xFA2F, 'M', '隷'),
+    (0xFA30, 'M', '侮'),
+    (0xFA31, 'M', '僧'),
+    (0xFA32, 'M', '免'),
+    (0xFA33, 'M', '勉'),
+    (0xFA34, 'M', '勤'),
+    (0xFA35, 'M', '卑'),
+    (0xFA36, 'M', '喝'),
+    (0xFA37, 'M', '嘆'),
+    (0xFA38, 'M', '器'),
+    (0xFA39, 'M', '塀'),
+    (0xFA3A, 'M', '墨'),
+    (0xFA3B, 'M', '層'),
+    (0xFA3C, 'M', '屮'),
+    (0xFA3D, 'M', '悔'),
+    (0xFA3E, 'M', '慨'),
+    (0xFA3F, 'M', '憎'),
+    (0xFA40, 'M', '懲'),
+    (0xFA41, 'M', '敏'),
+    (0xFA42, 'M', '既'),
+    (0xFA43, 'M', '暑'),
+    (0xFA44, 'M', '梅'),
+    (0xFA45, 'M', '海'),
+    (0xFA46, 'M', '渚'),
+    (0xFA47, 'M', '漢'),
+    (0xFA48, 'M', '煮'),
+    (0xFA49, 'M', '爫'),
+    (0xFA4A, 'M', '琢'),
+    (0xFA4B, 'M', '碑'),
+    (0xFA4C, 'M', '社'),
+    (0xFA4D, 'M', '祉'),
+    (0xFA4E, 'M', '祈'),
+    (0xFA4F, 'M', '祐'),
+    (0xFA50, 'M', '祖'),
+    (0xFA51, 'M', '祝'),
+    (0xFA52, 'M', '禍'),
+    (0xFA53, 'M', '禎'),
+    (0xFA54, 'M', '穀'),
+    (0xFA55, 'M', '突'),
+    (0xFA56, 'M', '節'),
+    (0xFA57, 'M', '練'),
+    (0xFA58, 'M', '縉'),
+    (0xFA59, 'M', '繁'),
+    (0xFA5A, 'M', '署'),
+    (0xFA5B, 'M', '者'),
+    (0xFA5C, 'M', '臭'),
+    (0xFA5D, 'M', '艹'),
+    (0xFA5F, 'M', '著'),
+    (0xFA60, 'M', '褐'),
+    (0xFA61, 'M', '視'),
+    (0xFA62, 'M', '謁'),
+    (0xFA63, 'M', '謹'),
+    (0xFA64, 'M', '賓'),
+    (0xFA65, 'M', '贈'),
+    (0xFA66, 'M', '辶'),
+    (0xFA67, 'M', '逸'),
+    (0xFA68, 'M', '難'),
+    (0xFA69, 'M', '響'),
+    (0xFA6A, 'M', '頻'),
+    (0xFA6B, 'M', '恵'),
+    (0xFA6C, 'M', '𤋮'),
+    (0xFA6D, 'M', '舘'),
+    (0xFA6E, 'X'),
+    (0xFA70, 'M', '並'),
+    (0xFA71, 'M', '况'),
+    (0xFA72, 'M', '全'),
+    (0xFA73, 'M', '侀'),
+    (0xFA74, 'M', '充'),
+    (0xFA75, 'M', '冀'),
+    (0xFA76, 'M', '勇'),
+    (0xFA77, 'M', '勺'),
+    (0xFA78, 'M', '喝'),
+    (0xFA79, 'M', '啕'),
+    (0xFA7A, 'M', '喙'),
+    (0xFA7B, 'M', '嗢'),
+    (0xFA7C, 'M', '塚'),
+    ]
+
+def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFA7D, 'M', '墳'),
+    (0xFA7E, 'M', '奄'),
+    (0xFA7F, 'M', '奔'),
+    (0xFA80, 'M', '婢'),
+    (0xFA81, 'M', '嬨'),
+    (0xFA82, 'M', '廒'),
+    (0xFA83, 'M', '廙'),
+    (0xFA84, 'M', '彩'),
+    (0xFA85, 'M', '徭'),
+    (0xFA86, 'M', '惘'),
+    (0xFA87, 'M', '慎'),
+    (0xFA88, 'M', '愈'),
+    (0xFA89, 'M', '憎'),
+    (0xFA8A, 'M', '慠'),
+    (0xFA8B, 'M', '懲'),
+    (0xFA8C, 'M', '戴'),
+    (0xFA8D, 'M', '揄'),
+    (0xFA8E, 'M', '搜'),
+    (0xFA8F, 'M', '摒'),
+    (0xFA90, 'M', '敖'),
+    (0xFA91, 'M', '晴'),
+    (0xFA92, 'M', '朗'),
+    (0xFA93, 'M', '望'),
+    (0xFA94, 'M', '杖'),
+    (0xFA95, 'M', '歹'),
+    (0xFA96, 'M', '殺'),
+    (0xFA97, 'M', '流'),
+    (0xFA98, 'M', '滛'),
+    (0xFA99, 'M', '滋'),
+    (0xFA9A, 'M', '漢'),
+    (0xFA9B, 'M', '瀞'),
+    (0xFA9C, 'M', '煮'),
+    (0xFA9D, 'M', '瞧'),
+    (0xFA9E, 'M', '爵'),
+    (0xFA9F, 'M', '犯'),
+    (0xFAA0, 'M', '猪'),
+    (0xFAA1, 'M', '瑱'),
+    (0xFAA2, 'M', '甆'),
+    (0xFAA3, 'M', '画'),
+    (0xFAA4, 'M', '瘝'),
+    (0xFAA5, 'M', '瘟'),
+    (0xFAA6, 'M', '益'),
+    (0xFAA7, 'M', '盛'),
+    (0xFAA8, 'M', '直'),
+    (0xFAA9, 'M', '睊'),
+    (0xFAAA, 'M', '着'),
+    (0xFAAB, 'M', '磌'),
+    (0xFAAC, 'M', '窱'),
+    (0xFAAD, 'M', '節'),
+    (0xFAAE, 'M', '类'),
+    (0xFAAF, 'M', '絛'),
+    (0xFAB0, 'M', '練'),
+    (0xFAB1, 'M', '缾'),
+    (0xFAB2, 'M', '者'),
+    (0xFAB3, 'M', '荒'),
+    (0xFAB4, 'M', '華'),
+    (0xFAB5, 'M', '蝹'),
+    (0xFAB6, 'M', '襁'),
+    (0xFAB7, 'M', '覆'),
+    (0xFAB8, 'M', '視'),
+    (0xFAB9, 'M', '調'),
+    (0xFABA, 'M', '諸'),
+    (0xFABB, 'M', '請'),
+    (0xFABC, 'M', '謁'),
+    (0xFABD, 'M', '諾'),
+    (0xFABE, 'M', '諭'),
+    (0xFABF, 'M', '謹'),
+    (0xFAC0, 'M', '變'),
+    (0xFAC1, 'M', '贈'),
+    (0xFAC2, 'M', '輸'),
+    (0xFAC3, 'M', '遲'),
+    (0xFAC4, 'M', '醙'),
+    (0xFAC5, 'M', '鉶'),
+    (0xFAC6, 'M', '陼'),
+    (0xFAC7, 'M', '難'),
+    (0xFAC8, 'M', '靖'),
+    (0xFAC9, 'M', '韛'),
+    (0xFACA, 'M', '響'),
+    (0xFACB, 'M', '頋'),
+    (0xFACC, 'M', '頻'),
+    (0xFACD, 'M', '鬒'),
+    (0xFACE, 'M', '龜'),
+    (0xFACF, 'M', '𢡊'),
+    (0xFAD0, 'M', '𢡄'),
+    (0xFAD1, 'M', '𣏕'),
+    (0xFAD2, 'M', '㮝'),
+    (0xFAD3, 'M', '䀘'),
+    (0xFAD4, 'M', '䀹'),
+    (0xFAD5, 'M', '𥉉'),
+    (0xFAD6, 'M', '𥳐'),
+    (0xFAD7, 'M', '𧻓'),
+    (0xFAD8, 'M', '齃'),
+    (0xFAD9, 'M', '龎'),
+    (0xFADA, 'X'),
+    (0xFB00, 'M', 'ff'),
+    (0xFB01, 'M', 'fi'),
+    (0xFB02, 'M', 'fl'),
+    (0xFB03, 'M', 'ffi'),
+    (0xFB04, 'M', 'ffl'),
+    (0xFB05, 'M', 'st'),
+    ]
+
+def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFB07, 'X'),
+    (0xFB13, 'M', 'մն'),
+    (0xFB14, 'M', 'մե'),
+    (0xFB15, 'M', 'մի'),
+    (0xFB16, 'M', 'վն'),
+    (0xFB17, 'M', 'մխ'),
+    (0xFB18, 'X'),
+    (0xFB1D, 'M', 'יִ'),
+    (0xFB1E, 'V'),
+    (0xFB1F, 'M', 'ײַ'),
+    (0xFB20, 'M', 'ע'),
+    (0xFB21, 'M', 'א'),
+    (0xFB22, 'M', 'ד'),
+    (0xFB23, 'M', 'ה'),
+    (0xFB24, 'M', 'כ'),
+    (0xFB25, 'M', 'ל'),
+    (0xFB26, 'M', 'ם'),
+    (0xFB27, 'M', 'ר'),
+    (0xFB28, 'M', 'ת'),
+    (0xFB29, '3', '+'),
+    (0xFB2A, 'M', 'שׁ'),
+    (0xFB2B, 'M', 'שׂ'),
+    (0xFB2C, 'M', 'שּׁ'),
+    (0xFB2D, 'M', 'שּׂ'),
+    (0xFB2E, 'M', 'אַ'),
+    (0xFB2F, 'M', 'אָ'),
+    (0xFB30, 'M', 'אּ'),
+    (0xFB31, 'M', 'בּ'),
+    (0xFB32, 'M', 'גּ'),
+    (0xFB33, 'M', 'דּ'),
+    (0xFB34, 'M', 'הּ'),
+    (0xFB35, 'M', 'וּ'),
+    (0xFB36, 'M', 'זּ'),
+    (0xFB37, 'X'),
+    (0xFB38, 'M', 'טּ'),
+    (0xFB39, 'M', 'יּ'),
+    (0xFB3A, 'M', 'ךּ'),
+    (0xFB3B, 'M', 'כּ'),
+    (0xFB3C, 'M', 'לּ'),
+    (0xFB3D, 'X'),
+    (0xFB3E, 'M', 'מּ'),
+    (0xFB3F, 'X'),
+    (0xFB40, 'M', 'נּ'),
+    (0xFB41, 'M', 'סּ'),
+    (0xFB42, 'X'),
+    (0xFB43, 'M', 'ףּ'),
+    (0xFB44, 'M', 'פּ'),
+    (0xFB45, 'X'),
+    (0xFB46, 'M', 'צּ'),
+    (0xFB47, 'M', 'קּ'),
+    (0xFB48, 'M', 'רּ'),
+    (0xFB49, 'M', 'שּ'),
+    (0xFB4A, 'M', 'תּ'),
+    (0xFB4B, 'M', 'וֹ'),
+    (0xFB4C, 'M', 'בֿ'),
+    (0xFB4D, 'M', 'כֿ'),
+    (0xFB4E, 'M', 'פֿ'),
+    (0xFB4F, 'M', 'אל'),
+    (0xFB50, 'M', 'ٱ'),
+    (0xFB52, 'M', 'ٻ'),
+    (0xFB56, 'M', 'پ'),
+    (0xFB5A, 'M', 'ڀ'),
+    (0xFB5E, 'M', 'ٺ'),
+    (0xFB62, 'M', 'ٿ'),
+    (0xFB66, 'M', 'ٹ'),
+    (0xFB6A, 'M', 'ڤ'),
+    (0xFB6E, 'M', 'ڦ'),
+    (0xFB72, 'M', 'ڄ'),
+    (0xFB76, 'M', 'ڃ'),
+    (0xFB7A, 'M', 'چ'),
+    (0xFB7E, 'M', 'ڇ'),
+    (0xFB82, 'M', 'ڍ'),
+    (0xFB84, 'M', 'ڌ'),
+    (0xFB86, 'M', 'ڎ'),
+    (0xFB88, 'M', 'ڈ'),
+    (0xFB8A, 'M', 'ژ'),
+    (0xFB8C, 'M', 'ڑ'),
+    (0xFB8E, 'M', 'ک'),
+    (0xFB92, 'M', 'گ'),
+    (0xFB96, 'M', 'ڳ'),
+    (0xFB9A, 'M', 'ڱ'),
+    (0xFB9E, 'M', 'ں'),
+    (0xFBA0, 'M', 'ڻ'),
+    (0xFBA4, 'M', 'ۀ'),
+    (0xFBA6, 'M', 'ہ'),
+    (0xFBAA, 'M', 'ھ'),
+    (0xFBAE, 'M', 'ے'),
+    (0xFBB0, 'M', 'ۓ'),
+    (0xFBB2, 'V'),
+    (0xFBC3, 'X'),
+    (0xFBD3, 'M', 'ڭ'),
+    (0xFBD7, 'M', 'ۇ'),
+    (0xFBD9, 'M', 'ۆ'),
+    (0xFBDB, 'M', 'ۈ'),
+    (0xFBDD, 'M', 'ۇٴ'),
+    (0xFBDE, 'M', 'ۋ'),
+    (0xFBE0, 'M', 'ۅ'),
+    (0xFBE2, 'M', 'ۉ'),
+    (0xFBE4, 'M', 'ې'),
+    (0xFBE8, 'M', 'ى'),
+    ]
+
+def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFBEA, 'M', 'ئا'),
+    (0xFBEC, 'M', 'ئە'),
+    (0xFBEE, 'M', 'ئو'),
+    (0xFBF0, 'M', 'ئۇ'),
+    (0xFBF2, 'M', 'ئۆ'),
+    (0xFBF4, 'M', 'ئۈ'),
+    (0xFBF6, 'M', 'ئې'),
+    (0xFBF9, 'M', 'ئى'),
+    (0xFBFC, 'M', 'ی'),
+    (0xFC00, 'M', 'ئج'),
+    (0xFC01, 'M', 'ئح'),
+    (0xFC02, 'M', 'ئم'),
+    (0xFC03, 'M', 'ئى'),
+    (0xFC04, 'M', 'ئي'),
+    (0xFC05, 'M', 'بج'),
+    (0xFC06, 'M', 'بح'),
+    (0xFC07, 'M', 'بخ'),
+    (0xFC08, 'M', 'بم'),
+    (0xFC09, 'M', 'بى'),
+    (0xFC0A, 'M', 'بي'),
+    (0xFC0B, 'M', 'تج'),
+    (0xFC0C, 'M', 'تح'),
+    (0xFC0D, 'M', 'تخ'),
+    (0xFC0E, 'M', 'تم'),
+    (0xFC0F, 'M', 'تى'),
+    (0xFC10, 'M', 'تي'),
+    (0xFC11, 'M', 'ثج'),
+    (0xFC12, 'M', 'ثم'),
+    (0xFC13, 'M', 'ثى'),
+    (0xFC14, 'M', 'ثي'),
+    (0xFC15, 'M', 'جح'),
+    (0xFC16, 'M', 'جم'),
+    (0xFC17, 'M', 'حج'),
+    (0xFC18, 'M', 'حم'),
+    (0xFC19, 'M', 'خج'),
+    (0xFC1A, 'M', 'خح'),
+    (0xFC1B, 'M', 'خم'),
+    (0xFC1C, 'M', 'سج'),
+    (0xFC1D, 'M', 'سح'),
+    (0xFC1E, 'M', 'سخ'),
+    (0xFC1F, 'M', 'سم'),
+    (0xFC20, 'M', 'صح'),
+    (0xFC21, 'M', 'صم'),
+    (0xFC22, 'M', 'ضج'),
+    (0xFC23, 'M', 'ضح'),
+    (0xFC24, 'M', 'ضخ'),
+    (0xFC25, 'M', 'ضم'),
+    (0xFC26, 'M', 'طح'),
+    (0xFC27, 'M', 'طم'),
+    (0xFC28, 'M', 'ظم'),
+    (0xFC29, 'M', 'عج'),
+    (0xFC2A, 'M', 'عم'),
+    (0xFC2B, 'M', 'غج'),
+    (0xFC2C, 'M', 'غم'),
+    (0xFC2D, 'M', 'فج'),
+    (0xFC2E, 'M', 'فح'),
+    (0xFC2F, 'M', 'فخ'),
+    (0xFC30, 'M', 'فم'),
+    (0xFC31, 'M', 'فى'),
+    (0xFC32, 'M', 'في'),
+    (0xFC33, 'M', 'قح'),
+    (0xFC34, 'M', 'قم'),
+    (0xFC35, 'M', 'قى'),
+    (0xFC36, 'M', 'قي'),
+    (0xFC37, 'M', 'كا'),
+    (0xFC38, 'M', 'كج'),
+    (0xFC39, 'M', 'كح'),
+    (0xFC3A, 'M', 'كخ'),
+    (0xFC3B, 'M', 'كل'),
+    (0xFC3C, 'M', 'كم'),
+    (0xFC3D, 'M', 'كى'),
+    (0xFC3E, 'M', 'كي'),
+    (0xFC3F, 'M', 'لج'),
+    (0xFC40, 'M', 'لح'),
+    (0xFC41, 'M', 'لخ'),
+    (0xFC42, 'M', 'لم'),
+    (0xFC43, 'M', 'لى'),
+    (0xFC44, 'M', 'لي'),
+    (0xFC45, 'M', 'مج'),
+    (0xFC46, 'M', 'مح'),
+    (0xFC47, 'M', 'مخ'),
+    (0xFC48, 'M', 'مم'),
+    (0xFC49, 'M', 'مى'),
+    (0xFC4A, 'M', 'مي'),
+    (0xFC4B, 'M', 'نج'),
+    (0xFC4C, 'M', 'نح'),
+    (0xFC4D, 'M', 'نخ'),
+    (0xFC4E, 'M', 'نم'),
+    (0xFC4F, 'M', 'نى'),
+    (0xFC50, 'M', 'ني'),
+    (0xFC51, 'M', 'هج'),
+    (0xFC52, 'M', 'هم'),
+    (0xFC53, 'M', 'هى'),
+    (0xFC54, 'M', 'هي'),
+    (0xFC55, 'M', 'يج'),
+    (0xFC56, 'M', 'يح'),
+    (0xFC57, 'M', 'يخ'),
+    (0xFC58, 'M', 'يم'),
+    (0xFC59, 'M', 'يى'),
+    (0xFC5A, 'M', 'يي'),
+    ]
+
+def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFC5B, 'M', 'ذٰ'),
+    (0xFC5C, 'M', 'رٰ'),
+    (0xFC5D, 'M', 'ىٰ'),
+    (0xFC5E, '3', ' ٌّ'),
+    (0xFC5F, '3', ' ٍّ'),
+    (0xFC60, '3', ' َّ'),
+    (0xFC61, '3', ' ُّ'),
+    (0xFC62, '3', ' ِّ'),
+    (0xFC63, '3', ' ّٰ'),
+    (0xFC64, 'M', 'ئر'),
+    (0xFC65, 'M', 'ئز'),
+    (0xFC66, 'M', 'ئم'),
+    (0xFC67, 'M', 'ئن'),
+    (0xFC68, 'M', 'ئى'),
+    (0xFC69, 'M', 'ئي'),
+    (0xFC6A, 'M', 'بر'),
+    (0xFC6B, 'M', 'بز'),
+    (0xFC6C, 'M', 'بم'),
+    (0xFC6D, 'M', 'بن'),
+    (0xFC6E, 'M', 'بى'),
+    (0xFC6F, 'M', 'بي'),
+    (0xFC70, 'M', 'تر'),
+    (0xFC71, 'M', 'تز'),
+    (0xFC72, 'M', 'تم'),
+    (0xFC73, 'M', 'تن'),
+    (0xFC74, 'M', 'تى'),
+    (0xFC75, 'M', 'تي'),
+    (0xFC76, 'M', 'ثر'),
+    (0xFC77, 'M', 'ثز'),
+    (0xFC78, 'M', 'ثم'),
+    (0xFC79, 'M', 'ثن'),
+    (0xFC7A, 'M', 'ثى'),
+    (0xFC7B, 'M', 'ثي'),
+    (0xFC7C, 'M', 'فى'),
+    (0xFC7D, 'M', 'في'),
+    (0xFC7E, 'M', 'قى'),
+    (0xFC7F, 'M', 'قي'),
+    (0xFC80, 'M', 'كا'),
+    (0xFC81, 'M', 'كل'),
+    (0xFC82, 'M', 'كم'),
+    (0xFC83, 'M', 'كى'),
+    (0xFC84, 'M', 'كي'),
+    (0xFC85, 'M', 'لم'),
+    (0xFC86, 'M', 'لى'),
+    (0xFC87, 'M', 'لي'),
+    (0xFC88, 'M', 'ما'),
+    (0xFC89, 'M', 'مم'),
+    (0xFC8A, 'M', 'نر'),
+    (0xFC8B, 'M', 'نز'),
+    (0xFC8C, 'M', 'نم'),
+    (0xFC8D, 'M', 'نن'),
+    (0xFC8E, 'M', 'نى'),
+    (0xFC8F, 'M', 'ني'),
+    (0xFC90, 'M', 'ىٰ'),
+    (0xFC91, 'M', 'ير'),
+    (0xFC92, 'M', 'يز'),
+    (0xFC93, 'M', 'يم'),
+    (0xFC94, 'M', 'ين'),
+    (0xFC95, 'M', 'يى'),
+    (0xFC96, 'M', 'يي'),
+    (0xFC97, 'M', 'ئج'),
+    (0xFC98, 'M', 'ئح'),
+    (0xFC99, 'M', 'ئخ'),
+    (0xFC9A, 'M', 'ئم'),
+    (0xFC9B, 'M', 'ئه'),
+    (0xFC9C, 'M', 'بج'),
+    (0xFC9D, 'M', 'بح'),
+    (0xFC9E, 'M', 'بخ'),
+    (0xFC9F, 'M', 'بم'),
+    (0xFCA0, 'M', 'به'),
+    (0xFCA1, 'M', 'تج'),
+    (0xFCA2, 'M', 'تح'),
+    (0xFCA3, 'M', 'تخ'),
+    (0xFCA4, 'M', 'تم'),
+    (0xFCA5, 'M', 'ته'),
+    (0xFCA6, 'M', 'ثم'),
+    (0xFCA7, 'M', 'جح'),
+    (0xFCA8, 'M', 'جم'),
+    (0xFCA9, 'M', 'حج'),
+    (0xFCAA, 'M', 'حم'),
+    (0xFCAB, 'M', 'خج'),
+    (0xFCAC, 'M', 'خم'),
+    (0xFCAD, 'M', 'سج'),
+    (0xFCAE, 'M', 'سح'),
+    (0xFCAF, 'M', 'سخ'),
+    (0xFCB0, 'M', 'سم'),
+    (0xFCB1, 'M', 'صح'),
+    (0xFCB2, 'M', 'صخ'),
+    (0xFCB3, 'M', 'صم'),
+    (0xFCB4, 'M', 'ضج'),
+    (0xFCB5, 'M', 'ضح'),
+    (0xFCB6, 'M', 'ضخ'),
+    (0xFCB7, 'M', 'ضم'),
+    (0xFCB8, 'M', 'طح'),
+    (0xFCB9, 'M', 'ظم'),
+    (0xFCBA, 'M', 'عج'),
+    (0xFCBB, 'M', 'عم'),
+    (0xFCBC, 'M', 'غج'),
+    (0xFCBD, 'M', 'غم'),
+    (0xFCBE, 'M', 'فج'),
+    ]
+
+def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFCBF, 'M', 'فح'),
+    (0xFCC0, 'M', 'فخ'),
+    (0xFCC1, 'M', 'فم'),
+    (0xFCC2, 'M', 'قح'),
+    (0xFCC3, 'M', 'قم'),
+    (0xFCC4, 'M', 'كج'),
+    (0xFCC5, 'M', 'كح'),
+    (0xFCC6, 'M', 'كخ'),
+    (0xFCC7, 'M', 'كل'),
+    (0xFCC8, 'M', 'كم'),
+    (0xFCC9, 'M', 'لج'),
+    (0xFCCA, 'M', 'لح'),
+    (0xFCCB, 'M', 'لخ'),
+    (0xFCCC, 'M', 'لم'),
+    (0xFCCD, 'M', 'له'),
+    (0xFCCE, 'M', 'مج'),
+    (0xFCCF, 'M', 'مح'),
+    (0xFCD0, 'M', 'مخ'),
+    (0xFCD1, 'M', 'مم'),
+    (0xFCD2, 'M', 'نج'),
+    (0xFCD3, 'M', 'نح'),
+    (0xFCD4, 'M', 'نخ'),
+    (0xFCD5, 'M', 'نم'),
+    (0xFCD6, 'M', 'نه'),
+    (0xFCD7, 'M', 'هج'),
+    (0xFCD8, 'M', 'هم'),
+    (0xFCD9, 'M', 'هٰ'),
+    (0xFCDA, 'M', 'يج'),
+    (0xFCDB, 'M', 'يح'),
+    (0xFCDC, 'M', 'يخ'),
+    (0xFCDD, 'M', 'يم'),
+    (0xFCDE, 'M', 'يه'),
+    (0xFCDF, 'M', 'ئم'),
+    (0xFCE0, 'M', 'ئه'),
+    (0xFCE1, 'M', 'بم'),
+    (0xFCE2, 'M', 'به'),
+    (0xFCE3, 'M', 'تم'),
+    (0xFCE4, 'M', 'ته'),
+    (0xFCE5, 'M', 'ثم'),
+    (0xFCE6, 'M', 'ثه'),
+    (0xFCE7, 'M', 'سم'),
+    (0xFCE8, 'M', 'سه'),
+    (0xFCE9, 'M', 'شم'),
+    (0xFCEA, 'M', 'شه'),
+    (0xFCEB, 'M', 'كل'),
+    (0xFCEC, 'M', 'كم'),
+    (0xFCED, 'M', 'لم'),
+    (0xFCEE, 'M', 'نم'),
+    (0xFCEF, 'M', 'نه'),
+    (0xFCF0, 'M', 'يم'),
+    (0xFCF1, 'M', 'يه'),
+    (0xFCF2, 'M', 'ـَّ'),
+    (0xFCF3, 'M', 'ـُّ'),
+    (0xFCF4, 'M', 'ـِّ'),
+    (0xFCF5, 'M', 'طى'),
+    (0xFCF6, 'M', 'طي'),
+    (0xFCF7, 'M', 'عى'),
+    (0xFCF8, 'M', 'عي'),
+    (0xFCF9, 'M', 'غى'),
+    (0xFCFA, 'M', 'غي'),
+    (0xFCFB, 'M', 'سى'),
+    (0xFCFC, 'M', 'سي'),
+    (0xFCFD, 'M', 'شى'),
+    (0xFCFE, 'M', 'شي'),
+    (0xFCFF, 'M', 'حى'),
+    (0xFD00, 'M', 'حي'),
+    (0xFD01, 'M', 'جى'),
+    (0xFD02, 'M', 'جي'),
+    (0xFD03, 'M', 'خى'),
+    (0xFD04, 'M', 'خي'),
+    (0xFD05, 'M', 'صى'),
+    (0xFD06, 'M', 'صي'),
+    (0xFD07, 'M', 'ضى'),
+    (0xFD08, 'M', 'ضي'),
+    (0xFD09, 'M', 'شج'),
+    (0xFD0A, 'M', 'شح'),
+    (0xFD0B, 'M', 'شخ'),
+    (0xFD0C, 'M', 'شم'),
+    (0xFD0D, 'M', 'شر'),
+    (0xFD0E, 'M', 'سر'),
+    (0xFD0F, 'M', 'صر'),
+    (0xFD10, 'M', 'ضر'),
+    (0xFD11, 'M', 'طى'),
+    (0xFD12, 'M', 'طي'),
+    (0xFD13, 'M', 'عى'),
+    (0xFD14, 'M', 'عي'),
+    (0xFD15, 'M', 'غى'),
+    (0xFD16, 'M', 'غي'),
+    (0xFD17, 'M', 'سى'),
+    (0xFD18, 'M', 'سي'),
+    (0xFD19, 'M', 'شى'),
+    (0xFD1A, 'M', 'شي'),
+    (0xFD1B, 'M', 'حى'),
+    (0xFD1C, 'M', 'حي'),
+    (0xFD1D, 'M', 'جى'),
+    (0xFD1E, 'M', 'جي'),
+    (0xFD1F, 'M', 'خى'),
+    (0xFD20, 'M', 'خي'),
+    (0xFD21, 'M', 'صى'),
+    (0xFD22, 'M', 'صي'),
+    ]
+
+def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFD23, 'M', 'ضى'),
+    (0xFD24, 'M', 'ضي'),
+    (0xFD25, 'M', 'شج'),
+    (0xFD26, 'M', 'شح'),
+    (0xFD27, 'M', 'شخ'),
+    (0xFD28, 'M', 'شم'),
+    (0xFD29, 'M', 'شر'),
+    (0xFD2A, 'M', 'سر'),
+    (0xFD2B, 'M', 'صر'),
+    (0xFD2C, 'M', 'ضر'),
+    (0xFD2D, 'M', 'شج'),
+    (0xFD2E, 'M', 'شح'),
+    (0xFD2F, 'M', 'شخ'),
+    (0xFD30, 'M', 'شم'),
+    (0xFD31, 'M', 'سه'),
+    (0xFD32, 'M', 'شه'),
+    (0xFD33, 'M', 'طم'),
+    (0xFD34, 'M', 'سج'),
+    (0xFD35, 'M', 'سح'),
+    (0xFD36, 'M', 'سخ'),
+    (0xFD37, 'M', 'شج'),
+    (0xFD38, 'M', 'شح'),
+    (0xFD39, 'M', 'شخ'),
+    (0xFD3A, 'M', 'طم'),
+    (0xFD3B, 'M', 'ظم'),
+    (0xFD3C, 'M', 'اً'),
+    (0xFD3E, 'V'),
+    (0xFD50, 'M', 'تجم'),
+    (0xFD51, 'M', 'تحج'),
+    (0xFD53, 'M', 'تحم'),
+    (0xFD54, 'M', 'تخم'),
+    (0xFD55, 'M', 'تمج'),
+    (0xFD56, 'M', 'تمح'),
+    (0xFD57, 'M', 'تمخ'),
+    (0xFD58, 'M', 'جمح'),
+    (0xFD5A, 'M', 'حمي'),
+    (0xFD5B, 'M', 'حمى'),
+    (0xFD5C, 'M', 'سحج'),
+    (0xFD5D, 'M', 'سجح'),
+    (0xFD5E, 'M', 'سجى'),
+    (0xFD5F, 'M', 'سمح'),
+    (0xFD61, 'M', 'سمج'),
+    (0xFD62, 'M', 'سمم'),
+    (0xFD64, 'M', 'صحح'),
+    (0xFD66, 'M', 'صمم'),
+    (0xFD67, 'M', 'شحم'),
+    (0xFD69, 'M', 'شجي'),
+    (0xFD6A, 'M', 'شمخ'),
+    (0xFD6C, 'M', 'شمم'),
+    (0xFD6E, 'M', 'ضحى'),
+    (0xFD6F, 'M', 'ضخم'),
+    (0xFD71, 'M', 'طمح'),
+    (0xFD73, 'M', 'طمم'),
+    (0xFD74, 'M', 'طمي'),
+    (0xFD75, 'M', 'عجم'),
+    (0xFD76, 'M', 'عمم'),
+    (0xFD78, 'M', 'عمى'),
+    (0xFD79, 'M', 'غمم'),
+    (0xFD7A, 'M', 'غمي'),
+    (0xFD7B, 'M', 'غمى'),
+    (0xFD7C, 'M', 'فخم'),
+    (0xFD7E, 'M', 'قمح'),
+    (0xFD7F, 'M', 'قمم'),
+    (0xFD80, 'M', 'لحم'),
+    (0xFD81, 'M', 'لحي'),
+    (0xFD82, 'M', 'لحى'),
+    (0xFD83, 'M', 'لجج'),
+    (0xFD85, 'M', 'لخم'),
+    (0xFD87, 'M', 'لمح'),
+    (0xFD89, 'M', 'محج'),
+    (0xFD8A, 'M', 'محم'),
+    (0xFD8B, 'M', 'محي'),
+    (0xFD8C, 'M', 'مجح'),
+    (0xFD8D, 'M', 'مجم'),
+    (0xFD8E, 'M', 'مخج'),
+    (0xFD8F, 'M', 'مخم'),
+    (0xFD90, 'X'),
+    (0xFD92, 'M', 'مجخ'),
+    (0xFD93, 'M', 'همج'),
+    (0xFD94, 'M', 'همم'),
+    (0xFD95, 'M', 'نحم'),
+    (0xFD96, 'M', 'نحى'),
+    (0xFD97, 'M', 'نجم'),
+    (0xFD99, 'M', 'نجى'),
+    (0xFD9A, 'M', 'نمي'),
+    (0xFD9B, 'M', 'نمى'),
+    (0xFD9C, 'M', 'يمم'),
+    (0xFD9E, 'M', 'بخي'),
+    (0xFD9F, 'M', 'تجي'),
+    (0xFDA0, 'M', 'تجى'),
+    (0xFDA1, 'M', 'تخي'),
+    (0xFDA2, 'M', 'تخى'),
+    (0xFDA3, 'M', 'تمي'),
+    (0xFDA4, 'M', 'تمى'),
+    (0xFDA5, 'M', 'جمي'),
+    (0xFDA6, 'M', 'جحى'),
+    (0xFDA7, 'M', 'جمى'),
+    (0xFDA8, 'M', 'سخى'),
+    (0xFDA9, 'M', 'صحي'),
+    (0xFDAA, 'M', 'شحي'),
+    ]
+
+def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFDAB, 'M', 'ضحي'),
+    (0xFDAC, 'M', 'لجي'),
+    (0xFDAD, 'M', 'لمي'),
+    (0xFDAE, 'M', 'يحي'),
+    (0xFDAF, 'M', 'يجي'),
+    (0xFDB0, 'M', 'يمي'),
+    (0xFDB1, 'M', 'ممي'),
+    (0xFDB2, 'M', 'قمي'),
+    (0xFDB3, 'M', 'نحي'),
+    (0xFDB4, 'M', 'قمح'),
+    (0xFDB5, 'M', 'لحم'),
+    (0xFDB6, 'M', 'عمي'),
+    (0xFDB7, 'M', 'كمي'),
+    (0xFDB8, 'M', 'نجح'),
+    (0xFDB9, 'M', 'مخي'),
+    (0xFDBA, 'M', 'لجم'),
+    (0xFDBB, 'M', 'كمم'),
+    (0xFDBC, 'M', 'لجم'),
+    (0xFDBD, 'M', 'نجح'),
+    (0xFDBE, 'M', 'جحي'),
+    (0xFDBF, 'M', 'حجي'),
+    (0xFDC0, 'M', 'مجي'),
+    (0xFDC1, 'M', 'فمي'),
+    (0xFDC2, 'M', 'بحي'),
+    (0xFDC3, 'M', 'كمم'),
+    (0xFDC4, 'M', 'عجم'),
+    (0xFDC5, 'M', 'صمم'),
+    (0xFDC6, 'M', 'سخي'),
+    (0xFDC7, 'M', 'نجي'),
+    (0xFDC8, 'X'),
+    (0xFDCF, 'V'),
+    (0xFDD0, 'X'),
+    (0xFDF0, 'M', 'صلے'),
+    (0xFDF1, 'M', 'قلے'),
+    (0xFDF2, 'M', 'الله'),
+    (0xFDF3, 'M', 'اكبر'),
+    (0xFDF4, 'M', 'محمد'),
+    (0xFDF5, 'M', 'صلعم'),
+    (0xFDF6, 'M', 'رسول'),
+    (0xFDF7, 'M', 'عليه'),
+    (0xFDF8, 'M', 'وسلم'),
+    (0xFDF9, 'M', 'صلى'),
+    (0xFDFA, '3', 'صلى الله عليه وسلم'),
+    (0xFDFB, '3', 'جل جلاله'),
+    (0xFDFC, 'M', 'ریال'),
+    (0xFDFD, 'V'),
+    (0xFE00, 'I'),
+    (0xFE10, '3', ','),
+    (0xFE11, 'M', '、'),
+    (0xFE12, 'X'),
+    (0xFE13, '3', ':'),
+    (0xFE14, '3', ';'),
+    (0xFE15, '3', '!'),
+    (0xFE16, '3', '?'),
+    (0xFE17, 'M', '〖'),
+    (0xFE18, 'M', '〗'),
+    (0xFE19, 'X'),
+    (0xFE20, 'V'),
+    (0xFE30, 'X'),
+    (0xFE31, 'M', '—'),
+    (0xFE32, 'M', '–'),
+    (0xFE33, '3', '_'),
+    (0xFE35, '3', '('),
+    (0xFE36, '3', ')'),
+    (0xFE37, '3', '{'),
+    (0xFE38, '3', '}'),
+    (0xFE39, 'M', '〔'),
+    (0xFE3A, 'M', '〕'),
+    (0xFE3B, 'M', '【'),
+    (0xFE3C, 'M', '】'),
+    (0xFE3D, 'M', '《'),
+    (0xFE3E, 'M', '》'),
+    (0xFE3F, 'M', '〈'),
+    (0xFE40, 'M', '〉'),
+    (0xFE41, 'M', '「'),
+    (0xFE42, 'M', '」'),
+    (0xFE43, 'M', '『'),
+    (0xFE44, 'M', '』'),
+    (0xFE45, 'V'),
+    (0xFE47, '3', '['),
+    (0xFE48, '3', ']'),
+    (0xFE49, '3', ' ̅'),
+    (0xFE4D, '3', '_'),
+    (0xFE50, '3', ','),
+    (0xFE51, 'M', '、'),
+    (0xFE52, 'X'),
+    (0xFE54, '3', ';'),
+    (0xFE55, '3', ':'),
+    (0xFE56, '3', '?'),
+    (0xFE57, '3', '!'),
+    (0xFE58, 'M', '—'),
+    (0xFE59, '3', '('),
+    (0xFE5A, '3', ')'),
+    (0xFE5B, '3', '{'),
+    (0xFE5C, '3', '}'),
+    (0xFE5D, 'M', '〔'),
+    (0xFE5E, 'M', '〕'),
+    (0xFE5F, '3', '#'),
+    (0xFE60, '3', '&'),
+    (0xFE61, '3', '*'),
+    ]
+
+def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFE62, '3', '+'),
+    (0xFE63, 'M', '-'),
+    (0xFE64, '3', '<'),
+    (0xFE65, '3', '>'),
+    (0xFE66, '3', '='),
+    (0xFE67, 'X'),
+    (0xFE68, '3', '\\'),
+    (0xFE69, '3', '$'),
+    (0xFE6A, '3', '%'),
+    (0xFE6B, '3', '@'),
+    (0xFE6C, 'X'),
+    (0xFE70, '3', ' ً'),
+    (0xFE71, 'M', 'ـً'),
+    (0xFE72, '3', ' ٌ'),
+    (0xFE73, 'V'),
+    (0xFE74, '3', ' ٍ'),
+    (0xFE75, 'X'),
+    (0xFE76, '3', ' َ'),
+    (0xFE77, 'M', 'ـَ'),
+    (0xFE78, '3', ' ُ'),
+    (0xFE79, 'M', 'ـُ'),
+    (0xFE7A, '3', ' ِ'),
+    (0xFE7B, 'M', 'ـِ'),
+    (0xFE7C, '3', ' ّ'),
+    (0xFE7D, 'M', 'ـّ'),
+    (0xFE7E, '3', ' ْ'),
+    (0xFE7F, 'M', 'ـْ'),
+    (0xFE80, 'M', 'ء'),
+    (0xFE81, 'M', 'آ'),
+    (0xFE83, 'M', 'أ'),
+    (0xFE85, 'M', 'ؤ'),
+    (0xFE87, 'M', 'إ'),
+    (0xFE89, 'M', 'ئ'),
+    (0xFE8D, 'M', 'ا'),
+    (0xFE8F, 'M', 'ب'),
+    (0xFE93, 'M', 'ة'),
+    (0xFE95, 'M', 'ت'),
+    (0xFE99, 'M', 'ث'),
+    (0xFE9D, 'M', 'ج'),
+    (0xFEA1, 'M', 'ح'),
+    (0xFEA5, 'M', 'خ'),
+    (0xFEA9, 'M', 'د'),
+    (0xFEAB, 'M', 'ذ'),
+    (0xFEAD, 'M', 'ر'),
+    (0xFEAF, 'M', 'ز'),
+    (0xFEB1, 'M', 'س'),
+    (0xFEB5, 'M', 'ش'),
+    (0xFEB9, 'M', 'ص'),
+    (0xFEBD, 'M', 'ض'),
+    (0xFEC1, 'M', 'ط'),
+    (0xFEC5, 'M', 'ظ'),
+    (0xFEC9, 'M', 'ع'),
+    (0xFECD, 'M', 'غ'),
+    (0xFED1, 'M', 'ف'),
+    (0xFED5, 'M', 'ق'),
+    (0xFED9, 'M', 'ك'),
+    (0xFEDD, 'M', 'ل'),
+    (0xFEE1, 'M', 'م'),
+    (0xFEE5, 'M', 'ن'),
+    (0xFEE9, 'M', 'ه'),
+    (0xFEED, 'M', 'و'),
+    (0xFEEF, 'M', 'ى'),
+    (0xFEF1, 'M', 'ي'),
+    (0xFEF5, 'M', 'لآ'),
+    (0xFEF7, 'M', 'لأ'),
+    (0xFEF9, 'M', 'لإ'),
+    (0xFEFB, 'M', 'لا'),
+    (0xFEFD, 'X'),
+    (0xFEFF, 'I'),
+    (0xFF00, 'X'),
+    (0xFF01, '3', '!'),
+    (0xFF02, '3', '"'),
+    (0xFF03, '3', '#'),
+    (0xFF04, '3', '$'),
+    (0xFF05, '3', '%'),
+    (0xFF06, '3', '&'),
+    (0xFF07, '3', '\''),
+    (0xFF08, '3', '('),
+    (0xFF09, '3', ')'),
+    (0xFF0A, '3', '*'),
+    (0xFF0B, '3', '+'),
+    (0xFF0C, '3', ','),
+    (0xFF0D, 'M', '-'),
+    (0xFF0E, 'M', '.'),
+    (0xFF0F, '3', '/'),
+    (0xFF10, 'M', '0'),
+    (0xFF11, 'M', '1'),
+    (0xFF12, 'M', '2'),
+    (0xFF13, 'M', '3'),
+    (0xFF14, 'M', '4'),
+    (0xFF15, 'M', '5'),
+    (0xFF16, 'M', '6'),
+    (0xFF17, 'M', '7'),
+    (0xFF18, 'M', '8'),
+    (0xFF19, 'M', '9'),
+    (0xFF1A, '3', ':'),
+    (0xFF1B, '3', ';'),
+    (0xFF1C, '3', '<'),
+    (0xFF1D, '3', '='),
+    (0xFF1E, '3', '>'),
+    ]
+
+def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFF1F, '3', '?'),
+    (0xFF20, '3', '@'),
+    (0xFF21, 'M', 'a'),
+    (0xFF22, 'M', 'b'),
+    (0xFF23, 'M', 'c'),
+    (0xFF24, 'M', 'd'),
+    (0xFF25, 'M', 'e'),
+    (0xFF26, 'M', 'f'),
+    (0xFF27, 'M', 'g'),
+    (0xFF28, 'M', 'h'),
+    (0xFF29, 'M', 'i'),
+    (0xFF2A, 'M', 'j'),
+    (0xFF2B, 'M', 'k'),
+    (0xFF2C, 'M', 'l'),
+    (0xFF2D, 'M', 'm'),
+    (0xFF2E, 'M', 'n'),
+    (0xFF2F, 'M', 'o'),
+    (0xFF30, 'M', 'p'),
+    (0xFF31, 'M', 'q'),
+    (0xFF32, 'M', 'r'),
+    (0xFF33, 'M', 's'),
+    (0xFF34, 'M', 't'),
+    (0xFF35, 'M', 'u'),
+    (0xFF36, 'M', 'v'),
+    (0xFF37, 'M', 'w'),
+    (0xFF38, 'M', 'x'),
+    (0xFF39, 'M', 'y'),
+    (0xFF3A, 'M', 'z'),
+    (0xFF3B, '3', '['),
+    (0xFF3C, '3', '\\'),
+    (0xFF3D, '3', ']'),
+    (0xFF3E, '3', '^'),
+    (0xFF3F, '3', '_'),
+    (0xFF40, '3', '`'),
+    (0xFF41, 'M', 'a'),
+    (0xFF42, 'M', 'b'),
+    (0xFF43, 'M', 'c'),
+    (0xFF44, 'M', 'd'),
+    (0xFF45, 'M', 'e'),
+    (0xFF46, 'M', 'f'),
+    (0xFF47, 'M', 'g'),
+    (0xFF48, 'M', 'h'),
+    (0xFF49, 'M', 'i'),
+    (0xFF4A, 'M', 'j'),
+    (0xFF4B, 'M', 'k'),
+    (0xFF4C, 'M', 'l'),
+    (0xFF4D, 'M', 'm'),
+    (0xFF4E, 'M', 'n'),
+    (0xFF4F, 'M', 'o'),
+    (0xFF50, 'M', 'p'),
+    (0xFF51, 'M', 'q'),
+    (0xFF52, 'M', 'r'),
+    (0xFF53, 'M', 's'),
+    (0xFF54, 'M', 't'),
+    (0xFF55, 'M', 'u'),
+    (0xFF56, 'M', 'v'),
+    (0xFF57, 'M', 'w'),
+    (0xFF58, 'M', 'x'),
+    (0xFF59, 'M', 'y'),
+    (0xFF5A, 'M', 'z'),
+    (0xFF5B, '3', '{'),
+    (0xFF5C, '3', '|'),
+    (0xFF5D, '3', '}'),
+    (0xFF5E, '3', '~'),
+    (0xFF5F, 'M', '⦅'),
+    (0xFF60, 'M', '⦆'),
+    (0xFF61, 'M', '.'),
+    (0xFF62, 'M', '「'),
+    (0xFF63, 'M', '」'),
+    (0xFF64, 'M', '、'),
+    (0xFF65, 'M', '・'),
+    (0xFF66, 'M', 'ヲ'),
+    (0xFF67, 'M', 'ァ'),
+    (0xFF68, 'M', 'ィ'),
+    (0xFF69, 'M', 'ゥ'),
+    (0xFF6A, 'M', 'ェ'),
+    (0xFF6B, 'M', 'ォ'),
+    (0xFF6C, 'M', 'ャ'),
+    (0xFF6D, 'M', 'ュ'),
+    (0xFF6E, 'M', 'ョ'),
+    (0xFF6F, 'M', 'ッ'),
+    (0xFF70, 'M', 'ー'),
+    (0xFF71, 'M', 'ア'),
+    (0xFF72, 'M', 'イ'),
+    (0xFF73, 'M', 'ウ'),
+    (0xFF74, 'M', 'エ'),
+    (0xFF75, 'M', 'オ'),
+    (0xFF76, 'M', 'カ'),
+    (0xFF77, 'M', 'キ'),
+    (0xFF78, 'M', 'ク'),
+    (0xFF79, 'M', 'ケ'),
+    (0xFF7A, 'M', 'コ'),
+    (0xFF7B, 'M', 'サ'),
+    (0xFF7C, 'M', 'シ'),
+    (0xFF7D, 'M', 'ス'),
+    (0xFF7E, 'M', 'セ'),
+    (0xFF7F, 'M', 'ソ'),
+    (0xFF80, 'M', 'タ'),
+    (0xFF81, 'M', 'チ'),
+    (0xFF82, 'M', 'ツ'),
+    ]
+
+def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFF83, 'M', 'テ'),
+    (0xFF84, 'M', 'ト'),
+    (0xFF85, 'M', 'ナ'),
+    (0xFF86, 'M', 'ニ'),
+    (0xFF87, 'M', 'ヌ'),
+    (0xFF88, 'M', 'ネ'),
+    (0xFF89, 'M', 'ノ'),
+    (0xFF8A, 'M', 'ハ'),
+    (0xFF8B, 'M', 'ヒ'),
+    (0xFF8C, 'M', 'フ'),
+    (0xFF8D, 'M', 'ヘ'),
+    (0xFF8E, 'M', 'ホ'),
+    (0xFF8F, 'M', 'マ'),
+    (0xFF90, 'M', 'ミ'),
+    (0xFF91, 'M', 'ム'),
+    (0xFF92, 'M', 'メ'),
+    (0xFF93, 'M', 'モ'),
+    (0xFF94, 'M', 'ヤ'),
+    (0xFF95, 'M', 'ユ'),
+    (0xFF96, 'M', 'ヨ'),
+    (0xFF97, 'M', 'ラ'),
+    (0xFF98, 'M', 'リ'),
+    (0xFF99, 'M', 'ル'),
+    (0xFF9A, 'M', 'レ'),
+    (0xFF9B, 'M', 'ロ'),
+    (0xFF9C, 'M', 'ワ'),
+    (0xFF9D, 'M', 'ン'),
+    (0xFF9E, 'M', '゙'),
+    (0xFF9F, 'M', '゚'),
+    (0xFFA0, 'X'),
+    (0xFFA1, 'M', 'ᄀ'),
+    (0xFFA2, 'M', 'ᄁ'),
+    (0xFFA3, 'M', 'ᆪ'),
+    (0xFFA4, 'M', 'ᄂ'),
+    (0xFFA5, 'M', 'ᆬ'),
+    (0xFFA6, 'M', 'ᆭ'),
+    (0xFFA7, 'M', 'ᄃ'),
+    (0xFFA8, 'M', 'ᄄ'),
+    (0xFFA9, 'M', 'ᄅ'),
+    (0xFFAA, 'M', 'ᆰ'),
+    (0xFFAB, 'M', 'ᆱ'),
+    (0xFFAC, 'M', 'ᆲ'),
+    (0xFFAD, 'M', 'ᆳ'),
+    (0xFFAE, 'M', 'ᆴ'),
+    (0xFFAF, 'M', 'ᆵ'),
+    (0xFFB0, 'M', 'ᄚ'),
+    (0xFFB1, 'M', 'ᄆ'),
+    (0xFFB2, 'M', 'ᄇ'),
+    (0xFFB3, 'M', 'ᄈ'),
+    (0xFFB4, 'M', 'ᄡ'),
+    (0xFFB5, 'M', 'ᄉ'),
+    (0xFFB6, 'M', 'ᄊ'),
+    (0xFFB7, 'M', 'ᄋ'),
+    (0xFFB8, 'M', 'ᄌ'),
+    (0xFFB9, 'M', 'ᄍ'),
+    (0xFFBA, 'M', 'ᄎ'),
+    (0xFFBB, 'M', 'ᄏ'),
+    (0xFFBC, 'M', 'ᄐ'),
+    (0xFFBD, 'M', 'ᄑ'),
+    (0xFFBE, 'M', 'ᄒ'),
+    (0xFFBF, 'X'),
+    (0xFFC2, 'M', 'ᅡ'),
+    (0xFFC3, 'M', 'ᅢ'),
+    (0xFFC4, 'M', 'ᅣ'),
+    (0xFFC5, 'M', 'ᅤ'),
+    (0xFFC6, 'M', 'ᅥ'),
+    (0xFFC7, 'M', 'ᅦ'),
+    (0xFFC8, 'X'),
+    (0xFFCA, 'M', 'ᅧ'),
+    (0xFFCB, 'M', 'ᅨ'),
+    (0xFFCC, 'M', 'ᅩ'),
+    (0xFFCD, 'M', 'ᅪ'),
+    (0xFFCE, 'M', 'ᅫ'),
+    (0xFFCF, 'M', 'ᅬ'),
+    (0xFFD0, 'X'),
+    (0xFFD2, 'M', 'ᅭ'),
+    (0xFFD3, 'M', 'ᅮ'),
+    (0xFFD4, 'M', 'ᅯ'),
+    (0xFFD5, 'M', 'ᅰ'),
+    (0xFFD6, 'M', 'ᅱ'),
+    (0xFFD7, 'M', 'ᅲ'),
+    (0xFFD8, 'X'),
+    (0xFFDA, 'M', 'ᅳ'),
+    (0xFFDB, 'M', 'ᅴ'),
+    (0xFFDC, 'M', 'ᅵ'),
+    (0xFFDD, 'X'),
+    (0xFFE0, 'M', '¢'),
+    (0xFFE1, 'M', '£'),
+    (0xFFE2, 'M', '¬'),
+    (0xFFE3, '3', ' ̄'),
+    (0xFFE4, 'M', '¦'),
+    (0xFFE5, 'M', '¥'),
+    (0xFFE6, 'M', '₩'),
+    (0xFFE7, 'X'),
+    (0xFFE8, 'M', '│'),
+    (0xFFE9, 'M', '←'),
+    (0xFFEA, 'M', '↑'),
+    (0xFFEB, 'M', '→'),
+    (0xFFEC, 'M', '↓'),
+    (0xFFED, 'M', '■'),
+    ]
+
+def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFFEE, 'M', '○'),
+    (0xFFEF, 'X'),
+    (0x10000, 'V'),
+    (0x1000C, 'X'),
+    (0x1000D, 'V'),
+    (0x10027, 'X'),
+    (0x10028, 'V'),
+    (0x1003B, 'X'),
+    (0x1003C, 'V'),
+    (0x1003E, 'X'),
+    (0x1003F, 'V'),
+    (0x1004E, 'X'),
+    (0x10050, 'V'),
+    (0x1005E, 'X'),
+    (0x10080, 'V'),
+    (0x100FB, 'X'),
+    (0x10100, 'V'),
+    (0x10103, 'X'),
+    (0x10107, 'V'),
+    (0x10134, 'X'),
+    (0x10137, 'V'),
+    (0x1018F, 'X'),
+    (0x10190, 'V'),
+    (0x1019D, 'X'),
+    (0x101A0, 'V'),
+    (0x101A1, 'X'),
+    (0x101D0, 'V'),
+    (0x101FE, 'X'),
+    (0x10280, 'V'),
+    (0x1029D, 'X'),
+    (0x102A0, 'V'),
+    (0x102D1, 'X'),
+    (0x102E0, 'V'),
+    (0x102FC, 'X'),
+    (0x10300, 'V'),
+    (0x10324, 'X'),
+    (0x1032D, 'V'),
+    (0x1034B, 'X'),
+    (0x10350, 'V'),
+    (0x1037B, 'X'),
+    (0x10380, 'V'),
+    (0x1039E, 'X'),
+    (0x1039F, 'V'),
+    (0x103C4, 'X'),
+    (0x103C8, 'V'),
+    (0x103D6, 'X'),
+    (0x10400, 'M', '𐐨'),
+    (0x10401, 'M', '𐐩'),
+    (0x10402, 'M', '𐐪'),
+    (0x10403, 'M', '𐐫'),
+    (0x10404, 'M', '𐐬'),
+    (0x10405, 'M', '𐐭'),
+    (0x10406, 'M', '𐐮'),
+    (0x10407, 'M', '𐐯'),
+    (0x10408, 'M', '𐐰'),
+    (0x10409, 'M', '𐐱'),
+    (0x1040A, 'M', '𐐲'),
+    (0x1040B, 'M', '𐐳'),
+    (0x1040C, 'M', '𐐴'),
+    (0x1040D, 'M', '𐐵'),
+    (0x1040E, 'M', '𐐶'),
+    (0x1040F, 'M', '𐐷'),
+    (0x10410, 'M', '𐐸'),
+    (0x10411, 'M', '𐐹'),
+    (0x10412, 'M', '𐐺'),
+    (0x10413, 'M', '𐐻'),
+    (0x10414, 'M', '𐐼'),
+    (0x10415, 'M', '𐐽'),
+    (0x10416, 'M', '𐐾'),
+    (0x10417, 'M', '𐐿'),
+    (0x10418, 'M', '𐑀'),
+    (0x10419, 'M', '𐑁'),
+    (0x1041A, 'M', '𐑂'),
+    (0x1041B, 'M', '𐑃'),
+    (0x1041C, 'M', '𐑄'),
+    (0x1041D, 'M', '𐑅'),
+    (0x1041E, 'M', '𐑆'),
+    (0x1041F, 'M', '𐑇'),
+    (0x10420, 'M', '𐑈'),
+    (0x10421, 'M', '𐑉'),
+    (0x10422, 'M', '𐑊'),
+    (0x10423, 'M', '𐑋'),
+    (0x10424, 'M', '𐑌'),
+    (0x10425, 'M', '𐑍'),
+    (0x10426, 'M', '𐑎'),
+    (0x10427, 'M', '𐑏'),
+    (0x10428, 'V'),
+    (0x1049E, 'X'),
+    (0x104A0, 'V'),
+    (0x104AA, 'X'),
+    (0x104B0, 'M', '𐓘'),
+    (0x104B1, 'M', '𐓙'),
+    (0x104B2, 'M', '𐓚'),
+    (0x104B3, 'M', '𐓛'),
+    (0x104B4, 'M', '𐓜'),
+    (0x104B5, 'M', '𐓝'),
+    (0x104B6, 'M', '𐓞'),
+    (0x104B7, 'M', '𐓟'),
+    (0x104B8, 'M', '𐓠'),
+    (0x104B9, 'M', '𐓡'),
+    ]
+
+def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x104BA, 'M', '𐓢'),
+    (0x104BB, 'M', '𐓣'),
+    (0x104BC, 'M', '𐓤'),
+    (0x104BD, 'M', '𐓥'),
+    (0x104BE, 'M', '𐓦'),
+    (0x104BF, 'M', '𐓧'),
+    (0x104C0, 'M', '𐓨'),
+    (0x104C1, 'M', '𐓩'),
+    (0x104C2, 'M', '𐓪'),
+    (0x104C3, 'M', '𐓫'),
+    (0x104C4, 'M', '𐓬'),
+    (0x104C5, 'M', '𐓭'),
+    (0x104C6, 'M', '𐓮'),
+    (0x104C7, 'M', '𐓯'),
+    (0x104C8, 'M', '𐓰'),
+    (0x104C9, 'M', '𐓱'),
+    (0x104CA, 'M', '𐓲'),
+    (0x104CB, 'M', '𐓳'),
+    (0x104CC, 'M', '𐓴'),
+    (0x104CD, 'M', '𐓵'),
+    (0x104CE, 'M', '𐓶'),
+    (0x104CF, 'M', '𐓷'),
+    (0x104D0, 'M', '𐓸'),
+    (0x104D1, 'M', '𐓹'),
+    (0x104D2, 'M', '𐓺'),
+    (0x104D3, 'M', '𐓻'),
+    (0x104D4, 'X'),
+    (0x104D8, 'V'),
+    (0x104FC, 'X'),
+    (0x10500, 'V'),
+    (0x10528, 'X'),
+    (0x10530, 'V'),
+    (0x10564, 'X'),
+    (0x1056F, 'V'),
+    (0x10570, 'M', '𐖗'),
+    (0x10571, 'M', '𐖘'),
+    (0x10572, 'M', '𐖙'),
+    (0x10573, 'M', '𐖚'),
+    (0x10574, 'M', '𐖛'),
+    (0x10575, 'M', '𐖜'),
+    (0x10576, 'M', '𐖝'),
+    (0x10577, 'M', '𐖞'),
+    (0x10578, 'M', '𐖟'),
+    (0x10579, 'M', '𐖠'),
+    (0x1057A, 'M', '𐖡'),
+    (0x1057B, 'X'),
+    (0x1057C, 'M', '𐖣'),
+    (0x1057D, 'M', '𐖤'),
+    (0x1057E, 'M', '𐖥'),
+    (0x1057F, 'M', '𐖦'),
+    (0x10580, 'M', '𐖧'),
+    (0x10581, 'M', '𐖨'),
+    (0x10582, 'M', '𐖩'),
+    (0x10583, 'M', '𐖪'),
+    (0x10584, 'M', '𐖫'),
+    (0x10585, 'M', '𐖬'),
+    (0x10586, 'M', '𐖭'),
+    (0x10587, 'M', '𐖮'),
+    (0x10588, 'M', '𐖯'),
+    (0x10589, 'M', '𐖰'),
+    (0x1058A, 'M', '𐖱'),
+    (0x1058B, 'X'),
+    (0x1058C, 'M', '𐖳'),
+    (0x1058D, 'M', '𐖴'),
+    (0x1058E, 'M', '𐖵'),
+    (0x1058F, 'M', '𐖶'),
+    (0x10590, 'M', '𐖷'),
+    (0x10591, 'M', '𐖸'),
+    (0x10592, 'M', '𐖹'),
+    (0x10593, 'X'),
+    (0x10594, 'M', '𐖻'),
+    (0x10595, 'M', '𐖼'),
+    (0x10596, 'X'),
+    (0x10597, 'V'),
+    (0x105A2, 'X'),
+    (0x105A3, 'V'),
+    (0x105B2, 'X'),
+    (0x105B3, 'V'),
+    (0x105BA, 'X'),
+    (0x105BB, 'V'),
+    (0x105BD, 'X'),
+    (0x10600, 'V'),
+    (0x10737, 'X'),
+    (0x10740, 'V'),
+    (0x10756, 'X'),
+    (0x10760, 'V'),
+    (0x10768, 'X'),
+    (0x10780, 'V'),
+    (0x10781, 'M', 'ː'),
+    (0x10782, 'M', 'ˑ'),
+    (0x10783, 'M', 'æ'),
+    (0x10784, 'M', 'ʙ'),
+    (0x10785, 'M', 'ɓ'),
+    (0x10786, 'X'),
+    (0x10787, 'M', 'ʣ'),
+    (0x10788, 'M', 'ꭦ'),
+    (0x10789, 'M', 'ʥ'),
+    (0x1078A, 'M', 'ʤ'),
+    (0x1078B, 'M', 'ɖ'),
+    (0x1078C, 'M', 'ɗ'),
+    ]
+
+def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1078D, 'M', 'ᶑ'),
+    (0x1078E, 'M', 'ɘ'),
+    (0x1078F, 'M', 'ɞ'),
+    (0x10790, 'M', 'ʩ'),
+    (0x10791, 'M', 'ɤ'),
+    (0x10792, 'M', 'ɢ'),
+    (0x10793, 'M', 'ɠ'),
+    (0x10794, 'M', 'ʛ'),
+    (0x10795, 'M', 'ħ'),
+    (0x10796, 'M', 'ʜ'),
+    (0x10797, 'M', 'ɧ'),
+    (0x10798, 'M', 'ʄ'),
+    (0x10799, 'M', 'ʪ'),
+    (0x1079A, 'M', 'ʫ'),
+    (0x1079B, 'M', 'ɬ'),
+    (0x1079C, 'M', '𝼄'),
+    (0x1079D, 'M', 'ꞎ'),
+    (0x1079E, 'M', 'ɮ'),
+    (0x1079F, 'M', '𝼅'),
+    (0x107A0, 'M', 'ʎ'),
+    (0x107A1, 'M', '𝼆'),
+    (0x107A2, 'M', 'ø'),
+    (0x107A3, 'M', 'ɶ'),
+    (0x107A4, 'M', 'ɷ'),
+    (0x107A5, 'M', 'q'),
+    (0x107A6, 'M', 'ɺ'),
+    (0x107A7, 'M', '𝼈'),
+    (0x107A8, 'M', 'ɽ'),
+    (0x107A9, 'M', 'ɾ'),
+    (0x107AA, 'M', 'ʀ'),
+    (0x107AB, 'M', 'ʨ'),
+    (0x107AC, 'M', 'ʦ'),
+    (0x107AD, 'M', 'ꭧ'),
+    (0x107AE, 'M', 'ʧ'),
+    (0x107AF, 'M', 'ʈ'),
+    (0x107B0, 'M', 'ⱱ'),
+    (0x107B1, 'X'),
+    (0x107B2, 'M', 'ʏ'),
+    (0x107B3, 'M', 'ʡ'),
+    (0x107B4, 'M', 'ʢ'),
+    (0x107B5, 'M', 'ʘ'),
+    (0x107B6, 'M', 'ǀ'),
+    (0x107B7, 'M', 'ǁ'),
+    (0x107B8, 'M', 'ǂ'),
+    (0x107B9, 'M', '𝼊'),
+    (0x107BA, 'M', '𝼞'),
+    (0x107BB, 'X'),
+    (0x10800, 'V'),
+    (0x10806, 'X'),
+    (0x10808, 'V'),
+    (0x10809, 'X'),
+    (0x1080A, 'V'),
+    (0x10836, 'X'),
+    (0x10837, 'V'),
+    (0x10839, 'X'),
+    (0x1083C, 'V'),
+    (0x1083D, 'X'),
+    (0x1083F, 'V'),
+    (0x10856, 'X'),
+    (0x10857, 'V'),
+    (0x1089F, 'X'),
+    (0x108A7, 'V'),
+    (0x108B0, 'X'),
+    (0x108E0, 'V'),
+    (0x108F3, 'X'),
+    (0x108F4, 'V'),
+    (0x108F6, 'X'),
+    (0x108FB, 'V'),
+    (0x1091C, 'X'),
+    (0x1091F, 'V'),
+    (0x1093A, 'X'),
+    (0x1093F, 'V'),
+    (0x10940, 'X'),
+    (0x10980, 'V'),
+    (0x109B8, 'X'),
+    (0x109BC, 'V'),
+    (0x109D0, 'X'),
+    (0x109D2, 'V'),
+    (0x10A04, 'X'),
+    (0x10A05, 'V'),
+    (0x10A07, 'X'),
+    (0x10A0C, 'V'),
+    (0x10A14, 'X'),
+    (0x10A15, 'V'),
+    (0x10A18, 'X'),
+    (0x10A19, 'V'),
+    (0x10A36, 'X'),
+    (0x10A38, 'V'),
+    (0x10A3B, 'X'),
+    (0x10A3F, 'V'),
+    (0x10A49, 'X'),
+    (0x10A50, 'V'),
+    (0x10A59, 'X'),
+    (0x10A60, 'V'),
+    (0x10AA0, 'X'),
+    (0x10AC0, 'V'),
+    (0x10AE7, 'X'),
+    (0x10AEB, 'V'),
+    (0x10AF7, 'X'),
+    (0x10B00, 'V'),
+    ]
+
+def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x10B36, 'X'),
+    (0x10B39, 'V'),
+    (0x10B56, 'X'),
+    (0x10B58, 'V'),
+    (0x10B73, 'X'),
+    (0x10B78, 'V'),
+    (0x10B92, 'X'),
+    (0x10B99, 'V'),
+    (0x10B9D, 'X'),
+    (0x10BA9, 'V'),
+    (0x10BB0, 'X'),
+    (0x10C00, 'V'),
+    (0x10C49, 'X'),
+    (0x10C80, 'M', '𐳀'),
+    (0x10C81, 'M', '𐳁'),
+    (0x10C82, 'M', '𐳂'),
+    (0x10C83, 'M', '𐳃'),
+    (0x10C84, 'M', '𐳄'),
+    (0x10C85, 'M', '𐳅'),
+    (0x10C86, 'M', '𐳆'),
+    (0x10C87, 'M', '𐳇'),
+    (0x10C88, 'M', '𐳈'),
+    (0x10C89, 'M', '𐳉'),
+    (0x10C8A, 'M', '𐳊'),
+    (0x10C8B, 'M', '𐳋'),
+    (0x10C8C, 'M', '𐳌'),
+    (0x10C8D, 'M', '𐳍'),
+    (0x10C8E, 'M', '𐳎'),
+    (0x10C8F, 'M', '𐳏'),
+    (0x10C90, 'M', '𐳐'),
+    (0x10C91, 'M', '𐳑'),
+    (0x10C92, 'M', '𐳒'),
+    (0x10C93, 'M', '𐳓'),
+    (0x10C94, 'M', '𐳔'),
+    (0x10C95, 'M', '𐳕'),
+    (0x10C96, 'M', '𐳖'),
+    (0x10C97, 'M', '𐳗'),
+    (0x10C98, 'M', '𐳘'),
+    (0x10C99, 'M', '𐳙'),
+    (0x10C9A, 'M', '𐳚'),
+    (0x10C9B, 'M', '𐳛'),
+    (0x10C9C, 'M', '𐳜'),
+    (0x10C9D, 'M', '𐳝'),
+    (0x10C9E, 'M', '𐳞'),
+    (0x10C9F, 'M', '𐳟'),
+    (0x10CA0, 'M', '𐳠'),
+    (0x10CA1, 'M', '𐳡'),
+    (0x10CA2, 'M', '𐳢'),
+    (0x10CA3, 'M', '𐳣'),
+    (0x10CA4, 'M', '𐳤'),
+    (0x10CA5, 'M', '𐳥'),
+    (0x10CA6, 'M', '𐳦'),
+    (0x10CA7, 'M', '𐳧'),
+    (0x10CA8, 'M', '𐳨'),
+    (0x10CA9, 'M', '𐳩'),
+    (0x10CAA, 'M', '𐳪'),
+    (0x10CAB, 'M', '𐳫'),
+    (0x10CAC, 'M', '𐳬'),
+    (0x10CAD, 'M', '𐳭'),
+    (0x10CAE, 'M', '𐳮'),
+    (0x10CAF, 'M', '𐳯'),
+    (0x10CB0, 'M', '𐳰'),
+    (0x10CB1, 'M', '𐳱'),
+    (0x10CB2, 'M', '𐳲'),
+    (0x10CB3, 'X'),
+    (0x10CC0, 'V'),
+    (0x10CF3, 'X'),
+    (0x10CFA, 'V'),
+    (0x10D28, 'X'),
+    (0x10D30, 'V'),
+    (0x10D3A, 'X'),
+    (0x10E60, 'V'),
+    (0x10E7F, 'X'),
+    (0x10E80, 'V'),
+    (0x10EAA, 'X'),
+    (0x10EAB, 'V'),
+    (0x10EAE, 'X'),
+    (0x10EB0, 'V'),
+    (0x10EB2, 'X'),
+    (0x10EFD, 'V'),
+    (0x10F28, 'X'),
+    (0x10F30, 'V'),
+    (0x10F5A, 'X'),
+    (0x10F70, 'V'),
+    (0x10F8A, 'X'),
+    (0x10FB0, 'V'),
+    (0x10FCC, 'X'),
+    (0x10FE0, 'V'),
+    (0x10FF7, 'X'),
+    (0x11000, 'V'),
+    (0x1104E, 'X'),
+    (0x11052, 'V'),
+    (0x11076, 'X'),
+    (0x1107F, 'V'),
+    (0x110BD, 'X'),
+    (0x110BE, 'V'),
+    (0x110C3, 'X'),
+    (0x110D0, 'V'),
+    (0x110E9, 'X'),
+    (0x110F0, 'V'),
+    ]
+
+def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x110FA, 'X'),
+    (0x11100, 'V'),
+    (0x11135, 'X'),
+    (0x11136, 'V'),
+    (0x11148, 'X'),
+    (0x11150, 'V'),
+    (0x11177, 'X'),
+    (0x11180, 'V'),
+    (0x111E0, 'X'),
+    (0x111E1, 'V'),
+    (0x111F5, 'X'),
+    (0x11200, 'V'),
+    (0x11212, 'X'),
+    (0x11213, 'V'),
+    (0x11242, 'X'),
+    (0x11280, 'V'),
+    (0x11287, 'X'),
+    (0x11288, 'V'),
+    (0x11289, 'X'),
+    (0x1128A, 'V'),
+    (0x1128E, 'X'),
+    (0x1128F, 'V'),
+    (0x1129E, 'X'),
+    (0x1129F, 'V'),
+    (0x112AA, 'X'),
+    (0x112B0, 'V'),
+    (0x112EB, 'X'),
+    (0x112F0, 'V'),
+    (0x112FA, 'X'),
+    (0x11300, 'V'),
+    (0x11304, 'X'),
+    (0x11305, 'V'),
+    (0x1130D, 'X'),
+    (0x1130F, 'V'),
+    (0x11311, 'X'),
+    (0x11313, 'V'),
+    (0x11329, 'X'),
+    (0x1132A, 'V'),
+    (0x11331, 'X'),
+    (0x11332, 'V'),
+    (0x11334, 'X'),
+    (0x11335, 'V'),
+    (0x1133A, 'X'),
+    (0x1133B, 'V'),
+    (0x11345, 'X'),
+    (0x11347, 'V'),
+    (0x11349, 'X'),
+    (0x1134B, 'V'),
+    (0x1134E, 'X'),
+    (0x11350, 'V'),
+    (0x11351, 'X'),
+    (0x11357, 'V'),
+    (0x11358, 'X'),
+    (0x1135D, 'V'),
+    (0x11364, 'X'),
+    (0x11366, 'V'),
+    (0x1136D, 'X'),
+    (0x11370, 'V'),
+    (0x11375, 'X'),
+    (0x11400, 'V'),
+    (0x1145C, 'X'),
+    (0x1145D, 'V'),
+    (0x11462, 'X'),
+    (0x11480, 'V'),
+    (0x114C8, 'X'),
+    (0x114D0, 'V'),
+    (0x114DA, 'X'),
+    (0x11580, 'V'),
+    (0x115B6, 'X'),
+    (0x115B8, 'V'),
+    (0x115DE, 'X'),
+    (0x11600, 'V'),
+    (0x11645, 'X'),
+    (0x11650, 'V'),
+    (0x1165A, 'X'),
+    (0x11660, 'V'),
+    (0x1166D, 'X'),
+    (0x11680, 'V'),
+    (0x116BA, 'X'),
+    (0x116C0, 'V'),
+    (0x116CA, 'X'),
+    (0x11700, 'V'),
+    (0x1171B, 'X'),
+    (0x1171D, 'V'),
+    (0x1172C, 'X'),
+    (0x11730, 'V'),
+    (0x11747, 'X'),
+    (0x11800, 'V'),
+    (0x1183C, 'X'),
+    (0x118A0, 'M', '𑣀'),
+    (0x118A1, 'M', '𑣁'),
+    (0x118A2, 'M', '𑣂'),
+    (0x118A3, 'M', '𑣃'),
+    (0x118A4, 'M', '𑣄'),
+    (0x118A5, 'M', '𑣅'),
+    (0x118A6, 'M', '𑣆'),
+    (0x118A7, 'M', '𑣇'),
+    (0x118A8, 'M', '𑣈'),
+    (0x118A9, 'M', '𑣉'),
+    (0x118AA, 'M', '𑣊'),
+    ]
+
+def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x118AB, 'M', '𑣋'),
+    (0x118AC, 'M', '𑣌'),
+    (0x118AD, 'M', '𑣍'),
+    (0x118AE, 'M', '𑣎'),
+    (0x118AF, 'M', '𑣏'),
+    (0x118B0, 'M', '𑣐'),
+    (0x118B1, 'M', '𑣑'),
+    (0x118B2, 'M', '𑣒'),
+    (0x118B3, 'M', '𑣓'),
+    (0x118B4, 'M', '𑣔'),
+    (0x118B5, 'M', '𑣕'),
+    (0x118B6, 'M', '𑣖'),
+    (0x118B7, 'M', '𑣗'),
+    (0x118B8, 'M', '𑣘'),
+    (0x118B9, 'M', '𑣙'),
+    (0x118BA, 'M', '𑣚'),
+    (0x118BB, 'M', '𑣛'),
+    (0x118BC, 'M', '𑣜'),
+    (0x118BD, 'M', '𑣝'),
+    (0x118BE, 'M', '𑣞'),
+    (0x118BF, 'M', '𑣟'),
+    (0x118C0, 'V'),
+    (0x118F3, 'X'),
+    (0x118FF, 'V'),
+    (0x11907, 'X'),
+    (0x11909, 'V'),
+    (0x1190A, 'X'),
+    (0x1190C, 'V'),
+    (0x11914, 'X'),
+    (0x11915, 'V'),
+    (0x11917, 'X'),
+    (0x11918, 'V'),
+    (0x11936, 'X'),
+    (0x11937, 'V'),
+    (0x11939, 'X'),
+    (0x1193B, 'V'),
+    (0x11947, 'X'),
+    (0x11950, 'V'),
+    (0x1195A, 'X'),
+    (0x119A0, 'V'),
+    (0x119A8, 'X'),
+    (0x119AA, 'V'),
+    (0x119D8, 'X'),
+    (0x119DA, 'V'),
+    (0x119E5, 'X'),
+    (0x11A00, 'V'),
+    (0x11A48, 'X'),
+    (0x11A50, 'V'),
+    (0x11AA3, 'X'),
+    (0x11AB0, 'V'),
+    (0x11AF9, 'X'),
+    (0x11B00, 'V'),
+    (0x11B0A, 'X'),
+    (0x11C00, 'V'),
+    (0x11C09, 'X'),
+    (0x11C0A, 'V'),
+    (0x11C37, 'X'),
+    (0x11C38, 'V'),
+    (0x11C46, 'X'),
+    (0x11C50, 'V'),
+    (0x11C6D, 'X'),
+    (0x11C70, 'V'),
+    (0x11C90, 'X'),
+    (0x11C92, 'V'),
+    (0x11CA8, 'X'),
+    (0x11CA9, 'V'),
+    (0x11CB7, 'X'),
+    (0x11D00, 'V'),
+    (0x11D07, 'X'),
+    (0x11D08, 'V'),
+    (0x11D0A, 'X'),
+    (0x11D0B, 'V'),
+    (0x11D37, 'X'),
+    (0x11D3A, 'V'),
+    (0x11D3B, 'X'),
+    (0x11D3C, 'V'),
+    (0x11D3E, 'X'),
+    (0x11D3F, 'V'),
+    (0x11D48, 'X'),
+    (0x11D50, 'V'),
+    (0x11D5A, 'X'),
+    (0x11D60, 'V'),
+    (0x11D66, 'X'),
+    (0x11D67, 'V'),
+    (0x11D69, 'X'),
+    (0x11D6A, 'V'),
+    (0x11D8F, 'X'),
+    (0x11D90, 'V'),
+    (0x11D92, 'X'),
+    (0x11D93, 'V'),
+    (0x11D99, 'X'),
+    (0x11DA0, 'V'),
+    (0x11DAA, 'X'),
+    (0x11EE0, 'V'),
+    (0x11EF9, 'X'),
+    (0x11F00, 'V'),
+    (0x11F11, 'X'),
+    (0x11F12, 'V'),
+    (0x11F3B, 'X'),
+    (0x11F3E, 'V'),
+    ]
+
+def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x11F5A, 'X'),
+    (0x11FB0, 'V'),
+    (0x11FB1, 'X'),
+    (0x11FC0, 'V'),
+    (0x11FF2, 'X'),
+    (0x11FFF, 'V'),
+    (0x1239A, 'X'),
+    (0x12400, 'V'),
+    (0x1246F, 'X'),
+    (0x12470, 'V'),
+    (0x12475, 'X'),
+    (0x12480, 'V'),
+    (0x12544, 'X'),
+    (0x12F90, 'V'),
+    (0x12FF3, 'X'),
+    (0x13000, 'V'),
+    (0x13430, 'X'),
+    (0x13440, 'V'),
+    (0x13456, 'X'),
+    (0x14400, 'V'),
+    (0x14647, 'X'),
+    (0x16800, 'V'),
+    (0x16A39, 'X'),
+    (0x16A40, 'V'),
+    (0x16A5F, 'X'),
+    (0x16A60, 'V'),
+    (0x16A6A, 'X'),
+    (0x16A6E, 'V'),
+    (0x16ABF, 'X'),
+    (0x16AC0, 'V'),
+    (0x16ACA, 'X'),
+    (0x16AD0, 'V'),
+    (0x16AEE, 'X'),
+    (0x16AF0, 'V'),
+    (0x16AF6, 'X'),
+    (0x16B00, 'V'),
+    (0x16B46, 'X'),
+    (0x16B50, 'V'),
+    (0x16B5A, 'X'),
+    (0x16B5B, 'V'),
+    (0x16B62, 'X'),
+    (0x16B63, 'V'),
+    (0x16B78, 'X'),
+    (0x16B7D, 'V'),
+    (0x16B90, 'X'),
+    (0x16E40, 'M', '𖹠'),
+    (0x16E41, 'M', '𖹡'),
+    (0x16E42, 'M', '𖹢'),
+    (0x16E43, 'M', '𖹣'),
+    (0x16E44, 'M', '𖹤'),
+    (0x16E45, 'M', '𖹥'),
+    (0x16E46, 'M', '𖹦'),
+    (0x16E47, 'M', '𖹧'),
+    (0x16E48, 'M', '𖹨'),
+    (0x16E49, 'M', '𖹩'),
+    (0x16E4A, 'M', '𖹪'),
+    (0x16E4B, 'M', '𖹫'),
+    (0x16E4C, 'M', '𖹬'),
+    (0x16E4D, 'M', '𖹭'),
+    (0x16E4E, 'M', '𖹮'),
+    (0x16E4F, 'M', '𖹯'),
+    (0x16E50, 'M', '𖹰'),
+    (0x16E51, 'M', '𖹱'),
+    (0x16E52, 'M', '𖹲'),
+    (0x16E53, 'M', '𖹳'),
+    (0x16E54, 'M', '𖹴'),
+    (0x16E55, 'M', '𖹵'),
+    (0x16E56, 'M', '𖹶'),
+    (0x16E57, 'M', '𖹷'),
+    (0x16E58, 'M', '𖹸'),
+    (0x16E59, 'M', '𖹹'),
+    (0x16E5A, 'M', '𖹺'),
+    (0x16E5B, 'M', '𖹻'),
+    (0x16E5C, 'M', '𖹼'),
+    (0x16E5D, 'M', '𖹽'),
+    (0x16E5E, 'M', '𖹾'),
+    (0x16E5F, 'M', '𖹿'),
+    (0x16E60, 'V'),
+    (0x16E9B, 'X'),
+    (0x16F00, 'V'),
+    (0x16F4B, 'X'),
+    (0x16F4F, 'V'),
+    (0x16F88, 'X'),
+    (0x16F8F, 'V'),
+    (0x16FA0, 'X'),
+    (0x16FE0, 'V'),
+    (0x16FE5, 'X'),
+    (0x16FF0, 'V'),
+    (0x16FF2, 'X'),
+    (0x17000, 'V'),
+    (0x187F8, 'X'),
+    (0x18800, 'V'),
+    (0x18CD6, 'X'),
+    (0x18D00, 'V'),
+    (0x18D09, 'X'),
+    (0x1AFF0, 'V'),
+    (0x1AFF4, 'X'),
+    (0x1AFF5, 'V'),
+    (0x1AFFC, 'X'),
+    (0x1AFFD, 'V'),
+    ]
+
+def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1AFFF, 'X'),
+    (0x1B000, 'V'),
+    (0x1B123, 'X'),
+    (0x1B132, 'V'),
+    (0x1B133, 'X'),
+    (0x1B150, 'V'),
+    (0x1B153, 'X'),
+    (0x1B155, 'V'),
+    (0x1B156, 'X'),
+    (0x1B164, 'V'),
+    (0x1B168, 'X'),
+    (0x1B170, 'V'),
+    (0x1B2FC, 'X'),
+    (0x1BC00, 'V'),
+    (0x1BC6B, 'X'),
+    (0x1BC70, 'V'),
+    (0x1BC7D, 'X'),
+    (0x1BC80, 'V'),
+    (0x1BC89, 'X'),
+    (0x1BC90, 'V'),
+    (0x1BC9A, 'X'),
+    (0x1BC9C, 'V'),
+    (0x1BCA0, 'I'),
+    (0x1BCA4, 'X'),
+    (0x1CF00, 'V'),
+    (0x1CF2E, 'X'),
+    (0x1CF30, 'V'),
+    (0x1CF47, 'X'),
+    (0x1CF50, 'V'),
+    (0x1CFC4, 'X'),
+    (0x1D000, 'V'),
+    (0x1D0F6, 'X'),
+    (0x1D100, 'V'),
+    (0x1D127, 'X'),
+    (0x1D129, 'V'),
+    (0x1D15E, 'M', '𝅗𝅥'),
+    (0x1D15F, 'M', '𝅘𝅥'),
+    (0x1D160, 'M', '𝅘𝅥𝅮'),
+    (0x1D161, 'M', '𝅘𝅥𝅯'),
+    (0x1D162, 'M', '𝅘𝅥𝅰'),
+    (0x1D163, 'M', '𝅘𝅥𝅱'),
+    (0x1D164, 'M', '𝅘𝅥𝅲'),
+    (0x1D165, 'V'),
+    (0x1D173, 'X'),
+    (0x1D17B, 'V'),
+    (0x1D1BB, 'M', '𝆹𝅥'),
+    (0x1D1BC, 'M', '𝆺𝅥'),
+    (0x1D1BD, 'M', '𝆹𝅥𝅮'),
+    (0x1D1BE, 'M', '𝆺𝅥𝅮'),
+    (0x1D1BF, 'M', '𝆹𝅥𝅯'),
+    (0x1D1C0, 'M', '𝆺𝅥𝅯'),
+    (0x1D1C1, 'V'),
+    (0x1D1EB, 'X'),
+    (0x1D200, 'V'),
+    (0x1D246, 'X'),
+    (0x1D2C0, 'V'),
+    (0x1D2D4, 'X'),
+    (0x1D2E0, 'V'),
+    (0x1D2F4, 'X'),
+    (0x1D300, 'V'),
+    (0x1D357, 'X'),
+    (0x1D360, 'V'),
+    (0x1D379, 'X'),
+    (0x1D400, 'M', 'a'),
+    (0x1D401, 'M', 'b'),
+    (0x1D402, 'M', 'c'),
+    (0x1D403, 'M', 'd'),
+    (0x1D404, 'M', 'e'),
+    (0x1D405, 'M', 'f'),
+    (0x1D406, 'M', 'g'),
+    (0x1D407, 'M', 'h'),
+    (0x1D408, 'M', 'i'),
+    (0x1D409, 'M', 'j'),
+    (0x1D40A, 'M', 'k'),
+    (0x1D40B, 'M', 'l'),
+    (0x1D40C, 'M', 'm'),
+    (0x1D40D, 'M', 'n'),
+    (0x1D40E, 'M', 'o'),
+    (0x1D40F, 'M', 'p'),
+    (0x1D410, 'M', 'q'),
+    (0x1D411, 'M', 'r'),
+    (0x1D412, 'M', 's'),
+    (0x1D413, 'M', 't'),
+    (0x1D414, 'M', 'u'),
+    (0x1D415, 'M', 'v'),
+    (0x1D416, 'M', 'w'),
+    (0x1D417, 'M', 'x'),
+    (0x1D418, 'M', 'y'),
+    (0x1D419, 'M', 'z'),
+    (0x1D41A, 'M', 'a'),
+    (0x1D41B, 'M', 'b'),
+    (0x1D41C, 'M', 'c'),
+    (0x1D41D, 'M', 'd'),
+    (0x1D41E, 'M', 'e'),
+    (0x1D41F, 'M', 'f'),
+    (0x1D420, 'M', 'g'),
+    (0x1D421, 'M', 'h'),
+    (0x1D422, 'M', 'i'),
+    (0x1D423, 'M', 'j'),
+    (0x1D424, 'M', 'k'),
+    ]
+
+def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D425, 'M', 'l'),
+    (0x1D426, 'M', 'm'),
+    (0x1D427, 'M', 'n'),
+    (0x1D428, 'M', 'o'),
+    (0x1D429, 'M', 'p'),
+    (0x1D42A, 'M', 'q'),
+    (0x1D42B, 'M', 'r'),
+    (0x1D42C, 'M', 's'),
+    (0x1D42D, 'M', 't'),
+    (0x1D42E, 'M', 'u'),
+    (0x1D42F, 'M', 'v'),
+    (0x1D430, 'M', 'w'),
+    (0x1D431, 'M', 'x'),
+    (0x1D432, 'M', 'y'),
+    (0x1D433, 'M', 'z'),
+    (0x1D434, 'M', 'a'),
+    (0x1D435, 'M', 'b'),
+    (0x1D436, 'M', 'c'),
+    (0x1D437, 'M', 'd'),
+    (0x1D438, 'M', 'e'),
+    (0x1D439, 'M', 'f'),
+    (0x1D43A, 'M', 'g'),
+    (0x1D43B, 'M', 'h'),
+    (0x1D43C, 'M', 'i'),
+    (0x1D43D, 'M', 'j'),
+    (0x1D43E, 'M', 'k'),
+    (0x1D43F, 'M', 'l'),
+    (0x1D440, 'M', 'm'),
+    (0x1D441, 'M', 'n'),
+    (0x1D442, 'M', 'o'),
+    (0x1D443, 'M', 'p'),
+    (0x1D444, 'M', 'q'),
+    (0x1D445, 'M', 'r'),
+    (0x1D446, 'M', 's'),
+    (0x1D447, 'M', 't'),
+    (0x1D448, 'M', 'u'),
+    (0x1D449, 'M', 'v'),
+    (0x1D44A, 'M', 'w'),
+    (0x1D44B, 'M', 'x'),
+    (0x1D44C, 'M', 'y'),
+    (0x1D44D, 'M', 'z'),
+    (0x1D44E, 'M', 'a'),
+    (0x1D44F, 'M', 'b'),
+    (0x1D450, 'M', 'c'),
+    (0x1D451, 'M', 'd'),
+    (0x1D452, 'M', 'e'),
+    (0x1D453, 'M', 'f'),
+    (0x1D454, 'M', 'g'),
+    (0x1D455, 'X'),
+    (0x1D456, 'M', 'i'),
+    (0x1D457, 'M', 'j'),
+    (0x1D458, 'M', 'k'),
+    (0x1D459, 'M', 'l'),
+    (0x1D45A, 'M', 'm'),
+    (0x1D45B, 'M', 'n'),
+    (0x1D45C, 'M', 'o'),
+    (0x1D45D, 'M', 'p'),
+    (0x1D45E, 'M', 'q'),
+    (0x1D45F, 'M', 'r'),
+    (0x1D460, 'M', 's'),
+    (0x1D461, 'M', 't'),
+    (0x1D462, 'M', 'u'),
+    (0x1D463, 'M', 'v'),
+    (0x1D464, 'M', 'w'),
+    (0x1D465, 'M', 'x'),
+    (0x1D466, 'M', 'y'),
+    (0x1D467, 'M', 'z'),
+    (0x1D468, 'M', 'a'),
+    (0x1D469, 'M', 'b'),
+    (0x1D46A, 'M', 'c'),
+    (0x1D46B, 'M', 'd'),
+    (0x1D46C, 'M', 'e'),
+    (0x1D46D, 'M', 'f'),
+    (0x1D46E, 'M', 'g'),
+    (0x1D46F, 'M', 'h'),
+    (0x1D470, 'M', 'i'),
+    (0x1D471, 'M', 'j'),
+    (0x1D472, 'M', 'k'),
+    (0x1D473, 'M', 'l'),
+    (0x1D474, 'M', 'm'),
+    (0x1D475, 'M', 'n'),
+    (0x1D476, 'M', 'o'),
+    (0x1D477, 'M', 'p'),
+    (0x1D478, 'M', 'q'),
+    (0x1D479, 'M', 'r'),
+    (0x1D47A, 'M', 's'),
+    (0x1D47B, 'M', 't'),
+    (0x1D47C, 'M', 'u'),
+    (0x1D47D, 'M', 'v'),
+    (0x1D47E, 'M', 'w'),
+    (0x1D47F, 'M', 'x'),
+    (0x1D480, 'M', 'y'),
+    (0x1D481, 'M', 'z'),
+    (0x1D482, 'M', 'a'),
+    (0x1D483, 'M', 'b'),
+    (0x1D484, 'M', 'c'),
+    (0x1D485, 'M', 'd'),
+    (0x1D486, 'M', 'e'),
+    (0x1D487, 'M', 'f'),
+    (0x1D488, 'M', 'g'),
+    ]
+
+def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D489, 'M', 'h'),
+    (0x1D48A, 'M', 'i'),
+    (0x1D48B, 'M', 'j'),
+    (0x1D48C, 'M', 'k'),
+    (0x1D48D, 'M', 'l'),
+    (0x1D48E, 'M', 'm'),
+    (0x1D48F, 'M', 'n'),
+    (0x1D490, 'M', 'o'),
+    (0x1D491, 'M', 'p'),
+    (0x1D492, 'M', 'q'),
+    (0x1D493, 'M', 'r'),
+    (0x1D494, 'M', 's'),
+    (0x1D495, 'M', 't'),
+    (0x1D496, 'M', 'u'),
+    (0x1D497, 'M', 'v'),
+    (0x1D498, 'M', 'w'),
+    (0x1D499, 'M', 'x'),
+    (0x1D49A, 'M', 'y'),
+    (0x1D49B, 'M', 'z'),
+    (0x1D49C, 'M', 'a'),
+    (0x1D49D, 'X'),
+    (0x1D49E, 'M', 'c'),
+    (0x1D49F, 'M', 'd'),
+    (0x1D4A0, 'X'),
+    (0x1D4A2, 'M', 'g'),
+    (0x1D4A3, 'X'),
+    (0x1D4A5, 'M', 'j'),
+    (0x1D4A6, 'M', 'k'),
+    (0x1D4A7, 'X'),
+    (0x1D4A9, 'M', 'n'),
+    (0x1D4AA, 'M', 'o'),
+    (0x1D4AB, 'M', 'p'),
+    (0x1D4AC, 'M', 'q'),
+    (0x1D4AD, 'X'),
+    (0x1D4AE, 'M', 's'),
+    (0x1D4AF, 'M', 't'),
+    (0x1D4B0, 'M', 'u'),
+    (0x1D4B1, 'M', 'v'),
+    (0x1D4B2, 'M', 'w'),
+    (0x1D4B3, 'M', 'x'),
+    (0x1D4B4, 'M', 'y'),
+    (0x1D4B5, 'M', 'z'),
+    (0x1D4B6, 'M', 'a'),
+    (0x1D4B7, 'M', 'b'),
+    (0x1D4B8, 'M', 'c'),
+    (0x1D4B9, 'M', 'd'),
+    (0x1D4BA, 'X'),
+    (0x1D4BB, 'M', 'f'),
+    (0x1D4BC, 'X'),
+    (0x1D4BD, 'M', 'h'),
+    (0x1D4BE, 'M', 'i'),
+    (0x1D4BF, 'M', 'j'),
+    (0x1D4C0, 'M', 'k'),
+    (0x1D4C1, 'M', 'l'),
+    (0x1D4C2, 'M', 'm'),
+    (0x1D4C3, 'M', 'n'),
+    (0x1D4C4, 'X'),
+    (0x1D4C5, 'M', 'p'),
+    (0x1D4C6, 'M', 'q'),
+    (0x1D4C7, 'M', 'r'),
+    (0x1D4C8, 'M', 's'),
+    (0x1D4C9, 'M', 't'),
+    (0x1D4CA, 'M', 'u'),
+    (0x1D4CB, 'M', 'v'),
+    (0x1D4CC, 'M', 'w'),
+    (0x1D4CD, 'M', 'x'),
+    (0x1D4CE, 'M', 'y'),
+    (0x1D4CF, 'M', 'z'),
+    (0x1D4D0, 'M', 'a'),
+    (0x1D4D1, 'M', 'b'),
+    (0x1D4D2, 'M', 'c'),
+    (0x1D4D3, 'M', 'd'),
+    (0x1D4D4, 'M', 'e'),
+    (0x1D4D5, 'M', 'f'),
+    (0x1D4D6, 'M', 'g'),
+    (0x1D4D7, 'M', 'h'),
+    (0x1D4D8, 'M', 'i'),
+    (0x1D4D9, 'M', 'j'),
+    (0x1D4DA, 'M', 'k'),
+    (0x1D4DB, 'M', 'l'),
+    (0x1D4DC, 'M', 'm'),
+    (0x1D4DD, 'M', 'n'),
+    (0x1D4DE, 'M', 'o'),
+    (0x1D4DF, 'M', 'p'),
+    (0x1D4E0, 'M', 'q'),
+    (0x1D4E1, 'M', 'r'),
+    (0x1D4E2, 'M', 's'),
+    (0x1D4E3, 'M', 't'),
+    (0x1D4E4, 'M', 'u'),
+    (0x1D4E5, 'M', 'v'),
+    (0x1D4E6, 'M', 'w'),
+    (0x1D4E7, 'M', 'x'),
+    (0x1D4E8, 'M', 'y'),
+    (0x1D4E9, 'M', 'z'),
+    (0x1D4EA, 'M', 'a'),
+    (0x1D4EB, 'M', 'b'),
+    (0x1D4EC, 'M', 'c'),
+    (0x1D4ED, 'M', 'd'),
+    (0x1D4EE, 'M', 'e'),
+    (0x1D4EF, 'M', 'f'),
+    ]
+
+def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D4F0, 'M', 'g'),
+    (0x1D4F1, 'M', 'h'),
+    (0x1D4F2, 'M', 'i'),
+    (0x1D4F3, 'M', 'j'),
+    (0x1D4F4, 'M', 'k'),
+    (0x1D4F5, 'M', 'l'),
+    (0x1D4F6, 'M', 'm'),
+    (0x1D4F7, 'M', 'n'),
+    (0x1D4F8, 'M', 'o'),
+    (0x1D4F9, 'M', 'p'),
+    (0x1D4FA, 'M', 'q'),
+    (0x1D4FB, 'M', 'r'),
+    (0x1D4FC, 'M', 's'),
+    (0x1D4FD, 'M', 't'),
+    (0x1D4FE, 'M', 'u'),
+    (0x1D4FF, 'M', 'v'),
+    (0x1D500, 'M', 'w'),
+    (0x1D501, 'M', 'x'),
+    (0x1D502, 'M', 'y'),
+    (0x1D503, 'M', 'z'),
+    (0x1D504, 'M', 'a'),
+    (0x1D505, 'M', 'b'),
+    (0x1D506, 'X'),
+    (0x1D507, 'M', 'd'),
+    (0x1D508, 'M', 'e'),
+    (0x1D509, 'M', 'f'),
+    (0x1D50A, 'M', 'g'),
+    (0x1D50B, 'X'),
+    (0x1D50D, 'M', 'j'),
+    (0x1D50E, 'M', 'k'),
+    (0x1D50F, 'M', 'l'),
+    (0x1D510, 'M', 'm'),
+    (0x1D511, 'M', 'n'),
+    (0x1D512, 'M', 'o'),
+    (0x1D513, 'M', 'p'),
+    (0x1D514, 'M', 'q'),
+    (0x1D515, 'X'),
+    (0x1D516, 'M', 's'),
+    (0x1D517, 'M', 't'),
+    (0x1D518, 'M', 'u'),
+    (0x1D519, 'M', 'v'),
+    (0x1D51A, 'M', 'w'),
+    (0x1D51B, 'M', 'x'),
+    (0x1D51C, 'M', 'y'),
+    (0x1D51D, 'X'),
+    (0x1D51E, 'M', 'a'),
+    (0x1D51F, 'M', 'b'),
+    (0x1D520, 'M', 'c'),
+    (0x1D521, 'M', 'd'),
+    (0x1D522, 'M', 'e'),
+    (0x1D523, 'M', 'f'),
+    (0x1D524, 'M', 'g'),
+    (0x1D525, 'M', 'h'),
+    (0x1D526, 'M', 'i'),
+    (0x1D527, 'M', 'j'),
+    (0x1D528, 'M', 'k'),
+    (0x1D529, 'M', 'l'),
+    (0x1D52A, 'M', 'm'),
+    (0x1D52B, 'M', 'n'),
+    (0x1D52C, 'M', 'o'),
+    (0x1D52D, 'M', 'p'),
+    (0x1D52E, 'M', 'q'),
+    (0x1D52F, 'M', 'r'),
+    (0x1D530, 'M', 's'),
+    (0x1D531, 'M', 't'),
+    (0x1D532, 'M', 'u'),
+    (0x1D533, 'M', 'v'),
+    (0x1D534, 'M', 'w'),
+    (0x1D535, 'M', 'x'),
+    (0x1D536, 'M', 'y'),
+    (0x1D537, 'M', 'z'),
+    (0x1D538, 'M', 'a'),
+    (0x1D539, 'M', 'b'),
+    (0x1D53A, 'X'),
+    (0x1D53B, 'M', 'd'),
+    (0x1D53C, 'M', 'e'),
+    (0x1D53D, 'M', 'f'),
+    (0x1D53E, 'M', 'g'),
+    (0x1D53F, 'X'),
+    (0x1D540, 'M', 'i'),
+    (0x1D541, 'M', 'j'),
+    (0x1D542, 'M', 'k'),
+    (0x1D543, 'M', 'l'),
+    (0x1D544, 'M', 'm'),
+    (0x1D545, 'X'),
+    (0x1D546, 'M', 'o'),
+    (0x1D547, 'X'),
+    (0x1D54A, 'M', 's'),
+    (0x1D54B, 'M', 't'),
+    (0x1D54C, 'M', 'u'),
+    (0x1D54D, 'M', 'v'),
+    (0x1D54E, 'M', 'w'),
+    (0x1D54F, 'M', 'x'),
+    (0x1D550, 'M', 'y'),
+    (0x1D551, 'X'),
+    (0x1D552, 'M', 'a'),
+    (0x1D553, 'M', 'b'),
+    (0x1D554, 'M', 'c'),
+    (0x1D555, 'M', 'd'),
+    (0x1D556, 'M', 'e'),
+    ]
+
+def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D557, 'M', 'f'),
+    (0x1D558, 'M', 'g'),
+    (0x1D559, 'M', 'h'),
+    (0x1D55A, 'M', 'i'),
+    (0x1D55B, 'M', 'j'),
+    (0x1D55C, 'M', 'k'),
+    (0x1D55D, 'M', 'l'),
+    (0x1D55E, 'M', 'm'),
+    (0x1D55F, 'M', 'n'),
+    (0x1D560, 'M', 'o'),
+    (0x1D561, 'M', 'p'),
+    (0x1D562, 'M', 'q'),
+    (0x1D563, 'M', 'r'),
+    (0x1D564, 'M', 's'),
+    (0x1D565, 'M', 't'),
+    (0x1D566, 'M', 'u'),
+    (0x1D567, 'M', 'v'),
+    (0x1D568, 'M', 'w'),
+    (0x1D569, 'M', 'x'),
+    (0x1D56A, 'M', 'y'),
+    (0x1D56B, 'M', 'z'),
+    (0x1D56C, 'M', 'a'),
+    (0x1D56D, 'M', 'b'),
+    (0x1D56E, 'M', 'c'),
+    (0x1D56F, 'M', 'd'),
+    (0x1D570, 'M', 'e'),
+    (0x1D571, 'M', 'f'),
+    (0x1D572, 'M', 'g'),
+    (0x1D573, 'M', 'h'),
+    (0x1D574, 'M', 'i'),
+    (0x1D575, 'M', 'j'),
+    (0x1D576, 'M', 'k'),
+    (0x1D577, 'M', 'l'),
+    (0x1D578, 'M', 'm'),
+    (0x1D579, 'M', 'n'),
+    (0x1D57A, 'M', 'o'),
+    (0x1D57B, 'M', 'p'),
+    (0x1D57C, 'M', 'q'),
+    (0x1D57D, 'M', 'r'),
+    (0x1D57E, 'M', 's'),
+    (0x1D57F, 'M', 't'),
+    (0x1D580, 'M', 'u'),
+    (0x1D581, 'M', 'v'),
+    (0x1D582, 'M', 'w'),
+    (0x1D583, 'M', 'x'),
+    (0x1D584, 'M', 'y'),
+    (0x1D585, 'M', 'z'),
+    (0x1D586, 'M', 'a'),
+    (0x1D587, 'M', 'b'),
+    (0x1D588, 'M', 'c'),
+    (0x1D589, 'M', 'd'),
+    (0x1D58A, 'M', 'e'),
+    (0x1D58B, 'M', 'f'),
+    (0x1D58C, 'M', 'g'),
+    (0x1D58D, 'M', 'h'),
+    (0x1D58E, 'M', 'i'),
+    (0x1D58F, 'M', 'j'),
+    (0x1D590, 'M', 'k'),
+    (0x1D591, 'M', 'l'),
+    (0x1D592, 'M', 'm'),
+    (0x1D593, 'M', 'n'),
+    (0x1D594, 'M', 'o'),
+    (0x1D595, 'M', 'p'),
+    (0x1D596, 'M', 'q'),
+    (0x1D597, 'M', 'r'),
+    (0x1D598, 'M', 's'),
+    (0x1D599, 'M', 't'),
+    (0x1D59A, 'M', 'u'),
+    (0x1D59B, 'M', 'v'),
+    (0x1D59C, 'M', 'w'),
+    (0x1D59D, 'M', 'x'),
+    (0x1D59E, 'M', 'y'),
+    (0x1D59F, 'M', 'z'),
+    (0x1D5A0, 'M', 'a'),
+    (0x1D5A1, 'M', 'b'),
+    (0x1D5A2, 'M', 'c'),
+    (0x1D5A3, 'M', 'd'),
+    (0x1D5A4, 'M', 'e'),
+    (0x1D5A5, 'M', 'f'),
+    (0x1D5A6, 'M', 'g'),
+    (0x1D5A7, 'M', 'h'),
+    (0x1D5A8, 'M', 'i'),
+    (0x1D5A9, 'M', 'j'),
+    (0x1D5AA, 'M', 'k'),
+    (0x1D5AB, 'M', 'l'),
+    (0x1D5AC, 'M', 'm'),
+    (0x1D5AD, 'M', 'n'),
+    (0x1D5AE, 'M', 'o'),
+    (0x1D5AF, 'M', 'p'),
+    (0x1D5B0, 'M', 'q'),
+    (0x1D5B1, 'M', 'r'),
+    (0x1D5B2, 'M', 's'),
+    (0x1D5B3, 'M', 't'),
+    (0x1D5B4, 'M', 'u'),
+    (0x1D5B5, 'M', 'v'),
+    (0x1D5B6, 'M', 'w'),
+    (0x1D5B7, 'M', 'x'),
+    (0x1D5B8, 'M', 'y'),
+    (0x1D5B9, 'M', 'z'),
+    (0x1D5BA, 'M', 'a'),
+    ]
+
+def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D5BB, 'M', 'b'),
+    (0x1D5BC, 'M', 'c'),
+    (0x1D5BD, 'M', 'd'),
+    (0x1D5BE, 'M', 'e'),
+    (0x1D5BF, 'M', 'f'),
+    (0x1D5C0, 'M', 'g'),
+    (0x1D5C1, 'M', 'h'),
+    (0x1D5C2, 'M', 'i'),
+    (0x1D5C3, 'M', 'j'),
+    (0x1D5C4, 'M', 'k'),
+    (0x1D5C5, 'M', 'l'),
+    (0x1D5C6, 'M', 'm'),
+    (0x1D5C7, 'M', 'n'),
+    (0x1D5C8, 'M', 'o'),
+    (0x1D5C9, 'M', 'p'),
+    (0x1D5CA, 'M', 'q'),
+    (0x1D5CB, 'M', 'r'),
+    (0x1D5CC, 'M', 's'),
+    (0x1D5CD, 'M', 't'),
+    (0x1D5CE, 'M', 'u'),
+    (0x1D5CF, 'M', 'v'),
+    (0x1D5D0, 'M', 'w'),
+    (0x1D5D1, 'M', 'x'),
+    (0x1D5D2, 'M', 'y'),
+    (0x1D5D3, 'M', 'z'),
+    (0x1D5D4, 'M', 'a'),
+    (0x1D5D5, 'M', 'b'),
+    (0x1D5D6, 'M', 'c'),
+    (0x1D5D7, 'M', 'd'),
+    (0x1D5D8, 'M', 'e'),
+    (0x1D5D9, 'M', 'f'),
+    (0x1D5DA, 'M', 'g'),
+    (0x1D5DB, 'M', 'h'),
+    (0x1D5DC, 'M', 'i'),
+    (0x1D5DD, 'M', 'j'),
+    (0x1D5DE, 'M', 'k'),
+    (0x1D5DF, 'M', 'l'),
+    (0x1D5E0, 'M', 'm'),
+    (0x1D5E1, 'M', 'n'),
+    (0x1D5E2, 'M', 'o'),
+    (0x1D5E3, 'M', 'p'),
+    (0x1D5E4, 'M', 'q'),
+    (0x1D5E5, 'M', 'r'),
+    (0x1D5E6, 'M', 's'),
+    (0x1D5E7, 'M', 't'),
+    (0x1D5E8, 'M', 'u'),
+    (0x1D5E9, 'M', 'v'),
+    (0x1D5EA, 'M', 'w'),
+    (0x1D5EB, 'M', 'x'),
+    (0x1D5EC, 'M', 'y'),
+    (0x1D5ED, 'M', 'z'),
+    (0x1D5EE, 'M', 'a'),
+    (0x1D5EF, 'M', 'b'),
+    (0x1D5F0, 'M', 'c'),
+    (0x1D5F1, 'M', 'd'),
+    (0x1D5F2, 'M', 'e'),
+    (0x1D5F3, 'M', 'f'),
+    (0x1D5F4, 'M', 'g'),
+    (0x1D5F5, 'M', 'h'),
+    (0x1D5F6, 'M', 'i'),
+    (0x1D5F7, 'M', 'j'),
+    (0x1D5F8, 'M', 'k'),
+    (0x1D5F9, 'M', 'l'),
+    (0x1D5FA, 'M', 'm'),
+    (0x1D5FB, 'M', 'n'),
+    (0x1D5FC, 'M', 'o'),
+    (0x1D5FD, 'M', 'p'),
+    (0x1D5FE, 'M', 'q'),
+    (0x1D5FF, 'M', 'r'),
+    (0x1D600, 'M', 's'),
+    (0x1D601, 'M', 't'),
+    (0x1D602, 'M', 'u'),
+    (0x1D603, 'M', 'v'),
+    (0x1D604, 'M', 'w'),
+    (0x1D605, 'M', 'x'),
+    (0x1D606, 'M', 'y'),
+    (0x1D607, 'M', 'z'),
+    (0x1D608, 'M', 'a'),
+    (0x1D609, 'M', 'b'),
+    (0x1D60A, 'M', 'c'),
+    (0x1D60B, 'M', 'd'),
+    (0x1D60C, 'M', 'e'),
+    (0x1D60D, 'M', 'f'),
+    (0x1D60E, 'M', 'g'),
+    (0x1D60F, 'M', 'h'),
+    (0x1D610, 'M', 'i'),
+    (0x1D611, 'M', 'j'),
+    (0x1D612, 'M', 'k'),
+    (0x1D613, 'M', 'l'),
+    (0x1D614, 'M', 'm'),
+    (0x1D615, 'M', 'n'),
+    (0x1D616, 'M', 'o'),
+    (0x1D617, 'M', 'p'),
+    (0x1D618, 'M', 'q'),
+    (0x1D619, 'M', 'r'),
+    (0x1D61A, 'M', 's'),
+    (0x1D61B, 'M', 't'),
+    (0x1D61C, 'M', 'u'),
+    (0x1D61D, 'M', 'v'),
+    (0x1D61E, 'M', 'w'),
+    ]
+
+def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D61F, 'M', 'x'),
+    (0x1D620, 'M', 'y'),
+    (0x1D621, 'M', 'z'),
+    (0x1D622, 'M', 'a'),
+    (0x1D623, 'M', 'b'),
+    (0x1D624, 'M', 'c'),
+    (0x1D625, 'M', 'd'),
+    (0x1D626, 'M', 'e'),
+    (0x1D627, 'M', 'f'),
+    (0x1D628, 'M', 'g'),
+    (0x1D629, 'M', 'h'),
+    (0x1D62A, 'M', 'i'),
+    (0x1D62B, 'M', 'j'),
+    (0x1D62C, 'M', 'k'),
+    (0x1D62D, 'M', 'l'),
+    (0x1D62E, 'M', 'm'),
+    (0x1D62F, 'M', 'n'),
+    (0x1D630, 'M', 'o'),
+    (0x1D631, 'M', 'p'),
+    (0x1D632, 'M', 'q'),
+    (0x1D633, 'M', 'r'),
+    (0x1D634, 'M', 's'),
+    (0x1D635, 'M', 't'),
+    (0x1D636, 'M', 'u'),
+    (0x1D637, 'M', 'v'),
+    (0x1D638, 'M', 'w'),
+    (0x1D639, 'M', 'x'),
+    (0x1D63A, 'M', 'y'),
+    (0x1D63B, 'M', 'z'),
+    (0x1D63C, 'M', 'a'),
+    (0x1D63D, 'M', 'b'),
+    (0x1D63E, 'M', 'c'),
+    (0x1D63F, 'M', 'd'),
+    (0x1D640, 'M', 'e'),
+    (0x1D641, 'M', 'f'),
+    (0x1D642, 'M', 'g'),
+    (0x1D643, 'M', 'h'),
+    (0x1D644, 'M', 'i'),
+    (0x1D645, 'M', 'j'),
+    (0x1D646, 'M', 'k'),
+    (0x1D647, 'M', 'l'),
+    (0x1D648, 'M', 'm'),
+    (0x1D649, 'M', 'n'),
+    (0x1D64A, 'M', 'o'),
+    (0x1D64B, 'M', 'p'),
+    (0x1D64C, 'M', 'q'),
+    (0x1D64D, 'M', 'r'),
+    (0x1D64E, 'M', 's'),
+    (0x1D64F, 'M', 't'),
+    (0x1D650, 'M', 'u'),
+    (0x1D651, 'M', 'v'),
+    (0x1D652, 'M', 'w'),
+    (0x1D653, 'M', 'x'),
+    (0x1D654, 'M', 'y'),
+    (0x1D655, 'M', 'z'),
+    (0x1D656, 'M', 'a'),
+    (0x1D657, 'M', 'b'),
+    (0x1D658, 'M', 'c'),
+    (0x1D659, 'M', 'd'),
+    (0x1D65A, 'M', 'e'),
+    (0x1D65B, 'M', 'f'),
+    (0x1D65C, 'M', 'g'),
+    (0x1D65D, 'M', 'h'),
+    (0x1D65E, 'M', 'i'),
+    (0x1D65F, 'M', 'j'),
+    (0x1D660, 'M', 'k'),
+    (0x1D661, 'M', 'l'),
+    (0x1D662, 'M', 'm'),
+    (0x1D663, 'M', 'n'),
+    (0x1D664, 'M', 'o'),
+    (0x1D665, 'M', 'p'),
+    (0x1D666, 'M', 'q'),
+    (0x1D667, 'M', 'r'),
+    (0x1D668, 'M', 's'),
+    (0x1D669, 'M', 't'),
+    (0x1D66A, 'M', 'u'),
+    (0x1D66B, 'M', 'v'),
+    (0x1D66C, 'M', 'w'),
+    (0x1D66D, 'M', 'x'),
+    (0x1D66E, 'M', 'y'),
+    (0x1D66F, 'M', 'z'),
+    (0x1D670, 'M', 'a'),
+    (0x1D671, 'M', 'b'),
+    (0x1D672, 'M', 'c'),
+    (0x1D673, 'M', 'd'),
+    (0x1D674, 'M', 'e'),
+    (0x1D675, 'M', 'f'),
+    (0x1D676, 'M', 'g'),
+    (0x1D677, 'M', 'h'),
+    (0x1D678, 'M', 'i'),
+    (0x1D679, 'M', 'j'),
+    (0x1D67A, 'M', 'k'),
+    (0x1D67B, 'M', 'l'),
+    (0x1D67C, 'M', 'm'),
+    (0x1D67D, 'M', 'n'),
+    (0x1D67E, 'M', 'o'),
+    (0x1D67F, 'M', 'p'),
+    (0x1D680, 'M', 'q'),
+    (0x1D681, 'M', 'r'),
+    (0x1D682, 'M', 's'),
+    ]
+
+def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D683, 'M', 't'),
+    (0x1D684, 'M', 'u'),
+    (0x1D685, 'M', 'v'),
+    (0x1D686, 'M', 'w'),
+    (0x1D687, 'M', 'x'),
+    (0x1D688, 'M', 'y'),
+    (0x1D689, 'M', 'z'),
+    (0x1D68A, 'M', 'a'),
+    (0x1D68B, 'M', 'b'),
+    (0x1D68C, 'M', 'c'),
+    (0x1D68D, 'M', 'd'),
+    (0x1D68E, 'M', 'e'),
+    (0x1D68F, 'M', 'f'),
+    (0x1D690, 'M', 'g'),
+    (0x1D691, 'M', 'h'),
+    (0x1D692, 'M', 'i'),
+    (0x1D693, 'M', 'j'),
+    (0x1D694, 'M', 'k'),
+    (0x1D695, 'M', 'l'),
+    (0x1D696, 'M', 'm'),
+    (0x1D697, 'M', 'n'),
+    (0x1D698, 'M', 'o'),
+    (0x1D699, 'M', 'p'),
+    (0x1D69A, 'M', 'q'),
+    (0x1D69B, 'M', 'r'),
+    (0x1D69C, 'M', 's'),
+    (0x1D69D, 'M', 't'),
+    (0x1D69E, 'M', 'u'),
+    (0x1D69F, 'M', 'v'),
+    (0x1D6A0, 'M', 'w'),
+    (0x1D6A1, 'M', 'x'),
+    (0x1D6A2, 'M', 'y'),
+    (0x1D6A3, 'M', 'z'),
+    (0x1D6A4, 'M', 'ı'),
+    (0x1D6A5, 'M', 'ȷ'),
+    (0x1D6A6, 'X'),
+    (0x1D6A8, 'M', 'α'),
+    (0x1D6A9, 'M', 'β'),
+    (0x1D6AA, 'M', 'γ'),
+    (0x1D6AB, 'M', 'δ'),
+    (0x1D6AC, 'M', 'ε'),
+    (0x1D6AD, 'M', 'ζ'),
+    (0x1D6AE, 'M', 'η'),
+    (0x1D6AF, 'M', 'θ'),
+    (0x1D6B0, 'M', 'ι'),
+    (0x1D6B1, 'M', 'κ'),
+    (0x1D6B2, 'M', 'λ'),
+    (0x1D6B3, 'M', 'μ'),
+    (0x1D6B4, 'M', 'ν'),
+    (0x1D6B5, 'M', 'ξ'),
+    (0x1D6B6, 'M', 'ο'),
+    (0x1D6B7, 'M', 'π'),
+    (0x1D6B8, 'M', 'ρ'),
+    (0x1D6B9, 'M', 'θ'),
+    (0x1D6BA, 'M', 'σ'),
+    (0x1D6BB, 'M', 'τ'),
+    (0x1D6BC, 'M', 'υ'),
+    (0x1D6BD, 'M', 'φ'),
+    (0x1D6BE, 'M', 'χ'),
+    (0x1D6BF, 'M', 'ψ'),
+    (0x1D6C0, 'M', 'ω'),
+    (0x1D6C1, 'M', '∇'),
+    (0x1D6C2, 'M', 'α'),
+    (0x1D6C3, 'M', 'β'),
+    (0x1D6C4, 'M', 'γ'),
+    (0x1D6C5, 'M', 'δ'),
+    (0x1D6C6, 'M', 'ε'),
+    (0x1D6C7, 'M', 'ζ'),
+    (0x1D6C8, 'M', 'η'),
+    (0x1D6C9, 'M', 'θ'),
+    (0x1D6CA, 'M', 'ι'),
+    (0x1D6CB, 'M', 'κ'),
+    (0x1D6CC, 'M', 'λ'),
+    (0x1D6CD, 'M', 'μ'),
+    (0x1D6CE, 'M', 'ν'),
+    (0x1D6CF, 'M', 'ξ'),
+    (0x1D6D0, 'M', 'ο'),
+    (0x1D6D1, 'M', 'π'),
+    (0x1D6D2, 'M', 'ρ'),
+    (0x1D6D3, 'M', 'σ'),
+    (0x1D6D5, 'M', 'τ'),
+    (0x1D6D6, 'M', 'υ'),
+    (0x1D6D7, 'M', 'φ'),
+    (0x1D6D8, 'M', 'χ'),
+    (0x1D6D9, 'M', 'ψ'),
+    (0x1D6DA, 'M', 'ω'),
+    (0x1D6DB, 'M', '∂'),
+    (0x1D6DC, 'M', 'ε'),
+    (0x1D6DD, 'M', 'θ'),
+    (0x1D6DE, 'M', 'κ'),
+    (0x1D6DF, 'M', 'φ'),
+    (0x1D6E0, 'M', 'ρ'),
+    (0x1D6E1, 'M', 'π'),
+    (0x1D6E2, 'M', 'α'),
+    (0x1D6E3, 'M', 'β'),
+    (0x1D6E4, 'M', 'γ'),
+    (0x1D6E5, 'M', 'δ'),
+    (0x1D6E6, 'M', 'ε'),
+    (0x1D6E7, 'M', 'ζ'),
+    (0x1D6E8, 'M', 'η'),
+    ]
+
+def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D6E9, 'M', 'θ'),
+    (0x1D6EA, 'M', 'ι'),
+    (0x1D6EB, 'M', 'κ'),
+    (0x1D6EC, 'M', 'λ'),
+    (0x1D6ED, 'M', 'μ'),
+    (0x1D6EE, 'M', 'ν'),
+    (0x1D6EF, 'M', 'ξ'),
+    (0x1D6F0, 'M', 'ο'),
+    (0x1D6F1, 'M', 'π'),
+    (0x1D6F2, 'M', 'ρ'),
+    (0x1D6F3, 'M', 'θ'),
+    (0x1D6F4, 'M', 'σ'),
+    (0x1D6F5, 'M', 'τ'),
+    (0x1D6F6, 'M', 'υ'),
+    (0x1D6F7, 'M', 'φ'),
+    (0x1D6F8, 'M', 'χ'),
+    (0x1D6F9, 'M', 'ψ'),
+    (0x1D6FA, 'M', 'ω'),
+    (0x1D6FB, 'M', '∇'),
+    (0x1D6FC, 'M', 'α'),
+    (0x1D6FD, 'M', 'β'),
+    (0x1D6FE, 'M', 'γ'),
+    (0x1D6FF, 'M', 'δ'),
+    (0x1D700, 'M', 'ε'),
+    (0x1D701, 'M', 'ζ'),
+    (0x1D702, 'M', 'η'),
+    (0x1D703, 'M', 'θ'),
+    (0x1D704, 'M', 'ι'),
+    (0x1D705, 'M', 'κ'),
+    (0x1D706, 'M', 'λ'),
+    (0x1D707, 'M', 'μ'),
+    (0x1D708, 'M', 'ν'),
+    (0x1D709, 'M', 'ξ'),
+    (0x1D70A, 'M', 'ο'),
+    (0x1D70B, 'M', 'π'),
+    (0x1D70C, 'M', 'ρ'),
+    (0x1D70D, 'M', 'σ'),
+    (0x1D70F, 'M', 'τ'),
+    (0x1D710, 'M', 'υ'),
+    (0x1D711, 'M', 'φ'),
+    (0x1D712, 'M', 'χ'),
+    (0x1D713, 'M', 'ψ'),
+    (0x1D714, 'M', 'ω'),
+    (0x1D715, 'M', '∂'),
+    (0x1D716, 'M', 'ε'),
+    (0x1D717, 'M', 'θ'),
+    (0x1D718, 'M', 'κ'),
+    (0x1D719, 'M', 'φ'),
+    (0x1D71A, 'M', 'ρ'),
+    (0x1D71B, 'M', 'π'),
+    (0x1D71C, 'M', 'α'),
+    (0x1D71D, 'M', 'β'),
+    (0x1D71E, 'M', 'γ'),
+    (0x1D71F, 'M', 'δ'),
+    (0x1D720, 'M', 'ε'),
+    (0x1D721, 'M', 'ζ'),
+    (0x1D722, 'M', 'η'),
+    (0x1D723, 'M', 'θ'),
+    (0x1D724, 'M', 'ι'),
+    (0x1D725, 'M', 'κ'),
+    (0x1D726, 'M', 'λ'),
+    (0x1D727, 'M', 'μ'),
+    (0x1D728, 'M', 'ν'),
+    (0x1D729, 'M', 'ξ'),
+    (0x1D72A, 'M', 'ο'),
+    (0x1D72B, 'M', 'π'),
+    (0x1D72C, 'M', 'ρ'),
+    (0x1D72D, 'M', 'θ'),
+    (0x1D72E, 'M', 'σ'),
+    (0x1D72F, 'M', 'τ'),
+    (0x1D730, 'M', 'υ'),
+    (0x1D731, 'M', 'φ'),
+    (0x1D732, 'M', 'χ'),
+    (0x1D733, 'M', 'ψ'),
+    (0x1D734, 'M', 'ω'),
+    (0x1D735, 'M', '∇'),
+    (0x1D736, 'M', 'α'),
+    (0x1D737, 'M', 'β'),
+    (0x1D738, 'M', 'γ'),
+    (0x1D739, 'M', 'δ'),
+    (0x1D73A, 'M', 'ε'),
+    (0x1D73B, 'M', 'ζ'),
+    (0x1D73C, 'M', 'η'),
+    (0x1D73D, 'M', 'θ'),
+    (0x1D73E, 'M', 'ι'),
+    (0x1D73F, 'M', 'κ'),
+    (0x1D740, 'M', 'λ'),
+    (0x1D741, 'M', 'μ'),
+    (0x1D742, 'M', 'ν'),
+    (0x1D743, 'M', 'ξ'),
+    (0x1D744, 'M', 'ο'),
+    (0x1D745, 'M', 'π'),
+    (0x1D746, 'M', 'ρ'),
+    (0x1D747, 'M', 'σ'),
+    (0x1D749, 'M', 'τ'),
+    (0x1D74A, 'M', 'υ'),
+    (0x1D74B, 'M', 'φ'),
+    (0x1D74C, 'M', 'χ'),
+    (0x1D74D, 'M', 'ψ'),
+    (0x1D74E, 'M', 'ω'),
+    ]
+
+def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D74F, 'M', '∂'),
+    (0x1D750, 'M', 'ε'),
+    (0x1D751, 'M', 'θ'),
+    (0x1D752, 'M', 'κ'),
+    (0x1D753, 'M', 'φ'),
+    (0x1D754, 'M', 'ρ'),
+    (0x1D755, 'M', 'π'),
+    (0x1D756, 'M', 'α'),
+    (0x1D757, 'M', 'β'),
+    (0x1D758, 'M', 'γ'),
+    (0x1D759, 'M', 'δ'),
+    (0x1D75A, 'M', 'ε'),
+    (0x1D75B, 'M', 'ζ'),
+    (0x1D75C, 'M', 'η'),
+    (0x1D75D, 'M', 'θ'),
+    (0x1D75E, 'M', 'ι'),
+    (0x1D75F, 'M', 'κ'),
+    (0x1D760, 'M', 'λ'),
+    (0x1D761, 'M', 'μ'),
+    (0x1D762, 'M', 'ν'),
+    (0x1D763, 'M', 'ξ'),
+    (0x1D764, 'M', 'ο'),
+    (0x1D765, 'M', 'π'),
+    (0x1D766, 'M', 'ρ'),
+    (0x1D767, 'M', 'θ'),
+    (0x1D768, 'M', 'σ'),
+    (0x1D769, 'M', 'τ'),
+    (0x1D76A, 'M', 'υ'),
+    (0x1D76B, 'M', 'φ'),
+    (0x1D76C, 'M', 'χ'),
+    (0x1D76D, 'M', 'ψ'),
+    (0x1D76E, 'M', 'ω'),
+    (0x1D76F, 'M', '∇'),
+    (0x1D770, 'M', 'α'),
+    (0x1D771, 'M', 'β'),
+    (0x1D772, 'M', 'γ'),
+    (0x1D773, 'M', 'δ'),
+    (0x1D774, 'M', 'ε'),
+    (0x1D775, 'M', 'ζ'),
+    (0x1D776, 'M', 'η'),
+    (0x1D777, 'M', 'θ'),
+    (0x1D778, 'M', 'ι'),
+    (0x1D779, 'M', 'κ'),
+    (0x1D77A, 'M', 'λ'),
+    (0x1D77B, 'M', 'μ'),
+    (0x1D77C, 'M', 'ν'),
+    (0x1D77D, 'M', 'ξ'),
+    (0x1D77E, 'M', 'ο'),
+    (0x1D77F, 'M', 'π'),
+    (0x1D780, 'M', 'ρ'),
+    (0x1D781, 'M', 'σ'),
+    (0x1D783, 'M', 'τ'),
+    (0x1D784, 'M', 'υ'),
+    (0x1D785, 'M', 'φ'),
+    (0x1D786, 'M', 'χ'),
+    (0x1D787, 'M', 'ψ'),
+    (0x1D788, 'M', 'ω'),
+    (0x1D789, 'M', '∂'),
+    (0x1D78A, 'M', 'ε'),
+    (0x1D78B, 'M', 'θ'),
+    (0x1D78C, 'M', 'κ'),
+    (0x1D78D, 'M', 'φ'),
+    (0x1D78E, 'M', 'ρ'),
+    (0x1D78F, 'M', 'π'),
+    (0x1D790, 'M', 'α'),
+    (0x1D791, 'M', 'β'),
+    (0x1D792, 'M', 'γ'),
+    (0x1D793, 'M', 'δ'),
+    (0x1D794, 'M', 'ε'),
+    (0x1D795, 'M', 'ζ'),
+    (0x1D796, 'M', 'η'),
+    (0x1D797, 'M', 'θ'),
+    (0x1D798, 'M', 'ι'),
+    (0x1D799, 'M', 'κ'),
+    (0x1D79A, 'M', 'λ'),
+    (0x1D79B, 'M', 'μ'),
+    (0x1D79C, 'M', 'ν'),
+    (0x1D79D, 'M', 'ξ'),
+    (0x1D79E, 'M', 'ο'),
+    (0x1D79F, 'M', 'π'),
+    (0x1D7A0, 'M', 'ρ'),
+    (0x1D7A1, 'M', 'θ'),
+    (0x1D7A2, 'M', 'σ'),
+    (0x1D7A3, 'M', 'τ'),
+    (0x1D7A4, 'M', 'υ'),
+    (0x1D7A5, 'M', 'φ'),
+    (0x1D7A6, 'M', 'χ'),
+    (0x1D7A7, 'M', 'ψ'),
+    (0x1D7A8, 'M', 'ω'),
+    (0x1D7A9, 'M', '∇'),
+    (0x1D7AA, 'M', 'α'),
+    (0x1D7AB, 'M', 'β'),
+    (0x1D7AC, 'M', 'γ'),
+    (0x1D7AD, 'M', 'δ'),
+    (0x1D7AE, 'M', 'ε'),
+    (0x1D7AF, 'M', 'ζ'),
+    (0x1D7B0, 'M', 'η'),
+    (0x1D7B1, 'M', 'θ'),
+    (0x1D7B2, 'M', 'ι'),
+    (0x1D7B3, 'M', 'κ'),
+    ]
+
+def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D7B4, 'M', 'λ'),
+    (0x1D7B5, 'M', 'μ'),
+    (0x1D7B6, 'M', 'ν'),
+    (0x1D7B7, 'M', 'ξ'),
+    (0x1D7B8, 'M', 'ο'),
+    (0x1D7B9, 'M', 'π'),
+    (0x1D7BA, 'M', 'ρ'),
+    (0x1D7BB, 'M', 'σ'),
+    (0x1D7BD, 'M', 'τ'),
+    (0x1D7BE, 'M', 'υ'),
+    (0x1D7BF, 'M', 'φ'),
+    (0x1D7C0, 'M', 'χ'),
+    (0x1D7C1, 'M', 'ψ'),
+    (0x1D7C2, 'M', 'ω'),
+    (0x1D7C3, 'M', '∂'),
+    (0x1D7C4, 'M', 'ε'),
+    (0x1D7C5, 'M', 'θ'),
+    (0x1D7C6, 'M', 'κ'),
+    (0x1D7C7, 'M', 'φ'),
+    (0x1D7C8, 'M', 'ρ'),
+    (0x1D7C9, 'M', 'π'),
+    (0x1D7CA, 'M', 'ϝ'),
+    (0x1D7CC, 'X'),
+    (0x1D7CE, 'M', '0'),
+    (0x1D7CF, 'M', '1'),
+    (0x1D7D0, 'M', '2'),
+    (0x1D7D1, 'M', '3'),
+    (0x1D7D2, 'M', '4'),
+    (0x1D7D3, 'M', '5'),
+    (0x1D7D4, 'M', '6'),
+    (0x1D7D5, 'M', '7'),
+    (0x1D7D6, 'M', '8'),
+    (0x1D7D7, 'M', '9'),
+    (0x1D7D8, 'M', '0'),
+    (0x1D7D9, 'M', '1'),
+    (0x1D7DA, 'M', '2'),
+    (0x1D7DB, 'M', '3'),
+    (0x1D7DC, 'M', '4'),
+    (0x1D7DD, 'M', '5'),
+    (0x1D7DE, 'M', '6'),
+    (0x1D7DF, 'M', '7'),
+    (0x1D7E0, 'M', '8'),
+    (0x1D7E1, 'M', '9'),
+    (0x1D7E2, 'M', '0'),
+    (0x1D7E3, 'M', '1'),
+    (0x1D7E4, 'M', '2'),
+    (0x1D7E5, 'M', '3'),
+    (0x1D7E6, 'M', '4'),
+    (0x1D7E7, 'M', '5'),
+    (0x1D7E8, 'M', '6'),
+    (0x1D7E9, 'M', '7'),
+    (0x1D7EA, 'M', '8'),
+    (0x1D7EB, 'M', '9'),
+    (0x1D7EC, 'M', '0'),
+    (0x1D7ED, 'M', '1'),
+    (0x1D7EE, 'M', '2'),
+    (0x1D7EF, 'M', '3'),
+    (0x1D7F0, 'M', '4'),
+    (0x1D7F1, 'M', '5'),
+    (0x1D7F2, 'M', '6'),
+    (0x1D7F3, 'M', '7'),
+    (0x1D7F4, 'M', '8'),
+    (0x1D7F5, 'M', '9'),
+    (0x1D7F6, 'M', '0'),
+    (0x1D7F7, 'M', '1'),
+    (0x1D7F8, 'M', '2'),
+    (0x1D7F9, 'M', '3'),
+    (0x1D7FA, 'M', '4'),
+    (0x1D7FB, 'M', '5'),
+    (0x1D7FC, 'M', '6'),
+    (0x1D7FD, 'M', '7'),
+    (0x1D7FE, 'M', '8'),
+    (0x1D7FF, 'M', '9'),
+    (0x1D800, 'V'),
+    (0x1DA8C, 'X'),
+    (0x1DA9B, 'V'),
+    (0x1DAA0, 'X'),
+    (0x1DAA1, 'V'),
+    (0x1DAB0, 'X'),
+    (0x1DF00, 'V'),
+    (0x1DF1F, 'X'),
+    (0x1DF25, 'V'),
+    (0x1DF2B, 'X'),
+    (0x1E000, 'V'),
+    (0x1E007, 'X'),
+    (0x1E008, 'V'),
+    (0x1E019, 'X'),
+    (0x1E01B, 'V'),
+    (0x1E022, 'X'),
+    (0x1E023, 'V'),
+    (0x1E025, 'X'),
+    (0x1E026, 'V'),
+    (0x1E02B, 'X'),
+    (0x1E030, 'M', 'а'),
+    (0x1E031, 'M', 'б'),
+    (0x1E032, 'M', 'в'),
+    (0x1E033, 'M', 'г'),
+    (0x1E034, 'M', 'д'),
+    (0x1E035, 'M', 'е'),
+    (0x1E036, 'M', 'ж'),
+    ]
+
+def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E037, 'M', 'з'),
+    (0x1E038, 'M', 'и'),
+    (0x1E039, 'M', 'к'),
+    (0x1E03A, 'M', 'л'),
+    (0x1E03B, 'M', 'м'),
+    (0x1E03C, 'M', 'о'),
+    (0x1E03D, 'M', 'п'),
+    (0x1E03E, 'M', 'р'),
+    (0x1E03F, 'M', 'с'),
+    (0x1E040, 'M', 'т'),
+    (0x1E041, 'M', 'у'),
+    (0x1E042, 'M', 'ф'),
+    (0x1E043, 'M', 'х'),
+    (0x1E044, 'M', 'ц'),
+    (0x1E045, 'M', 'ч'),
+    (0x1E046, 'M', 'ш'),
+    (0x1E047, 'M', 'ы'),
+    (0x1E048, 'M', 'э'),
+    (0x1E049, 'M', 'ю'),
+    (0x1E04A, 'M', 'ꚉ'),
+    (0x1E04B, 'M', 'ә'),
+    (0x1E04C, 'M', 'і'),
+    (0x1E04D, 'M', 'ј'),
+    (0x1E04E, 'M', 'ө'),
+    (0x1E04F, 'M', 'ү'),
+    (0x1E050, 'M', 'ӏ'),
+    (0x1E051, 'M', 'а'),
+    (0x1E052, 'M', 'б'),
+    (0x1E053, 'M', 'в'),
+    (0x1E054, 'M', 'г'),
+    (0x1E055, 'M', 'д'),
+    (0x1E056, 'M', 'е'),
+    (0x1E057, 'M', 'ж'),
+    (0x1E058, 'M', 'з'),
+    (0x1E059, 'M', 'и'),
+    (0x1E05A, 'M', 'к'),
+    (0x1E05B, 'M', 'л'),
+    (0x1E05C, 'M', 'о'),
+    (0x1E05D, 'M', 'п'),
+    (0x1E05E, 'M', 'с'),
+    (0x1E05F, 'M', 'у'),
+    (0x1E060, 'M', 'ф'),
+    (0x1E061, 'M', 'х'),
+    (0x1E062, 'M', 'ц'),
+    (0x1E063, 'M', 'ч'),
+    (0x1E064, 'M', 'ш'),
+    (0x1E065, 'M', 'ъ'),
+    (0x1E066, 'M', 'ы'),
+    (0x1E067, 'M', 'ґ'),
+    (0x1E068, 'M', 'і'),
+    (0x1E069, 'M', 'ѕ'),
+    (0x1E06A, 'M', 'џ'),
+    (0x1E06B, 'M', 'ҫ'),
+    (0x1E06C, 'M', 'ꙑ'),
+    (0x1E06D, 'M', 'ұ'),
+    (0x1E06E, 'X'),
+    (0x1E08F, 'V'),
+    (0x1E090, 'X'),
+    (0x1E100, 'V'),
+    (0x1E12D, 'X'),
+    (0x1E130, 'V'),
+    (0x1E13E, 'X'),
+    (0x1E140, 'V'),
+    (0x1E14A, 'X'),
+    (0x1E14E, 'V'),
+    (0x1E150, 'X'),
+    (0x1E290, 'V'),
+    (0x1E2AF, 'X'),
+    (0x1E2C0, 'V'),
+    (0x1E2FA, 'X'),
+    (0x1E2FF, 'V'),
+    (0x1E300, 'X'),
+    (0x1E4D0, 'V'),
+    (0x1E4FA, 'X'),
+    (0x1E7E0, 'V'),
+    (0x1E7E7, 'X'),
+    (0x1E7E8, 'V'),
+    (0x1E7EC, 'X'),
+    (0x1E7ED, 'V'),
+    (0x1E7EF, 'X'),
+    (0x1E7F0, 'V'),
+    (0x1E7FF, 'X'),
+    (0x1E800, 'V'),
+    (0x1E8C5, 'X'),
+    (0x1E8C7, 'V'),
+    (0x1E8D7, 'X'),
+    (0x1E900, 'M', '𞤢'),
+    (0x1E901, 'M', '𞤣'),
+    (0x1E902, 'M', '𞤤'),
+    (0x1E903, 'M', '𞤥'),
+    (0x1E904, 'M', '𞤦'),
+    (0x1E905, 'M', '𞤧'),
+    (0x1E906, 'M', '𞤨'),
+    (0x1E907, 'M', '𞤩'),
+    (0x1E908, 'M', '𞤪'),
+    (0x1E909, 'M', '𞤫'),
+    (0x1E90A, 'M', '𞤬'),
+    (0x1E90B, 'M', '𞤭'),
+    (0x1E90C, 'M', '𞤮'),
+    (0x1E90D, 'M', '𞤯'),
+    ]
+
+def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E90E, 'M', '𞤰'),
+    (0x1E90F, 'M', '𞤱'),
+    (0x1E910, 'M', '𞤲'),
+    (0x1E911, 'M', '𞤳'),
+    (0x1E912, 'M', '𞤴'),
+    (0x1E913, 'M', '𞤵'),
+    (0x1E914, 'M', '𞤶'),
+    (0x1E915, 'M', '𞤷'),
+    (0x1E916, 'M', '𞤸'),
+    (0x1E917, 'M', '𞤹'),
+    (0x1E918, 'M', '𞤺'),
+    (0x1E919, 'M', '𞤻'),
+    (0x1E91A, 'M', '𞤼'),
+    (0x1E91B, 'M', '𞤽'),
+    (0x1E91C, 'M', '𞤾'),
+    (0x1E91D, 'M', '𞤿'),
+    (0x1E91E, 'M', '𞥀'),
+    (0x1E91F, 'M', '𞥁'),
+    (0x1E920, 'M', '𞥂'),
+    (0x1E921, 'M', '𞥃'),
+    (0x1E922, 'V'),
+    (0x1E94C, 'X'),
+    (0x1E950, 'V'),
+    (0x1E95A, 'X'),
+    (0x1E95E, 'V'),
+    (0x1E960, 'X'),
+    (0x1EC71, 'V'),
+    (0x1ECB5, 'X'),
+    (0x1ED01, 'V'),
+    (0x1ED3E, 'X'),
+    (0x1EE00, 'M', 'ا'),
+    (0x1EE01, 'M', 'ب'),
+    (0x1EE02, 'M', 'ج'),
+    (0x1EE03, 'M', 'د'),
+    (0x1EE04, 'X'),
+    (0x1EE05, 'M', 'و'),
+    (0x1EE06, 'M', 'ز'),
+    (0x1EE07, 'M', 'ح'),
+    (0x1EE08, 'M', 'ط'),
+    (0x1EE09, 'M', 'ي'),
+    (0x1EE0A, 'M', 'ك'),
+    (0x1EE0B, 'M', 'ل'),
+    (0x1EE0C, 'M', 'م'),
+    (0x1EE0D, 'M', 'ن'),
+    (0x1EE0E, 'M', 'س'),
+    (0x1EE0F, 'M', 'ع'),
+    (0x1EE10, 'M', 'ف'),
+    (0x1EE11, 'M', 'ص'),
+    (0x1EE12, 'M', 'ق'),
+    (0x1EE13, 'M', 'ر'),
+    (0x1EE14, 'M', 'ش'),
+    (0x1EE15, 'M', 'ت'),
+    (0x1EE16, 'M', 'ث'),
+    (0x1EE17, 'M', 'خ'),
+    (0x1EE18, 'M', 'ذ'),
+    (0x1EE19, 'M', 'ض'),
+    (0x1EE1A, 'M', 'ظ'),
+    (0x1EE1B, 'M', 'غ'),
+    (0x1EE1C, 'M', 'ٮ'),
+    (0x1EE1D, 'M', 'ں'),
+    (0x1EE1E, 'M', 'ڡ'),
+    (0x1EE1F, 'M', 'ٯ'),
+    (0x1EE20, 'X'),
+    (0x1EE21, 'M', 'ب'),
+    (0x1EE22, 'M', 'ج'),
+    (0x1EE23, 'X'),
+    (0x1EE24, 'M', 'ه'),
+    (0x1EE25, 'X'),
+    (0x1EE27, 'M', 'ح'),
+    (0x1EE28, 'X'),
+    (0x1EE29, 'M', 'ي'),
+    (0x1EE2A, 'M', 'ك'),
+    (0x1EE2B, 'M', 'ل'),
+    (0x1EE2C, 'M', 'م'),
+    (0x1EE2D, 'M', 'ن'),
+    (0x1EE2E, 'M', 'س'),
+    (0x1EE2F, 'M', 'ع'),
+    (0x1EE30, 'M', 'ف'),
+    (0x1EE31, 'M', 'ص'),
+    (0x1EE32, 'M', 'ق'),
+    (0x1EE33, 'X'),
+    (0x1EE34, 'M', 'ش'),
+    (0x1EE35, 'M', 'ت'),
+    (0x1EE36, 'M', 'ث'),
+    (0x1EE37, 'M', 'خ'),
+    (0x1EE38, 'X'),
+    (0x1EE39, 'M', 'ض'),
+    (0x1EE3A, 'X'),
+    (0x1EE3B, 'M', 'غ'),
+    (0x1EE3C, 'X'),
+    (0x1EE42, 'M', 'ج'),
+    (0x1EE43, 'X'),
+    (0x1EE47, 'M', 'ح'),
+    (0x1EE48, 'X'),
+    (0x1EE49, 'M', 'ي'),
+    (0x1EE4A, 'X'),
+    (0x1EE4B, 'M', 'ل'),
+    (0x1EE4C, 'X'),
+    (0x1EE4D, 'M', 'ن'),
+    (0x1EE4E, 'M', 'س'),
+    ]
+
+def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EE4F, 'M', 'ع'),
+    (0x1EE50, 'X'),
+    (0x1EE51, 'M', 'ص'),
+    (0x1EE52, 'M', 'ق'),
+    (0x1EE53, 'X'),
+    (0x1EE54, 'M', 'ش'),
+    (0x1EE55, 'X'),
+    (0x1EE57, 'M', 'خ'),
+    (0x1EE58, 'X'),
+    (0x1EE59, 'M', 'ض'),
+    (0x1EE5A, 'X'),
+    (0x1EE5B, 'M', 'غ'),
+    (0x1EE5C, 'X'),
+    (0x1EE5D, 'M', 'ں'),
+    (0x1EE5E, 'X'),
+    (0x1EE5F, 'M', 'ٯ'),
+    (0x1EE60, 'X'),
+    (0x1EE61, 'M', 'ب'),
+    (0x1EE62, 'M', 'ج'),
+    (0x1EE63, 'X'),
+    (0x1EE64, 'M', 'ه'),
+    (0x1EE65, 'X'),
+    (0x1EE67, 'M', 'ح'),
+    (0x1EE68, 'M', 'ط'),
+    (0x1EE69, 'M', 'ي'),
+    (0x1EE6A, 'M', 'ك'),
+    (0x1EE6B, 'X'),
+    (0x1EE6C, 'M', 'م'),
+    (0x1EE6D, 'M', 'ن'),
+    (0x1EE6E, 'M', 'س'),
+    (0x1EE6F, 'M', 'ع'),
+    (0x1EE70, 'M', 'ف'),
+    (0x1EE71, 'M', 'ص'),
+    (0x1EE72, 'M', 'ق'),
+    (0x1EE73, 'X'),
+    (0x1EE74, 'M', 'ش'),
+    (0x1EE75, 'M', 'ت'),
+    (0x1EE76, 'M', 'ث'),
+    (0x1EE77, 'M', 'خ'),
+    (0x1EE78, 'X'),
+    (0x1EE79, 'M', 'ض'),
+    (0x1EE7A, 'M', 'ظ'),
+    (0x1EE7B, 'M', 'غ'),
+    (0x1EE7C, 'M', 'ٮ'),
+    (0x1EE7D, 'X'),
+    (0x1EE7E, 'M', 'ڡ'),
+    (0x1EE7F, 'X'),
+    (0x1EE80, 'M', 'ا'),
+    (0x1EE81, 'M', 'ب'),
+    (0x1EE82, 'M', 'ج'),
+    (0x1EE83, 'M', 'د'),
+    (0x1EE84, 'M', 'ه'),
+    (0x1EE85, 'M', 'و'),
+    (0x1EE86, 'M', 'ز'),
+    (0x1EE87, 'M', 'ح'),
+    (0x1EE88, 'M', 'ط'),
+    (0x1EE89, 'M', 'ي'),
+    (0x1EE8A, 'X'),
+    (0x1EE8B, 'M', 'ل'),
+    (0x1EE8C, 'M', 'م'),
+    (0x1EE8D, 'M', 'ن'),
+    (0x1EE8E, 'M', 'س'),
+    (0x1EE8F, 'M', 'ع'),
+    (0x1EE90, 'M', 'ف'),
+    (0x1EE91, 'M', 'ص'),
+    (0x1EE92, 'M', 'ق'),
+    (0x1EE93, 'M', 'ر'),
+    (0x1EE94, 'M', 'ش'),
+    (0x1EE95, 'M', 'ت'),
+    (0x1EE96, 'M', 'ث'),
+    (0x1EE97, 'M', 'خ'),
+    (0x1EE98, 'M', 'ذ'),
+    (0x1EE99, 'M', 'ض'),
+    (0x1EE9A, 'M', 'ظ'),
+    (0x1EE9B, 'M', 'غ'),
+    (0x1EE9C, 'X'),
+    (0x1EEA1, 'M', 'ب'),
+    (0x1EEA2, 'M', 'ج'),
+    (0x1EEA3, 'M', 'د'),
+    (0x1EEA4, 'X'),
+    (0x1EEA5, 'M', 'و'),
+    (0x1EEA6, 'M', 'ز'),
+    (0x1EEA7, 'M', 'ح'),
+    (0x1EEA8, 'M', 'ط'),
+    (0x1EEA9, 'M', 'ي'),
+    (0x1EEAA, 'X'),
+    (0x1EEAB, 'M', 'ل'),
+    (0x1EEAC, 'M', 'م'),
+    (0x1EEAD, 'M', 'ن'),
+    (0x1EEAE, 'M', 'س'),
+    (0x1EEAF, 'M', 'ع'),
+    (0x1EEB0, 'M', 'ف'),
+    (0x1EEB1, 'M', 'ص'),
+    (0x1EEB2, 'M', 'ق'),
+    (0x1EEB3, 'M', 'ر'),
+    (0x1EEB4, 'M', 'ش'),
+    (0x1EEB5, 'M', 'ت'),
+    (0x1EEB6, 'M', 'ث'),
+    (0x1EEB7, 'M', 'خ'),
+    (0x1EEB8, 'M', 'ذ'),
+    ]
+
+def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EEB9, 'M', 'ض'),
+    (0x1EEBA, 'M', 'ظ'),
+    (0x1EEBB, 'M', 'غ'),
+    (0x1EEBC, 'X'),
+    (0x1EEF0, 'V'),
+    (0x1EEF2, 'X'),
+    (0x1F000, 'V'),
+    (0x1F02C, 'X'),
+    (0x1F030, 'V'),
+    (0x1F094, 'X'),
+    (0x1F0A0, 'V'),
+    (0x1F0AF, 'X'),
+    (0x1F0B1, 'V'),
+    (0x1F0C0, 'X'),
+    (0x1F0C1, 'V'),
+    (0x1F0D0, 'X'),
+    (0x1F0D1, 'V'),
+    (0x1F0F6, 'X'),
+    (0x1F101, '3', '0,'),
+    (0x1F102, '3', '1,'),
+    (0x1F103, '3', '2,'),
+    (0x1F104, '3', '3,'),
+    (0x1F105, '3', '4,'),
+    (0x1F106, '3', '5,'),
+    (0x1F107, '3', '6,'),
+    (0x1F108, '3', '7,'),
+    (0x1F109, '3', '8,'),
+    (0x1F10A, '3', '9,'),
+    (0x1F10B, 'V'),
+    (0x1F110, '3', '(a)'),
+    (0x1F111, '3', '(b)'),
+    (0x1F112, '3', '(c)'),
+    (0x1F113, '3', '(d)'),
+    (0x1F114, '3', '(e)'),
+    (0x1F115, '3', '(f)'),
+    (0x1F116, '3', '(g)'),
+    (0x1F117, '3', '(h)'),
+    (0x1F118, '3', '(i)'),
+    (0x1F119, '3', '(j)'),
+    (0x1F11A, '3', '(k)'),
+    (0x1F11B, '3', '(l)'),
+    (0x1F11C, '3', '(m)'),
+    (0x1F11D, '3', '(n)'),
+    (0x1F11E, '3', '(o)'),
+    (0x1F11F, '3', '(p)'),
+    (0x1F120, '3', '(q)'),
+    (0x1F121, '3', '(r)'),
+    (0x1F122, '3', '(s)'),
+    (0x1F123, '3', '(t)'),
+    (0x1F124, '3', '(u)'),
+    (0x1F125, '3', '(v)'),
+    (0x1F126, '3', '(w)'),
+    (0x1F127, '3', '(x)'),
+    (0x1F128, '3', '(y)'),
+    (0x1F129, '3', '(z)'),
+    (0x1F12A, 'M', '〔s〕'),
+    (0x1F12B, 'M', 'c'),
+    (0x1F12C, 'M', 'r'),
+    (0x1F12D, 'M', 'cd'),
+    (0x1F12E, 'M', 'wz'),
+    (0x1F12F, 'V'),
+    (0x1F130, 'M', 'a'),
+    (0x1F131, 'M', 'b'),
+    (0x1F132, 'M', 'c'),
+    (0x1F133, 'M', 'd'),
+    (0x1F134, 'M', 'e'),
+    (0x1F135, 'M', 'f'),
+    (0x1F136, 'M', 'g'),
+    (0x1F137, 'M', 'h'),
+    (0x1F138, 'M', 'i'),
+    (0x1F139, 'M', 'j'),
+    (0x1F13A, 'M', 'k'),
+    (0x1F13B, 'M', 'l'),
+    (0x1F13C, 'M', 'm'),
+    (0x1F13D, 'M', 'n'),
+    (0x1F13E, 'M', 'o'),
+    (0x1F13F, 'M', 'p'),
+    (0x1F140, 'M', 'q'),
+    (0x1F141, 'M', 'r'),
+    (0x1F142, 'M', 's'),
+    (0x1F143, 'M', 't'),
+    (0x1F144, 'M', 'u'),
+    (0x1F145, 'M', 'v'),
+    (0x1F146, 'M', 'w'),
+    (0x1F147, 'M', 'x'),
+    (0x1F148, 'M', 'y'),
+    (0x1F149, 'M', 'z'),
+    (0x1F14A, 'M', 'hv'),
+    (0x1F14B, 'M', 'mv'),
+    (0x1F14C, 'M', 'sd'),
+    (0x1F14D, 'M', 'ss'),
+    (0x1F14E, 'M', 'ppv'),
+    (0x1F14F, 'M', 'wc'),
+    (0x1F150, 'V'),
+    (0x1F16A, 'M', 'mc'),
+    (0x1F16B, 'M', 'md'),
+    (0x1F16C, 'M', 'mr'),
+    (0x1F16D, 'V'),
+    (0x1F190, 'M', 'dj'),
+    (0x1F191, 'V'),
+    ]
+
+def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1F1AE, 'X'),
+    (0x1F1E6, 'V'),
+    (0x1F200, 'M', 'ほか'),
+    (0x1F201, 'M', 'ココ'),
+    (0x1F202, 'M', 'サ'),
+    (0x1F203, 'X'),
+    (0x1F210, 'M', '手'),
+    (0x1F211, 'M', '字'),
+    (0x1F212, 'M', '双'),
+    (0x1F213, 'M', 'デ'),
+    (0x1F214, 'M', '二'),
+    (0x1F215, 'M', '多'),
+    (0x1F216, 'M', '解'),
+    (0x1F217, 'M', '天'),
+    (0x1F218, 'M', '交'),
+    (0x1F219, 'M', '映'),
+    (0x1F21A, 'M', '無'),
+    (0x1F21B, 'M', '料'),
+    (0x1F21C, 'M', '前'),
+    (0x1F21D, 'M', '後'),
+    (0x1F21E, 'M', '再'),
+    (0x1F21F, 'M', '新'),
+    (0x1F220, 'M', '初'),
+    (0x1F221, 'M', '終'),
+    (0x1F222, 'M', '生'),
+    (0x1F223, 'M', '販'),
+    (0x1F224, 'M', '声'),
+    (0x1F225, 'M', '吹'),
+    (0x1F226, 'M', '演'),
+    (0x1F227, 'M', '投'),
+    (0x1F228, 'M', '捕'),
+    (0x1F229, 'M', '一'),
+    (0x1F22A, 'M', '三'),
+    (0x1F22B, 'M', '遊'),
+    (0x1F22C, 'M', '左'),
+    (0x1F22D, 'M', '中'),
+    (0x1F22E, 'M', '右'),
+    (0x1F22F, 'M', '指'),
+    (0x1F230, 'M', '走'),
+    (0x1F231, 'M', '打'),
+    (0x1F232, 'M', '禁'),
+    (0x1F233, 'M', '空'),
+    (0x1F234, 'M', '合'),
+    (0x1F235, 'M', '満'),
+    (0x1F236, 'M', '有'),
+    (0x1F237, 'M', '月'),
+    (0x1F238, 'M', '申'),
+    (0x1F239, 'M', '割'),
+    (0x1F23A, 'M', '営'),
+    (0x1F23B, 'M', '配'),
+    (0x1F23C, 'X'),
+    (0x1F240, 'M', '〔本〕'),
+    (0x1F241, 'M', '〔三〕'),
+    (0x1F242, 'M', '〔二〕'),
+    (0x1F243, 'M', '〔安〕'),
+    (0x1F244, 'M', '〔点〕'),
+    (0x1F245, 'M', '〔打〕'),
+    (0x1F246, 'M', '〔盗〕'),
+    (0x1F247, 'M', '〔勝〕'),
+    (0x1F248, 'M', '〔敗〕'),
+    (0x1F249, 'X'),
+    (0x1F250, 'M', '得'),
+    (0x1F251, 'M', '可'),
+    (0x1F252, 'X'),
+    (0x1F260, 'V'),
+    (0x1F266, 'X'),
+    (0x1F300, 'V'),
+    (0x1F6D8, 'X'),
+    (0x1F6DC, 'V'),
+    (0x1F6ED, 'X'),
+    (0x1F6F0, 'V'),
+    (0x1F6FD, 'X'),
+    (0x1F700, 'V'),
+    (0x1F777, 'X'),
+    (0x1F77B, 'V'),
+    (0x1F7DA, 'X'),
+    (0x1F7E0, 'V'),
+    (0x1F7EC, 'X'),
+    (0x1F7F0, 'V'),
+    (0x1F7F1, 'X'),
+    (0x1F800, 'V'),
+    (0x1F80C, 'X'),
+    (0x1F810, 'V'),
+    (0x1F848, 'X'),
+    (0x1F850, 'V'),
+    (0x1F85A, 'X'),
+    (0x1F860, 'V'),
+    (0x1F888, 'X'),
+    (0x1F890, 'V'),
+    (0x1F8AE, 'X'),
+    (0x1F8B0, 'V'),
+    (0x1F8B2, 'X'),
+    (0x1F900, 'V'),
+    (0x1FA54, 'X'),
+    (0x1FA60, 'V'),
+    (0x1FA6E, 'X'),
+    (0x1FA70, 'V'),
+    (0x1FA7D, 'X'),
+    (0x1FA80, 'V'),
+    (0x1FA89, 'X'),
+    ]
+
+def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1FA90, 'V'),
+    (0x1FABE, 'X'),
+    (0x1FABF, 'V'),
+    (0x1FAC6, 'X'),
+    (0x1FACE, 'V'),
+    (0x1FADC, 'X'),
+    (0x1FAE0, 'V'),
+    (0x1FAE9, 'X'),
+    (0x1FAF0, 'V'),
+    (0x1FAF9, 'X'),
+    (0x1FB00, 'V'),
+    (0x1FB93, 'X'),
+    (0x1FB94, 'V'),
+    (0x1FBCB, 'X'),
+    (0x1FBF0, 'M', '0'),
+    (0x1FBF1, 'M', '1'),
+    (0x1FBF2, 'M', '2'),
+    (0x1FBF3, 'M', '3'),
+    (0x1FBF4, 'M', '4'),
+    (0x1FBF5, 'M', '5'),
+    (0x1FBF6, 'M', '6'),
+    (0x1FBF7, 'M', '7'),
+    (0x1FBF8, 'M', '8'),
+    (0x1FBF9, 'M', '9'),
+    (0x1FBFA, 'X'),
+    (0x20000, 'V'),
+    (0x2A6E0, 'X'),
+    (0x2A700, 'V'),
+    (0x2B73A, 'X'),
+    (0x2B740, 'V'),
+    (0x2B81E, 'X'),
+    (0x2B820, 'V'),
+    (0x2CEA2, 'X'),
+    (0x2CEB0, 'V'),
+    (0x2EBE1, 'X'),
+    (0x2EBF0, 'V'),
+    (0x2EE5E, 'X'),
+    (0x2F800, 'M', '丽'),
+    (0x2F801, 'M', '丸'),
+    (0x2F802, 'M', '乁'),
+    (0x2F803, 'M', '𠄢'),
+    (0x2F804, 'M', '你'),
+    (0x2F805, 'M', '侮'),
+    (0x2F806, 'M', '侻'),
+    (0x2F807, 'M', '倂'),
+    (0x2F808, 'M', '偺'),
+    (0x2F809, 'M', '備'),
+    (0x2F80A, 'M', '僧'),
+    (0x2F80B, 'M', '像'),
+    (0x2F80C, 'M', '㒞'),
+    (0x2F80D, 'M', '𠘺'),
+    (0x2F80E, 'M', '免'),
+    (0x2F80F, 'M', '兔'),
+    (0x2F810, 'M', '兤'),
+    (0x2F811, 'M', '具'),
+    (0x2F812, 'M', '𠔜'),
+    (0x2F813, 'M', '㒹'),
+    (0x2F814, 'M', '內'),
+    (0x2F815, 'M', '再'),
+    (0x2F816, 'M', '𠕋'),
+    (0x2F817, 'M', '冗'),
+    (0x2F818, 'M', '冤'),
+    (0x2F819, 'M', '仌'),
+    (0x2F81A, 'M', '冬'),
+    (0x2F81B, 'M', '况'),
+    (0x2F81C, 'M', '𩇟'),
+    (0x2F81D, 'M', '凵'),
+    (0x2F81E, 'M', '刃'),
+    (0x2F81F, 'M', '㓟'),
+    (0x2F820, 'M', '刻'),
+    (0x2F821, 'M', '剆'),
+    (0x2F822, 'M', '割'),
+    (0x2F823, 'M', '剷'),
+    (0x2F824, 'M', '㔕'),
+    (0x2F825, 'M', '勇'),
+    (0x2F826, 'M', '勉'),
+    (0x2F827, 'M', '勤'),
+    (0x2F828, 'M', '勺'),
+    (0x2F829, 'M', '包'),
+    (0x2F82A, 'M', '匆'),
+    (0x2F82B, 'M', '北'),
+    (0x2F82C, 'M', '卉'),
+    (0x2F82D, 'M', '卑'),
+    (0x2F82E, 'M', '博'),
+    (0x2F82F, 'M', '即'),
+    (0x2F830, 'M', '卽'),
+    (0x2F831, 'M', '卿'),
+    (0x2F834, 'M', '𠨬'),
+    (0x2F835, 'M', '灰'),
+    (0x2F836, 'M', '及'),
+    (0x2F837, 'M', '叟'),
+    (0x2F838, 'M', '𠭣'),
+    (0x2F839, 'M', '叫'),
+    (0x2F83A, 'M', '叱'),
+    (0x2F83B, 'M', '吆'),
+    (0x2F83C, 'M', '咞'),
+    (0x2F83D, 'M', '吸'),
+    (0x2F83E, 'M', '呈'),
+    (0x2F83F, 'M', '周'),
+    (0x2F840, 'M', '咢'),
+    ]
+
+def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F841, 'M', '哶'),
+    (0x2F842, 'M', '唐'),
+    (0x2F843, 'M', '啓'),
+    (0x2F844, 'M', '啣'),
+    (0x2F845, 'M', '善'),
+    (0x2F847, 'M', '喙'),
+    (0x2F848, 'M', '喫'),
+    (0x2F849, 'M', '喳'),
+    (0x2F84A, 'M', '嗂'),
+    (0x2F84B, 'M', '圖'),
+    (0x2F84C, 'M', '嘆'),
+    (0x2F84D, 'M', '圗'),
+    (0x2F84E, 'M', '噑'),
+    (0x2F84F, 'M', '噴'),
+    (0x2F850, 'M', '切'),
+    (0x2F851, 'M', '壮'),
+    (0x2F852, 'M', '城'),
+    (0x2F853, 'M', '埴'),
+    (0x2F854, 'M', '堍'),
+    (0x2F855, 'M', '型'),
+    (0x2F856, 'M', '堲'),
+    (0x2F857, 'M', '報'),
+    (0x2F858, 'M', '墬'),
+    (0x2F859, 'M', '𡓤'),
+    (0x2F85A, 'M', '売'),
+    (0x2F85B, 'M', '壷'),
+    (0x2F85C, 'M', '夆'),
+    (0x2F85D, 'M', '多'),
+    (0x2F85E, 'M', '夢'),
+    (0x2F85F, 'M', '奢'),
+    (0x2F860, 'M', '𡚨'),
+    (0x2F861, 'M', '𡛪'),
+    (0x2F862, 'M', '姬'),
+    (0x2F863, 'M', '娛'),
+    (0x2F864, 'M', '娧'),
+    (0x2F865, 'M', '姘'),
+    (0x2F866, 'M', '婦'),
+    (0x2F867, 'M', '㛮'),
+    (0x2F868, 'X'),
+    (0x2F869, 'M', '嬈'),
+    (0x2F86A, 'M', '嬾'),
+    (0x2F86C, 'M', '𡧈'),
+    (0x2F86D, 'M', '寃'),
+    (0x2F86E, 'M', '寘'),
+    (0x2F86F, 'M', '寧'),
+    (0x2F870, 'M', '寳'),
+    (0x2F871, 'M', '𡬘'),
+    (0x2F872, 'M', '寿'),
+    (0x2F873, 'M', '将'),
+    (0x2F874, 'X'),
+    (0x2F875, 'M', '尢'),
+    (0x2F876, 'M', '㞁'),
+    (0x2F877, 'M', '屠'),
+    (0x2F878, 'M', '屮'),
+    (0x2F879, 'M', '峀'),
+    (0x2F87A, 'M', '岍'),
+    (0x2F87B, 'M', '𡷤'),
+    (0x2F87C, 'M', '嵃'),
+    (0x2F87D, 'M', '𡷦'),
+    (0x2F87E, 'M', '嵮'),
+    (0x2F87F, 'M', '嵫'),
+    (0x2F880, 'M', '嵼'),
+    (0x2F881, 'M', '巡'),
+    (0x2F882, 'M', '巢'),
+    (0x2F883, 'M', '㠯'),
+    (0x2F884, 'M', '巽'),
+    (0x2F885, 'M', '帨'),
+    (0x2F886, 'M', '帽'),
+    (0x2F887, 'M', '幩'),
+    (0x2F888, 'M', '㡢'),
+    (0x2F889, 'M', '𢆃'),
+    (0x2F88A, 'M', '㡼'),
+    (0x2F88B, 'M', '庰'),
+    (0x2F88C, 'M', '庳'),
+    (0x2F88D, 'M', '庶'),
+    (0x2F88E, 'M', '廊'),
+    (0x2F88F, 'M', '𪎒'),
+    (0x2F890, 'M', '廾'),
+    (0x2F891, 'M', '𢌱'),
+    (0x2F893, 'M', '舁'),
+    (0x2F894, 'M', '弢'),
+    (0x2F896, 'M', '㣇'),
+    (0x2F897, 'M', '𣊸'),
+    (0x2F898, 'M', '𦇚'),
+    (0x2F899, 'M', '形'),
+    (0x2F89A, 'M', '彫'),
+    (0x2F89B, 'M', '㣣'),
+    (0x2F89C, 'M', '徚'),
+    (0x2F89D, 'M', '忍'),
+    (0x2F89E, 'M', '志'),
+    (0x2F89F, 'M', '忹'),
+    (0x2F8A0, 'M', '悁'),
+    (0x2F8A1, 'M', '㤺'),
+    (0x2F8A2, 'M', '㤜'),
+    (0x2F8A3, 'M', '悔'),
+    (0x2F8A4, 'M', '𢛔'),
+    (0x2F8A5, 'M', '惇'),
+    (0x2F8A6, 'M', '慈'),
+    (0x2F8A7, 'M', '慌'),
+    (0x2F8A8, 'M', '慎'),
+    ]
+
+def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F8A9, 'M', '慌'),
+    (0x2F8AA, 'M', '慺'),
+    (0x2F8AB, 'M', '憎'),
+    (0x2F8AC, 'M', '憲'),
+    (0x2F8AD, 'M', '憤'),
+    (0x2F8AE, 'M', '憯'),
+    (0x2F8AF, 'M', '懞'),
+    (0x2F8B0, 'M', '懲'),
+    (0x2F8B1, 'M', '懶'),
+    (0x2F8B2, 'M', '成'),
+    (0x2F8B3, 'M', '戛'),
+    (0x2F8B4, 'M', '扝'),
+    (0x2F8B5, 'M', '抱'),
+    (0x2F8B6, 'M', '拔'),
+    (0x2F8B7, 'M', '捐'),
+    (0x2F8B8, 'M', '𢬌'),
+    (0x2F8B9, 'M', '挽'),
+    (0x2F8BA, 'M', '拼'),
+    (0x2F8BB, 'M', '捨'),
+    (0x2F8BC, 'M', '掃'),
+    (0x2F8BD, 'M', '揤'),
+    (0x2F8BE, 'M', '𢯱'),
+    (0x2F8BF, 'M', '搢'),
+    (0x2F8C0, 'M', '揅'),
+    (0x2F8C1, 'M', '掩'),
+    (0x2F8C2, 'M', '㨮'),
+    (0x2F8C3, 'M', '摩'),
+    (0x2F8C4, 'M', '摾'),
+    (0x2F8C5, 'M', '撝'),
+    (0x2F8C6, 'M', '摷'),
+    (0x2F8C7, 'M', '㩬'),
+    (0x2F8C8, 'M', '敏'),
+    (0x2F8C9, 'M', '敬'),
+    (0x2F8CA, 'M', '𣀊'),
+    (0x2F8CB, 'M', '旣'),
+    (0x2F8CC, 'M', '書'),
+    (0x2F8CD, 'M', '晉'),
+    (0x2F8CE, 'M', '㬙'),
+    (0x2F8CF, 'M', '暑'),
+    (0x2F8D0, 'M', '㬈'),
+    (0x2F8D1, 'M', '㫤'),
+    (0x2F8D2, 'M', '冒'),
+    (0x2F8D3, 'M', '冕'),
+    (0x2F8D4, 'M', '最'),
+    (0x2F8D5, 'M', '暜'),
+    (0x2F8D6, 'M', '肭'),
+    (0x2F8D7, 'M', '䏙'),
+    (0x2F8D8, 'M', '朗'),
+    (0x2F8D9, 'M', '望'),
+    (0x2F8DA, 'M', '朡'),
+    (0x2F8DB, 'M', '杞'),
+    (0x2F8DC, 'M', '杓'),
+    (0x2F8DD, 'M', '𣏃'),
+    (0x2F8DE, 'M', '㭉'),
+    (0x2F8DF, 'M', '柺'),
+    (0x2F8E0, 'M', '枅'),
+    (0x2F8E1, 'M', '桒'),
+    (0x2F8E2, 'M', '梅'),
+    (0x2F8E3, 'M', '𣑭'),
+    (0x2F8E4, 'M', '梎'),
+    (0x2F8E5, 'M', '栟'),
+    (0x2F8E6, 'M', '椔'),
+    (0x2F8E7, 'M', '㮝'),
+    (0x2F8E8, 'M', '楂'),
+    (0x2F8E9, 'M', '榣'),
+    (0x2F8EA, 'M', '槪'),
+    (0x2F8EB, 'M', '檨'),
+    (0x2F8EC, 'M', '𣚣'),
+    (0x2F8ED, 'M', '櫛'),
+    (0x2F8EE, 'M', '㰘'),
+    (0x2F8EF, 'M', '次'),
+    (0x2F8F0, 'M', '𣢧'),
+    (0x2F8F1, 'M', '歔'),
+    (0x2F8F2, 'M', '㱎'),
+    (0x2F8F3, 'M', '歲'),
+    (0x2F8F4, 'M', '殟'),
+    (0x2F8F5, 'M', '殺'),
+    (0x2F8F6, 'M', '殻'),
+    (0x2F8F7, 'M', '𣪍'),
+    (0x2F8F8, 'M', '𡴋'),
+    (0x2F8F9, 'M', '𣫺'),
+    (0x2F8FA, 'M', '汎'),
+    (0x2F8FB, 'M', '𣲼'),
+    (0x2F8FC, 'M', '沿'),
+    (0x2F8FD, 'M', '泍'),
+    (0x2F8FE, 'M', '汧'),
+    (0x2F8FF, 'M', '洖'),
+    (0x2F900, 'M', '派'),
+    (0x2F901, 'M', '海'),
+    (0x2F902, 'M', '流'),
+    (0x2F903, 'M', '浩'),
+    (0x2F904, 'M', '浸'),
+    (0x2F905, 'M', '涅'),
+    (0x2F906, 'M', '𣴞'),
+    (0x2F907, 'M', '洴'),
+    (0x2F908, 'M', '港'),
+    (0x2F909, 'M', '湮'),
+    (0x2F90A, 'M', '㴳'),
+    (0x2F90B, 'M', '滋'),
+    (0x2F90C, 'M', '滇'),
+    ]
+
+def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F90D, 'M', '𣻑'),
+    (0x2F90E, 'M', '淹'),
+    (0x2F90F, 'M', '潮'),
+    (0x2F910, 'M', '𣽞'),
+    (0x2F911, 'M', '𣾎'),
+    (0x2F912, 'M', '濆'),
+    (0x2F913, 'M', '瀹'),
+    (0x2F914, 'M', '瀞'),
+    (0x2F915, 'M', '瀛'),
+    (0x2F916, 'M', '㶖'),
+    (0x2F917, 'M', '灊'),
+    (0x2F918, 'M', '災'),
+    (0x2F919, 'M', '灷'),
+    (0x2F91A, 'M', '炭'),
+    (0x2F91B, 'M', '𠔥'),
+    (0x2F91C, 'M', '煅'),
+    (0x2F91D, 'M', '𤉣'),
+    (0x2F91E, 'M', '熜'),
+    (0x2F91F, 'X'),
+    (0x2F920, 'M', '爨'),
+    (0x2F921, 'M', '爵'),
+    (0x2F922, 'M', '牐'),
+    (0x2F923, 'M', '𤘈'),
+    (0x2F924, 'M', '犀'),
+    (0x2F925, 'M', '犕'),
+    (0x2F926, 'M', '𤜵'),
+    (0x2F927, 'M', '𤠔'),
+    (0x2F928, 'M', '獺'),
+    (0x2F929, 'M', '王'),
+    (0x2F92A, 'M', '㺬'),
+    (0x2F92B, 'M', '玥'),
+    (0x2F92C, 'M', '㺸'),
+    (0x2F92E, 'M', '瑇'),
+    (0x2F92F, 'M', '瑜'),
+    (0x2F930, 'M', '瑱'),
+    (0x2F931, 'M', '璅'),
+    (0x2F932, 'M', '瓊'),
+    (0x2F933, 'M', '㼛'),
+    (0x2F934, 'M', '甤'),
+    (0x2F935, 'M', '𤰶'),
+    (0x2F936, 'M', '甾'),
+    (0x2F937, 'M', '𤲒'),
+    (0x2F938, 'M', '異'),
+    (0x2F939, 'M', '𢆟'),
+    (0x2F93A, 'M', '瘐'),
+    (0x2F93B, 'M', '𤾡'),
+    (0x2F93C, 'M', '𤾸'),
+    (0x2F93D, 'M', '𥁄'),
+    (0x2F93E, 'M', '㿼'),
+    (0x2F93F, 'M', '䀈'),
+    (0x2F940, 'M', '直'),
+    (0x2F941, 'M', '𥃳'),
+    (0x2F942, 'M', '𥃲'),
+    (0x2F943, 'M', '𥄙'),
+    (0x2F944, 'M', '𥄳'),
+    (0x2F945, 'M', '眞'),
+    (0x2F946, 'M', '真'),
+    (0x2F948, 'M', '睊'),
+    (0x2F949, 'M', '䀹'),
+    (0x2F94A, 'M', '瞋'),
+    (0x2F94B, 'M', '䁆'),
+    (0x2F94C, 'M', '䂖'),
+    (0x2F94D, 'M', '𥐝'),
+    (0x2F94E, 'M', '硎'),
+    (0x2F94F, 'M', '碌'),
+    (0x2F950, 'M', '磌'),
+    (0x2F951, 'M', '䃣'),
+    (0x2F952, 'M', '𥘦'),
+    (0x2F953, 'M', '祖'),
+    (0x2F954, 'M', '𥚚'),
+    (0x2F955, 'M', '𥛅'),
+    (0x2F956, 'M', '福'),
+    (0x2F957, 'M', '秫'),
+    (0x2F958, 'M', '䄯'),
+    (0x2F959, 'M', '穀'),
+    (0x2F95A, 'M', '穊'),
+    (0x2F95B, 'M', '穏'),
+    (0x2F95C, 'M', '𥥼'),
+    (0x2F95D, 'M', '𥪧'),
+    (0x2F95F, 'X'),
+    (0x2F960, 'M', '䈂'),
+    (0x2F961, 'M', '𥮫'),
+    (0x2F962, 'M', '篆'),
+    (0x2F963, 'M', '築'),
+    (0x2F964, 'M', '䈧'),
+    (0x2F965, 'M', '𥲀'),
+    (0x2F966, 'M', '糒'),
+    (0x2F967, 'M', '䊠'),
+    (0x2F968, 'M', '糨'),
+    (0x2F969, 'M', '糣'),
+    (0x2F96A, 'M', '紀'),
+    (0x2F96B, 'M', '𥾆'),
+    (0x2F96C, 'M', '絣'),
+    (0x2F96D, 'M', '䌁'),
+    (0x2F96E, 'M', '緇'),
+    (0x2F96F, 'M', '縂'),
+    (0x2F970, 'M', '繅'),
+    (0x2F971, 'M', '䌴'),
+    (0x2F972, 'M', '𦈨'),
+    (0x2F973, 'M', '𦉇'),
+    ]
+
+def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F974, 'M', '䍙'),
+    (0x2F975, 'M', '𦋙'),
+    (0x2F976, 'M', '罺'),
+    (0x2F977, 'M', '𦌾'),
+    (0x2F978, 'M', '羕'),
+    (0x2F979, 'M', '翺'),
+    (0x2F97A, 'M', '者'),
+    (0x2F97B, 'M', '𦓚'),
+    (0x2F97C, 'M', '𦔣'),
+    (0x2F97D, 'M', '聠'),
+    (0x2F97E, 'M', '𦖨'),
+    (0x2F97F, 'M', '聰'),
+    (0x2F980, 'M', '𣍟'),
+    (0x2F981, 'M', '䏕'),
+    (0x2F982, 'M', '育'),
+    (0x2F983, 'M', '脃'),
+    (0x2F984, 'M', '䐋'),
+    (0x2F985, 'M', '脾'),
+    (0x2F986, 'M', '媵'),
+    (0x2F987, 'M', '𦞧'),
+    (0x2F988, 'M', '𦞵'),
+    (0x2F989, 'M', '𣎓'),
+    (0x2F98A, 'M', '𣎜'),
+    (0x2F98B, 'M', '舁'),
+    (0x2F98C, 'M', '舄'),
+    (0x2F98D, 'M', '辞'),
+    (0x2F98E, 'M', '䑫'),
+    (0x2F98F, 'M', '芑'),
+    (0x2F990, 'M', '芋'),
+    (0x2F991, 'M', '芝'),
+    (0x2F992, 'M', '劳'),
+    (0x2F993, 'M', '花'),
+    (0x2F994, 'M', '芳'),
+    (0x2F995, 'M', '芽'),
+    (0x2F996, 'M', '苦'),
+    (0x2F997, 'M', '𦬼'),
+    (0x2F998, 'M', '若'),
+    (0x2F999, 'M', '茝'),
+    (0x2F99A, 'M', '荣'),
+    (0x2F99B, 'M', '莭'),
+    (0x2F99C, 'M', '茣'),
+    (0x2F99D, 'M', '莽'),
+    (0x2F99E, 'M', '菧'),
+    (0x2F99F, 'M', '著'),
+    (0x2F9A0, 'M', '荓'),
+    (0x2F9A1, 'M', '菊'),
+    (0x2F9A2, 'M', '菌'),
+    (0x2F9A3, 'M', '菜'),
+    (0x2F9A4, 'M', '𦰶'),
+    (0x2F9A5, 'M', '𦵫'),
+    (0x2F9A6, 'M', '𦳕'),
+    (0x2F9A7, 'M', '䔫'),
+    (0x2F9A8, 'M', '蓱'),
+    (0x2F9A9, 'M', '蓳'),
+    (0x2F9AA, 'M', '蔖'),
+    (0x2F9AB, 'M', '𧏊'),
+    (0x2F9AC, 'M', '蕤'),
+    (0x2F9AD, 'M', '𦼬'),
+    (0x2F9AE, 'M', '䕝'),
+    (0x2F9AF, 'M', '䕡'),
+    (0x2F9B0, 'M', '𦾱'),
+    (0x2F9B1, 'M', '𧃒'),
+    (0x2F9B2, 'M', '䕫'),
+    (0x2F9B3, 'M', '虐'),
+    (0x2F9B4, 'M', '虜'),
+    (0x2F9B5, 'M', '虧'),
+    (0x2F9B6, 'M', '虩'),
+    (0x2F9B7, 'M', '蚩'),
+    (0x2F9B8, 'M', '蚈'),
+    (0x2F9B9, 'M', '蜎'),
+    (0x2F9BA, 'M', '蛢'),
+    (0x2F9BB, 'M', '蝹'),
+    (0x2F9BC, 'M', '蜨'),
+    (0x2F9BD, 'M', '蝫'),
+    (0x2F9BE, 'M', '螆'),
+    (0x2F9BF, 'X'),
+    (0x2F9C0, 'M', '蟡'),
+    (0x2F9C1, 'M', '蠁'),
+    (0x2F9C2, 'M', '䗹'),
+    (0x2F9C3, 'M', '衠'),
+    (0x2F9C4, 'M', '衣'),
+    (0x2F9C5, 'M', '𧙧'),
+    (0x2F9C6, 'M', '裗'),
+    (0x2F9C7, 'M', '裞'),
+    (0x2F9C8, 'M', '䘵'),
+    (0x2F9C9, 'M', '裺'),
+    (0x2F9CA, 'M', '㒻'),
+    (0x2F9CB, 'M', '𧢮'),
+    (0x2F9CC, 'M', '𧥦'),
+    (0x2F9CD, 'M', '䚾'),
+    (0x2F9CE, 'M', '䛇'),
+    (0x2F9CF, 'M', '誠'),
+    (0x2F9D0, 'M', '諭'),
+    (0x2F9D1, 'M', '變'),
+    (0x2F9D2, 'M', '豕'),
+    (0x2F9D3, 'M', '𧲨'),
+    (0x2F9D4, 'M', '貫'),
+    (0x2F9D5, 'M', '賁'),
+    (0x2F9D6, 'M', '贛'),
+    (0x2F9D7, 'M', '起'),
+    ]
+
+def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F9D8, 'M', '𧼯'),
+    (0x2F9D9, 'M', '𠠄'),
+    (0x2F9DA, 'M', '跋'),
+    (0x2F9DB, 'M', '趼'),
+    (0x2F9DC, 'M', '跰'),
+    (0x2F9DD, 'M', '𠣞'),
+    (0x2F9DE, 'M', '軔'),
+    (0x2F9DF, 'M', '輸'),
+    (0x2F9E0, 'M', '𨗒'),
+    (0x2F9E1, 'M', '𨗭'),
+    (0x2F9E2, 'M', '邔'),
+    (0x2F9E3, 'M', '郱'),
+    (0x2F9E4, 'M', '鄑'),
+    (0x2F9E5, 'M', '𨜮'),
+    (0x2F9E6, 'M', '鄛'),
+    (0x2F9E7, 'M', '鈸'),
+    (0x2F9E8, 'M', '鋗'),
+    (0x2F9E9, 'M', '鋘'),
+    (0x2F9EA, 'M', '鉼'),
+    (0x2F9EB, 'M', '鏹'),
+    (0x2F9EC, 'M', '鐕'),
+    (0x2F9ED, 'M', '𨯺'),
+    (0x2F9EE, 'M', '開'),
+    (0x2F9EF, 'M', '䦕'),
+    (0x2F9F0, 'M', '閷'),
+    (0x2F9F1, 'M', '𨵷'),
+    (0x2F9F2, 'M', '䧦'),
+    (0x2F9F3, 'M', '雃'),
+    (0x2F9F4, 'M', '嶲'),
+    (0x2F9F5, 'M', '霣'),
+    (0x2F9F6, 'M', '𩅅'),
+    (0x2F9F7, 'M', '𩈚'),
+    (0x2F9F8, 'M', '䩮'),
+    (0x2F9F9, 'M', '䩶'),
+    (0x2F9FA, 'M', '韠'),
+    (0x2F9FB, 'M', '𩐊'),
+    (0x2F9FC, 'M', '䪲'),
+    (0x2F9FD, 'M', '𩒖'),
+    (0x2F9FE, 'M', '頋'),
+    (0x2FA00, 'M', '頩'),
+    (0x2FA01, 'M', '𩖶'),
+    (0x2FA02, 'M', '飢'),
+    (0x2FA03, 'M', '䬳'),
+    (0x2FA04, 'M', '餩'),
+    (0x2FA05, 'M', '馧'),
+    (0x2FA06, 'M', '駂'),
+    (0x2FA07, 'M', '駾'),
+    (0x2FA08, 'M', '䯎'),
+    (0x2FA09, 'M', '𩬰'),
+    (0x2FA0A, 'M', '鬒'),
+    (0x2FA0B, 'M', '鱀'),
+    (0x2FA0C, 'M', '鳽'),
+    (0x2FA0D, 'M', '䳎'),
+    (0x2FA0E, 'M', '䳭'),
+    (0x2FA0F, 'M', '鵧'),
+    (0x2FA10, 'M', '𪃎'),
+    (0x2FA11, 'M', '䳸'),
+    (0x2FA12, 'M', '𪄅'),
+    (0x2FA13, 'M', '𪈎'),
+    (0x2FA14, 'M', '𪊑'),
+    (0x2FA15, 'M', '麻'),
+    (0x2FA16, 'M', '䵖'),
+    (0x2FA17, 'M', '黹'),
+    (0x2FA18, 'M', '黾'),
+    (0x2FA19, 'M', '鼅'),
+    (0x2FA1A, 'M', '鼏'),
+    (0x2FA1B, 'M', '鼖'),
+    (0x2FA1C, 'M', '鼻'),
+    (0x2FA1D, 'M', '𪘀'),
+    (0x2FA1E, 'X'),
+    (0x30000, 'V'),
+    (0x3134B, 'X'),
+    (0x31350, 'V'),
+    (0x323B0, 'X'),
+    (0xE0100, 'I'),
+    (0xE01F0, 'X'),
+    ]
+
+uts46data = tuple(
+    _seg_0()
+    + _seg_1()
+    + _seg_2()
+    + _seg_3()
+    + _seg_4()
+    + _seg_5()
+    + _seg_6()
+    + _seg_7()
+    + _seg_8()
+    + _seg_9()
+    + _seg_10()
+    + _seg_11()
+    + _seg_12()
+    + _seg_13()
+    + _seg_14()
+    + _seg_15()
+    + _seg_16()
+    + _seg_17()
+    + _seg_18()
+    + _seg_19()
+    + _seg_20()
+    + _seg_21()
+    + _seg_22()
+    + _seg_23()
+    + _seg_24()
+    + _seg_25()
+    + _seg_26()
+    + _seg_27()
+    + _seg_28()
+    + _seg_29()
+    + _seg_30()
+    + _seg_31()
+    + _seg_32()
+    + _seg_33()
+    + _seg_34()
+    + _seg_35()
+    + _seg_36()
+    + _seg_37()
+    + _seg_38()
+    + _seg_39()
+    + _seg_40()
+    + _seg_41()
+    + _seg_42()
+    + _seg_43()
+    + _seg_44()
+    + _seg_45()
+    + _seg_46()
+    + _seg_47()
+    + _seg_48()
+    + _seg_49()
+    + _seg_50()
+    + _seg_51()
+    + _seg_52()
+    + _seg_53()
+    + _seg_54()
+    + _seg_55()
+    + _seg_56()
+    + _seg_57()
+    + _seg_58()
+    + _seg_59()
+    + _seg_60()
+    + _seg_61()
+    + _seg_62()
+    + _seg_63()
+    + _seg_64()
+    + _seg_65()
+    + _seg_66()
+    + _seg_67()
+    + _seg_68()
+    + _seg_69()
+    + _seg_70()
+    + _seg_71()
+    + _seg_72()
+    + _seg_73()
+    + _seg_74()
+    + _seg_75()
+    + _seg_76()
+    + _seg_77()
+    + _seg_78()
+    + _seg_79()
+    + _seg_80()
+    + _seg_81()
+)  # type: Tuple[Union[Tuple[int, str], Tuple[int, str, str]], ...]
diff --git a/lib/python3.11/site-packages/isympy.py b/lib/python3.11/site-packages/isympy.py
new file mode 100644
index 0000000000000000000000000000000000000000..50e9bc78d08904b8c177105ee90d984ea4b01d20
--- /dev/null
+++ b/lib/python3.11/site-packages/isympy.py
@@ -0,0 +1,342 @@
+"""
+Python shell for SymPy.
+
+This is just a normal Python shell (IPython shell if you have the
+IPython package installed), that executes the following commands for
+the user:
+
+    >>> from __future__ import division
+    >>> from sympy import *
+    >>> x, y, z, t = symbols('x y z t')
+    >>> k, m, n = symbols('k m n', integer=True)
+    >>> f, g, h = symbols('f g h', cls=Function)
+    >>> init_printing()
+
+So starting 'isympy' is equivalent to starting Python (or IPython) and
+executing the above commands by hand.  It is intended for easy and quick
+experimentation with SymPy.  isympy is a good way to use SymPy as an
+interactive calculator. If you have IPython and Matplotlib installed, then
+interactive plotting is enabled by default.
+
+COMMAND LINE OPTIONS
+--------------------
+
+-c CONSOLE, --console=CONSOLE
+
+     Use the specified shell (Python or IPython) shell as the console
+     backend instead of the default one (IPython if present, Python
+     otherwise), e.g.:
+
+        $isympy -c python
+
+    CONSOLE must be one of 'ipython' or 'python'
+
+-p PRETTY, --pretty PRETTY
+
+    Setup pretty-printing in SymPy. When pretty-printing is enabled,
+    expressions can be printed with Unicode or ASCII. The default is
+    to use pretty-printing (with Unicode if the terminal supports it).
+    When this option is 'no', expressions will not be pretty-printed
+    and ASCII will be used:
+
+        $isympy -p no
+
+    PRETTY must be one of 'unicode', 'ascii', or 'no'
+
+-t TYPES, --types=TYPES
+
+    Setup the ground types for the polys.  By default, gmpy ground types
+    are used if gmpy2 or gmpy is installed, otherwise it falls back to python
+    ground types, which are a little bit slower.  You can manually
+    choose python ground types even if gmpy is installed (e.g., for
+    testing purposes):
+
+        $isympy -t python
+
+    TYPES must be one of 'gmpy', 'gmpy1' or 'python'
+
+    Note that the ground type gmpy1 is primarily intended for testing; it
+    forces the use of gmpy version 1 even if gmpy2 is available.
+
+    This is the same as setting the environment variable
+    SYMPY_GROUND_TYPES to the given ground type (e.g.,
+    SYMPY_GROUND_TYPES='gmpy')
+
+    The ground types can be determined interactively from the variable
+    sympy.polys.domains.GROUND_TYPES.
+
+-o ORDER, --order ORDER
+
+    Setup the ordering of terms for printing.  The default is lex, which
+    orders terms lexicographically (e.g., x**2 + x + 1). You can choose
+    other orderings, such as rev-lex, which will use reverse
+    lexicographic ordering (e.g., 1 + x + x**2):
+
+        $isympy -o rev-lex
+
+    ORDER must be one of 'lex', 'rev-lex', 'grlex', 'rev-grlex',
+    'grevlex', 'rev-grevlex', 'old', or 'none'.
+
+    Note that for very large expressions, ORDER='none' may speed up
+    printing considerably but the terms will have no canonical order.
+
+-q, --quiet
+
+    Print only Python's and SymPy's versions to stdout at startup.
+
+-d, --doctest
+
+    Use the same format that should be used for doctests.  This is
+    equivalent to -c python -p no.
+
+-C, --no-cache
+
+    Disable the caching mechanism.  Disabling the cache may slow certain
+    operations down considerably.  This is useful for testing the cache,
+    or for benchmarking, as the cache can result in deceptive timings.
+
+    This is equivalent to setting the environment variable
+    SYMPY_USE_CACHE to 'no'.
+
+-a, --auto-symbols (requires at least IPython 0.11)
+
+    Automatically create missing symbols.  Normally, typing a name of a
+    Symbol that has not been instantiated first would raise NameError,
+    but with this option enabled, any undefined name will be
+    automatically created as a Symbol.
+
+    Note that this is intended only for interactive, calculator style
+    usage. In a script that uses SymPy, Symbols should be instantiated
+    at the top, so that it's clear what they are.
+
+    This will not override any names that are already defined, which
+    includes the single character letters represented by the mnemonic
+    QCOSINE (see the "Gotchas and Pitfalls" document in the
+    documentation). You can delete existing names by executing "del
+    name".  If a name is defined, typing "'name' in dir()" will return True.
+
+    The Symbols that are created using this have default assumptions.
+    If you want to place assumptions on symbols, you should create them
+    using symbols() or var().
+
+    Finally, this only works in the top level namespace. So, for
+    example, if you define a function in isympy with an undefined
+    Symbol, it will not work.
+
+    See also the -i and -I options.
+
+-i, --int-to-Integer (requires at least IPython 0.11)
+
+    Automatically wrap int literals with Integer.  This makes it so that
+    things like 1/2 will come out as Rational(1, 2), rather than 0.5.  This
+    works by preprocessing the source and wrapping all int literals with
+    Integer.  Note that this will not change the behavior of int literals
+    assigned to variables, and it also won't change the behavior of functions
+    that return int literals.
+
+    If you want an int, you can wrap the literal in int(), e.g. int(3)/int(2)
+    gives 1.5 (with division imported from __future__).
+
+-I, --interactive (requires at least IPython 0.11)
+
+    This is equivalent to --auto-symbols --int-to-Integer.  Future options
+    designed for ease of interactive use may be added to this.
+
+-D, --debug
+
+    Enable debugging output.  This is the same as setting the
+    environment variable SYMPY_DEBUG to 'True'.  The debug status is set
+    in the variable SYMPY_DEBUG within isympy.
+
+-- IPython options
+
+    Additionally you can pass command line options directly to the IPython
+    interpreter (the standard Python shell is not supported).  However you
+    need to add the '--' separator between two types of options, e.g the
+    startup banner option and the colors option. You need to enter the
+    options as required by the version of IPython that you are using, too:
+
+    in IPython 0.11,
+
+        $isympy -q -- --colors=NoColor
+
+    or older versions of IPython,
+
+        $isympy -q -- -colors NoColor
+
+See also isympy --help.
+"""
+
+import os
+import sys
+
+# DO NOT IMPORT SYMPY HERE! Or the setting of the sympy environment variables
+# by the command line will break.
+
+def main() -> None:
+    from argparse import ArgumentParser, RawDescriptionHelpFormatter
+
+    VERSION = None
+    if '--version' in sys.argv:
+        # We cannot import sympy before this is run, because flags like -C and
+        # -t set environment variables that must be set before SymPy is
+        # imported. The only thing we need to import it for is to get the
+        # version, which only matters with the --version flag.
+        import sympy
+        VERSION = sympy.__version__
+
+    usage = 'isympy [options] -- [ipython options]'
+    parser = ArgumentParser(
+        usage=usage,
+        description=__doc__,
+        formatter_class=RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument('--version', action='version', version=VERSION)
+
+    parser.add_argument(
+        '-c', '--console',
+        dest='console',
+        action='store',
+        default=None,
+        choices=['ipython', 'python'],
+        metavar='CONSOLE',
+        help='select type of interactive session: ipython | python; defaults '
+        'to ipython if IPython is installed, otherwise python')
+
+    parser.add_argument(
+        '-p', '--pretty',
+        dest='pretty',
+        action='store',
+        default=None,
+        metavar='PRETTY',
+        choices=['unicode', 'ascii', 'no'],
+        help='setup pretty printing: unicode | ascii | no; defaults to '
+        'unicode printing if the terminal supports it, otherwise ascii')
+
+    parser.add_argument(
+        '-t', '--types',
+        dest='types',
+        action='store',
+        default=None,
+        metavar='TYPES',
+        choices=['gmpy', 'gmpy1', 'python'],
+        help='setup ground types: gmpy | gmpy1 | python; defaults to gmpy if gmpy2 '
+        'or gmpy is installed, otherwise python')
+
+    parser.add_argument(
+        '-o', '--order',
+        dest='order',
+        action='store',
+        default=None,
+        metavar='ORDER',
+        choices=['lex', 'grlex', 'grevlex', 'rev-lex', 'rev-grlex', 'rev-grevlex', 'old', 'none'],
+        help='setup ordering of terms: [rev-]lex | [rev-]grlex | [rev-]grevlex | old | none; defaults to lex')
+
+    parser.add_argument(
+        '-q', '--quiet',
+        dest='quiet',
+        action='store_true',
+        default=False,
+        help='print only version information at startup')
+
+    parser.add_argument(
+        '-d', '--doctest',
+        dest='doctest',
+        action='store_true',
+        default=False,
+        help='use the doctest format for output (you can just copy and paste it)')
+
+    parser.add_argument(
+        '-C', '--no-cache',
+        dest='cache',
+        action='store_false',
+        default=True,
+        help='disable caching mechanism')
+
+    parser.add_argument(
+        '-a', '--auto-symbols',
+        dest='auto_symbols',
+        action='store_true',
+        default=False,
+        help='automatically construct missing symbols')
+
+    parser.add_argument(
+        '-i', '--int-to-Integer',
+        dest='auto_int_to_Integer',
+        action='store_true',
+        default=False,
+        help="automatically wrap int literals with Integer")
+
+    parser.add_argument(
+        '-I', '--interactive',
+        dest='interactive',
+        action='store_true',
+        default=False,
+        help="equivalent to -a -i")
+
+    parser.add_argument(
+        '-D', '--debug',
+        dest='debug',
+        action='store_true',
+        default=False,
+        help='enable debugging output')
+
+    (options, ipy_args) = parser.parse_known_args()
+    if '--' in ipy_args:
+        ipy_args.remove('--')
+
+    if not options.cache:
+        os.environ['SYMPY_USE_CACHE'] = 'no'
+
+    if options.types:
+        os.environ['SYMPY_GROUND_TYPES'] = options.types
+
+    if options.debug:
+        os.environ['SYMPY_DEBUG'] = str(options.debug)
+
+    if options.doctest:
+        options.pretty = 'no'
+        options.console = 'python'
+
+    session = options.console
+
+    if session is not None:
+        ipython = session == 'ipython'
+    else:
+        try:
+            import IPython
+            ipython = True
+        except ImportError:
+            if not options.quiet:
+                from sympy.interactive.session import no_ipython
+                print(no_ipython)
+            ipython = False
+
+    args = {
+        'pretty_print': True,
+        'use_unicode':  None,
+        'use_latex':    None,
+        'order':        None,
+        'argv':         ipy_args,
+    }
+
+    if options.pretty == 'unicode':
+        args['use_unicode'] = True
+    elif options.pretty == 'ascii':
+        args['use_unicode'] = False
+    elif options.pretty == 'no':
+        args['pretty_print'] = False
+
+    if options.order is not None:
+        args['order'] = options.order
+
+    args['quiet'] = options.quiet
+    args['auto_symbols'] = options.auto_symbols or options.interactive
+    args['auto_int_to_Integer'] = options.auto_int_to_Integer or options.interactive
+
+    from sympy.interactive import init_session
+    init_session(ipython, **args)
+
+if __name__ == "__main__":
+    main()
diff --git a/lib/python3.11/site-packages/jinja2/__init__.py b/lib/python3.11/site-packages/jinja2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e32392679edd18917d0f218bfb316d5256203042
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/__init__.py
@@ -0,0 +1,37 @@
+"""Jinja is a template engine written in pure Python. It provides a
+non-XML syntax that supports inline expressions and an optional
+sandboxed environment.
+"""
+from .bccache import BytecodeCache as BytecodeCache
+from .bccache import FileSystemBytecodeCache as FileSystemBytecodeCache
+from .bccache import MemcachedBytecodeCache as MemcachedBytecodeCache
+from .environment import Environment as Environment
+from .environment import Template as Template
+from .exceptions import TemplateAssertionError as TemplateAssertionError
+from .exceptions import TemplateError as TemplateError
+from .exceptions import TemplateNotFound as TemplateNotFound
+from .exceptions import TemplateRuntimeError as TemplateRuntimeError
+from .exceptions import TemplatesNotFound as TemplatesNotFound
+from .exceptions import TemplateSyntaxError as TemplateSyntaxError
+from .exceptions import UndefinedError as UndefinedError
+from .loaders import BaseLoader as BaseLoader
+from .loaders import ChoiceLoader as ChoiceLoader
+from .loaders import DictLoader as DictLoader
+from .loaders import FileSystemLoader as FileSystemLoader
+from .loaders import FunctionLoader as FunctionLoader
+from .loaders import ModuleLoader as ModuleLoader
+from .loaders import PackageLoader as PackageLoader
+from .loaders import PrefixLoader as PrefixLoader
+from .runtime import ChainableUndefined as ChainableUndefined
+from .runtime import DebugUndefined as DebugUndefined
+from .runtime import make_logging_undefined as make_logging_undefined
+from .runtime import StrictUndefined as StrictUndefined
+from .runtime import Undefined as Undefined
+from .utils import clear_caches as clear_caches
+from .utils import is_undefined as is_undefined
+from .utils import pass_context as pass_context
+from .utils import pass_environment as pass_environment
+from .utils import pass_eval_context as pass_eval_context
+from .utils import select_autoescape as select_autoescape
+
+__version__ = "3.1.2"
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7848359f8c6794a4b9189bba6d30aec417a666b8
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/_identifier.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/_identifier.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7cc78e1fe351ba8a844c3a633c3fa8e304568150
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/_identifier.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/async_utils.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/async_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c04179e3ff4e6cbeb815a66481a58a69185ab83
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/async_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/bccache.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/bccache.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e23ecdfa1cc961a7a61079ce0cb14d9d9246cf4f
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/bccache.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/compiler.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/compiler.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c1153689fefa3523466466e2673e3db14c87e55
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/compiler.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/constants.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/constants.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61ca1723d0ec682e1a2e00f47439fde2c6ea0da7
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/constants.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/debug.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/debug.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66122169cbe1b3880cee4ae4509ac549315be3ae
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/debug.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/defaults.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/defaults.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c23ea94f02cb27962a8a3a59f42f633dd088a87
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/defaults.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/environment.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/environment.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a7e31caff4651f6e85e5787152fe389e7a56d47f
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/environment.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/exceptions.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..37d780065f03640014c5e82de4c9f9256fb2c543
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/exceptions.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/ext.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/ext.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb04219027a0df0ade4def8b13fdd2d80577db6b
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/ext.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/filters.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/filters.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7827b7a2f36b0abd8b52f061b5ab1c28e7c7f8dc
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/filters.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/idtracking.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/idtracking.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7cc348009c8097eadd88ddf977385ffc26145050
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/idtracking.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/lexer.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/lexer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f12e079add3e3827555a88f4093d1bbb01aa8d10
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/lexer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/loaders.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/loaders.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05988ea921c75d0925d35f17c4e1a39b67cee88e
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/loaders.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/meta.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/meta.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..abfbc853fffaf7f0c322edd909d47aee9a9314e7
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/meta.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/nativetypes.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/nativetypes.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44c94692d644f88bb7f7a1323164497bcb5656ee
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/nativetypes.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/nodes.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/nodes.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..947e118c99f1671aa7ee0faba3f044cf192aa154
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/nodes.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/optimizer.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/optimizer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cecc8e9e807f6e88e462ad59805f58b745cd669f
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/optimizer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/parser.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/parser.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9eec778a2486f4a086c01e365a3baba4d7c9291
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/parser.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/runtime.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/runtime.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94d6e367d9ddbe59a63b0e9b6f2f248a756c9989
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/runtime.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/sandbox.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/sandbox.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af0f199f8bf50da19716f500444e9030cb8fa54f
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/sandbox.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/tests.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/tests.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e0bbb56719e6ed4327153851828a1e877ef9548a
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/tests.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/utils.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b378ae2165a742f9ff89da68ba818448290c1dfb
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/__pycache__/visitor.cpython-311.pyc b/lib/python3.11/site-packages/jinja2/__pycache__/visitor.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d1fcb1dbbb433acaccf4bad78696cdb870b74347
Binary files /dev/null and b/lib/python3.11/site-packages/jinja2/__pycache__/visitor.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/jinja2/_identifier.py b/lib/python3.11/site-packages/jinja2/_identifier.py
new file mode 100644
index 0000000000000000000000000000000000000000..928c1503c7d414a8a86bbf5a82c68d42cb089bd2
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/_identifier.py
@@ -0,0 +1,6 @@
+import re
+
+# generated by scripts/generate_identifier_pattern.py
+pattern = re.compile(
+    r"[\w·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-ٰٟۖ-ۜ۟-۪ۤۧۨ-ܑۭܰ-݊ަ-ް߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛࣓-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣঁ-ঃ়া-ৄেৈো-্ৗৢৣ৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑੰੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣஂா-ூெ-ைொ-்ௗఀ-ఄా-ౄె-ైొ-్ౕౖౢౣಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣංඃ්ා-ුූෘ-ෟෲෳัิ-ฺ็-๎ັິ-ູົຼ່-ໍ༹༘༙༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏႚ-ႝ፝-፟ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝᠋-᠍ᢅᢆᢩᤠ-ᤫᤰ-᤻ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼᪰-᪽ᬀ-ᬄ᬴-᭄᭫-᭳ᮀ-ᮂᮡ-ᮭ᯦-᯳ᰤ-᰷᳐-᳔᳒-᳨᳭ᳲ-᳴᳷-᳹᷀-᷹᷻-᷿‿⁀⁔⃐-⃥⃜⃡-⃰℘℮⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-ꣅ꣠-꣱ꣿꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀ꧥꨩ-ꨶꩃꩌꩍꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭ﬞ︀-️︠-︯︳︴﹍-﹏＿𐇽𐋠𐍶-𐍺𐨁-𐨃𐨅𐨆𐨌-𐨏𐨸-𐨿𐨺𐫦𐫥𐴤-𐽆𐴧-𐽐𑀀-𑀂𑀸-𑁆𑁿-𑂂𑂰-𑂺𑄀-𑄂𑄧-𑄴𑅅𑅆𑅳𑆀-𑆂𑆳-𑇀𑇉-𑇌𑈬-𑈷𑈾𑋟-𑋪𑌀-𑌃𑌻𑌼𑌾-𑍄𑍇𑍈𑍋-𑍍𑍗𑍢𑍣𑍦-𑍬𑍰-𑍴𑐵-𑑆𑑞𑒰-𑓃𑖯-𑖵𑖸-𑗀𑗜𑗝𑘰-𑙀𑚫-𑚷𑜝-𑜫𑠬-𑠺𑨁-𑨊𑨳-𑨹𑨻-𑨾𑩇𑩑-𑩛𑪊-𑪙𑰯-𑰶𑰸-𑰿𑲒-𑲧𑲩-𑲶𑴱-𑴶𑴺𑴼𑴽𑴿-𑵅𑵇𑶊-𑶎𑶐𑶑𑶓-𑶗𑻳-𑻶𖫰-𖫴𖬰-𖬶𖽑-𖽾𖾏-𖾒𛲝𛲞𝅥-𝅩𝅭-𝅲𝅻-𝆂𝆅-𝆋𝆪-𝆭𝉂-𝉄𝨀-𝨶𝨻-𝩬𝩵𝪄𝪛-𝪟𝪡-𝪯𞀀-𞀆𞀈-𞀘𞀛-𞀡𞀣𞀤𞀦-𞣐𞀪-𞣖𞥄-𞥊󠄀-󠇯]+"  # noqa: B950
+)
diff --git a/lib/python3.11/site-packages/jinja2/async_utils.py b/lib/python3.11/site-packages/jinja2/async_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a4f3892cef1a53632476933f2ce2d86fc31b10a
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/async_utils.py
@@ -0,0 +1,84 @@
+import inspect
+import typing as t
+from functools import WRAPPER_ASSIGNMENTS
+from functools import wraps
+
+from .utils import _PassArg
+from .utils import pass_eval_context
+
+V = t.TypeVar("V")
+
+
+def async_variant(normal_func):  # type: ignore
+    def decorator(async_func):  # type: ignore
+        pass_arg = _PassArg.from_obj(normal_func)
+        need_eval_context = pass_arg is None
+
+        if pass_arg is _PassArg.environment:
+
+            def is_async(args: t.Any) -> bool:
+                return t.cast(bool, args[0].is_async)
+
+        else:
+
+            def is_async(args: t.Any) -> bool:
+                return t.cast(bool, args[0].environment.is_async)
+
+        # Take the doc and annotations from the sync function, but the
+        # name from the async function. Pallets-Sphinx-Themes
+        # build_function_directive expects __wrapped__ to point to the
+        # sync function.
+        async_func_attrs = ("__module__", "__name__", "__qualname__")
+        normal_func_attrs = tuple(set(WRAPPER_ASSIGNMENTS).difference(async_func_attrs))
+
+        @wraps(normal_func, assigned=normal_func_attrs)
+        @wraps(async_func, assigned=async_func_attrs, updated=())
+        def wrapper(*args, **kwargs):  # type: ignore
+            b = is_async(args)
+
+            if need_eval_context:
+                args = args[1:]
+
+            if b:
+                return async_func(*args, **kwargs)
+
+            return normal_func(*args, **kwargs)
+
+        if need_eval_context:
+            wrapper = pass_eval_context(wrapper)
+
+        wrapper.jinja_async_variant = True
+        return wrapper
+
+    return decorator
+
+
+_common_primitives = {int, float, bool, str, list, dict, tuple, type(None)}
+
+
+async def auto_await(value: t.Union[t.Awaitable["V"], "V"]) -> "V":
+    # Avoid a costly call to isawaitable
+    if type(value) in _common_primitives:
+        return t.cast("V", value)
+
+    if inspect.isawaitable(value):
+        return await t.cast("t.Awaitable[V]", value)
+
+    return t.cast("V", value)
+
+
+async def auto_aiter(
+    iterable: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+) -> "t.AsyncIterator[V]":
+    if hasattr(iterable, "__aiter__"):
+        async for item in t.cast("t.AsyncIterable[V]", iterable):
+            yield item
+    else:
+        for item in t.cast("t.Iterable[V]", iterable):
+            yield item
+
+
+async def auto_to_list(
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+) -> t.List["V"]:
+    return [x async for x in auto_aiter(value)]
diff --git a/lib/python3.11/site-packages/jinja2/bccache.py b/lib/python3.11/site-packages/jinja2/bccache.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0ddf56ef62b03cba6b6c5f9b94d819393f09d38
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/bccache.py
@@ -0,0 +1,406 @@
+"""The optional bytecode cache system. This is useful if you have very
+complex template situations and the compilation of all those templates
+slows down your application too much.
+
+Situations where this is useful are often forking web applications that
+are initialized on the first request.
+"""
+import errno
+import fnmatch
+import marshal
+import os
+import pickle
+import stat
+import sys
+import tempfile
+import typing as t
+from hashlib import sha1
+from io import BytesIO
+from types import CodeType
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .environment import Environment
+
+    class _MemcachedClient(te.Protocol):
+        def get(self, key: str) -> bytes:
+            ...
+
+        def set(self, key: str, value: bytes, timeout: t.Optional[int] = None) -> None:
+            ...
+
+
+bc_version = 5
+# Magic bytes to identify Jinja bytecode cache files. Contains the
+# Python major and minor version to avoid loading incompatible bytecode
+# if a project upgrades its Python version.
+bc_magic = (
+    b"j2"
+    + pickle.dumps(bc_version, 2)
+    + pickle.dumps((sys.version_info[0] << 24) | sys.version_info[1], 2)
+)
+
+
+class Bucket:
+    """Buckets are used to store the bytecode for one template.  It's created
+    and initialized by the bytecode cache and passed to the loading functions.
+
+    The buckets get an internal checksum from the cache assigned and use this
+    to automatically reject outdated cache material.  Individual bytecode
+    cache subclasses don't have to care about cache invalidation.
+    """
+
+    def __init__(self, environment: "Environment", key: str, checksum: str) -> None:
+        self.environment = environment
+        self.key = key
+        self.checksum = checksum
+        self.reset()
+
+    def reset(self) -> None:
+        """Resets the bucket (unloads the bytecode)."""
+        self.code: t.Optional[CodeType] = None
+
+    def load_bytecode(self, f: t.BinaryIO) -> None:
+        """Loads bytecode from a file or file like object."""
+        # make sure the magic header is correct
+        magic = f.read(len(bc_magic))
+        if magic != bc_magic:
+            self.reset()
+            return
+        # the source code of the file changed, we need to reload
+        checksum = pickle.load(f)
+        if self.checksum != checksum:
+            self.reset()
+            return
+        # if marshal_load fails then we need to reload
+        try:
+            self.code = marshal.load(f)
+        except (EOFError, ValueError, TypeError):
+            self.reset()
+            return
+
+    def write_bytecode(self, f: t.IO[bytes]) -> None:
+        """Dump the bytecode into the file or file like object passed."""
+        if self.code is None:
+            raise TypeError("can't write empty bucket")
+        f.write(bc_magic)
+        pickle.dump(self.checksum, f, 2)
+        marshal.dump(self.code, f)
+
+    def bytecode_from_string(self, string: bytes) -> None:
+        """Load bytecode from bytes."""
+        self.load_bytecode(BytesIO(string))
+
+    def bytecode_to_string(self) -> bytes:
+        """Return the bytecode as bytes."""
+        out = BytesIO()
+        self.write_bytecode(out)
+        return out.getvalue()
+
+
+class BytecodeCache:
+    """To implement your own bytecode cache you have to subclass this class
+    and override :meth:`load_bytecode` and :meth:`dump_bytecode`.  Both of
+    these methods are passed a :class:`~jinja2.bccache.Bucket`.
+
+    A very basic bytecode cache that saves the bytecode on the file system::
+
+        from os import path
+
+        class MyCache(BytecodeCache):
+
+            def __init__(self, directory):
+                self.directory = directory
+
+            def load_bytecode(self, bucket):
+                filename = path.join(self.directory, bucket.key)
+                if path.exists(filename):
+                    with open(filename, 'rb') as f:
+                        bucket.load_bytecode(f)
+
+            def dump_bytecode(self, bucket):
+                filename = path.join(self.directory, bucket.key)
+                with open(filename, 'wb') as f:
+                    bucket.write_bytecode(f)
+
+    A more advanced version of a filesystem based bytecode cache is part of
+    Jinja.
+    """
+
+    def load_bytecode(self, bucket: Bucket) -> None:
+        """Subclasses have to override this method to load bytecode into a
+        bucket.  If they are not able to find code in the cache for the
+        bucket, it must not do anything.
+        """
+        raise NotImplementedError()
+
+    def dump_bytecode(self, bucket: Bucket) -> None:
+        """Subclasses have to override this method to write the bytecode
+        from a bucket back to the cache.  If it unable to do so it must not
+        fail silently but raise an exception.
+        """
+        raise NotImplementedError()
+
+    def clear(self) -> None:
+        """Clears the cache.  This method is not used by Jinja but should be
+        implemented to allow applications to clear the bytecode cache used
+        by a particular environment.
+        """
+
+    def get_cache_key(
+        self, name: str, filename: t.Optional[t.Union[str]] = None
+    ) -> str:
+        """Returns the unique hash key for this template name."""
+        hash = sha1(name.encode("utf-8"))
+
+        if filename is not None:
+            hash.update(f"|{filename}".encode())
+
+        return hash.hexdigest()
+
+    def get_source_checksum(self, source: str) -> str:
+        """Returns a checksum for the source."""
+        return sha1(source.encode("utf-8")).hexdigest()
+
+    def get_bucket(
+        self,
+        environment: "Environment",
+        name: str,
+        filename: t.Optional[str],
+        source: str,
+    ) -> Bucket:
+        """Return a cache bucket for the given template.  All arguments are
+        mandatory but filename may be `None`.
+        """
+        key = self.get_cache_key(name, filename)
+        checksum = self.get_source_checksum(source)
+        bucket = Bucket(environment, key, checksum)
+        self.load_bytecode(bucket)
+        return bucket
+
+    def set_bucket(self, bucket: Bucket) -> None:
+        """Put the bucket into the cache."""
+        self.dump_bytecode(bucket)
+
+
+class FileSystemBytecodeCache(BytecodeCache):
+    """A bytecode cache that stores bytecode on the filesystem.  It accepts
+    two arguments: The directory where the cache items are stored and a
+    pattern string that is used to build the filename.
+
+    If no directory is specified a default cache directory is selected.  On
+    Windows the user's temp directory is used, on UNIX systems a directory
+    is created for the user in the system temp directory.
+
+    The pattern can be used to have multiple separate caches operate on the
+    same directory.  The default pattern is ``'__jinja2_%s.cache'``.  ``%s``
+    is replaced with the cache key.
+
+    >>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
+
+    This bytecode cache supports clearing of the cache using the clear method.
+    """
+
+    def __init__(
+        self, directory: t.Optional[str] = None, pattern: str = "__jinja2_%s.cache"
+    ) -> None:
+        if directory is None:
+            directory = self._get_default_cache_dir()
+        self.directory = directory
+        self.pattern = pattern
+
+    def _get_default_cache_dir(self) -> str:
+        def _unsafe_dir() -> "te.NoReturn":
+            raise RuntimeError(
+                "Cannot determine safe temp directory.  You "
+                "need to explicitly provide one."
+            )
+
+        tmpdir = tempfile.gettempdir()
+
+        # On windows the temporary directory is used specific unless
+        # explicitly forced otherwise.  We can just use that.
+        if os.name == "nt":
+            return tmpdir
+        if not hasattr(os, "getuid"):
+            _unsafe_dir()
+
+        dirname = f"_jinja2-cache-{os.getuid()}"
+        actual_dir = os.path.join(tmpdir, dirname)
+
+        try:
+            os.mkdir(actual_dir, stat.S_IRWXU)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+        try:
+            os.chmod(actual_dir, stat.S_IRWXU)
+            actual_dir_stat = os.lstat(actual_dir)
+            if (
+                actual_dir_stat.st_uid != os.getuid()
+                or not stat.S_ISDIR(actual_dir_stat.st_mode)
+                or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU
+            ):
+                _unsafe_dir()
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        actual_dir_stat = os.lstat(actual_dir)
+        if (
+            actual_dir_stat.st_uid != os.getuid()
+            or not stat.S_ISDIR(actual_dir_stat.st_mode)
+            or stat.S_IMODE(actual_dir_stat.st_mode) != stat.S_IRWXU
+        ):
+            _unsafe_dir()
+
+        return actual_dir
+
+    def _get_cache_filename(self, bucket: Bucket) -> str:
+        return os.path.join(self.directory, self.pattern % (bucket.key,))
+
+    def load_bytecode(self, bucket: Bucket) -> None:
+        filename = self._get_cache_filename(bucket)
+
+        # Don't test for existence before opening the file, since the
+        # file could disappear after the test before the open.
+        try:
+            f = open(filename, "rb")
+        except (FileNotFoundError, IsADirectoryError, PermissionError):
+            # PermissionError can occur on Windows when an operation is
+            # in progress, such as calling clear().
+            return
+
+        with f:
+            bucket.load_bytecode(f)
+
+    def dump_bytecode(self, bucket: Bucket) -> None:
+        # Write to a temporary file, then rename to the real name after
+        # writing. This avoids another process reading the file before
+        # it is fully written.
+        name = self._get_cache_filename(bucket)
+        f = tempfile.NamedTemporaryFile(
+            mode="wb",
+            dir=os.path.dirname(name),
+            prefix=os.path.basename(name),
+            suffix=".tmp",
+            delete=False,
+        )
+
+        def remove_silent() -> None:
+            try:
+                os.remove(f.name)
+            except OSError:
+                # Another process may have called clear(). On Windows,
+                # another program may be holding the file open.
+                pass
+
+        try:
+            with f:
+                bucket.write_bytecode(f)
+        except BaseException:
+            remove_silent()
+            raise
+
+        try:
+            os.replace(f.name, name)
+        except OSError:
+            # Another process may have called clear(). On Windows,
+            # another program may be holding the file open.
+            remove_silent()
+        except BaseException:
+            remove_silent()
+            raise
+
+    def clear(self) -> None:
+        # imported lazily here because google app-engine doesn't support
+        # write access on the file system and the function does not exist
+        # normally.
+        from os import remove
+
+        files = fnmatch.filter(os.listdir(self.directory), self.pattern % ("*",))
+        for filename in files:
+            try:
+                remove(os.path.join(self.directory, filename))
+            except OSError:
+                pass
+
+
+class MemcachedBytecodeCache(BytecodeCache):
+    """This class implements a bytecode cache that uses a memcache cache for
+    storing the information.  It does not enforce a specific memcache library
+    (tummy's memcache or cmemcache) but will accept any class that provides
+    the minimal interface required.
+
+    Libraries compatible with this class:
+
+    -   `cachelib <https://github.com/pallets/cachelib>`_
+    -   `python-memcached <https://pypi.org/project/python-memcached/>`_
+
+    (Unfortunately the django cache interface is not compatible because it
+    does not support storing binary data, only text. You can however pass
+    the underlying cache client to the bytecode cache which is available
+    as `django.core.cache.cache._client`.)
+
+    The minimal interface for the client passed to the constructor is this:
+
+    .. class:: MinimalClientInterface
+
+        .. method:: set(key, value[, timeout])
+
+            Stores the bytecode in the cache.  `value` is a string and
+            `timeout` the timeout of the key.  If timeout is not provided
+            a default timeout or no timeout should be assumed, if it's
+            provided it's an integer with the number of seconds the cache
+            item should exist.
+
+        .. method:: get(key)
+
+            Returns the value for the cache key.  If the item does not
+            exist in the cache the return value must be `None`.
+
+    The other arguments to the constructor are the prefix for all keys that
+    is added before the actual cache key and the timeout for the bytecode in
+    the cache system.  We recommend a high (or no) timeout.
+
+    This bytecode cache does not support clearing of used items in the cache.
+    The clear method is a no-operation function.
+
+    .. versionadded:: 2.7
+       Added support for ignoring memcache errors through the
+       `ignore_memcache_errors` parameter.
+    """
+
+    def __init__(
+        self,
+        client: "_MemcachedClient",
+        prefix: str = "jinja2/bytecode/",
+        timeout: t.Optional[int] = None,
+        ignore_memcache_errors: bool = True,
+    ):
+        self.client = client
+        self.prefix = prefix
+        self.timeout = timeout
+        self.ignore_memcache_errors = ignore_memcache_errors
+
+    def load_bytecode(self, bucket: Bucket) -> None:
+        try:
+            code = self.client.get(self.prefix + bucket.key)
+        except Exception:
+            if not self.ignore_memcache_errors:
+                raise
+        else:
+            bucket.bytecode_from_string(code)
+
+    def dump_bytecode(self, bucket: Bucket) -> None:
+        key = self.prefix + bucket.key
+        value = bucket.bytecode_to_string()
+
+        try:
+            if self.timeout is not None:
+                self.client.set(key, value, self.timeout)
+            else:
+                self.client.set(key, value)
+        except Exception:
+            if not self.ignore_memcache_errors:
+                raise
diff --git a/lib/python3.11/site-packages/jinja2/compiler.py b/lib/python3.11/site-packages/jinja2/compiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..3458095f54ede1322eb2ab9e34288da87db54ca1
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/compiler.py
@@ -0,0 +1,1957 @@
+"""Compiles nodes from the parser into Python code."""
+import typing as t
+from contextlib import contextmanager
+from functools import update_wrapper
+from io import StringIO
+from itertools import chain
+from keyword import iskeyword as is_python_keyword
+
+from markupsafe import escape
+from markupsafe import Markup
+
+from . import nodes
+from .exceptions import TemplateAssertionError
+from .idtracking import Symbols
+from .idtracking import VAR_LOAD_ALIAS
+from .idtracking import VAR_LOAD_PARAMETER
+from .idtracking import VAR_LOAD_RESOLVE
+from .idtracking import VAR_LOAD_UNDEFINED
+from .nodes import EvalContext
+from .optimizer import Optimizer
+from .utils import _PassArg
+from .utils import concat
+from .visitor import NodeVisitor
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .environment import Environment
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+
+operators = {
+    "eq": "==",
+    "ne": "!=",
+    "gt": ">",
+    "gteq": ">=",
+    "lt": "<",
+    "lteq": "<=",
+    "in": "in",
+    "notin": "not in",
+}
+
+
+def optimizeconst(f: F) -> F:
+    def new_func(
+        self: "CodeGenerator", node: nodes.Expr, frame: "Frame", **kwargs: t.Any
+    ) -> t.Any:
+        # Only optimize if the frame is not volatile
+        if self.optimizer is not None and not frame.eval_ctx.volatile:
+            new_node = self.optimizer.visit(node, frame.eval_ctx)
+
+            if new_node != node:
+                return self.visit(new_node, frame)
+
+        return f(self, node, frame, **kwargs)
+
+    return update_wrapper(t.cast(F, new_func), f)
+
+
+def _make_binop(op: str) -> t.Callable[["CodeGenerator", nodes.BinExpr, "Frame"], None]:
+    @optimizeconst
+    def visitor(self: "CodeGenerator", node: nodes.BinExpr, frame: Frame) -> None:
+        if (
+            self.environment.sandboxed
+            and op in self.environment.intercepted_binops  # type: ignore
+        ):
+            self.write(f"environment.call_binop(context, {op!r}, ")
+            self.visit(node.left, frame)
+            self.write(", ")
+            self.visit(node.right, frame)
+        else:
+            self.write("(")
+            self.visit(node.left, frame)
+            self.write(f" {op} ")
+            self.visit(node.right, frame)
+
+        self.write(")")
+
+    return visitor
+
+
+def _make_unop(
+    op: str,
+) -> t.Callable[["CodeGenerator", nodes.UnaryExpr, "Frame"], None]:
+    @optimizeconst
+    def visitor(self: "CodeGenerator", node: nodes.UnaryExpr, frame: Frame) -> None:
+        if (
+            self.environment.sandboxed
+            and op in self.environment.intercepted_unops  # type: ignore
+        ):
+            self.write(f"environment.call_unop(context, {op!r}, ")
+            self.visit(node.node, frame)
+        else:
+            self.write("(" + op)
+            self.visit(node.node, frame)
+
+        self.write(")")
+
+    return visitor
+
+
+def generate(
+    node: nodes.Template,
+    environment: "Environment",
+    name: t.Optional[str],
+    filename: t.Optional[str],
+    stream: t.Optional[t.TextIO] = None,
+    defer_init: bool = False,
+    optimized: bool = True,
+) -> t.Optional[str]:
+    """Generate the python source for a node tree."""
+    if not isinstance(node, nodes.Template):
+        raise TypeError("Can't compile non template nodes")
+
+    generator = environment.code_generator_class(
+        environment, name, filename, stream, defer_init, optimized
+    )
+    generator.visit(node)
+
+    if stream is None:
+        return generator.stream.getvalue()  # type: ignore
+
+    return None
+
+
+def has_safe_repr(value: t.Any) -> bool:
+    """Does the node have a safe representation?"""
+    if value is None or value is NotImplemented or value is Ellipsis:
+        return True
+
+    if type(value) in {bool, int, float, complex, range, str, Markup}:
+        return True
+
+    if type(value) in {tuple, list, set, frozenset}:
+        return all(has_safe_repr(v) for v in value)
+
+    if type(value) is dict:
+        return all(has_safe_repr(k) and has_safe_repr(v) for k, v in value.items())
+
+    return False
+
+
+def find_undeclared(
+    nodes: t.Iterable[nodes.Node], names: t.Iterable[str]
+) -> t.Set[str]:
+    """Check if the names passed are accessed undeclared.  The return value
+    is a set of all the undeclared names from the sequence of names found.
+    """
+    visitor = UndeclaredNameVisitor(names)
+    try:
+        for node in nodes:
+            visitor.visit(node)
+    except VisitorExit:
+        pass
+    return visitor.undeclared
+
+
+class MacroRef:
+    def __init__(self, node: t.Union[nodes.Macro, nodes.CallBlock]) -> None:
+        self.node = node
+        self.accesses_caller = False
+        self.accesses_kwargs = False
+        self.accesses_varargs = False
+
+
+class Frame:
+    """Holds compile time information for us."""
+
+    def __init__(
+        self,
+        eval_ctx: EvalContext,
+        parent: t.Optional["Frame"] = None,
+        level: t.Optional[int] = None,
+    ) -> None:
+        self.eval_ctx = eval_ctx
+
+        # the parent of this frame
+        self.parent = parent
+
+        if parent is None:
+            self.symbols = Symbols(level=level)
+
+            # in some dynamic inheritance situations the compiler needs to add
+            # write tests around output statements.
+            self.require_output_check = False
+
+            # inside some tags we are using a buffer rather than yield statements.
+            # this for example affects {% filter %} or {% macro %}.  If a frame
+            # is buffered this variable points to the name of the list used as
+            # buffer.
+            self.buffer: t.Optional[str] = None
+
+            # the name of the block we're in, otherwise None.
+            self.block: t.Optional[str] = None
+
+        else:
+            self.symbols = Symbols(parent.symbols, level=level)
+            self.require_output_check = parent.require_output_check
+            self.buffer = parent.buffer
+            self.block = parent.block
+
+        # a toplevel frame is the root + soft frames such as if conditions.
+        self.toplevel = False
+
+        # the root frame is basically just the outermost frame, so no if
+        # conditions.  This information is used to optimize inheritance
+        # situations.
+        self.rootlevel = False
+
+        # variables set inside of loops and blocks should not affect outer frames,
+        # but they still needs to be kept track of as part of the active context.
+        self.loop_frame = False
+        self.block_frame = False
+
+        # track whether the frame is being used in an if-statement or conditional
+        # expression as it determines which errors should be raised during runtime
+        # or compile time.
+        self.soft_frame = False
+
+    def copy(self) -> "Frame":
+        """Create a copy of the current one."""
+        rv = object.__new__(self.__class__)
+        rv.__dict__.update(self.__dict__)
+        rv.symbols = self.symbols.copy()
+        return rv
+
+    def inner(self, isolated: bool = False) -> "Frame":
+        """Return an inner frame."""
+        if isolated:
+            return Frame(self.eval_ctx, level=self.symbols.level + 1)
+        return Frame(self.eval_ctx, self)
+
+    def soft(self) -> "Frame":
+        """Return a soft frame.  A soft frame may not be modified as
+        standalone thing as it shares the resources with the frame it
+        was created of, but it's not a rootlevel frame any longer.
+
+        This is only used to implement if-statements and conditional
+        expressions.
+        """
+        rv = self.copy()
+        rv.rootlevel = False
+        rv.soft_frame = True
+        return rv
+
+    __copy__ = copy
+
+
+class VisitorExit(RuntimeError):
+    """Exception used by the `UndeclaredNameVisitor` to signal a stop."""
+
+
+class DependencyFinderVisitor(NodeVisitor):
+    """A visitor that collects filter and test calls."""
+
+    def __init__(self) -> None:
+        self.filters: t.Set[str] = set()
+        self.tests: t.Set[str] = set()
+
+    def visit_Filter(self, node: nodes.Filter) -> None:
+        self.generic_visit(node)
+        self.filters.add(node.name)
+
+    def visit_Test(self, node: nodes.Test) -> None:
+        self.generic_visit(node)
+        self.tests.add(node.name)
+
+    def visit_Block(self, node: nodes.Block) -> None:
+        """Stop visiting at blocks."""
+
+
+class UndeclaredNameVisitor(NodeVisitor):
+    """A visitor that checks if a name is accessed without being
+    declared.  This is different from the frame visitor as it will
+    not stop at closure frames.
+    """
+
+    def __init__(self, names: t.Iterable[str]) -> None:
+        self.names = set(names)
+        self.undeclared: t.Set[str] = set()
+
+    def visit_Name(self, node: nodes.Name) -> None:
+        if node.ctx == "load" and node.name in self.names:
+            self.undeclared.add(node.name)
+            if self.undeclared == self.names:
+                raise VisitorExit()
+        else:
+            self.names.discard(node.name)
+
+    def visit_Block(self, node: nodes.Block) -> None:
+        """Stop visiting a blocks."""
+
+
+class CompilerExit(Exception):
+    """Raised if the compiler encountered a situation where it just
+    doesn't make sense to further process the code.  Any block that
+    raises such an exception is not further processed.
+    """
+
+
+class CodeGenerator(NodeVisitor):
+    def __init__(
+        self,
+        environment: "Environment",
+        name: t.Optional[str],
+        filename: t.Optional[str],
+        stream: t.Optional[t.TextIO] = None,
+        defer_init: bool = False,
+        optimized: bool = True,
+    ) -> None:
+        if stream is None:
+            stream = StringIO()
+        self.environment = environment
+        self.name = name
+        self.filename = filename
+        self.stream = stream
+        self.created_block_context = False
+        self.defer_init = defer_init
+        self.optimizer: t.Optional[Optimizer] = None
+
+        if optimized:
+            self.optimizer = Optimizer(environment)
+
+        # aliases for imports
+        self.import_aliases: t.Dict[str, str] = {}
+
+        # a registry for all blocks.  Because blocks are moved out
+        # into the global python scope they are registered here
+        self.blocks: t.Dict[str, nodes.Block] = {}
+
+        # the number of extends statements so far
+        self.extends_so_far = 0
+
+        # some templates have a rootlevel extends.  In this case we
+        # can safely assume that we're a child template and do some
+        # more optimizations.
+        self.has_known_extends = False
+
+        # the current line number
+        self.code_lineno = 1
+
+        # registry of all filters and tests (global, not block local)
+        self.tests: t.Dict[str, str] = {}
+        self.filters: t.Dict[str, str] = {}
+
+        # the debug information
+        self.debug_info: t.List[t.Tuple[int, int]] = []
+        self._write_debug_info: t.Optional[int] = None
+
+        # the number of new lines before the next write()
+        self._new_lines = 0
+
+        # the line number of the last written statement
+        self._last_line = 0
+
+        # true if nothing was written so far.
+        self._first_write = True
+
+        # used by the `temporary_identifier` method to get new
+        # unique, temporary identifier
+        self._last_identifier = 0
+
+        # the current indentation
+        self._indentation = 0
+
+        # Tracks toplevel assignments
+        self._assign_stack: t.List[t.Set[str]] = []
+
+        # Tracks parameter definition blocks
+        self._param_def_block: t.List[t.Set[str]] = []
+
+        # Tracks the current context.
+        self._context_reference_stack = ["context"]
+
+    @property
+    def optimized(self) -> bool:
+        return self.optimizer is not None
+
+    # -- Various compilation helpers
+
+    def fail(self, msg: str, lineno: int) -> "te.NoReturn":
+        """Fail with a :exc:`TemplateAssertionError`."""
+        raise TemplateAssertionError(msg, lineno, self.name, self.filename)
+
+    def temporary_identifier(self) -> str:
+        """Get a new unique identifier."""
+        self._last_identifier += 1
+        return f"t_{self._last_identifier}"
+
+    def buffer(self, frame: Frame) -> None:
+        """Enable buffering for the frame from that point onwards."""
+        frame.buffer = self.temporary_identifier()
+        self.writeline(f"{frame.buffer} = []")
+
+    def return_buffer_contents(
+        self, frame: Frame, force_unescaped: bool = False
+    ) -> None:
+        """Return the buffer contents of the frame."""
+        if not force_unescaped:
+            if frame.eval_ctx.volatile:
+                self.writeline("if context.eval_ctx.autoescape:")
+                self.indent()
+                self.writeline(f"return Markup(concat({frame.buffer}))")
+                self.outdent()
+                self.writeline("else:")
+                self.indent()
+                self.writeline(f"return concat({frame.buffer})")
+                self.outdent()
+                return
+            elif frame.eval_ctx.autoescape:
+                self.writeline(f"return Markup(concat({frame.buffer}))")
+                return
+        self.writeline(f"return concat({frame.buffer})")
+
+    def indent(self) -> None:
+        """Indent by one."""
+        self._indentation += 1
+
+    def outdent(self, step: int = 1) -> None:
+        """Outdent by step."""
+        self._indentation -= step
+
+    def start_write(self, frame: Frame, node: t.Optional[nodes.Node] = None) -> None:
+        """Yield or write into the frame buffer."""
+        if frame.buffer is None:
+            self.writeline("yield ", node)
+        else:
+            self.writeline(f"{frame.buffer}.append(", node)
+
+    def end_write(self, frame: Frame) -> None:
+        """End the writing process started by `start_write`."""
+        if frame.buffer is not None:
+            self.write(")")
+
+    def simple_write(
+        self, s: str, frame: Frame, node: t.Optional[nodes.Node] = None
+    ) -> None:
+        """Simple shortcut for start_write + write + end_write."""
+        self.start_write(frame, node)
+        self.write(s)
+        self.end_write(frame)
+
+    def blockvisit(self, nodes: t.Iterable[nodes.Node], frame: Frame) -> None:
+        """Visit a list of nodes as block in a frame.  If the current frame
+        is no buffer a dummy ``if 0: yield None`` is written automatically.
+        """
+        try:
+            self.writeline("pass")
+            for node in nodes:
+                self.visit(node, frame)
+        except CompilerExit:
+            pass
+
+    def write(self, x: str) -> None:
+        """Write a string into the output stream."""
+        if self._new_lines:
+            if not self._first_write:
+                self.stream.write("\n" * self._new_lines)
+                self.code_lineno += self._new_lines
+                if self._write_debug_info is not None:
+                    self.debug_info.append((self._write_debug_info, self.code_lineno))
+                    self._write_debug_info = None
+            self._first_write = False
+            self.stream.write("    " * self._indentation)
+            self._new_lines = 0
+        self.stream.write(x)
+
+    def writeline(
+        self, x: str, node: t.Optional[nodes.Node] = None, extra: int = 0
+    ) -> None:
+        """Combination of newline and write."""
+        self.newline(node, extra)
+        self.write(x)
+
+    def newline(self, node: t.Optional[nodes.Node] = None, extra: int = 0) -> None:
+        """Add one or more newlines before the next write."""
+        self._new_lines = max(self._new_lines, 1 + extra)
+        if node is not None and node.lineno != self._last_line:
+            self._write_debug_info = node.lineno
+            self._last_line = node.lineno
+
+    def signature(
+        self,
+        node: t.Union[nodes.Call, nodes.Filter, nodes.Test],
+        frame: Frame,
+        extra_kwargs: t.Optional[t.Mapping[str, t.Any]] = None,
+    ) -> None:
+        """Writes a function call to the stream for the current node.
+        A leading comma is added automatically.  The extra keyword
+        arguments may not include python keywords otherwise a syntax
+        error could occur.  The extra keyword arguments should be given
+        as python dict.
+        """
+        # if any of the given keyword arguments is a python keyword
+        # we have to make sure that no invalid call is created.
+        kwarg_workaround = any(
+            is_python_keyword(t.cast(str, k))
+            for k in chain((x.key for x in node.kwargs), extra_kwargs or ())
+        )
+
+        for arg in node.args:
+            self.write(", ")
+            self.visit(arg, frame)
+
+        if not kwarg_workaround:
+            for kwarg in node.kwargs:
+                self.write(", ")
+                self.visit(kwarg, frame)
+            if extra_kwargs is not None:
+                for key, value in extra_kwargs.items():
+                    self.write(f", {key}={value}")
+        if node.dyn_args:
+            self.write(", *")
+            self.visit(node.dyn_args, frame)
+
+        if kwarg_workaround:
+            if node.dyn_kwargs is not None:
+                self.write(", **dict({")
+            else:
+                self.write(", **{")
+            for kwarg in node.kwargs:
+                self.write(f"{kwarg.key!r}: ")
+                self.visit(kwarg.value, frame)
+                self.write(", ")
+            if extra_kwargs is not None:
+                for key, value in extra_kwargs.items():
+                    self.write(f"{key!r}: {value}, ")
+            if node.dyn_kwargs is not None:
+                self.write("}, **")
+                self.visit(node.dyn_kwargs, frame)
+                self.write(")")
+            else:
+                self.write("}")
+
+        elif node.dyn_kwargs is not None:
+            self.write(", **")
+            self.visit(node.dyn_kwargs, frame)
+
+    def pull_dependencies(self, nodes: t.Iterable[nodes.Node]) -> None:
+        """Find all filter and test names used in the template and
+        assign them to variables in the compiled namespace. Checking
+        that the names are registered with the environment is done when
+        compiling the Filter and Test nodes. If the node is in an If or
+        CondExpr node, the check is done at runtime instead.
+
+        .. versionchanged:: 3.0
+            Filters and tests in If and CondExpr nodes are checked at
+            runtime instead of compile time.
+        """
+        visitor = DependencyFinderVisitor()
+
+        for node in nodes:
+            visitor.visit(node)
+
+        for id_map, names, dependency in (self.filters, visitor.filters, "filters"), (
+            self.tests,
+            visitor.tests,
+            "tests",
+        ):
+            for name in sorted(names):
+                if name not in id_map:
+                    id_map[name] = self.temporary_identifier()
+
+                # add check during runtime that dependencies used inside of executed
+                # blocks are defined, as this step may be skipped during compile time
+                self.writeline("try:")
+                self.indent()
+                self.writeline(f"{id_map[name]} = environment.{dependency}[{name!r}]")
+                self.outdent()
+                self.writeline("except KeyError:")
+                self.indent()
+                self.writeline("@internalcode")
+                self.writeline(f"def {id_map[name]}(*unused):")
+                self.indent()
+                self.writeline(
+                    f'raise TemplateRuntimeError("No {dependency[:-1]}'
+                    f' named {name!r} found.")'
+                )
+                self.outdent()
+                self.outdent()
+
+    def enter_frame(self, frame: Frame) -> None:
+        undefs = []
+        for target, (action, param) in frame.symbols.loads.items():
+            if action == VAR_LOAD_PARAMETER:
+                pass
+            elif action == VAR_LOAD_RESOLVE:
+                self.writeline(f"{target} = {self.get_resolve_func()}({param!r})")
+            elif action == VAR_LOAD_ALIAS:
+                self.writeline(f"{target} = {param}")
+            elif action == VAR_LOAD_UNDEFINED:
+                undefs.append(target)
+            else:
+                raise NotImplementedError("unknown load instruction")
+        if undefs:
+            self.writeline(f"{' = '.join(undefs)} = missing")
+
+    def leave_frame(self, frame: Frame, with_python_scope: bool = False) -> None:
+        if not with_python_scope:
+            undefs = []
+            for target in frame.symbols.loads:
+                undefs.append(target)
+            if undefs:
+                self.writeline(f"{' = '.join(undefs)} = missing")
+
+    def choose_async(self, async_value: str = "async ", sync_value: str = "") -> str:
+        return async_value if self.environment.is_async else sync_value
+
+    def func(self, name: str) -> str:
+        return f"{self.choose_async()}def {name}"
+
+    def macro_body(
+        self, node: t.Union[nodes.Macro, nodes.CallBlock], frame: Frame
+    ) -> t.Tuple[Frame, MacroRef]:
+        """Dump the function def of a macro or call block."""
+        frame = frame.inner()
+        frame.symbols.analyze_node(node)
+        macro_ref = MacroRef(node)
+
+        explicit_caller = None
+        skip_special_params = set()
+        args = []
+
+        for idx, arg in enumerate(node.args):
+            if arg.name == "caller":
+                explicit_caller = idx
+            if arg.name in ("kwargs", "varargs"):
+                skip_special_params.add(arg.name)
+            args.append(frame.symbols.ref(arg.name))
+
+        undeclared = find_undeclared(node.body, ("caller", "kwargs", "varargs"))
+
+        if "caller" in undeclared:
+            # In older Jinja versions there was a bug that allowed caller
+            # to retain the special behavior even if it was mentioned in
+            # the argument list.  However thankfully this was only really
+            # working if it was the last argument.  So we are explicitly
+            # checking this now and error out if it is anywhere else in
+            # the argument list.
+            if explicit_caller is not None:
+                try:
+                    node.defaults[explicit_caller - len(node.args)]
+                except IndexError:
+                    self.fail(
+                        "When defining macros or call blocks the "
+                        'special "caller" argument must be omitted '
+                        "or be given a default.",
+                        node.lineno,
+                    )
+            else:
+                args.append(frame.symbols.declare_parameter("caller"))
+            macro_ref.accesses_caller = True
+        if "kwargs" in undeclared and "kwargs" not in skip_special_params:
+            args.append(frame.symbols.declare_parameter("kwargs"))
+            macro_ref.accesses_kwargs = True
+        if "varargs" in undeclared and "varargs" not in skip_special_params:
+            args.append(frame.symbols.declare_parameter("varargs"))
+            macro_ref.accesses_varargs = True
+
+        # macros are delayed, they never require output checks
+        frame.require_output_check = False
+        frame.symbols.analyze_node(node)
+        self.writeline(f"{self.func('macro')}({', '.join(args)}):", node)
+        self.indent()
+
+        self.buffer(frame)
+        self.enter_frame(frame)
+
+        self.push_parameter_definitions(frame)
+        for idx, arg in enumerate(node.args):
+            ref = frame.symbols.ref(arg.name)
+            self.writeline(f"if {ref} is missing:")
+            self.indent()
+            try:
+                default = node.defaults[idx - len(node.args)]
+            except IndexError:
+                self.writeline(
+                    f'{ref} = undefined("parameter {arg.name!r} was not provided",'
+                    f" name={arg.name!r})"
+                )
+            else:
+                self.writeline(f"{ref} = ")
+                self.visit(default, frame)
+            self.mark_parameter_stored(ref)
+            self.outdent()
+        self.pop_parameter_definitions()
+
+        self.blockvisit(node.body, frame)
+        self.return_buffer_contents(frame, force_unescaped=True)
+        self.leave_frame(frame, with_python_scope=True)
+        self.outdent()
+
+        return frame, macro_ref
+
+    def macro_def(self, macro_ref: MacroRef, frame: Frame) -> None:
+        """Dump the macro definition for the def created by macro_body."""
+        arg_tuple = ", ".join(repr(x.name) for x in macro_ref.node.args)
+        name = getattr(macro_ref.node, "name", None)
+        if len(macro_ref.node.args) == 1:
+            arg_tuple += ","
+        self.write(
+            f"Macro(environment, macro, {name!r}, ({arg_tuple}),"
+            f" {macro_ref.accesses_kwargs!r}, {macro_ref.accesses_varargs!r},"
+            f" {macro_ref.accesses_caller!r}, context.eval_ctx.autoescape)"
+        )
+
+    def position(self, node: nodes.Node) -> str:
+        """Return a human readable position for the node."""
+        rv = f"line {node.lineno}"
+        if self.name is not None:
+            rv = f"{rv} in {self.name!r}"
+        return rv
+
+    def dump_local_context(self, frame: Frame) -> str:
+        items_kv = ", ".join(
+            f"{name!r}: {target}"
+            for name, target in frame.symbols.dump_stores().items()
+        )
+        return f"{{{items_kv}}}"
+
+    def write_commons(self) -> None:
+        """Writes a common preamble that is used by root and block functions.
+        Primarily this sets up common local helpers and enforces a generator
+        through a dead branch.
+        """
+        self.writeline("resolve = context.resolve_or_missing")
+        self.writeline("undefined = environment.undefined")
+        self.writeline("concat = environment.concat")
+        # always use the standard Undefined class for the implicit else of
+        # conditional expressions
+        self.writeline("cond_expr_undefined = Undefined")
+        self.writeline("if 0: yield None")
+
+    def push_parameter_definitions(self, frame: Frame) -> None:
+        """Pushes all parameter targets from the given frame into a local
+        stack that permits tracking of yet to be assigned parameters.  In
+        particular this enables the optimization from `visit_Name` to skip
+        undefined expressions for parameters in macros as macros can reference
+        otherwise unbound parameters.
+        """
+        self._param_def_block.append(frame.symbols.dump_param_targets())
+
+    def pop_parameter_definitions(self) -> None:
+        """Pops the current parameter definitions set."""
+        self._param_def_block.pop()
+
+    def mark_parameter_stored(self, target: str) -> None:
+        """Marks a parameter in the current parameter definitions as stored.
+        This will skip the enforced undefined checks.
+        """
+        if self._param_def_block:
+            self._param_def_block[-1].discard(target)
+
+    def push_context_reference(self, target: str) -> None:
+        self._context_reference_stack.append(target)
+
+    def pop_context_reference(self) -> None:
+        self._context_reference_stack.pop()
+
+    def get_context_ref(self) -> str:
+        return self._context_reference_stack[-1]
+
+    def get_resolve_func(self) -> str:
+        target = self._context_reference_stack[-1]
+        if target == "context":
+            return "resolve"
+        return f"{target}.resolve"
+
+    def derive_context(self, frame: Frame) -> str:
+        return f"{self.get_context_ref()}.derived({self.dump_local_context(frame)})"
+
+    def parameter_is_undeclared(self, target: str) -> bool:
+        """Checks if a given target is an undeclared parameter."""
+        if not self._param_def_block:
+            return False
+        return target in self._param_def_block[-1]
+
+    def push_assign_tracking(self) -> None:
+        """Pushes a new layer for assignment tracking."""
+        self._assign_stack.append(set())
+
+    def pop_assign_tracking(self, frame: Frame) -> None:
+        """Pops the topmost level for assignment tracking and updates the
+        context variables if necessary.
+        """
+        vars = self._assign_stack.pop()
+        if (
+            not frame.block_frame
+            and not frame.loop_frame
+            and not frame.toplevel
+            or not vars
+        ):
+            return
+        public_names = [x for x in vars if x[:1] != "_"]
+        if len(vars) == 1:
+            name = next(iter(vars))
+            ref = frame.symbols.ref(name)
+            if frame.loop_frame:
+                self.writeline(f"_loop_vars[{name!r}] = {ref}")
+                return
+            if frame.block_frame:
+                self.writeline(f"_block_vars[{name!r}] = {ref}")
+                return
+            self.writeline(f"context.vars[{name!r}] = {ref}")
+        else:
+            if frame.loop_frame:
+                self.writeline("_loop_vars.update({")
+            elif frame.block_frame:
+                self.writeline("_block_vars.update({")
+            else:
+                self.writeline("context.vars.update({")
+            for idx, name in enumerate(vars):
+                if idx:
+                    self.write(", ")
+                ref = frame.symbols.ref(name)
+                self.write(f"{name!r}: {ref}")
+            self.write("})")
+        if not frame.block_frame and not frame.loop_frame and public_names:
+            if len(public_names) == 1:
+                self.writeline(f"context.exported_vars.add({public_names[0]!r})")
+            else:
+                names_str = ", ".join(map(repr, public_names))
+                self.writeline(f"context.exported_vars.update(({names_str}))")
+
+    # -- Statement Visitors
+
+    def visit_Template(
+        self, node: nodes.Template, frame: t.Optional[Frame] = None
+    ) -> None:
+        assert frame is None, "no root frame allowed"
+        eval_ctx = EvalContext(self.environment, self.name)
+
+        from .runtime import exported, async_exported
+
+        if self.environment.is_async:
+            exported_names = sorted(exported + async_exported)
+        else:
+            exported_names = sorted(exported)
+
+        self.writeline("from jinja2.runtime import " + ", ".join(exported_names))
+
+        # if we want a deferred initialization we cannot move the
+        # environment into a local name
+        envenv = "" if self.defer_init else ", environment=environment"
+
+        # do we have an extends tag at all?  If not, we can save some
+        # overhead by just not processing any inheritance code.
+        have_extends = node.find(nodes.Extends) is not None
+
+        # find all blocks
+        for block in node.find_all(nodes.Block):
+            if block.name in self.blocks:
+                self.fail(f"block {block.name!r} defined twice", block.lineno)
+            self.blocks[block.name] = block
+
+        # find all imports and import them
+        for import_ in node.find_all(nodes.ImportedName):
+            if import_.importname not in self.import_aliases:
+                imp = import_.importname
+                self.import_aliases[imp] = alias = self.temporary_identifier()
+                if "." in imp:
+                    module, obj = imp.rsplit(".", 1)
+                    self.writeline(f"from {module} import {obj} as {alias}")
+                else:
+                    self.writeline(f"import {imp} as {alias}")
+
+        # add the load name
+        self.writeline(f"name = {self.name!r}")
+
+        # generate the root render function.
+        self.writeline(
+            f"{self.func('root')}(context, missing=missing{envenv}):", extra=1
+        )
+        self.indent()
+        self.write_commons()
+
+        # process the root
+        frame = Frame(eval_ctx)
+        if "self" in find_undeclared(node.body, ("self",)):
+            ref = frame.symbols.declare_parameter("self")
+            self.writeline(f"{ref} = TemplateReference(context)")
+        frame.symbols.analyze_node(node)
+        frame.toplevel = frame.rootlevel = True
+        frame.require_output_check = have_extends and not self.has_known_extends
+        if have_extends:
+            self.writeline("parent_template = None")
+        self.enter_frame(frame)
+        self.pull_dependencies(node.body)
+        self.blockvisit(node.body, frame)
+        self.leave_frame(frame, with_python_scope=True)
+        self.outdent()
+
+        # make sure that the parent root is called.
+        if have_extends:
+            if not self.has_known_extends:
+                self.indent()
+                self.writeline("if parent_template is not None:")
+            self.indent()
+            if not self.environment.is_async:
+                self.writeline("yield from parent_template.root_render_func(context)")
+            else:
+                self.writeline(
+                    "async for event in parent_template.root_render_func(context):"
+                )
+                self.indent()
+                self.writeline("yield event")
+                self.outdent()
+            self.outdent(1 + (not self.has_known_extends))
+
+        # at this point we now have the blocks collected and can visit them too.
+        for name, block in self.blocks.items():
+            self.writeline(
+                f"{self.func('block_' + name)}(context, missing=missing{envenv}):",
+                block,
+                1,
+            )
+            self.indent()
+            self.write_commons()
+            # It's important that we do not make this frame a child of the
+            # toplevel template.  This would cause a variety of
+            # interesting issues with identifier tracking.
+            block_frame = Frame(eval_ctx)
+            block_frame.block_frame = True
+            undeclared = find_undeclared(block.body, ("self", "super"))
+            if "self" in undeclared:
+                ref = block_frame.symbols.declare_parameter("self")
+                self.writeline(f"{ref} = TemplateReference(context)")
+            if "super" in undeclared:
+                ref = block_frame.symbols.declare_parameter("super")
+                self.writeline(f"{ref} = context.super({name!r}, block_{name})")
+            block_frame.symbols.analyze_node(block)
+            block_frame.block = name
+            self.writeline("_block_vars = {}")
+            self.enter_frame(block_frame)
+            self.pull_dependencies(block.body)
+            self.blockvisit(block.body, block_frame)
+            self.leave_frame(block_frame, with_python_scope=True)
+            self.outdent()
+
+        blocks_kv_str = ", ".join(f"{x!r}: block_{x}" for x in self.blocks)
+        self.writeline(f"blocks = {{{blocks_kv_str}}}", extra=1)
+        debug_kv_str = "&".join(f"{k}={v}" for k, v in self.debug_info)
+        self.writeline(f"debug_info = {debug_kv_str!r}")
+
+    def visit_Block(self, node: nodes.Block, frame: Frame) -> None:
+        """Call a block and register it for the template."""
+        level = 0
+        if frame.toplevel:
+            # if we know that we are a child template, there is no need to
+            # check if we are one
+            if self.has_known_extends:
+                return
+            if self.extends_so_far > 0:
+                self.writeline("if parent_template is None:")
+                self.indent()
+                level += 1
+
+        if node.scoped:
+            context = self.derive_context(frame)
+        else:
+            context = self.get_context_ref()
+
+        if node.required:
+            self.writeline(f"if len(context.blocks[{node.name!r}]) <= 1:", node)
+            self.indent()
+            self.writeline(
+                f'raise TemplateRuntimeError("Required block {node.name!r} not found")',
+                node,
+            )
+            self.outdent()
+
+        if not self.environment.is_async and frame.buffer is None:
+            self.writeline(
+                f"yield from context.blocks[{node.name!r}][0]({context})", node
+            )
+        else:
+            self.writeline(
+                f"{self.choose_async()}for event in"
+                f" context.blocks[{node.name!r}][0]({context}):",
+                node,
+            )
+            self.indent()
+            self.simple_write("event", frame)
+            self.outdent()
+
+        self.outdent(level)
+
+    def visit_Extends(self, node: nodes.Extends, frame: Frame) -> None:
+        """Calls the extender."""
+        if not frame.toplevel:
+            self.fail("cannot use extend from a non top-level scope", node.lineno)
+
+        # if the number of extends statements in general is zero so
+        # far, we don't have to add a check if something extended
+        # the template before this one.
+        if self.extends_so_far > 0:
+
+            # if we have a known extends we just add a template runtime
+            # error into the generated code.  We could catch that at compile
+            # time too, but i welcome it not to confuse users by throwing the
+            # same error at different times just "because we can".
+            if not self.has_known_extends:
+                self.writeline("if parent_template is not None:")
+                self.indent()
+            self.writeline('raise TemplateRuntimeError("extended multiple times")')
+
+            # if we have a known extends already we don't need that code here
+            # as we know that the template execution will end here.
+            if self.has_known_extends:
+                raise CompilerExit()
+            else:
+                self.outdent()
+
+        self.writeline("parent_template = environment.get_template(", node)
+        self.visit(node.template, frame)
+        self.write(f", {self.name!r})")
+        self.writeline("for name, parent_block in parent_template.blocks.items():")
+        self.indent()
+        self.writeline("context.blocks.setdefault(name, []).append(parent_block)")
+        self.outdent()
+
+        # if this extends statement was in the root level we can take
+        # advantage of that information and simplify the generated code
+        # in the top level from this point onwards
+        if frame.rootlevel:
+            self.has_known_extends = True
+
+        # and now we have one more
+        self.extends_so_far += 1
+
+    def visit_Include(self, node: nodes.Include, frame: Frame) -> None:
+        """Handles includes."""
+        if node.ignore_missing:
+            self.writeline("try:")
+            self.indent()
+
+        func_name = "get_or_select_template"
+        if isinstance(node.template, nodes.Const):
+            if isinstance(node.template.value, str):
+                func_name = "get_template"
+            elif isinstance(node.template.value, (tuple, list)):
+                func_name = "select_template"
+        elif isinstance(node.template, (nodes.Tuple, nodes.List)):
+            func_name = "select_template"
+
+        self.writeline(f"template = environment.{func_name}(", node)
+        self.visit(node.template, frame)
+        self.write(f", {self.name!r})")
+        if node.ignore_missing:
+            self.outdent()
+            self.writeline("except TemplateNotFound:")
+            self.indent()
+            self.writeline("pass")
+            self.outdent()
+            self.writeline("else:")
+            self.indent()
+
+        skip_event_yield = False
+        if node.with_context:
+            self.writeline(
+                f"{self.choose_async()}for event in template.root_render_func("
+                "template.new_context(context.get_all(), True,"
+                f" {self.dump_local_context(frame)})):"
+            )
+        elif self.environment.is_async:
+            self.writeline(
+                "for event in (await template._get_default_module_async())"
+                "._body_stream:"
+            )
+        else:
+            self.writeline("yield from template._get_default_module()._body_stream")
+            skip_event_yield = True
+
+        if not skip_event_yield:
+            self.indent()
+            self.simple_write("event", frame)
+            self.outdent()
+
+        if node.ignore_missing:
+            self.outdent()
+
+    def _import_common(
+        self, node: t.Union[nodes.Import, nodes.FromImport], frame: Frame
+    ) -> None:
+        self.write(f"{self.choose_async('await ')}environment.get_template(")
+        self.visit(node.template, frame)
+        self.write(f", {self.name!r}).")
+
+        if node.with_context:
+            f_name = f"make_module{self.choose_async('_async')}"
+            self.write(
+                f"{f_name}(context.get_all(), True, {self.dump_local_context(frame)})"
+            )
+        else:
+            self.write(f"_get_default_module{self.choose_async('_async')}(context)")
+
+    def visit_Import(self, node: nodes.Import, frame: Frame) -> None:
+        """Visit regular imports."""
+        self.writeline(f"{frame.symbols.ref(node.target)} = ", node)
+        if frame.toplevel:
+            self.write(f"context.vars[{node.target!r}] = ")
+
+        self._import_common(node, frame)
+
+        if frame.toplevel and not node.target.startswith("_"):
+            self.writeline(f"context.exported_vars.discard({node.target!r})")
+
+    def visit_FromImport(self, node: nodes.FromImport, frame: Frame) -> None:
+        """Visit named imports."""
+        self.newline(node)
+        self.write("included_template = ")
+        self._import_common(node, frame)
+        var_names = []
+        discarded_names = []
+        for name in node.names:
+            if isinstance(name, tuple):
+                name, alias = name
+            else:
+                alias = name
+            self.writeline(
+                f"{frame.symbols.ref(alias)} ="
+                f" getattr(included_template, {name!r}, missing)"
+            )
+            self.writeline(f"if {frame.symbols.ref(alias)} is missing:")
+            self.indent()
+            message = (
+                "the template {included_template.__name__!r}"
+                f" (imported on {self.position(node)})"
+                f" does not export the requested name {name!r}"
+            )
+            self.writeline(
+                f"{frame.symbols.ref(alias)} = undefined(f{message!r}, name={name!r})"
+            )
+            self.outdent()
+            if frame.toplevel:
+                var_names.append(alias)
+                if not alias.startswith("_"):
+                    discarded_names.append(alias)
+
+        if var_names:
+            if len(var_names) == 1:
+                name = var_names[0]
+                self.writeline(f"context.vars[{name!r}] = {frame.symbols.ref(name)}")
+            else:
+                names_kv = ", ".join(
+                    f"{name!r}: {frame.symbols.ref(name)}" for name in var_names
+                )
+                self.writeline(f"context.vars.update({{{names_kv}}})")
+        if discarded_names:
+            if len(discarded_names) == 1:
+                self.writeline(f"context.exported_vars.discard({discarded_names[0]!r})")
+            else:
+                names_str = ", ".join(map(repr, discarded_names))
+                self.writeline(
+                    f"context.exported_vars.difference_update(({names_str}))"
+                )
+
+    def visit_For(self, node: nodes.For, frame: Frame) -> None:
+        loop_frame = frame.inner()
+        loop_frame.loop_frame = True
+        test_frame = frame.inner()
+        else_frame = frame.inner()
+
+        # try to figure out if we have an extended loop.  An extended loop
+        # is necessary if the loop is in recursive mode if the special loop
+        # variable is accessed in the body if the body is a scoped block.
+        extended_loop = (
+            node.recursive
+            or "loop"
+            in find_undeclared(node.iter_child_nodes(only=("body",)), ("loop",))
+            or any(block.scoped for block in node.find_all(nodes.Block))
+        )
+
+        loop_ref = None
+        if extended_loop:
+            loop_ref = loop_frame.symbols.declare_parameter("loop")
+
+        loop_frame.symbols.analyze_node(node, for_branch="body")
+        if node.else_:
+            else_frame.symbols.analyze_node(node, for_branch="else")
+
+        if node.test:
+            loop_filter_func = self.temporary_identifier()
+            test_frame.symbols.analyze_node(node, for_branch="test")
+            self.writeline(f"{self.func(loop_filter_func)}(fiter):", node.test)
+            self.indent()
+            self.enter_frame(test_frame)
+            self.writeline(self.choose_async("async for ", "for "))
+            self.visit(node.target, loop_frame)
+            self.write(" in ")
+            self.write(self.choose_async("auto_aiter(fiter)", "fiter"))
+            self.write(":")
+            self.indent()
+            self.writeline("if ", node.test)
+            self.visit(node.test, test_frame)
+            self.write(":")
+            self.indent()
+            self.writeline("yield ")
+            self.visit(node.target, loop_frame)
+            self.outdent(3)
+            self.leave_frame(test_frame, with_python_scope=True)
+
+        # if we don't have an recursive loop we have to find the shadowed
+        # variables at that point.  Because loops can be nested but the loop
+        # variable is a special one we have to enforce aliasing for it.
+        if node.recursive:
+            self.writeline(
+                f"{self.func('loop')}(reciter, loop_render_func, depth=0):", node
+            )
+            self.indent()
+            self.buffer(loop_frame)
+
+            # Use the same buffer for the else frame
+            else_frame.buffer = loop_frame.buffer
+
+        # make sure the loop variable is a special one and raise a template
+        # assertion error if a loop tries to write to loop
+        if extended_loop:
+            self.writeline(f"{loop_ref} = missing")
+
+        for name in node.find_all(nodes.Name):
+            if name.ctx == "store" and name.name == "loop":
+                self.fail(
+                    "Can't assign to special loop variable in for-loop target",
+                    name.lineno,
+                )
+
+        if node.else_:
+            iteration_indicator = self.temporary_identifier()
+            self.writeline(f"{iteration_indicator} = 1")
+
+        self.writeline(self.choose_async("async for ", "for "), node)
+        self.visit(node.target, loop_frame)
+        if extended_loop:
+            self.write(f", {loop_ref} in {self.choose_async('Async')}LoopContext(")
+        else:
+            self.write(" in ")
+
+        if node.test:
+            self.write(f"{loop_filter_func}(")
+        if node.recursive:
+            self.write("reciter")
+        else:
+            if self.environment.is_async and not extended_loop:
+                self.write("auto_aiter(")
+            self.visit(node.iter, frame)
+            if self.environment.is_async and not extended_loop:
+                self.write(")")
+        if node.test:
+            self.write(")")
+
+        if node.recursive:
+            self.write(", undefined, loop_render_func, depth):")
+        else:
+            self.write(", undefined):" if extended_loop else ":")
+
+        self.indent()
+        self.enter_frame(loop_frame)
+
+        self.writeline("_loop_vars = {}")
+        self.blockvisit(node.body, loop_frame)
+        if node.else_:
+            self.writeline(f"{iteration_indicator} = 0")
+        self.outdent()
+        self.leave_frame(
+            loop_frame, with_python_scope=node.recursive and not node.else_
+        )
+
+        if node.else_:
+            self.writeline(f"if {iteration_indicator}:")
+            self.indent()
+            self.enter_frame(else_frame)
+            self.blockvisit(node.else_, else_frame)
+            self.leave_frame(else_frame)
+            self.outdent()
+
+        # if the node was recursive we have to return the buffer contents
+        # and start the iteration code
+        if node.recursive:
+            self.return_buffer_contents(loop_frame)
+            self.outdent()
+            self.start_write(frame, node)
+            self.write(f"{self.choose_async('await ')}loop(")
+            if self.environment.is_async:
+                self.write("auto_aiter(")
+            self.visit(node.iter, frame)
+            if self.environment.is_async:
+                self.write(")")
+            self.write(", loop)")
+            self.end_write(frame)
+
+        # at the end of the iteration, clear any assignments made in the
+        # loop from the top level
+        if self._assign_stack:
+            self._assign_stack[-1].difference_update(loop_frame.symbols.stores)
+
+    def visit_If(self, node: nodes.If, frame: Frame) -> None:
+        if_frame = frame.soft()
+        self.writeline("if ", node)
+        self.visit(node.test, if_frame)
+        self.write(":")
+        self.indent()
+        self.blockvisit(node.body, if_frame)
+        self.outdent()
+        for elif_ in node.elif_:
+            self.writeline("elif ", elif_)
+            self.visit(elif_.test, if_frame)
+            self.write(":")
+            self.indent()
+            self.blockvisit(elif_.body, if_frame)
+            self.outdent()
+        if node.else_:
+            self.writeline("else:")
+            self.indent()
+            self.blockvisit(node.else_, if_frame)
+            self.outdent()
+
+    def visit_Macro(self, node: nodes.Macro, frame: Frame) -> None:
+        macro_frame, macro_ref = self.macro_body(node, frame)
+        self.newline()
+        if frame.toplevel:
+            if not node.name.startswith("_"):
+                self.write(f"context.exported_vars.add({node.name!r})")
+            self.writeline(f"context.vars[{node.name!r}] = ")
+        self.write(f"{frame.symbols.ref(node.name)} = ")
+        self.macro_def(macro_ref, macro_frame)
+
+    def visit_CallBlock(self, node: nodes.CallBlock, frame: Frame) -> None:
+        call_frame, macro_ref = self.macro_body(node, frame)
+        self.writeline("caller = ")
+        self.macro_def(macro_ref, call_frame)
+        self.start_write(frame, node)
+        self.visit_Call(node.call, frame, forward_caller=True)
+        self.end_write(frame)
+
+    def visit_FilterBlock(self, node: nodes.FilterBlock, frame: Frame) -> None:
+        filter_frame = frame.inner()
+        filter_frame.symbols.analyze_node(node)
+        self.enter_frame(filter_frame)
+        self.buffer(filter_frame)
+        self.blockvisit(node.body, filter_frame)
+        self.start_write(frame, node)
+        self.visit_Filter(node.filter, filter_frame)
+        self.end_write(frame)
+        self.leave_frame(filter_frame)
+
+    def visit_With(self, node: nodes.With, frame: Frame) -> None:
+        with_frame = frame.inner()
+        with_frame.symbols.analyze_node(node)
+        self.enter_frame(with_frame)
+        for target, expr in zip(node.targets, node.values):
+            self.newline()
+            self.visit(target, with_frame)
+            self.write(" = ")
+            self.visit(expr, frame)
+        self.blockvisit(node.body, with_frame)
+        self.leave_frame(with_frame)
+
+    def visit_ExprStmt(self, node: nodes.ExprStmt, frame: Frame) -> None:
+        self.newline(node)
+        self.visit(node.node, frame)
+
+    class _FinalizeInfo(t.NamedTuple):
+        const: t.Optional[t.Callable[..., str]]
+        src: t.Optional[str]
+
+    @staticmethod
+    def _default_finalize(value: t.Any) -> t.Any:
+        """The default finalize function if the environment isn't
+        configured with one. Or, if the environment has one, this is
+        called on that function's output for constants.
+        """
+        return str(value)
+
+    _finalize: t.Optional[_FinalizeInfo] = None
+
+    def _make_finalize(self) -> _FinalizeInfo:
+        """Build the finalize function to be used on constants and at
+        runtime. Cached so it's only created once for all output nodes.
+
+        Returns a ``namedtuple`` with the following attributes:
+
+        ``const``
+            A function to finalize constant data at compile time.
+
+        ``src``
+            Source code to output around nodes to be evaluated at
+            runtime.
+        """
+        if self._finalize is not None:
+            return self._finalize
+
+        finalize: t.Optional[t.Callable[..., t.Any]]
+        finalize = default = self._default_finalize
+        src = None
+
+        if self.environment.finalize:
+            src = "environment.finalize("
+            env_finalize = self.environment.finalize
+            pass_arg = {
+                _PassArg.context: "context",
+                _PassArg.eval_context: "context.eval_ctx",
+                _PassArg.environment: "environment",
+            }.get(
+                _PassArg.from_obj(env_finalize)  # type: ignore
+            )
+            finalize = None
+
+            if pass_arg is None:
+
+                def finalize(value: t.Any) -> t.Any:
+                    return default(env_finalize(value))
+
+            else:
+                src = f"{src}{pass_arg}, "
+
+                if pass_arg == "environment":
+
+                    def finalize(value: t.Any) -> t.Any:
+                        return default(env_finalize(self.environment, value))
+
+        self._finalize = self._FinalizeInfo(finalize, src)
+        return self._finalize
+
+    def _output_const_repr(self, group: t.Iterable[t.Any]) -> str:
+        """Given a group of constant values converted from ``Output``
+        child nodes, produce a string to write to the template module
+        source.
+        """
+        return repr(concat(group))
+
+    def _output_child_to_const(
+        self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
+    ) -> str:
+        """Try to optimize a child of an ``Output`` node by trying to
+        convert it to constant, finalized data at compile time.
+
+        If :exc:`Impossible` is raised, the node is not constant and
+        will be evaluated at runtime. Any other exception will also be
+        evaluated at runtime for easier debugging.
+        """
+        const = node.as_const(frame.eval_ctx)
+
+        if frame.eval_ctx.autoescape:
+            const = escape(const)
+
+        # Template data doesn't go through finalize.
+        if isinstance(node, nodes.TemplateData):
+            return str(const)
+
+        return finalize.const(const)  # type: ignore
+
+    def _output_child_pre(
+        self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
+    ) -> None:
+        """Output extra source code before visiting a child of an
+        ``Output`` node.
+        """
+        if frame.eval_ctx.volatile:
+            self.write("(escape if context.eval_ctx.autoescape else str)(")
+        elif frame.eval_ctx.autoescape:
+            self.write("escape(")
+        else:
+            self.write("str(")
+
+        if finalize.src is not None:
+            self.write(finalize.src)
+
+    def _output_child_post(
+        self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
+    ) -> None:
+        """Output extra source code after visiting a child of an
+        ``Output`` node.
+        """
+        self.write(")")
+
+        if finalize.src is not None:
+            self.write(")")
+
+    def visit_Output(self, node: nodes.Output, frame: Frame) -> None:
+        # If an extends is active, don't render outside a block.
+        if frame.require_output_check:
+            # A top-level extends is known to exist at compile time.
+            if self.has_known_extends:
+                return
+
+            self.writeline("if parent_template is None:")
+            self.indent()
+
+        finalize = self._make_finalize()
+        body: t.List[t.Union[t.List[t.Any], nodes.Expr]] = []
+
+        # Evaluate constants at compile time if possible. Each item in
+        # body will be either a list of static data or a node to be
+        # evaluated at runtime.
+        for child in node.nodes:
+            try:
+                if not (
+                    # If the finalize function requires runtime context,
+                    # constants can't be evaluated at compile time.
+                    finalize.const
+                    # Unless it's basic template data that won't be
+                    # finalized anyway.
+                    or isinstance(child, nodes.TemplateData)
+                ):
+                    raise nodes.Impossible()
+
+                const = self._output_child_to_const(child, frame, finalize)
+            except (nodes.Impossible, Exception):
+                # The node was not constant and needs to be evaluated at
+                # runtime. Or another error was raised, which is easier
+                # to debug at runtime.
+                body.append(child)
+                continue
+
+            if body and isinstance(body[-1], list):
+                body[-1].append(const)
+            else:
+                body.append([const])
+
+        if frame.buffer is not None:
+            if len(body) == 1:
+                self.writeline(f"{frame.buffer}.append(")
+            else:
+                self.writeline(f"{frame.buffer}.extend((")
+
+            self.indent()
+
+        for item in body:
+            if isinstance(item, list):
+                # A group of constant data to join and output.
+                val = self._output_const_repr(item)
+
+                if frame.buffer is None:
+                    self.writeline("yield " + val)
+                else:
+                    self.writeline(val + ",")
+            else:
+                if frame.buffer is None:
+                    self.writeline("yield ", item)
+                else:
+                    self.newline(item)
+
+                # A node to be evaluated at runtime.
+                self._output_child_pre(item, frame, finalize)
+                self.visit(item, frame)
+                self._output_child_post(item, frame, finalize)
+
+                if frame.buffer is not None:
+                    self.write(",")
+
+        if frame.buffer is not None:
+            self.outdent()
+            self.writeline(")" if len(body) == 1 else "))")
+
+        if frame.require_output_check:
+            self.outdent()
+
+    def visit_Assign(self, node: nodes.Assign, frame: Frame) -> None:
+        self.push_assign_tracking()
+        self.newline(node)
+        self.visit(node.target, frame)
+        self.write(" = ")
+        self.visit(node.node, frame)
+        self.pop_assign_tracking(frame)
+
+    def visit_AssignBlock(self, node: nodes.AssignBlock, frame: Frame) -> None:
+        self.push_assign_tracking()
+        block_frame = frame.inner()
+        # This is a special case.  Since a set block always captures we
+        # will disable output checks.  This way one can use set blocks
+        # toplevel even in extended templates.
+        block_frame.require_output_check = False
+        block_frame.symbols.analyze_node(node)
+        self.enter_frame(block_frame)
+        self.buffer(block_frame)
+        self.blockvisit(node.body, block_frame)
+        self.newline(node)
+        self.visit(node.target, frame)
+        self.write(" = (Markup if context.eval_ctx.autoescape else identity)(")
+        if node.filter is not None:
+            self.visit_Filter(node.filter, block_frame)
+        else:
+            self.write(f"concat({block_frame.buffer})")
+        self.write(")")
+        self.pop_assign_tracking(frame)
+        self.leave_frame(block_frame)
+
+    # -- Expression Visitors
+
+    def visit_Name(self, node: nodes.Name, frame: Frame) -> None:
+        if node.ctx == "store" and (
+            frame.toplevel or frame.loop_frame or frame.block_frame
+        ):
+            if self._assign_stack:
+                self._assign_stack[-1].add(node.name)
+        ref = frame.symbols.ref(node.name)
+
+        # If we are looking up a variable we might have to deal with the
+        # case where it's undefined.  We can skip that case if the load
+        # instruction indicates a parameter which are always defined.
+        if node.ctx == "load":
+            load = frame.symbols.find_load(ref)
+            if not (
+                load is not None
+                and load[0] == VAR_LOAD_PARAMETER
+                and not self.parameter_is_undeclared(ref)
+            ):
+                self.write(
+                    f"(undefined(name={node.name!r}) if {ref} is missing else {ref})"
+                )
+                return
+
+        self.write(ref)
+
+    def visit_NSRef(self, node: nodes.NSRef, frame: Frame) -> None:
+        # NSRefs can only be used to store values; since they use the normal
+        # `foo.bar` notation they will be parsed as a normal attribute access
+        # when used anywhere but in a `set` context
+        ref = frame.symbols.ref(node.name)
+        self.writeline(f"if not isinstance({ref}, Namespace):")
+        self.indent()
+        self.writeline(
+            "raise TemplateRuntimeError"
+            '("cannot assign attribute on non-namespace object")'
+        )
+        self.outdent()
+        self.writeline(f"{ref}[{node.attr!r}]")
+
+    def visit_Const(self, node: nodes.Const, frame: Frame) -> None:
+        val = node.as_const(frame.eval_ctx)
+        if isinstance(val, float):
+            self.write(str(val))
+        else:
+            self.write(repr(val))
+
+    def visit_TemplateData(self, node: nodes.TemplateData, frame: Frame) -> None:
+        try:
+            self.write(repr(node.as_const(frame.eval_ctx)))
+        except nodes.Impossible:
+            self.write(
+                f"(Markup if context.eval_ctx.autoescape else identity)({node.data!r})"
+            )
+
+    def visit_Tuple(self, node: nodes.Tuple, frame: Frame) -> None:
+        self.write("(")
+        idx = -1
+        for idx, item in enumerate(node.items):
+            if idx:
+                self.write(", ")
+            self.visit(item, frame)
+        self.write(",)" if idx == 0 else ")")
+
+    def visit_List(self, node: nodes.List, frame: Frame) -> None:
+        self.write("[")
+        for idx, item in enumerate(node.items):
+            if idx:
+                self.write(", ")
+            self.visit(item, frame)
+        self.write("]")
+
+    def visit_Dict(self, node: nodes.Dict, frame: Frame) -> None:
+        self.write("{")
+        for idx, item in enumerate(node.items):
+            if idx:
+                self.write(", ")
+            self.visit(item.key, frame)
+            self.write(": ")
+            self.visit(item.value, frame)
+        self.write("}")
+
+    visit_Add = _make_binop("+")
+    visit_Sub = _make_binop("-")
+    visit_Mul = _make_binop("*")
+    visit_Div = _make_binop("/")
+    visit_FloorDiv = _make_binop("//")
+    visit_Pow = _make_binop("**")
+    visit_Mod = _make_binop("%")
+    visit_And = _make_binop("and")
+    visit_Or = _make_binop("or")
+    visit_Pos = _make_unop("+")
+    visit_Neg = _make_unop("-")
+    visit_Not = _make_unop("not ")
+
+    @optimizeconst
+    def visit_Concat(self, node: nodes.Concat, frame: Frame) -> None:
+        if frame.eval_ctx.volatile:
+            func_name = "(markup_join if context.eval_ctx.volatile else str_join)"
+        elif frame.eval_ctx.autoescape:
+            func_name = "markup_join"
+        else:
+            func_name = "str_join"
+        self.write(f"{func_name}((")
+        for arg in node.nodes:
+            self.visit(arg, frame)
+            self.write(", ")
+        self.write("))")
+
+    @optimizeconst
+    def visit_Compare(self, node: nodes.Compare, frame: Frame) -> None:
+        self.write("(")
+        self.visit(node.expr, frame)
+        for op in node.ops:
+            self.visit(op, frame)
+        self.write(")")
+
+    def visit_Operand(self, node: nodes.Operand, frame: Frame) -> None:
+        self.write(f" {operators[node.op]} ")
+        self.visit(node.expr, frame)
+
+    @optimizeconst
+    def visit_Getattr(self, node: nodes.Getattr, frame: Frame) -> None:
+        if self.environment.is_async:
+            self.write("(await auto_await(")
+
+        self.write("environment.getattr(")
+        self.visit(node.node, frame)
+        self.write(f", {node.attr!r})")
+
+        if self.environment.is_async:
+            self.write("))")
+
+    @optimizeconst
+    def visit_Getitem(self, node: nodes.Getitem, frame: Frame) -> None:
+        # slices bypass the environment getitem method.
+        if isinstance(node.arg, nodes.Slice):
+            self.visit(node.node, frame)
+            self.write("[")
+            self.visit(node.arg, frame)
+            self.write("]")
+        else:
+            if self.environment.is_async:
+                self.write("(await auto_await(")
+
+            self.write("environment.getitem(")
+            self.visit(node.node, frame)
+            self.write(", ")
+            self.visit(node.arg, frame)
+            self.write(")")
+
+            if self.environment.is_async:
+                self.write("))")
+
+    def visit_Slice(self, node: nodes.Slice, frame: Frame) -> None:
+        if node.start is not None:
+            self.visit(node.start, frame)
+        self.write(":")
+        if node.stop is not None:
+            self.visit(node.stop, frame)
+        if node.step is not None:
+            self.write(":")
+            self.visit(node.step, frame)
+
+    @contextmanager
+    def _filter_test_common(
+        self, node: t.Union[nodes.Filter, nodes.Test], frame: Frame, is_filter: bool
+    ) -> t.Iterator[None]:
+        if self.environment.is_async:
+            self.write("(await auto_await(")
+
+        if is_filter:
+            self.write(f"{self.filters[node.name]}(")
+            func = self.environment.filters.get(node.name)
+        else:
+            self.write(f"{self.tests[node.name]}(")
+            func = self.environment.tests.get(node.name)
+
+        # When inside an If or CondExpr frame, allow the filter to be
+        # undefined at compile time and only raise an error if it's
+        # actually called at runtime. See pull_dependencies.
+        if func is None and not frame.soft_frame:
+            type_name = "filter" if is_filter else "test"
+            self.fail(f"No {type_name} named {node.name!r}.", node.lineno)
+
+        pass_arg = {
+            _PassArg.context: "context",
+            _PassArg.eval_context: "context.eval_ctx",
+            _PassArg.environment: "environment",
+        }.get(
+            _PassArg.from_obj(func)  # type: ignore
+        )
+
+        if pass_arg is not None:
+            self.write(f"{pass_arg}, ")
+
+        # Back to the visitor function to handle visiting the target of
+        # the filter or test.
+        yield
+
+        self.signature(node, frame)
+        self.write(")")
+
+        if self.environment.is_async:
+            self.write("))")
+
+    @optimizeconst
+    def visit_Filter(self, node: nodes.Filter, frame: Frame) -> None:
+        with self._filter_test_common(node, frame, True):
+            # if the filter node is None we are inside a filter block
+            # and want to write to the current buffer
+            if node.node is not None:
+                self.visit(node.node, frame)
+            elif frame.eval_ctx.volatile:
+                self.write(
+                    f"(Markup(concat({frame.buffer}))"
+                    f" if context.eval_ctx.autoescape else concat({frame.buffer}))"
+                )
+            elif frame.eval_ctx.autoescape:
+                self.write(f"Markup(concat({frame.buffer}))")
+            else:
+                self.write(f"concat({frame.buffer})")
+
+    @optimizeconst
+    def visit_Test(self, node: nodes.Test, frame: Frame) -> None:
+        with self._filter_test_common(node, frame, False):
+            self.visit(node.node, frame)
+
+    @optimizeconst
+    def visit_CondExpr(self, node: nodes.CondExpr, frame: Frame) -> None:
+        frame = frame.soft()
+
+        def write_expr2() -> None:
+            if node.expr2 is not None:
+                self.visit(node.expr2, frame)
+                return
+
+            self.write(
+                f'cond_expr_undefined("the inline if-expression on'
+                f" {self.position(node)} evaluated to false and no else"
+                f' section was defined.")'
+            )
+
+        self.write("(")
+        self.visit(node.expr1, frame)
+        self.write(" if ")
+        self.visit(node.test, frame)
+        self.write(" else ")
+        write_expr2()
+        self.write(")")
+
+    @optimizeconst
+    def visit_Call(
+        self, node: nodes.Call, frame: Frame, forward_caller: bool = False
+    ) -> None:
+        if self.environment.is_async:
+            self.write("(await auto_await(")
+        if self.environment.sandboxed:
+            self.write("environment.call(context, ")
+        else:
+            self.write("context.call(")
+        self.visit(node.node, frame)
+        extra_kwargs = {"caller": "caller"} if forward_caller else None
+        loop_kwargs = {"_loop_vars": "_loop_vars"} if frame.loop_frame else {}
+        block_kwargs = {"_block_vars": "_block_vars"} if frame.block_frame else {}
+        if extra_kwargs:
+            extra_kwargs.update(loop_kwargs, **block_kwargs)
+        elif loop_kwargs or block_kwargs:
+            extra_kwargs = dict(loop_kwargs, **block_kwargs)
+        self.signature(node, frame, extra_kwargs)
+        self.write(")")
+        if self.environment.is_async:
+            self.write("))")
+
+    def visit_Keyword(self, node: nodes.Keyword, frame: Frame) -> None:
+        self.write(node.key + "=")
+        self.visit(node.value, frame)
+
+    # -- Unused nodes for extensions
+
+    def visit_MarkSafe(self, node: nodes.MarkSafe, frame: Frame) -> None:
+        self.write("Markup(")
+        self.visit(node.expr, frame)
+        self.write(")")
+
+    def visit_MarkSafeIfAutoescape(
+        self, node: nodes.MarkSafeIfAutoescape, frame: Frame
+    ) -> None:
+        self.write("(Markup if context.eval_ctx.autoescape else identity)(")
+        self.visit(node.expr, frame)
+        self.write(")")
+
+    def visit_EnvironmentAttribute(
+        self, node: nodes.EnvironmentAttribute, frame: Frame
+    ) -> None:
+        self.write("environment." + node.name)
+
+    def visit_ExtensionAttribute(
+        self, node: nodes.ExtensionAttribute, frame: Frame
+    ) -> None:
+        self.write(f"environment.extensions[{node.identifier!r}].{node.name}")
+
+    def visit_ImportedName(self, node: nodes.ImportedName, frame: Frame) -> None:
+        self.write(self.import_aliases[node.importname])
+
+    def visit_InternalName(self, node: nodes.InternalName, frame: Frame) -> None:
+        self.write(node.name)
+
+    def visit_ContextReference(
+        self, node: nodes.ContextReference, frame: Frame
+    ) -> None:
+        self.write("context")
+
+    def visit_DerivedContextReference(
+        self, node: nodes.DerivedContextReference, frame: Frame
+    ) -> None:
+        self.write(self.derive_context(frame))
+
+    def visit_Continue(self, node: nodes.Continue, frame: Frame) -> None:
+        self.writeline("continue", node)
+
+    def visit_Break(self, node: nodes.Break, frame: Frame) -> None:
+        self.writeline("break", node)
+
+    def visit_Scope(self, node: nodes.Scope, frame: Frame) -> None:
+        scope_frame = frame.inner()
+        scope_frame.symbols.analyze_node(node)
+        self.enter_frame(scope_frame)
+        self.blockvisit(node.body, scope_frame)
+        self.leave_frame(scope_frame)
+
+    def visit_OverlayScope(self, node: nodes.OverlayScope, frame: Frame) -> None:
+        ctx = self.temporary_identifier()
+        self.writeline(f"{ctx} = {self.derive_context(frame)}")
+        self.writeline(f"{ctx}.vars = ")
+        self.visit(node.context, frame)
+        self.push_context_reference(ctx)
+
+        scope_frame = frame.inner(isolated=True)
+        scope_frame.symbols.analyze_node(node)
+        self.enter_frame(scope_frame)
+        self.blockvisit(node.body, scope_frame)
+        self.leave_frame(scope_frame)
+        self.pop_context_reference()
+
+    def visit_EvalContextModifier(
+        self, node: nodes.EvalContextModifier, frame: Frame
+    ) -> None:
+        for keyword in node.options:
+            self.writeline(f"context.eval_ctx.{keyword.key} = ")
+            self.visit(keyword.value, frame)
+            try:
+                val = keyword.value.as_const(frame.eval_ctx)
+            except nodes.Impossible:
+                frame.eval_ctx.volatile = True
+            else:
+                setattr(frame.eval_ctx, keyword.key, val)
+
+    def visit_ScopedEvalContextModifier(
+        self, node: nodes.ScopedEvalContextModifier, frame: Frame
+    ) -> None:
+        old_ctx_name = self.temporary_identifier()
+        saved_ctx = frame.eval_ctx.save()
+        self.writeline(f"{old_ctx_name} = context.eval_ctx.save()")
+        self.visit_EvalContextModifier(node, frame)
+        for child in node.body:
+            self.visit(child, frame)
+        frame.eval_ctx.revert(saved_ctx)
+        self.writeline(f"context.eval_ctx.revert({old_ctx_name})")
diff --git a/lib/python3.11/site-packages/jinja2/constants.py b/lib/python3.11/site-packages/jinja2/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..41a1c23b0a7fe134b1f662545876eb65b31b071e
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/constants.py
@@ -0,0 +1,20 @@
+#: list of lorem ipsum words used by the lipsum() helper function
+LOREM_IPSUM_WORDS = """\
+a ac accumsan ad adipiscing aenean aliquam aliquet amet ante aptent arcu at
+auctor augue bibendum blandit class commodo condimentum congue consectetuer
+consequat conubia convallis cras cubilia cum curabitur curae cursus dapibus
+diam dictum dictumst dignissim dis dolor donec dui duis egestas eget eleifend
+elementum elit enim erat eros est et etiam eu euismod facilisi facilisis fames
+faucibus felis fermentum feugiat fringilla fusce gravida habitant habitasse hac
+hendrerit hymenaeos iaculis id imperdiet in inceptos integer interdum ipsum
+justo lacinia lacus laoreet lectus leo libero ligula litora lobortis lorem
+luctus maecenas magna magnis malesuada massa mattis mauris metus mi molestie
+mollis montes morbi mus nam nascetur natoque nec neque netus nibh nisi nisl non
+nonummy nostra nulla nullam nunc odio orci ornare parturient pede pellentesque
+penatibus per pharetra phasellus placerat platea porta porttitor posuere
+potenti praesent pretium primis proin pulvinar purus quam quis quisque rhoncus
+ridiculus risus rutrum sagittis sapien scelerisque sed sem semper senectus sit
+sociis sociosqu sodales sollicitudin suscipit suspendisse taciti tellus tempor
+tempus tincidunt torquent tortor tristique turpis ullamcorper ultrices
+ultricies urna ut varius vehicula vel velit venenatis vestibulum vitae vivamus
+viverra volutpat vulputate"""
diff --git a/lib/python3.11/site-packages/jinja2/debug.py b/lib/python3.11/site-packages/jinja2/debug.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ed7e9297e01b87c4e999d19d48a4265b38b574f
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/debug.py
@@ -0,0 +1,191 @@
+import sys
+import typing as t
+from types import CodeType
+from types import TracebackType
+
+from .exceptions import TemplateSyntaxError
+from .utils import internal_code
+from .utils import missing
+
+if t.TYPE_CHECKING:
+    from .runtime import Context
+
+
+def rewrite_traceback_stack(source: t.Optional[str] = None) -> BaseException:
+    """Rewrite the current exception to replace any tracebacks from
+    within compiled template code with tracebacks that look like they
+    came from the template source.
+
+    This must be called within an ``except`` block.
+
+    :param source: For ``TemplateSyntaxError``, the original source if
+        known.
+    :return: The original exception with the rewritten traceback.
+    """
+    _, exc_value, tb = sys.exc_info()
+    exc_value = t.cast(BaseException, exc_value)
+    tb = t.cast(TracebackType, tb)
+
+    if isinstance(exc_value, TemplateSyntaxError) and not exc_value.translated:
+        exc_value.translated = True
+        exc_value.source = source
+        # Remove the old traceback, otherwise the frames from the
+        # compiler still show up.
+        exc_value.with_traceback(None)
+        # Outside of runtime, so the frame isn't executing template
+        # code, but it still needs to point at the template.
+        tb = fake_traceback(
+            exc_value, None, exc_value.filename or "<unknown>", exc_value.lineno
+        )
+    else:
+        # Skip the frame for the render function.
+        tb = tb.tb_next
+
+    stack = []
+
+    # Build the stack of traceback object, replacing any in template
+    # code with the source file and line information.
+    while tb is not None:
+        # Skip frames decorated with @internalcode. These are internal
+        # calls that aren't useful in template debugging output.
+        if tb.tb_frame.f_code in internal_code:
+            tb = tb.tb_next
+            continue
+
+        template = tb.tb_frame.f_globals.get("__jinja_template__")
+
+        if template is not None:
+            lineno = template.get_corresponding_lineno(tb.tb_lineno)
+            fake_tb = fake_traceback(exc_value, tb, template.filename, lineno)
+            stack.append(fake_tb)
+        else:
+            stack.append(tb)
+
+        tb = tb.tb_next
+
+    tb_next = None
+
+    # Assign tb_next in reverse to avoid circular references.
+    for tb in reversed(stack):
+        tb.tb_next = tb_next
+        tb_next = tb
+
+    return exc_value.with_traceback(tb_next)
+
+
+def fake_traceback(  # type: ignore
+    exc_value: BaseException, tb: t.Optional[TracebackType], filename: str, lineno: int
+) -> TracebackType:
+    """Produce a new traceback object that looks like it came from the
+    template source instead of the compiled code. The filename, line
+    number, and location name will point to the template, and the local
+    variables will be the current template context.
+
+    :param exc_value: The original exception to be re-raised to create
+        the new traceback.
+    :param tb: The original traceback to get the local variables and
+        code info from.
+    :param filename: The template filename.
+    :param lineno: The line number in the template source.
+    """
+    if tb is not None:
+        # Replace the real locals with the context that would be
+        # available at that point in the template.
+        locals = get_template_locals(tb.tb_frame.f_locals)
+        locals.pop("__jinja_exception__", None)
+    else:
+        locals = {}
+
+    globals = {
+        "__name__": filename,
+        "__file__": filename,
+        "__jinja_exception__": exc_value,
+    }
+    # Raise an exception at the correct line number.
+    code: CodeType = compile(
+        "\n" * (lineno - 1) + "raise __jinja_exception__", filename, "exec"
+    )
+
+    # Build a new code object that points to the template file and
+    # replaces the location with a block name.
+    location = "template"
+
+    if tb is not None:
+        function = tb.tb_frame.f_code.co_name
+
+        if function == "root":
+            location = "top-level template code"
+        elif function.startswith("block_"):
+            location = f"block {function[6:]!r}"
+
+    if sys.version_info >= (3, 8):
+        code = code.replace(co_name=location)
+    else:
+        code = CodeType(
+            code.co_argcount,
+            code.co_kwonlyargcount,
+            code.co_nlocals,
+            code.co_stacksize,
+            code.co_flags,
+            code.co_code,
+            code.co_consts,
+            code.co_names,
+            code.co_varnames,
+            code.co_filename,
+            location,
+            code.co_firstlineno,
+            code.co_lnotab,
+            code.co_freevars,
+            code.co_cellvars,
+        )
+
+    # Execute the new code, which is guaranteed to raise, and return
+    # the new traceback without this frame.
+    try:
+        exec(code, globals, locals)
+    except BaseException:
+        return sys.exc_info()[2].tb_next  # type: ignore
+
+
+def get_template_locals(real_locals: t.Mapping[str, t.Any]) -> t.Dict[str, t.Any]:
+    """Based on the runtime locals, get the context that would be
+    available at that point in the template.
+    """
+    # Start with the current template context.
+    ctx: "t.Optional[Context]" = real_locals.get("context")
+
+    if ctx is not None:
+        data: t.Dict[str, t.Any] = ctx.get_all().copy()
+    else:
+        data = {}
+
+    # Might be in a derived context that only sets local variables
+    # rather than pushing a context. Local variables follow the scheme
+    # l_depth_name. Find the highest-depth local that has a value for
+    # each name.
+    local_overrides: t.Dict[str, t.Tuple[int, t.Any]] = {}
+
+    for name, value in real_locals.items():
+        if not name.startswith("l_") or value is missing:
+            # Not a template variable, or no longer relevant.
+            continue
+
+        try:
+            _, depth_str, name = name.split("_", 2)
+            depth = int(depth_str)
+        except ValueError:
+            continue
+
+        cur_depth = local_overrides.get(name, (-1,))[0]
+
+        if cur_depth < depth:
+            local_overrides[name] = (depth, value)
+
+    # Modify the context with any derived context.
+    for name, (_, value) in local_overrides.items():
+        if value is missing:
+            data.pop(name, None)
+        else:
+            data[name] = value
+
+    return data
diff --git a/lib/python3.11/site-packages/jinja2/defaults.py b/lib/python3.11/site-packages/jinja2/defaults.py
new file mode 100644
index 0000000000000000000000000000000000000000..638cad3d2d8907330bde56e2b76c9b185c523b45
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/defaults.py
@@ -0,0 +1,48 @@
+import typing as t
+
+from .filters import FILTERS as DEFAULT_FILTERS  # noqa: F401
+from .tests import TESTS as DEFAULT_TESTS  # noqa: F401
+from .utils import Cycler
+from .utils import generate_lorem_ipsum
+from .utils import Joiner
+from .utils import Namespace
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+# defaults for the parser / lexer
+BLOCK_START_STRING = "{%"
+BLOCK_END_STRING = "%}"
+VARIABLE_START_STRING = "{{"
+VARIABLE_END_STRING = "}}"
+COMMENT_START_STRING = "{#"
+COMMENT_END_STRING = "#}"
+LINE_STATEMENT_PREFIX: t.Optional[str] = None
+LINE_COMMENT_PREFIX: t.Optional[str] = None
+TRIM_BLOCKS = False
+LSTRIP_BLOCKS = False
+NEWLINE_SEQUENCE: "te.Literal['\\n', '\\r\\n', '\\r']" = "\n"
+KEEP_TRAILING_NEWLINE = False
+
+# default filters, tests and namespace
+
+DEFAULT_NAMESPACE = {
+    "range": range,
+    "dict": dict,
+    "lipsum": generate_lorem_ipsum,
+    "cycler": Cycler,
+    "joiner": Joiner,
+    "namespace": Namespace,
+}
+
+# default policies
+DEFAULT_POLICIES: t.Dict[str, t.Any] = {
+    "compiler.ascii_str": True,
+    "urlize.rel": "noopener",
+    "urlize.target": None,
+    "urlize.extra_schemes": None,
+    "truncate.leeway": 5,
+    "json.dumps_function": None,
+    "json.dumps_kwargs": {"sort_keys": True},
+    "ext.i18n.trimmed": False,
+}
diff --git a/lib/python3.11/site-packages/jinja2/environment.py b/lib/python3.11/site-packages/jinja2/environment.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea04e8b44330fe22909a2c875c6601e33bd1ffc2
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/environment.py
@@ -0,0 +1,1667 @@
+"""Classes for managing templates and their runtime and compile time
+options.
+"""
+import os
+import typing
+import typing as t
+import weakref
+from collections import ChainMap
+from functools import lru_cache
+from functools import partial
+from functools import reduce
+from types import CodeType
+
+from markupsafe import Markup
+
+from . import nodes
+from .compiler import CodeGenerator
+from .compiler import generate
+from .defaults import BLOCK_END_STRING
+from .defaults import BLOCK_START_STRING
+from .defaults import COMMENT_END_STRING
+from .defaults import COMMENT_START_STRING
+from .defaults import DEFAULT_FILTERS
+from .defaults import DEFAULT_NAMESPACE
+from .defaults import DEFAULT_POLICIES
+from .defaults import DEFAULT_TESTS
+from .defaults import KEEP_TRAILING_NEWLINE
+from .defaults import LINE_COMMENT_PREFIX
+from .defaults import LINE_STATEMENT_PREFIX
+from .defaults import LSTRIP_BLOCKS
+from .defaults import NEWLINE_SEQUENCE
+from .defaults import TRIM_BLOCKS
+from .defaults import VARIABLE_END_STRING
+from .defaults import VARIABLE_START_STRING
+from .exceptions import TemplateNotFound
+from .exceptions import TemplateRuntimeError
+from .exceptions import TemplatesNotFound
+from .exceptions import TemplateSyntaxError
+from .exceptions import UndefinedError
+from .lexer import get_lexer
+from .lexer import Lexer
+from .lexer import TokenStream
+from .nodes import EvalContext
+from .parser import Parser
+from .runtime import Context
+from .runtime import new_context
+from .runtime import Undefined
+from .utils import _PassArg
+from .utils import concat
+from .utils import consume
+from .utils import import_string
+from .utils import internalcode
+from .utils import LRUCache
+from .utils import missing
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .bccache import BytecodeCache
+    from .ext import Extension
+    from .loaders import BaseLoader
+
+_env_bound = t.TypeVar("_env_bound", bound="Environment")
+
+
+# for direct template usage we have up to ten living environments
+@lru_cache(maxsize=10)
+def get_spontaneous_environment(cls: t.Type[_env_bound], *args: t.Any) -> _env_bound:
+    """Return a new spontaneous environment. A spontaneous environment
+    is used for templates created directly rather than through an
+    existing environment.
+
+    :param cls: Environment class to create.
+    :param args: Positional arguments passed to environment.
+    """
+    env = cls(*args)
+    env.shared = True
+    return env
+
+
+def create_cache(
+    size: int,
+) -> t.Optional[t.MutableMapping[t.Tuple[weakref.ref, str], "Template"]]:
+    """Return the cache class for the given size."""
+    if size == 0:
+        return None
+
+    if size < 0:
+        return {}
+
+    return LRUCache(size)  # type: ignore
+
+
+def copy_cache(
+    cache: t.Optional[t.MutableMapping],
+) -> t.Optional[t.MutableMapping[t.Tuple[weakref.ref, str], "Template"]]:
+    """Create an empty copy of the given cache."""
+    if cache is None:
+        return None
+
+    if type(cache) is dict:
+        return {}
+
+    return LRUCache(cache.capacity)  # type: ignore
+
+
+def load_extensions(
+    environment: "Environment",
+    extensions: t.Sequence[t.Union[str, t.Type["Extension"]]],
+) -> t.Dict[str, "Extension"]:
+    """Load the extensions from the list and bind it to the environment.
+    Returns a dict of instantiated extensions.
+    """
+    result = {}
+
+    for extension in extensions:
+        if isinstance(extension, str):
+            extension = t.cast(t.Type["Extension"], import_string(extension))
+
+        result[extension.identifier] = extension(environment)
+
+    return result
+
+
+def _environment_config_check(environment: "Environment") -> "Environment":
+    """Perform a sanity check on the environment."""
+    assert issubclass(
+        environment.undefined, Undefined
+    ), "'undefined' must be a subclass of 'jinja2.Undefined'."
+    assert (
+        environment.block_start_string
+        != environment.variable_start_string
+        != environment.comment_start_string
+    ), "block, variable and comment start strings must be different."
+    assert environment.newline_sequence in {
+        "\r",
+        "\r\n",
+        "\n",
+    }, "'newline_sequence' must be one of '\\n', '\\r\\n', or '\\r'."
+    return environment
+
+
+class Environment:
+    r"""The core component of Jinja is the `Environment`.  It contains
+    important shared variables like configuration, filters, tests,
+    globals and others.  Instances of this class may be modified if
+    they are not shared and if no template was loaded so far.
+    Modifications on environments after the first template was loaded
+    will lead to surprising effects and undefined behavior.
+
+    Here are the possible initialization parameters:
+
+        `block_start_string`
+            The string marking the beginning of a block.  Defaults to ``'{%'``.
+
+        `block_end_string`
+            The string marking the end of a block.  Defaults to ``'%}'``.
+
+        `variable_start_string`
+            The string marking the beginning of a print statement.
+            Defaults to ``'{{'``.
+
+        `variable_end_string`
+            The string marking the end of a print statement.  Defaults to
+            ``'}}'``.
+
+        `comment_start_string`
+            The string marking the beginning of a comment.  Defaults to ``'{#'``.
+
+        `comment_end_string`
+            The string marking the end of a comment.  Defaults to ``'#}'``.
+
+        `line_statement_prefix`
+            If given and a string, this will be used as prefix for line based
+            statements.  See also :ref:`line-statements`.
+
+        `line_comment_prefix`
+            If given and a string, this will be used as prefix for line based
+            comments.  See also :ref:`line-statements`.
+
+            .. versionadded:: 2.2
+
+        `trim_blocks`
+            If this is set to ``True`` the first newline after a block is
+            removed (block, not variable tag!).  Defaults to `False`.
+
+        `lstrip_blocks`
+            If this is set to ``True`` leading spaces and tabs are stripped
+            from the start of a line to a block.  Defaults to `False`.
+
+        `newline_sequence`
+            The sequence that starts a newline.  Must be one of ``'\r'``,
+            ``'\n'`` or ``'\r\n'``.  The default is ``'\n'`` which is a
+            useful default for Linux and OS X systems as well as web
+            applications.
+
+        `keep_trailing_newline`
+            Preserve the trailing newline when rendering templates.
+            The default is ``False``, which causes a single newline,
+            if present, to be stripped from the end of the template.
+
+            .. versionadded:: 2.7
+
+        `extensions`
+            List of Jinja extensions to use.  This can either be import paths
+            as strings or extension classes.  For more information have a
+            look at :ref:`the extensions documentation <jinja-extensions>`.
+
+        `optimized`
+            should the optimizer be enabled?  Default is ``True``.
+
+        `undefined`
+            :class:`Undefined` or a subclass of it that is used to represent
+            undefined values in the template.
+
+        `finalize`
+            A callable that can be used to process the result of a variable
+            expression before it is output.  For example one can convert
+            ``None`` implicitly into an empty string here.
+
+        `autoescape`
+            If set to ``True`` the XML/HTML autoescaping feature is enabled by
+            default.  For more details about autoescaping see
+            :class:`~markupsafe.Markup`.  As of Jinja 2.4 this can also
+            be a callable that is passed the template name and has to
+            return ``True`` or ``False`` depending on autoescape should be
+            enabled by default.
+
+            .. versionchanged:: 2.4
+               `autoescape` can now be a function
+
+        `loader`
+            The template loader for this environment.
+
+        `cache_size`
+            The size of the cache.  Per default this is ``400`` which means
+            that if more than 400 templates are loaded the loader will clean
+            out the least recently used template.  If the cache size is set to
+            ``0`` templates are recompiled all the time, if the cache size is
+            ``-1`` the cache will not be cleaned.
+
+            .. versionchanged:: 2.8
+               The cache size was increased to 400 from a low 50.
+
+        `auto_reload`
+            Some loaders load templates from locations where the template
+            sources may change (ie: file system or database).  If
+            ``auto_reload`` is set to ``True`` (default) every time a template is
+            requested the loader checks if the source changed and if yes, it
+            will reload the template.  For higher performance it's possible to
+            disable that.
+
+        `bytecode_cache`
+            If set to a bytecode cache object, this object will provide a
+            cache for the internal Jinja bytecode so that templates don't
+            have to be parsed if they were not changed.
+
+            See :ref:`bytecode-cache` for more information.
+
+        `enable_async`
+            If set to true this enables async template execution which
+            allows using async functions and generators.
+    """
+
+    #: if this environment is sandboxed.  Modifying this variable won't make
+    #: the environment sandboxed though.  For a real sandboxed environment
+    #: have a look at jinja2.sandbox.  This flag alone controls the code
+    #: generation by the compiler.
+    sandboxed = False
+
+    #: True if the environment is just an overlay
+    overlayed = False
+
+    #: the environment this environment is linked to if it is an overlay
+    linked_to: t.Optional["Environment"] = None
+
+    #: shared environments have this set to `True`.  A shared environment
+    #: must not be modified
+    shared = False
+
+    #: the class that is used for code generation.  See
+    #: :class:`~jinja2.compiler.CodeGenerator` for more information.
+    code_generator_class: t.Type["CodeGenerator"] = CodeGenerator
+
+    concat = "".join
+
+    #: the context class that is used for templates.  See
+    #: :class:`~jinja2.runtime.Context` for more information.
+    context_class: t.Type[Context] = Context
+
+    template_class: t.Type["Template"]
+
+    def __init__(
+        self,
+        block_start_string: str = BLOCK_START_STRING,
+        block_end_string: str = BLOCK_END_STRING,
+        variable_start_string: str = VARIABLE_START_STRING,
+        variable_end_string: str = VARIABLE_END_STRING,
+        comment_start_string: str = COMMENT_START_STRING,
+        comment_end_string: str = COMMENT_END_STRING,
+        line_statement_prefix: t.Optional[str] = LINE_STATEMENT_PREFIX,
+        line_comment_prefix: t.Optional[str] = LINE_COMMENT_PREFIX,
+        trim_blocks: bool = TRIM_BLOCKS,
+        lstrip_blocks: bool = LSTRIP_BLOCKS,
+        newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = NEWLINE_SEQUENCE,
+        keep_trailing_newline: bool = KEEP_TRAILING_NEWLINE,
+        extensions: t.Sequence[t.Union[str, t.Type["Extension"]]] = (),
+        optimized: bool = True,
+        undefined: t.Type[Undefined] = Undefined,
+        finalize: t.Optional[t.Callable[..., t.Any]] = None,
+        autoescape: t.Union[bool, t.Callable[[t.Optional[str]], bool]] = False,
+        loader: t.Optional["BaseLoader"] = None,
+        cache_size: int = 400,
+        auto_reload: bool = True,
+        bytecode_cache: t.Optional["BytecodeCache"] = None,
+        enable_async: bool = False,
+    ):
+        # !!Important notice!!
+        #   The constructor accepts quite a few arguments that should be
+        #   passed by keyword rather than position.  However it's important to
+        #   not change the order of arguments because it's used at least
+        #   internally in those cases:
+        #       -   spontaneous environments (i18n extension and Template)
+        #       -   unittests
+        #   If parameter changes are required only add parameters at the end
+        #   and don't change the arguments (or the defaults!) of the arguments
+        #   existing already.
+
+        # lexer / parser information
+        self.block_start_string = block_start_string
+        self.block_end_string = block_end_string
+        self.variable_start_string = variable_start_string
+        self.variable_end_string = variable_end_string
+        self.comment_start_string = comment_start_string
+        self.comment_end_string = comment_end_string
+        self.line_statement_prefix = line_statement_prefix
+        self.line_comment_prefix = line_comment_prefix
+        self.trim_blocks = trim_blocks
+        self.lstrip_blocks = lstrip_blocks
+        self.newline_sequence = newline_sequence
+        self.keep_trailing_newline = keep_trailing_newline
+
+        # runtime information
+        self.undefined: t.Type[Undefined] = undefined
+        self.optimized = optimized
+        self.finalize = finalize
+        self.autoescape = autoescape
+
+        # defaults
+        self.filters = DEFAULT_FILTERS.copy()
+        self.tests = DEFAULT_TESTS.copy()
+        self.globals = DEFAULT_NAMESPACE.copy()
+
+        # set the loader provided
+        self.loader = loader
+        self.cache = create_cache(cache_size)
+        self.bytecode_cache = bytecode_cache
+        self.auto_reload = auto_reload
+
+        # configurable policies
+        self.policies = DEFAULT_POLICIES.copy()
+
+        # load extensions
+        self.extensions = load_extensions(self, extensions)
+
+        self.is_async = enable_async
+        _environment_config_check(self)
+
+    def add_extension(self, extension: t.Union[str, t.Type["Extension"]]) -> None:
+        """Adds an extension after the environment was created.
+
+        .. versionadded:: 2.5
+        """
+        self.extensions.update(load_extensions(self, [extension]))
+
+    def extend(self, **attributes: t.Any) -> None:
+        """Add the items to the instance of the environment if they do not exist
+        yet.  This is used by :ref:`extensions <writing-extensions>` to register
+        callbacks and configuration values without breaking inheritance.
+        """
+        for key, value in attributes.items():
+            if not hasattr(self, key):
+                setattr(self, key, value)
+
+    def overlay(
+        self,
+        block_start_string: str = missing,
+        block_end_string: str = missing,
+        variable_start_string: str = missing,
+        variable_end_string: str = missing,
+        comment_start_string: str = missing,
+        comment_end_string: str = missing,
+        line_statement_prefix: t.Optional[str] = missing,
+        line_comment_prefix: t.Optional[str] = missing,
+        trim_blocks: bool = missing,
+        lstrip_blocks: bool = missing,
+        newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = missing,
+        keep_trailing_newline: bool = missing,
+        extensions: t.Sequence[t.Union[str, t.Type["Extension"]]] = missing,
+        optimized: bool = missing,
+        undefined: t.Type[Undefined] = missing,
+        finalize: t.Optional[t.Callable[..., t.Any]] = missing,
+        autoescape: t.Union[bool, t.Callable[[t.Optional[str]], bool]] = missing,
+        loader: t.Optional["BaseLoader"] = missing,
+        cache_size: int = missing,
+        auto_reload: bool = missing,
+        bytecode_cache: t.Optional["BytecodeCache"] = missing,
+        enable_async: bool = False,
+    ) -> "Environment":
+        """Create a new overlay environment that shares all the data with the
+        current environment except for cache and the overridden attributes.
+        Extensions cannot be removed for an overlayed environment.  An overlayed
+        environment automatically gets all the extensions of the environment it
+        is linked to plus optional extra extensions.
+
+        Creating overlays should happen after the initial environment was set
+        up completely.  Not all attributes are truly linked, some are just
+        copied over so modifications on the original environment may not shine
+        through.
+
+        .. versionchanged:: 3.1.2
+            Added the ``newline_sequence``,, ``keep_trailing_newline``,
+            and ``enable_async`` parameters to match ``__init__``.
+        """
+        args = dict(locals())
+        del args["self"], args["cache_size"], args["extensions"], args["enable_async"]
+
+        rv = object.__new__(self.__class__)
+        rv.__dict__.update(self.__dict__)
+        rv.overlayed = True
+        rv.linked_to = self
+
+        for key, value in args.items():
+            if value is not missing:
+                setattr(rv, key, value)
+
+        if cache_size is not missing:
+            rv.cache = create_cache(cache_size)
+        else:
+            rv.cache = copy_cache(self.cache)
+
+        rv.extensions = {}
+        for key, value in self.extensions.items():
+            rv.extensions[key] = value.bind(rv)
+        if extensions is not missing:
+            rv.extensions.update(load_extensions(rv, extensions))
+
+        if enable_async is not missing:
+            rv.is_async = enable_async
+
+        return _environment_config_check(rv)
+
+    @property
+    def lexer(self) -> Lexer:
+        """The lexer for this environment."""
+        return get_lexer(self)
+
+    def iter_extensions(self) -> t.Iterator["Extension"]:
+        """Iterates over the extensions by priority."""
+        return iter(sorted(self.extensions.values(), key=lambda x: x.priority))
+
+    def getitem(
+        self, obj: t.Any, argument: t.Union[str, t.Any]
+    ) -> t.Union[t.Any, Undefined]:
+        """Get an item or attribute of an object but prefer the item."""
+        try:
+            return obj[argument]
+        except (AttributeError, TypeError, LookupError):
+            if isinstance(argument, str):
+                try:
+                    attr = str(argument)
+                except Exception:
+                    pass
+                else:
+                    try:
+                        return getattr(obj, attr)
+                    except AttributeError:
+                        pass
+            return self.undefined(obj=obj, name=argument)
+
+    def getattr(self, obj: t.Any, attribute: str) -> t.Any:
+        """Get an item or attribute of an object but prefer the attribute.
+        Unlike :meth:`getitem` the attribute *must* be a string.
+        """
+        try:
+            return getattr(obj, attribute)
+        except AttributeError:
+            pass
+        try:
+            return obj[attribute]
+        except (TypeError, LookupError, AttributeError):
+            return self.undefined(obj=obj, name=attribute)
+
+    def _filter_test_common(
+        self,
+        name: t.Union[str, Undefined],
+        value: t.Any,
+        args: t.Optional[t.Sequence[t.Any]],
+        kwargs: t.Optional[t.Mapping[str, t.Any]],
+        context: t.Optional[Context],
+        eval_ctx: t.Optional[EvalContext],
+        is_filter: bool,
+    ) -> t.Any:
+        if is_filter:
+            env_map = self.filters
+            type_name = "filter"
+        else:
+            env_map = self.tests
+            type_name = "test"
+
+        func = env_map.get(name)  # type: ignore
+
+        if func is None:
+            msg = f"No {type_name} named {name!r}."
+
+            if isinstance(name, Undefined):
+                try:
+                    name._fail_with_undefined_error()
+                except Exception as e:
+                    msg = f"{msg} ({e}; did you forget to quote the callable name?)"
+
+            raise TemplateRuntimeError(msg)
+
+        args = [value, *(args if args is not None else ())]
+        kwargs = kwargs if kwargs is not None else {}
+        pass_arg = _PassArg.from_obj(func)
+
+        if pass_arg is _PassArg.context:
+            if context is None:
+                raise TemplateRuntimeError(
+                    f"Attempted to invoke a context {type_name} without context."
+                )
+
+            args.insert(0, context)
+        elif pass_arg is _PassArg.eval_context:
+            if eval_ctx is None:
+                if context is not None:
+                    eval_ctx = context.eval_ctx
+                else:
+                    eval_ctx = EvalContext(self)
+
+            args.insert(0, eval_ctx)
+        elif pass_arg is _PassArg.environment:
+            args.insert(0, self)
+
+        return func(*args, **kwargs)
+
+    def call_filter(
+        self,
+        name: str,
+        value: t.Any,
+        args: t.Optional[t.Sequence[t.Any]] = None,
+        kwargs: t.Optional[t.Mapping[str, t.Any]] = None,
+        context: t.Optional[Context] = None,
+        eval_ctx: t.Optional[EvalContext] = None,
+    ) -> t.Any:
+        """Invoke a filter on a value the same way the compiler does.
+
+        This might return a coroutine if the filter is running from an
+        environment in async mode and the filter supports async
+        execution. It's your responsibility to await this if needed.
+
+        .. versionadded:: 2.7
+        """
+        return self._filter_test_common(
+            name, value, args, kwargs, context, eval_ctx, True
+        )
+
+    def call_test(
+        self,
+        name: str,
+        value: t.Any,
+        args: t.Optional[t.Sequence[t.Any]] = None,
+        kwargs: t.Optional[t.Mapping[str, t.Any]] = None,
+        context: t.Optional[Context] = None,
+        eval_ctx: t.Optional[EvalContext] = None,
+    ) -> t.Any:
+        """Invoke a test on a value the same way the compiler does.
+
+        This might return a coroutine if the test is running from an
+        environment in async mode and the test supports async execution.
+        It's your responsibility to await this if needed.
+
+        .. versionchanged:: 3.0
+            Tests support ``@pass_context``, etc. decorators. Added
+            the ``context`` and ``eval_ctx`` parameters.
+
+        .. versionadded:: 2.7
+        """
+        return self._filter_test_common(
+            name, value, args, kwargs, context, eval_ctx, False
+        )
+
+    @internalcode
+    def parse(
+        self,
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> nodes.Template:
+        """Parse the sourcecode and return the abstract syntax tree.  This
+        tree of nodes is used by the compiler to convert the template into
+        executable source- or bytecode.  This is useful for debugging or to
+        extract information from templates.
+
+        If you are :ref:`developing Jinja extensions <writing-extensions>`
+        this gives you a good overview of the node tree generated.
+        """
+        try:
+            return self._parse(source, name, filename)
+        except TemplateSyntaxError:
+            self.handle_exception(source=source)
+
+    def _parse(
+        self, source: str, name: t.Optional[str], filename: t.Optional[str]
+    ) -> nodes.Template:
+        """Internal parsing function used by `parse` and `compile`."""
+        return Parser(self, source, name, filename).parse()
+
+    def lex(
+        self,
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> t.Iterator[t.Tuple[int, str, str]]:
+        """Lex the given sourcecode and return a generator that yields
+        tokens as tuples in the form ``(lineno, token_type, value)``.
+        This can be useful for :ref:`extension development <writing-extensions>`
+        and debugging templates.
+
+        This does not perform preprocessing.  If you want the preprocessing
+        of the extensions to be applied you have to filter source through
+        the :meth:`preprocess` method.
+        """
+        source = str(source)
+        try:
+            return self.lexer.tokeniter(source, name, filename)
+        except TemplateSyntaxError:
+            self.handle_exception(source=source)
+
+    def preprocess(
+        self,
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> str:
+        """Preprocesses the source with all extensions.  This is automatically
+        called for all parsing and compiling methods but *not* for :meth:`lex`
+        because there you usually only want the actual source tokenized.
+        """
+        return reduce(
+            lambda s, e: e.preprocess(s, name, filename),
+            self.iter_extensions(),
+            str(source),
+        )
+
+    def _tokenize(
+        self,
+        source: str,
+        name: t.Optional[str],
+        filename: t.Optional[str] = None,
+        state: t.Optional[str] = None,
+    ) -> TokenStream:
+        """Called by the parser to do the preprocessing and filtering
+        for all the extensions.  Returns a :class:`~jinja2.lexer.TokenStream`.
+        """
+        source = self.preprocess(source, name, filename)
+        stream = self.lexer.tokenize(source, name, filename, state)
+
+        for ext in self.iter_extensions():
+            stream = ext.filter_stream(stream)  # type: ignore
+
+            if not isinstance(stream, TokenStream):
+                stream = TokenStream(stream, name, filename)  # type: ignore
+
+        return stream
+
+    def _generate(
+        self,
+        source: nodes.Template,
+        name: t.Optional[str],
+        filename: t.Optional[str],
+        defer_init: bool = False,
+    ) -> str:
+        """Internal hook that can be overridden to hook a different generate
+        method in.
+
+        .. versionadded:: 2.5
+        """
+        return generate(  # type: ignore
+            source,
+            self,
+            name,
+            filename,
+            defer_init=defer_init,
+            optimized=self.optimized,
+        )
+
+    def _compile(self, source: str, filename: str) -> CodeType:
+        """Internal hook that can be overridden to hook a different compile
+        method in.
+
+        .. versionadded:: 2.5
+        """
+        return compile(source, filename, "exec")  # type: ignore
+
+    @typing.overload
+    def compile(  # type: ignore
+        self,
+        source: t.Union[str, nodes.Template],
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        raw: "te.Literal[False]" = False,
+        defer_init: bool = False,
+    ) -> CodeType:
+        ...
+
+    @typing.overload
+    def compile(
+        self,
+        source: t.Union[str, nodes.Template],
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        raw: "te.Literal[True]" = ...,
+        defer_init: bool = False,
+    ) -> str:
+        ...
+
+    @internalcode
+    def compile(
+        self,
+        source: t.Union[str, nodes.Template],
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        raw: bool = False,
+        defer_init: bool = False,
+    ) -> t.Union[str, CodeType]:
+        """Compile a node or template source code.  The `name` parameter is
+        the load name of the template after it was joined using
+        :meth:`join_path` if necessary, not the filename on the file system.
+        the `filename` parameter is the estimated filename of the template on
+        the file system.  If the template came from a database or memory this
+        can be omitted.
+
+        The return value of this method is a python code object.  If the `raw`
+        parameter is `True` the return value will be a string with python
+        code equivalent to the bytecode returned otherwise.  This method is
+        mainly used internally.
+
+        `defer_init` is use internally to aid the module code generator.  This
+        causes the generated code to be able to import without the global
+        environment variable to be set.
+
+        .. versionadded:: 2.4
+           `defer_init` parameter added.
+        """
+        source_hint = None
+        try:
+            if isinstance(source, str):
+                source_hint = source
+                source = self._parse(source, name, filename)
+            source = self._generate(source, name, filename, defer_init=defer_init)
+            if raw:
+                return source
+            if filename is None:
+                filename = "<template>"
+            return self._compile(source, filename)
+        except TemplateSyntaxError:
+            self.handle_exception(source=source_hint)
+
+    def compile_expression(
+        self, source: str, undefined_to_none: bool = True
+    ) -> "TemplateExpression":
+        """A handy helper method that returns a callable that accepts keyword
+        arguments that appear as variables in the expression.  If called it
+        returns the result of the expression.
+
+        This is useful if applications want to use the same rules as Jinja
+        in template "configuration files" or similar situations.
+
+        Example usage:
+
+        >>> env = Environment()
+        >>> expr = env.compile_expression('foo == 42')
+        >>> expr(foo=23)
+        False
+        >>> expr(foo=42)
+        True
+
+        Per default the return value is converted to `None` if the
+        expression returns an undefined value.  This can be changed
+        by setting `undefined_to_none` to `False`.
+
+        >>> env.compile_expression('var')() is None
+        True
+        >>> env.compile_expression('var', undefined_to_none=False)()
+        Undefined
+
+        .. versionadded:: 2.1
+        """
+        parser = Parser(self, source, state="variable")
+        try:
+            expr = parser.parse_expression()
+            if not parser.stream.eos:
+                raise TemplateSyntaxError(
+                    "chunk after expression", parser.stream.current.lineno, None, None
+                )
+            expr.set_environment(self)
+        except TemplateSyntaxError:
+            self.handle_exception(source=source)
+
+        body = [nodes.Assign(nodes.Name("result", "store"), expr, lineno=1)]
+        template = self.from_string(nodes.Template(body, lineno=1))
+        return TemplateExpression(template, undefined_to_none)
+
+    def compile_templates(
+        self,
+        target: t.Union[str, os.PathLike],
+        extensions: t.Optional[t.Collection[str]] = None,
+        filter_func: t.Optional[t.Callable[[str], bool]] = None,
+        zip: t.Optional[str] = "deflated",
+        log_function: t.Optional[t.Callable[[str], None]] = None,
+        ignore_errors: bool = True,
+    ) -> None:
+        """Finds all the templates the loader can find, compiles them
+        and stores them in `target`.  If `zip` is `None`, instead of in a
+        zipfile, the templates will be stored in a directory.
+        By default a deflate zip algorithm is used. To switch to
+        the stored algorithm, `zip` can be set to ``'stored'``.
+
+        `extensions` and `filter_func` are passed to :meth:`list_templates`.
+        Each template returned will be compiled to the target folder or
+        zipfile.
+
+        By default template compilation errors are ignored.  In case a
+        log function is provided, errors are logged.  If you want template
+        syntax errors to abort the compilation you can set `ignore_errors`
+        to `False` and you will get an exception on syntax errors.
+
+        .. versionadded:: 2.4
+        """
+        from .loaders import ModuleLoader
+
+        if log_function is None:
+
+            def log_function(x: str) -> None:
+                pass
+
+        assert log_function is not None
+        assert self.loader is not None, "No loader configured."
+
+        def write_file(filename: str, data: str) -> None:
+            if zip:
+                info = ZipInfo(filename)
+                info.external_attr = 0o755 << 16
+                zip_file.writestr(info, data)
+            else:
+                with open(os.path.join(target, filename), "wb") as f:
+                    f.write(data.encode("utf8"))
+
+        if zip is not None:
+            from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED, ZIP_STORED
+
+            zip_file = ZipFile(
+                target, "w", dict(deflated=ZIP_DEFLATED, stored=ZIP_STORED)[zip]
+            )
+            log_function(f"Compiling into Zip archive {target!r}")
+        else:
+            if not os.path.isdir(target):
+                os.makedirs(target)
+            log_function(f"Compiling into folder {target!r}")
+
+        try:
+            for name in self.list_templates(extensions, filter_func):
+                source, filename, _ = self.loader.get_source(self, name)
+                try:
+                    code = self.compile(source, name, filename, True, True)
+                except TemplateSyntaxError as e:
+                    if not ignore_errors:
+                        raise
+                    log_function(f'Could not compile "{name}": {e}')
+                    continue
+
+                filename = ModuleLoader.get_module_filename(name)
+
+                write_file(filename, code)
+                log_function(f'Compiled "{name}" as {filename}')
+        finally:
+            if zip:
+                zip_file.close()
+
+        log_function("Finished compiling templates")
+
+    def list_templates(
+        self,
+        extensions: t.Optional[t.Collection[str]] = None,
+        filter_func: t.Optional[t.Callable[[str], bool]] = None,
+    ) -> t.List[str]:
+        """Returns a list of templates for this environment.  This requires
+        that the loader supports the loader's
+        :meth:`~BaseLoader.list_templates` method.
+
+        If there are other files in the template folder besides the
+        actual templates, the returned list can be filtered.  There are two
+        ways: either `extensions` is set to a list of file extensions for
+        templates, or a `filter_func` can be provided which is a callable that
+        is passed a template name and should return `True` if it should end up
+        in the result list.
+
+        If the loader does not support that, a :exc:`TypeError` is raised.
+
+        .. versionadded:: 2.4
+        """
+        assert self.loader is not None, "No loader configured."
+        names = self.loader.list_templates()
+
+        if extensions is not None:
+            if filter_func is not None:
+                raise TypeError(
+                    "either extensions or filter_func can be passed, but not both"
+                )
+
+            def filter_func(x: str) -> bool:
+                return "." in x and x.rsplit(".", 1)[1] in extensions  # type: ignore
+
+        if filter_func is not None:
+            names = [name for name in names if filter_func(name)]
+
+        return names
+
+    def handle_exception(self, source: t.Optional[str] = None) -> "te.NoReturn":
+        """Exception handling helper.  This is used internally to either raise
+        rewritten exceptions or return a rendered traceback for the template.
+        """
+        from .debug import rewrite_traceback_stack
+
+        raise rewrite_traceback_stack(source=source)
+
+    def join_path(self, template: str, parent: str) -> str:
+        """Join a template with the parent.  By default all the lookups are
+        relative to the loader root so this method returns the `template`
+        parameter unchanged, but if the paths should be relative to the
+        parent template, this function can be used to calculate the real
+        template name.
+
+        Subclasses may override this method and implement template path
+        joining here.
+        """
+        return template
+
+    @internalcode
+    def _load_template(
+        self, name: str, globals: t.Optional[t.MutableMapping[str, t.Any]]
+    ) -> "Template":
+        if self.loader is None:
+            raise TypeError("no loader for this environment specified")
+        cache_key = (weakref.ref(self.loader), name)
+        if self.cache is not None:
+            template = self.cache.get(cache_key)
+            if template is not None and (
+                not self.auto_reload or template.is_up_to_date
+            ):
+                # template.globals is a ChainMap, modifying it will only
+                # affect the template, not the environment globals.
+                if globals:
+                    template.globals.update(globals)
+
+                return template
+
+        template = self.loader.load(self, name, self.make_globals(globals))
+
+        if self.cache is not None:
+            self.cache[cache_key] = template
+        return template
+
+    @internalcode
+    def get_template(
+        self,
+        name: t.Union[str, "Template"],
+        parent: t.Optional[str] = None,
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ) -> "Template":
+        """Load a template by name with :attr:`loader` and return a
+        :class:`Template`. If the template does not exist a
+        :exc:`TemplateNotFound` exception is raised.
+
+        :param name: Name of the template to load. When loading
+            templates from the filesystem, "/" is used as the path
+            separator, even on Windows.
+        :param parent: The name of the parent template importing this
+            template. :meth:`join_path` can be used to implement name
+            transformations with this.
+        :param globals: Extend the environment :attr:`globals` with
+            these extra variables available for all renders of this
+            template. If the template has already been loaded and
+            cached, its globals are updated with any new items.
+
+        .. versionchanged:: 3.0
+            If a template is loaded from cache, ``globals`` will update
+            the template's globals instead of ignoring the new values.
+
+        .. versionchanged:: 2.4
+            If ``name`` is a :class:`Template` object it is returned
+            unchanged.
+        """
+        if isinstance(name, Template):
+            return name
+        if parent is not None:
+            name = self.join_path(name, parent)
+
+        return self._load_template(name, globals)
+
+    @internalcode
+    def select_template(
+        self,
+        names: t.Iterable[t.Union[str, "Template"]],
+        parent: t.Optional[str] = None,
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ) -> "Template":
+        """Like :meth:`get_template`, but tries loading multiple names.
+        If none of the names can be loaded a :exc:`TemplatesNotFound`
+        exception is raised.
+
+        :param names: List of template names to try loading in order.
+        :param parent: The name of the parent template importing this
+            template. :meth:`join_path` can be used to implement name
+            transformations with this.
+        :param globals: Extend the environment :attr:`globals` with
+            these extra variables available for all renders of this
+            template. If the template has already been loaded and
+            cached, its globals are updated with any new items.
+
+        .. versionchanged:: 3.0
+            If a template is loaded from cache, ``globals`` will update
+            the template's globals instead of ignoring the new values.
+
+        .. versionchanged:: 2.11
+            If ``names`` is :class:`Undefined`, an :exc:`UndefinedError`
+            is raised instead. If no templates were found and ``names``
+            contains :class:`Undefined`, the message is more helpful.
+
+        .. versionchanged:: 2.4
+            If ``names`` contains a :class:`Template` object it is
+            returned unchanged.
+
+        .. versionadded:: 2.3
+        """
+        if isinstance(names, Undefined):
+            names._fail_with_undefined_error()
+
+        if not names:
+            raise TemplatesNotFound(
+                message="Tried to select from an empty list of templates."
+            )
+
+        for name in names:
+            if isinstance(name, Template):
+                return name
+            if parent is not None:
+                name = self.join_path(name, parent)
+            try:
+                return self._load_template(name, globals)
+            except (TemplateNotFound, UndefinedError):
+                pass
+        raise TemplatesNotFound(names)  # type: ignore
+
+    @internalcode
+    def get_or_select_template(
+        self,
+        template_name_or_list: t.Union[
+            str, "Template", t.List[t.Union[str, "Template"]]
+        ],
+        parent: t.Optional[str] = None,
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ) -> "Template":
+        """Use :meth:`select_template` if an iterable of template names
+        is given, or :meth:`get_template` if one name is given.
+
+        .. versionadded:: 2.3
+        """
+        if isinstance(template_name_or_list, (str, Undefined)):
+            return self.get_template(template_name_or_list, parent, globals)
+        elif isinstance(template_name_or_list, Template):
+            return template_name_or_list
+        return self.select_template(template_name_or_list, parent, globals)
+
+    def from_string(
+        self,
+        source: t.Union[str, nodes.Template],
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+        template_class: t.Optional[t.Type["Template"]] = None,
+    ) -> "Template":
+        """Load a template from a source string without using
+        :attr:`loader`.
+
+        :param source: Jinja source to compile into a template.
+        :param globals: Extend the environment :attr:`globals` with
+            these extra variables available for all renders of this
+            template. If the template has already been loaded and
+            cached, its globals are updated with any new items.
+        :param template_class: Return an instance of this
+            :class:`Template` class.
+        """
+        gs = self.make_globals(globals)
+        cls = template_class or self.template_class
+        return cls.from_code(self, self.compile(source), gs, None)
+
+    def make_globals(
+        self, d: t.Optional[t.MutableMapping[str, t.Any]]
+    ) -> t.MutableMapping[str, t.Any]:
+        """Make the globals map for a template. Any given template
+        globals overlay the environment :attr:`globals`.
+
+        Returns a :class:`collections.ChainMap`. This allows any changes
+        to a template's globals to only affect that template, while
+        changes to the environment's globals are still reflected.
+        However, avoid modifying any globals after a template is loaded.
+
+        :param d: Dict of template-specific globals.
+
+        .. versionchanged:: 3.0
+            Use :class:`collections.ChainMap` to always prevent mutating
+            environment globals.
+        """
+        if d is None:
+            d = {}
+
+        return ChainMap(d, self.globals)
+
+
+class Template:
+    """A compiled template that can be rendered.
+
+    Use the methods on :class:`Environment` to create or load templates.
+    The environment is used to configure how templates are compiled and
+    behave.
+
+    It is also possible to create a template object directly. This is
+    not usually recommended. The constructor takes most of the same
+    arguments as :class:`Environment`. All templates created with the
+    same environment arguments share the same ephemeral ``Environment``
+    instance behind the scenes.
+
+    A template object should be considered immutable. Modifications on
+    the object are not supported.
+    """
+
+    #: Type of environment to create when creating a template directly
+    #: rather than through an existing environment.
+    environment_class: t.Type[Environment] = Environment
+
+    environment: Environment
+    globals: t.MutableMapping[str, t.Any]
+    name: t.Optional[str]
+    filename: t.Optional[str]
+    blocks: t.Dict[str, t.Callable[[Context], t.Iterator[str]]]
+    root_render_func: t.Callable[[Context], t.Iterator[str]]
+    _module: t.Optional["TemplateModule"]
+    _debug_info: str
+    _uptodate: t.Optional[t.Callable[[], bool]]
+
+    def __new__(
+        cls,
+        source: t.Union[str, nodes.Template],
+        block_start_string: str = BLOCK_START_STRING,
+        block_end_string: str = BLOCK_END_STRING,
+        variable_start_string: str = VARIABLE_START_STRING,
+        variable_end_string: str = VARIABLE_END_STRING,
+        comment_start_string: str = COMMENT_START_STRING,
+        comment_end_string: str = COMMENT_END_STRING,
+        line_statement_prefix: t.Optional[str] = LINE_STATEMENT_PREFIX,
+        line_comment_prefix: t.Optional[str] = LINE_COMMENT_PREFIX,
+        trim_blocks: bool = TRIM_BLOCKS,
+        lstrip_blocks: bool = LSTRIP_BLOCKS,
+        newline_sequence: "te.Literal['\\n', '\\r\\n', '\\r']" = NEWLINE_SEQUENCE,
+        keep_trailing_newline: bool = KEEP_TRAILING_NEWLINE,
+        extensions: t.Sequence[t.Union[str, t.Type["Extension"]]] = (),
+        optimized: bool = True,
+        undefined: t.Type[Undefined] = Undefined,
+        finalize: t.Optional[t.Callable[..., t.Any]] = None,
+        autoescape: t.Union[bool, t.Callable[[t.Optional[str]], bool]] = False,
+        enable_async: bool = False,
+    ) -> t.Any:  # it returns a `Template`, but this breaks the sphinx build...
+        env = get_spontaneous_environment(
+            cls.environment_class,  # type: ignore
+            block_start_string,
+            block_end_string,
+            variable_start_string,
+            variable_end_string,
+            comment_start_string,
+            comment_end_string,
+            line_statement_prefix,
+            line_comment_prefix,
+            trim_blocks,
+            lstrip_blocks,
+            newline_sequence,
+            keep_trailing_newline,
+            frozenset(extensions),
+            optimized,
+            undefined,  # type: ignore
+            finalize,
+            autoescape,
+            None,
+            0,
+            False,
+            None,
+            enable_async,
+        )
+        return env.from_string(source, template_class=cls)
+
+    @classmethod
+    def from_code(
+        cls,
+        environment: Environment,
+        code: CodeType,
+        globals: t.MutableMapping[str, t.Any],
+        uptodate: t.Optional[t.Callable[[], bool]] = None,
+    ) -> "Template":
+        """Creates a template object from compiled code and the globals.  This
+        is used by the loaders and environment to create a template object.
+        """
+        namespace = {"environment": environment, "__file__": code.co_filename}
+        exec(code, namespace)
+        rv = cls._from_namespace(environment, namespace, globals)
+        rv._uptodate = uptodate
+        return rv
+
+    @classmethod
+    def from_module_dict(
+        cls,
+        environment: Environment,
+        module_dict: t.MutableMapping[str, t.Any],
+        globals: t.MutableMapping[str, t.Any],
+    ) -> "Template":
+        """Creates a template object from a module.  This is used by the
+        module loader to create a template object.
+
+        .. versionadded:: 2.4
+        """
+        return cls._from_namespace(environment, module_dict, globals)
+
+    @classmethod
+    def _from_namespace(
+        cls,
+        environment: Environment,
+        namespace: t.MutableMapping[str, t.Any],
+        globals: t.MutableMapping[str, t.Any],
+    ) -> "Template":
+        t: "Template" = object.__new__(cls)
+        t.environment = environment
+        t.globals = globals
+        t.name = namespace["name"]
+        t.filename = namespace["__file__"]
+        t.blocks = namespace["blocks"]
+
+        # render function and module
+        t.root_render_func = namespace["root"]  # type: ignore
+        t._module = None
+
+        # debug and loader helpers
+        t._debug_info = namespace["debug_info"]
+        t._uptodate = None
+
+        # store the reference
+        namespace["environment"] = environment
+        namespace["__jinja_template__"] = t
+
+        return t
+
+    def render(self, *args: t.Any, **kwargs: t.Any) -> str:
+        """This method accepts the same arguments as the `dict` constructor:
+        A dict, a dict subclass or some keyword arguments.  If no arguments
+        are given the context will be empty.  These two calls do the same::
+
+            template.render(knights='that say nih')
+            template.render({'knights': 'that say nih'})
+
+        This will return the rendered template as a string.
+        """
+        if self.environment.is_async:
+            import asyncio
+
+            close = False
+
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                close = True
+
+            try:
+                return loop.run_until_complete(self.render_async(*args, **kwargs))
+            finally:
+                if close:
+                    loop.close()
+
+        ctx = self.new_context(dict(*args, **kwargs))
+
+        try:
+            return self.environment.concat(self.root_render_func(ctx))  # type: ignore
+        except Exception:
+            self.environment.handle_exception()
+
+    async def render_async(self, *args: t.Any, **kwargs: t.Any) -> str:
+        """This works similar to :meth:`render` but returns a coroutine
+        that when awaited returns the entire rendered template string.  This
+        requires the async feature to be enabled.
+
+        Example usage::
+
+            await template.render_async(knights='that say nih; asynchronously')
+        """
+        if not self.environment.is_async:
+            raise RuntimeError(
+                "The environment was not created with async mode enabled."
+            )
+
+        ctx = self.new_context(dict(*args, **kwargs))
+
+        try:
+            return self.environment.concat(  # type: ignore
+                [n async for n in self.root_render_func(ctx)]  # type: ignore
+            )
+        except Exception:
+            return self.environment.handle_exception()
+
+    def stream(self, *args: t.Any, **kwargs: t.Any) -> "TemplateStream":
+        """Works exactly like :meth:`generate` but returns a
+        :class:`TemplateStream`.
+        """
+        return TemplateStream(self.generate(*args, **kwargs))
+
+    def generate(self, *args: t.Any, **kwargs: t.Any) -> t.Iterator[str]:
+        """For very large templates it can be useful to not render the whole
+        template at once but evaluate each statement after another and yield
+        piece for piece.  This method basically does exactly that and returns
+        a generator that yields one item after another as strings.
+
+        It accepts the same arguments as :meth:`render`.
+        """
+        if self.environment.is_async:
+            import asyncio
+
+            async def to_list() -> t.List[str]:
+                return [x async for x in self.generate_async(*args, **kwargs)]
+
+            yield from asyncio.run(to_list())
+            return
+
+        ctx = self.new_context(dict(*args, **kwargs))
+
+        try:
+            yield from self.root_render_func(ctx)  # type: ignore
+        except Exception:
+            yield self.environment.handle_exception()
+
+    async def generate_async(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.AsyncIterator[str]:
+        """An async version of :meth:`generate`.  Works very similarly but
+        returns an async iterator instead.
+        """
+        if not self.environment.is_async:
+            raise RuntimeError(
+                "The environment was not created with async mode enabled."
+            )
+
+        ctx = self.new_context(dict(*args, **kwargs))
+
+        try:
+            async for event in self.root_render_func(ctx):  # type: ignore
+                yield event
+        except Exception:
+            yield self.environment.handle_exception()
+
+    def new_context(
+        self,
+        vars: t.Optional[t.Dict[str, t.Any]] = None,
+        shared: bool = False,
+        locals: t.Optional[t.Mapping[str, t.Any]] = None,
+    ) -> Context:
+        """Create a new :class:`Context` for this template.  The vars
+        provided will be passed to the template.  Per default the globals
+        are added to the context.  If shared is set to `True` the data
+        is passed as is to the context without adding the globals.
+
+        `locals` can be a dict of local variables for internal usage.
+        """
+        return new_context(
+            self.environment, self.name, self.blocks, vars, shared, self.globals, locals
+        )
+
+    def make_module(
+        self,
+        vars: t.Optional[t.Dict[str, t.Any]] = None,
+        shared: bool = False,
+        locals: t.Optional[t.Mapping[str, t.Any]] = None,
+    ) -> "TemplateModule":
+        """This method works like the :attr:`module` attribute when called
+        without arguments but it will evaluate the template on every call
+        rather than caching it.  It's also possible to provide
+        a dict which is then used as context.  The arguments are the same
+        as for the :meth:`new_context` method.
+        """
+        ctx = self.new_context(vars, shared, locals)
+        return TemplateModule(self, ctx)
+
+    async def make_module_async(
+        self,
+        vars: t.Optional[t.Dict[str, t.Any]] = None,
+        shared: bool = False,
+        locals: t.Optional[t.Mapping[str, t.Any]] = None,
+    ) -> "TemplateModule":
+        """As template module creation can invoke template code for
+        asynchronous executions this method must be used instead of the
+        normal :meth:`make_module` one.  Likewise the module attribute
+        becomes unavailable in async mode.
+        """
+        ctx = self.new_context(vars, shared, locals)
+        return TemplateModule(
+            self, ctx, [x async for x in self.root_render_func(ctx)]  # type: ignore
+        )
+
+    @internalcode
+    def _get_default_module(self, ctx: t.Optional[Context] = None) -> "TemplateModule":
+        """If a context is passed in, this means that the template was
+        imported. Imported templates have access to the current
+        template's globals by default, but they can only be accessed via
+        the context during runtime.
+
+        If there are new globals, we need to create a new module because
+        the cached module is already rendered and will not have access
+        to globals from the current context. This new module is not
+        cached because the template can be imported elsewhere, and it
+        should have access to only the current template's globals.
+        """
+        if self.environment.is_async:
+            raise RuntimeError("Module is not available in async mode.")
+
+        if ctx is not None:
+            keys = ctx.globals_keys - self.globals.keys()
+
+            if keys:
+                return self.make_module({k: ctx.parent[k] for k in keys})
+
+        if self._module is None:
+            self._module = self.make_module()
+
+        return self._module
+
+    async def _get_default_module_async(
+        self, ctx: t.Optional[Context] = None
+    ) -> "TemplateModule":
+        if ctx is not None:
+            keys = ctx.globals_keys - self.globals.keys()
+
+            if keys:
+                return await self.make_module_async({k: ctx.parent[k] for k in keys})
+
+        if self._module is None:
+            self._module = await self.make_module_async()
+
+        return self._module
+
+    @property
+    def module(self) -> "TemplateModule":
+        """The template as module.  This is used for imports in the
+        template runtime but is also useful if one wants to access
+        exported template variables from the Python layer:
+
+        >>> t = Template('{% macro foo() %}42{% endmacro %}23')
+        >>> str(t.module)
+        '23'
+        >>> t.module.foo() == u'42'
+        True
+
+        This attribute is not available if async mode is enabled.
+        """
+        return self._get_default_module()
+
+    def get_corresponding_lineno(self, lineno: int) -> int:
+        """Return the source line number of a line number in the
+        generated bytecode as they are not in sync.
+        """
+        for template_line, code_line in reversed(self.debug_info):
+            if code_line <= lineno:
+                return template_line
+        return 1
+
+    @property
+    def is_up_to_date(self) -> bool:
+        """If this variable is `False` there is a newer version available."""
+        if self._uptodate is None:
+            return True
+        return self._uptodate()
+
+    @property
+    def debug_info(self) -> t.List[t.Tuple[int, int]]:
+        """The debug info mapping."""
+        if self._debug_info:
+            return [
+                tuple(map(int, x.split("=")))  # type: ignore
+                for x in self._debug_info.split("&")
+            ]
+
+        return []
+
+    def __repr__(self) -> str:
+        if self.name is None:
+            name = f"memory:{id(self):x}"
+        else:
+            name = repr(self.name)
+        return f"<{type(self).__name__} {name}>"
+
+
+class TemplateModule:
+    """Represents an imported template.  All the exported names of the
+    template are available as attributes on this object.  Additionally
+    converting it into a string renders the contents.
+    """
+
+    def __init__(
+        self,
+        template: Template,
+        context: Context,
+        body_stream: t.Optional[t.Iterable[str]] = None,
+    ) -> None:
+        if body_stream is None:
+            if context.environment.is_async:
+                raise RuntimeError(
+                    "Async mode requires a body stream to be passed to"
+                    " a template module. Use the async methods of the"
+                    " API you are using."
+                )
+
+            body_stream = list(template.root_render_func(context))  # type: ignore
+
+        self._body_stream = body_stream
+        self.__dict__.update(context.get_exported())
+        self.__name__ = template.name
+
+    def __html__(self) -> Markup:
+        return Markup(concat(self._body_stream))
+
+    def __str__(self) -> str:
+        return concat(self._body_stream)
+
+    def __repr__(self) -> str:
+        if self.__name__ is None:
+            name = f"memory:{id(self):x}"
+        else:
+            name = repr(self.__name__)
+        return f"<{type(self).__name__} {name}>"
+
+
+class TemplateExpression:
+    """The :meth:`jinja2.Environment.compile_expression` method returns an
+    instance of this object.  It encapsulates the expression-like access
+    to the template with an expression it wraps.
+    """
+
+    def __init__(self, template: Template, undefined_to_none: bool) -> None:
+        self._template = template
+        self._undefined_to_none = undefined_to_none
+
+    def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Optional[t.Any]:
+        context = self._template.new_context(dict(*args, **kwargs))
+        consume(self._template.root_render_func(context))  # type: ignore
+        rv = context.vars["result"]
+        if self._undefined_to_none and isinstance(rv, Undefined):
+            rv = None
+        return rv
+
+
+class TemplateStream:
+    """A template stream works pretty much like an ordinary python generator
+    but it can buffer multiple items to reduce the number of total iterations.
+    Per default the output is unbuffered which means that for every unbuffered
+    instruction in the template one string is yielded.
+
+    If buffering is enabled with a buffer size of 5, five items are combined
+    into a new string.  This is mainly useful if you are streaming
+    big templates to a client via WSGI which flushes after each iteration.
+    """
+
+    def __init__(self, gen: t.Iterator[str]) -> None:
+        self._gen = gen
+        self.disable_buffering()
+
+    def dump(
+        self,
+        fp: t.Union[str, t.IO],
+        encoding: t.Optional[str] = None,
+        errors: t.Optional[str] = "strict",
+    ) -> None:
+        """Dump the complete stream into a file or file-like object.
+        Per default strings are written, if you want to encode
+        before writing specify an `encoding`.
+
+        Example usage::
+
+            Template('Hello {{ name }}!').stream(name='foo').dump('hello.html')
+        """
+        close = False
+
+        if isinstance(fp, str):
+            if encoding is None:
+                encoding = "utf-8"
+
+            fp = open(fp, "wb")
+            close = True
+        try:
+            if encoding is not None:
+                iterable = (x.encode(encoding, errors) for x in self)  # type: ignore
+            else:
+                iterable = self  # type: ignore
+
+            if hasattr(fp, "writelines"):
+                fp.writelines(iterable)
+            else:
+                for item in iterable:
+                    fp.write(item)
+        finally:
+            if close:
+                fp.close()
+
+    def disable_buffering(self) -> None:
+        """Disable the output buffering."""
+        self._next = partial(next, self._gen)
+        self.buffered = False
+
+    def _buffered_generator(self, size: int) -> t.Iterator[str]:
+        buf: t.List[str] = []
+        c_size = 0
+        push = buf.append
+
+        while True:
+            try:
+                while c_size < size:
+                    c = next(self._gen)
+                    push(c)
+                    if c:
+                        c_size += 1
+            except StopIteration:
+                if not c_size:
+                    return
+            yield concat(buf)
+            del buf[:]
+            c_size = 0
+
+    def enable_buffering(self, size: int = 5) -> None:
+        """Enable buffering.  Buffer `size` items before yielding them."""
+        if size <= 1:
+            raise ValueError("buffer size too small")
+
+        self.buffered = True
+        self._next = partial(next, self._buffered_generator(size))
+
+    def __iter__(self) -> "TemplateStream":
+        return self
+
+    def __next__(self) -> str:
+        return self._next()  # type: ignore
+
+
+# hook in default template class.  if anyone reads this comment: ignore that
+# it's possible to use custom templates ;-)
+Environment.template_class = Template
diff --git a/lib/python3.11/site-packages/jinja2/exceptions.py b/lib/python3.11/site-packages/jinja2/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..082ebe8f221d4e7e980e4d321c0a0c5da033b124
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/exceptions.py
@@ -0,0 +1,166 @@
+import typing as t
+
+if t.TYPE_CHECKING:
+    from .runtime import Undefined
+
+
+class TemplateError(Exception):
+    """Baseclass for all template errors."""
+
+    def __init__(self, message: t.Optional[str] = None) -> None:
+        super().__init__(message)
+
+    @property
+    def message(self) -> t.Optional[str]:
+        return self.args[0] if self.args else None
+
+
+class TemplateNotFound(IOError, LookupError, TemplateError):
+    """Raised if a template does not exist.
+
+    .. versionchanged:: 2.11
+        If the given name is :class:`Undefined` and no message was
+        provided, an :exc:`UndefinedError` is raised.
+    """
+
+    # Silence the Python warning about message being deprecated since
+    # it's not valid here.
+    message: t.Optional[str] = None
+
+    def __init__(
+        self,
+        name: t.Optional[t.Union[str, "Undefined"]],
+        message: t.Optional[str] = None,
+    ) -> None:
+        IOError.__init__(self, name)
+
+        if message is None:
+            from .runtime import Undefined
+
+            if isinstance(name, Undefined):
+                name._fail_with_undefined_error()
+
+            message = name
+
+        self.message = message
+        self.name = name
+        self.templates = [name]
+
+    def __str__(self) -> str:
+        return str(self.message)
+
+
+class TemplatesNotFound(TemplateNotFound):
+    """Like :class:`TemplateNotFound` but raised if multiple templates
+    are selected.  This is a subclass of :class:`TemplateNotFound`
+    exception, so just catching the base exception will catch both.
+
+    .. versionchanged:: 2.11
+        If a name in the list of names is :class:`Undefined`, a message
+        about it being undefined is shown rather than the empty string.
+
+    .. versionadded:: 2.2
+    """
+
+    def __init__(
+        self,
+        names: t.Sequence[t.Union[str, "Undefined"]] = (),
+        message: t.Optional[str] = None,
+    ) -> None:
+        if message is None:
+            from .runtime import Undefined
+
+            parts = []
+
+            for name in names:
+                if isinstance(name, Undefined):
+                    parts.append(name._undefined_message)
+                else:
+                    parts.append(name)
+
+            parts_str = ", ".join(map(str, parts))
+            message = f"none of the templates given were found: {parts_str}"
+
+        super().__init__(names[-1] if names else None, message)
+        self.templates = list(names)
+
+
+class TemplateSyntaxError(TemplateError):
+    """Raised to tell the user that there is a problem with the template."""
+
+    def __init__(
+        self,
+        message: str,
+        lineno: int,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.lineno = lineno
+        self.name = name
+        self.filename = filename
+        self.source: t.Optional[str] = None
+
+        # this is set to True if the debug.translate_syntax_error
+        # function translated the syntax error into a new traceback
+        self.translated = False
+
+    def __str__(self) -> str:
+        # for translated errors we only return the message
+        if self.translated:
+            return t.cast(str, self.message)
+
+        # otherwise attach some stuff
+        location = f"line {self.lineno}"
+        name = self.filename or self.name
+        if name:
+            location = f'File "{name}", {location}'
+        lines = [t.cast(str, self.message), "  " + location]
+
+        # if the source is set, add the line to the output
+        if self.source is not None:
+            try:
+                line = self.source.splitlines()[self.lineno - 1]
+            except IndexError:
+                pass
+            else:
+                lines.append("    " + line.strip())
+
+        return "\n".join(lines)
+
+    def __reduce__(self):  # type: ignore
+        # https://bugs.python.org/issue1692335 Exceptions that take
+        # multiple required arguments have problems with pickling.
+        # Without this, raises TypeError: __init__() missing 1 required
+        # positional argument: 'lineno'
+        return self.__class__, (self.message, self.lineno, self.name, self.filename)
+
+
+class TemplateAssertionError(TemplateSyntaxError):
+    """Like a template syntax error, but covers cases where something in the
+    template caused an error at compile time that wasn't necessarily caused
+    by a syntax error.  However it's a direct subclass of
+    :exc:`TemplateSyntaxError` and has the same attributes.
+    """
+
+
+class TemplateRuntimeError(TemplateError):
+    """A generic runtime error in the template engine.  Under some situations
+    Jinja may raise this exception.
+    """
+
+
+class UndefinedError(TemplateRuntimeError):
+    """Raised if a template tries to operate on :class:`Undefined`."""
+
+
+class SecurityError(TemplateRuntimeError):
+    """Raised if a template tries to do something insecure if the
+    sandbox is enabled.
+    """
+
+
+class FilterArgumentError(TemplateRuntimeError):
+    """This error is raised if a filter was called with inappropriate
+    arguments
+    """
diff --git a/lib/python3.11/site-packages/jinja2/ext.py b/lib/python3.11/site-packages/jinja2/ext.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5550540cda01ea9da32747754d34603a7bbac0a
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/ext.py
@@ -0,0 +1,859 @@
+"""Extension API for adding custom tags and behavior."""
+import pprint
+import re
+import typing as t
+
+from markupsafe import Markup
+
+from . import defaults
+from . import nodes
+from .environment import Environment
+from .exceptions import TemplateAssertionError
+from .exceptions import TemplateSyntaxError
+from .runtime import concat  # type: ignore
+from .runtime import Context
+from .runtime import Undefined
+from .utils import import_string
+from .utils import pass_context
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .lexer import Token
+    from .lexer import TokenStream
+    from .parser import Parser
+
+    class _TranslationsBasic(te.Protocol):
+        def gettext(self, message: str) -> str:
+            ...
+
+        def ngettext(self, singular: str, plural: str, n: int) -> str:
+            pass
+
+    class _TranslationsContext(_TranslationsBasic):
+        def pgettext(self, context: str, message: str) -> str:
+            ...
+
+        def npgettext(self, context: str, singular: str, plural: str, n: int) -> str:
+            ...
+
+    _SupportedTranslations = t.Union[_TranslationsBasic, _TranslationsContext]
+
+
+# I18N functions available in Jinja templates. If the I18N library
+# provides ugettext, it will be assigned to gettext.
+GETTEXT_FUNCTIONS: t.Tuple[str, ...] = (
+    "_",
+    "gettext",
+    "ngettext",
+    "pgettext",
+    "npgettext",
+)
+_ws_re = re.compile(r"\s*\n\s*")
+
+
+class Extension:
+    """Extensions can be used to add extra functionality to the Jinja template
+    system at the parser level.  Custom extensions are bound to an environment
+    but may not store environment specific data on `self`.  The reason for
+    this is that an extension can be bound to another environment (for
+    overlays) by creating a copy and reassigning the `environment` attribute.
+
+    As extensions are created by the environment they cannot accept any
+    arguments for configuration.  One may want to work around that by using
+    a factory function, but that is not possible as extensions are identified
+    by their import name.  The correct way to configure the extension is
+    storing the configuration values on the environment.  Because this way the
+    environment ends up acting as central configuration storage the
+    attributes may clash which is why extensions have to ensure that the names
+    they choose for configuration are not too generic.  ``prefix`` for example
+    is a terrible name, ``fragment_cache_prefix`` on the other hand is a good
+    name as includes the name of the extension (fragment cache).
+    """
+
+    identifier: t.ClassVar[str]
+
+    def __init_subclass__(cls) -> None:
+        cls.identifier = f"{cls.__module__}.{cls.__name__}"
+
+    #: if this extension parses this is the list of tags it's listening to.
+    tags: t.Set[str] = set()
+
+    #: the priority of that extension.  This is especially useful for
+    #: extensions that preprocess values.  A lower value means higher
+    #: priority.
+    #:
+    #: .. versionadded:: 2.4
+    priority = 100
+
+    def __init__(self, environment: Environment) -> None:
+        self.environment = environment
+
+    def bind(self, environment: Environment) -> "Extension":
+        """Create a copy of this extension bound to another environment."""
+        rv = object.__new__(self.__class__)
+        rv.__dict__.update(self.__dict__)
+        rv.environment = environment
+        return rv
+
+    def preprocess(
+        self, source: str, name: t.Optional[str], filename: t.Optional[str] = None
+    ) -> str:
+        """This method is called before the actual lexing and can be used to
+        preprocess the source.  The `filename` is optional.  The return value
+        must be the preprocessed source.
+        """
+        return source
+
+    def filter_stream(
+        self, stream: "TokenStream"
+    ) -> t.Union["TokenStream", t.Iterable["Token"]]:
+        """It's passed a :class:`~jinja2.lexer.TokenStream` that can be used
+        to filter tokens returned.  This method has to return an iterable of
+        :class:`~jinja2.lexer.Token`\\s, but it doesn't have to return a
+        :class:`~jinja2.lexer.TokenStream`.
+        """
+        return stream
+
+    def parse(self, parser: "Parser") -> t.Union[nodes.Node, t.List[nodes.Node]]:
+        """If any of the :attr:`tags` matched this method is called with the
+        parser as first argument.  The token the parser stream is pointing at
+        is the name token that matched.  This method has to return one or a
+        list of multiple nodes.
+        """
+        raise NotImplementedError()
+
+    def attr(
+        self, name: str, lineno: t.Optional[int] = None
+    ) -> nodes.ExtensionAttribute:
+        """Return an attribute node for the current extension.  This is useful
+        to pass constants on extensions to generated template code.
+
+        ::
+
+            self.attr('_my_attribute', lineno=lineno)
+        """
+        return nodes.ExtensionAttribute(self.identifier, name, lineno=lineno)
+
+    def call_method(
+        self,
+        name: str,
+        args: t.Optional[t.List[nodes.Expr]] = None,
+        kwargs: t.Optional[t.List[nodes.Keyword]] = None,
+        dyn_args: t.Optional[nodes.Expr] = None,
+        dyn_kwargs: t.Optional[nodes.Expr] = None,
+        lineno: t.Optional[int] = None,
+    ) -> nodes.Call:
+        """Call a method of the extension.  This is a shortcut for
+        :meth:`attr` + :class:`jinja2.nodes.Call`.
+        """
+        if args is None:
+            args = []
+        if kwargs is None:
+            kwargs = []
+        return nodes.Call(
+            self.attr(name, lineno=lineno),
+            args,
+            kwargs,
+            dyn_args,
+            dyn_kwargs,
+            lineno=lineno,
+        )
+
+
+@pass_context
+def _gettext_alias(
+    __context: Context, *args: t.Any, **kwargs: t.Any
+) -> t.Union[t.Any, Undefined]:
+    return __context.call(__context.resolve("gettext"), *args, **kwargs)
+
+
+def _make_new_gettext(func: t.Callable[[str], str]) -> t.Callable[..., str]:
+    @pass_context
+    def gettext(__context: Context, __string: str, **variables: t.Any) -> str:
+        rv = __context.call(func, __string)
+        if __context.eval_ctx.autoescape:
+            rv = Markup(rv)
+        # Always treat as a format string, even if there are no
+        # variables. This makes translation strings more consistent
+        # and predictable. This requires escaping
+        return rv % variables  # type: ignore
+
+    return gettext
+
+
+def _make_new_ngettext(func: t.Callable[[str, str, int], str]) -> t.Callable[..., str]:
+    @pass_context
+    def ngettext(
+        __context: Context,
+        __singular: str,
+        __plural: str,
+        __num: int,
+        **variables: t.Any,
+    ) -> str:
+        variables.setdefault("num", __num)
+        rv = __context.call(func, __singular, __plural, __num)
+        if __context.eval_ctx.autoescape:
+            rv = Markup(rv)
+        # Always treat as a format string, see gettext comment above.
+        return rv % variables  # type: ignore
+
+    return ngettext
+
+
+def _make_new_pgettext(func: t.Callable[[str, str], str]) -> t.Callable[..., str]:
+    @pass_context
+    def pgettext(
+        __context: Context, __string_ctx: str, __string: str, **variables: t.Any
+    ) -> str:
+        variables.setdefault("context", __string_ctx)
+        rv = __context.call(func, __string_ctx, __string)
+
+        if __context.eval_ctx.autoescape:
+            rv = Markup(rv)
+
+        # Always treat as a format string, see gettext comment above.
+        return rv % variables  # type: ignore
+
+    return pgettext
+
+
+def _make_new_npgettext(
+    func: t.Callable[[str, str, str, int], str]
+) -> t.Callable[..., str]:
+    @pass_context
+    def npgettext(
+        __context: Context,
+        __string_ctx: str,
+        __singular: str,
+        __plural: str,
+        __num: int,
+        **variables: t.Any,
+    ) -> str:
+        variables.setdefault("context", __string_ctx)
+        variables.setdefault("num", __num)
+        rv = __context.call(func, __string_ctx, __singular, __plural, __num)
+
+        if __context.eval_ctx.autoescape:
+            rv = Markup(rv)
+
+        # Always treat as a format string, see gettext comment above.
+        return rv % variables  # type: ignore
+
+    return npgettext
+
+
+class InternationalizationExtension(Extension):
+    """This extension adds gettext support to Jinja."""
+
+    tags = {"trans"}
+
+    # TODO: the i18n extension is currently reevaluating values in a few
+    # situations.  Take this example:
+    #   {% trans count=something() %}{{ count }} foo{% pluralize
+    #     %}{{ count }} fooss{% endtrans %}
+    # something is called twice here.  One time for the gettext value and
+    # the other time for the n-parameter of the ngettext function.
+
+    def __init__(self, environment: Environment) -> None:
+        super().__init__(environment)
+        environment.globals["_"] = _gettext_alias
+        environment.extend(
+            install_gettext_translations=self._install,
+            install_null_translations=self._install_null,
+            install_gettext_callables=self._install_callables,
+            uninstall_gettext_translations=self._uninstall,
+            extract_translations=self._extract,
+            newstyle_gettext=False,
+        )
+
+    def _install(
+        self, translations: "_SupportedTranslations", newstyle: t.Optional[bool] = None
+    ) -> None:
+        # ugettext and ungettext are preferred in case the I18N library
+        # is providing compatibility with older Python versions.
+        gettext = getattr(translations, "ugettext", None)
+        if gettext is None:
+            gettext = translations.gettext
+        ngettext = getattr(translations, "ungettext", None)
+        if ngettext is None:
+            ngettext = translations.ngettext
+
+        pgettext = getattr(translations, "pgettext", None)
+        npgettext = getattr(translations, "npgettext", None)
+        self._install_callables(
+            gettext, ngettext, newstyle=newstyle, pgettext=pgettext, npgettext=npgettext
+        )
+
+    def _install_null(self, newstyle: t.Optional[bool] = None) -> None:
+        import gettext
+
+        translations = gettext.NullTranslations()
+
+        if hasattr(translations, "pgettext"):
+            # Python < 3.8
+            pgettext = translations.pgettext  # type: ignore
+        else:
+
+            def pgettext(c: str, s: str) -> str:
+                return s
+
+        if hasattr(translations, "npgettext"):
+            npgettext = translations.npgettext  # type: ignore
+        else:
+
+            def npgettext(c: str, s: str, p: str, n: int) -> str:
+                return s if n == 1 else p
+
+        self._install_callables(
+            gettext=translations.gettext,
+            ngettext=translations.ngettext,
+            newstyle=newstyle,
+            pgettext=pgettext,
+            npgettext=npgettext,
+        )
+
+    def _install_callables(
+        self,
+        gettext: t.Callable[[str], str],
+        ngettext: t.Callable[[str, str, int], str],
+        newstyle: t.Optional[bool] = None,
+        pgettext: t.Optional[t.Callable[[str, str], str]] = None,
+        npgettext: t.Optional[t.Callable[[str, str, str, int], str]] = None,
+    ) -> None:
+        if newstyle is not None:
+            self.environment.newstyle_gettext = newstyle  # type: ignore
+        if self.environment.newstyle_gettext:  # type: ignore
+            gettext = _make_new_gettext(gettext)
+            ngettext = _make_new_ngettext(ngettext)
+
+            if pgettext is not None:
+                pgettext = _make_new_pgettext(pgettext)
+
+            if npgettext is not None:
+                npgettext = _make_new_npgettext(npgettext)
+
+        self.environment.globals.update(
+            gettext=gettext, ngettext=ngettext, pgettext=pgettext, npgettext=npgettext
+        )
+
+    def _uninstall(self, translations: "_SupportedTranslations") -> None:
+        for key in ("gettext", "ngettext", "pgettext", "npgettext"):
+            self.environment.globals.pop(key, None)
+
+    def _extract(
+        self,
+        source: t.Union[str, nodes.Template],
+        gettext_functions: t.Sequence[str] = GETTEXT_FUNCTIONS,
+    ) -> t.Iterator[
+        t.Tuple[int, str, t.Union[t.Optional[str], t.Tuple[t.Optional[str], ...]]]
+    ]:
+        if isinstance(source, str):
+            source = self.environment.parse(source)
+        return extract_from_ast(source, gettext_functions)
+
+    def parse(self, parser: "Parser") -> t.Union[nodes.Node, t.List[nodes.Node]]:
+        """Parse a translatable tag."""
+        lineno = next(parser.stream).lineno
+
+        context = None
+        context_token = parser.stream.next_if("string")
+
+        if context_token is not None:
+            context = context_token.value
+
+        # find all the variables referenced.  Additionally a variable can be
+        # defined in the body of the trans block too, but this is checked at
+        # a later state.
+        plural_expr: t.Optional[nodes.Expr] = None
+        plural_expr_assignment: t.Optional[nodes.Assign] = None
+        num_called_num = False
+        variables: t.Dict[str, nodes.Expr] = {}
+        trimmed = None
+        while parser.stream.current.type != "block_end":
+            if variables:
+                parser.stream.expect("comma")
+
+            # skip colon for python compatibility
+            if parser.stream.skip_if("colon"):
+                break
+
+            token = parser.stream.expect("name")
+            if token.value in variables:
+                parser.fail(
+                    f"translatable variable {token.value!r} defined twice.",
+                    token.lineno,
+                    exc=TemplateAssertionError,
+                )
+
+            # expressions
+            if parser.stream.current.type == "assign":
+                next(parser.stream)
+                variables[token.value] = var = parser.parse_expression()
+            elif trimmed is None and token.value in ("trimmed", "notrimmed"):
+                trimmed = token.value == "trimmed"
+                continue
+            else:
+                variables[token.value] = var = nodes.Name(token.value, "load")
+
+            if plural_expr is None:
+                if isinstance(var, nodes.Call):
+                    plural_expr = nodes.Name("_trans", "load")
+                    variables[token.value] = plural_expr
+                    plural_expr_assignment = nodes.Assign(
+                        nodes.Name("_trans", "store"), var
+                    )
+                else:
+                    plural_expr = var
+                num_called_num = token.value == "num"
+
+        parser.stream.expect("block_end")
+
+        plural = None
+        have_plural = False
+        referenced = set()
+
+        # now parse until endtrans or pluralize
+        singular_names, singular = self._parse_block(parser, True)
+        if singular_names:
+            referenced.update(singular_names)
+            if plural_expr is None:
+                plural_expr = nodes.Name(singular_names[0], "load")
+                num_called_num = singular_names[0] == "num"
+
+        # if we have a pluralize block, we parse that too
+        if parser.stream.current.test("name:pluralize"):
+            have_plural = True
+            next(parser.stream)
+            if parser.stream.current.type != "block_end":
+                token = parser.stream.expect("name")
+                if token.value not in variables:
+                    parser.fail(
+                        f"unknown variable {token.value!r} for pluralization",
+                        token.lineno,
+                        exc=TemplateAssertionError,
+                    )
+                plural_expr = variables[token.value]
+                num_called_num = token.value == "num"
+            parser.stream.expect("block_end")
+            plural_names, plural = self._parse_block(parser, False)
+            next(parser.stream)
+            referenced.update(plural_names)
+        else:
+            next(parser.stream)
+
+        # register free names as simple name expressions
+        for name in referenced:
+            if name not in variables:
+                variables[name] = nodes.Name(name, "load")
+
+        if not have_plural:
+            plural_expr = None
+        elif plural_expr is None:
+            parser.fail("pluralize without variables", lineno)
+
+        if trimmed is None:
+            trimmed = self.environment.policies["ext.i18n.trimmed"]
+        if trimmed:
+            singular = self._trim_whitespace(singular)
+            if plural:
+                plural = self._trim_whitespace(plural)
+
+        node = self._make_node(
+            singular,
+            plural,
+            context,
+            variables,
+            plural_expr,
+            bool(referenced),
+            num_called_num and have_plural,
+        )
+        node.set_lineno(lineno)
+        if plural_expr_assignment is not None:
+            return [plural_expr_assignment, node]
+        else:
+            return node
+
+    def _trim_whitespace(self, string: str, _ws_re: t.Pattern[str] = _ws_re) -> str:
+        return _ws_re.sub(" ", string.strip())
+
+    def _parse_block(
+        self, parser: "Parser", allow_pluralize: bool
+    ) -> t.Tuple[t.List[str], str]:
+        """Parse until the next block tag with a given name."""
+        referenced = []
+        buf = []
+
+        while True:
+            if parser.stream.current.type == "data":
+                buf.append(parser.stream.current.value.replace("%", "%%"))
+                next(parser.stream)
+            elif parser.stream.current.type == "variable_begin":
+                next(parser.stream)
+                name = parser.stream.expect("name").value
+                referenced.append(name)
+                buf.append(f"%({name})s")
+                parser.stream.expect("variable_end")
+            elif parser.stream.current.type == "block_begin":
+                next(parser.stream)
+                if parser.stream.current.test("name:endtrans"):
+                    break
+                elif parser.stream.current.test("name:pluralize"):
+                    if allow_pluralize:
+                        break
+                    parser.fail(
+                        "a translatable section can have only one pluralize section"
+                    )
+                parser.fail(
+                    "control structures in translatable sections are not allowed"
+                )
+            elif parser.stream.eos:
+                parser.fail("unclosed translation block")
+            else:
+                raise RuntimeError("internal parser error")
+
+        return referenced, concat(buf)
+
+    def _make_node(
+        self,
+        singular: str,
+        plural: t.Optional[str],
+        context: t.Optional[str],
+        variables: t.Dict[str, nodes.Expr],
+        plural_expr: t.Optional[nodes.Expr],
+        vars_referenced: bool,
+        num_called_num: bool,
+    ) -> nodes.Output:
+        """Generates a useful node from the data provided."""
+        newstyle = self.environment.newstyle_gettext  # type: ignore
+        node: nodes.Expr
+
+        # no variables referenced?  no need to escape for old style
+        # gettext invocations only if there are vars.
+        if not vars_referenced and not newstyle:
+            singular = singular.replace("%%", "%")
+            if plural:
+                plural = plural.replace("%%", "%")
+
+        func_name = "gettext"
+        func_args: t.List[nodes.Expr] = [nodes.Const(singular)]
+
+        if context is not None:
+            func_args.insert(0, nodes.Const(context))
+            func_name = f"p{func_name}"
+
+        if plural_expr is not None:
+            func_name = f"n{func_name}"
+            func_args.extend((nodes.Const(plural), plural_expr))
+
+        node = nodes.Call(nodes.Name(func_name, "load"), func_args, [], None, None)
+
+        # in case newstyle gettext is used, the method is powerful
+        # enough to handle the variable expansion and autoescape
+        # handling itself
+        if newstyle:
+            for key, value in variables.items():
+                # the function adds that later anyways in case num was
+                # called num, so just skip it.
+                if num_called_num and key == "num":
+                    continue
+                node.kwargs.append(nodes.Keyword(key, value))
+
+        # otherwise do that here
+        else:
+            # mark the return value as safe if we are in an
+            # environment with autoescaping turned on
+            node = nodes.MarkSafeIfAutoescape(node)
+            if variables:
+                node = nodes.Mod(
+                    node,
+                    nodes.Dict(
+                        [
+                            nodes.Pair(nodes.Const(key), value)
+                            for key, value in variables.items()
+                        ]
+                    ),
+                )
+        return nodes.Output([node])
+
+
+class ExprStmtExtension(Extension):
+    """Adds a `do` tag to Jinja that works like the print statement just
+    that it doesn't print the return value.
+    """
+
+    tags = {"do"}
+
+    def parse(self, parser: "Parser") -> nodes.ExprStmt:
+        node = nodes.ExprStmt(lineno=next(parser.stream).lineno)
+        node.node = parser.parse_tuple()
+        return node
+
+
+class LoopControlExtension(Extension):
+    """Adds break and continue to the template engine."""
+
+    tags = {"break", "continue"}
+
+    def parse(self, parser: "Parser") -> t.Union[nodes.Break, nodes.Continue]:
+        token = next(parser.stream)
+        if token.value == "break":
+            return nodes.Break(lineno=token.lineno)
+        return nodes.Continue(lineno=token.lineno)
+
+
+class DebugExtension(Extension):
+    """A ``{% debug %}`` tag that dumps the available variables,
+    filters, and tests.
+
+    .. code-block:: html+jinja
+
+        <pre>{% debug %}</pre>
+
+    .. code-block:: text
+
+        {'context': {'cycler': <class 'jinja2.utils.Cycler'>,
+                     ...,
+                     'namespace': <class 'jinja2.utils.Namespace'>},
+         'filters': ['abs', 'attr', 'batch', 'capitalize', 'center', 'count', 'd',
+                     ..., 'urlencode', 'urlize', 'wordcount', 'wordwrap', 'xmlattr'],
+         'tests': ['!=', '<', '<=', '==', '>', '>=', 'callable', 'defined',
+                   ..., 'odd', 'sameas', 'sequence', 'string', 'undefined', 'upper']}
+
+    .. versionadded:: 2.11.0
+    """
+
+    tags = {"debug"}
+
+    def parse(self, parser: "Parser") -> nodes.Output:
+        lineno = parser.stream.expect("name:debug").lineno
+        context = nodes.ContextReference()
+        result = self.call_method("_render", [context], lineno=lineno)
+        return nodes.Output([result], lineno=lineno)
+
+    def _render(self, context: Context) -> str:
+        result = {
+            "context": context.get_all(),
+            "filters": sorted(self.environment.filters.keys()),
+            "tests": sorted(self.environment.tests.keys()),
+        }
+
+        # Set the depth since the intent is to show the top few names.
+        return pprint.pformat(result, depth=3, compact=True)
+
+
+def extract_from_ast(
+    ast: nodes.Template,
+    gettext_functions: t.Sequence[str] = GETTEXT_FUNCTIONS,
+    babel_style: bool = True,
+) -> t.Iterator[
+    t.Tuple[int, str, t.Union[t.Optional[str], t.Tuple[t.Optional[str], ...]]]
+]:
+    """Extract localizable strings from the given template node.  Per
+    default this function returns matches in babel style that means non string
+    parameters as well as keyword arguments are returned as `None`.  This
+    allows Babel to figure out what you really meant if you are using
+    gettext functions that allow keyword arguments for placeholder expansion.
+    If you don't want that behavior set the `babel_style` parameter to `False`
+    which causes only strings to be returned and parameters are always stored
+    in tuples.  As a consequence invalid gettext calls (calls without a single
+    string parameter or string parameters after non-string parameters) are
+    skipped.
+
+    This example explains the behavior:
+
+    >>> from jinja2 import Environment
+    >>> env = Environment()
+    >>> node = env.parse('{{ (_("foo"), _(), ngettext("foo", "bar", 42)) }}')
+    >>> list(extract_from_ast(node))
+    [(1, '_', 'foo'), (1, '_', ()), (1, 'ngettext', ('foo', 'bar', None))]
+    >>> list(extract_from_ast(node, babel_style=False))
+    [(1, '_', ('foo',)), (1, 'ngettext', ('foo', 'bar'))]
+
+    For every string found this function yields a ``(lineno, function,
+    message)`` tuple, where:
+
+    * ``lineno`` is the number of the line on which the string was found,
+    * ``function`` is the name of the ``gettext`` function used (if the
+      string was extracted from embedded Python code), and
+    *   ``message`` is the string, or a tuple of strings for functions
+         with multiple string arguments.
+
+    This extraction function operates on the AST and is because of that unable
+    to extract any comments.  For comment support you have to use the babel
+    extraction interface or extract comments yourself.
+    """
+    out: t.Union[t.Optional[str], t.Tuple[t.Optional[str], ...]]
+
+    for node in ast.find_all(nodes.Call):
+        if (
+            not isinstance(node.node, nodes.Name)
+            or node.node.name not in gettext_functions
+        ):
+            continue
+
+        strings: t.List[t.Optional[str]] = []
+
+        for arg in node.args:
+            if isinstance(arg, nodes.Const) and isinstance(arg.value, str):
+                strings.append(arg.value)
+            else:
+                strings.append(None)
+
+        for _ in node.kwargs:
+            strings.append(None)
+        if node.dyn_args is not None:
+            strings.append(None)
+        if node.dyn_kwargs is not None:
+            strings.append(None)
+
+        if not babel_style:
+            out = tuple(x for x in strings if x is not None)
+
+            if not out:
+                continue
+        else:
+            if len(strings) == 1:
+                out = strings[0]
+            else:
+                out = tuple(strings)
+
+        yield node.lineno, node.node.name, out
+
+
+class _CommentFinder:
+    """Helper class to find comments in a token stream.  Can only
+    find comments for gettext calls forwards.  Once the comment
+    from line 4 is found, a comment for line 1 will not return a
+    usable value.
+    """
+
+    def __init__(
+        self, tokens: t.Sequence[t.Tuple[int, str, str]], comment_tags: t.Sequence[str]
+    ) -> None:
+        self.tokens = tokens
+        self.comment_tags = comment_tags
+        self.offset = 0
+        self.last_lineno = 0
+
+    def find_backwards(self, offset: int) -> t.List[str]:
+        try:
+            for _, token_type, token_value in reversed(
+                self.tokens[self.offset : offset]
+            ):
+                if token_type in ("comment", "linecomment"):
+                    try:
+                        prefix, comment = token_value.split(None, 1)
+                    except ValueError:
+                        continue
+                    if prefix in self.comment_tags:
+                        return [comment.rstrip()]
+            return []
+        finally:
+            self.offset = offset
+
+    def find_comments(self, lineno: int) -> t.List[str]:
+        if not self.comment_tags or self.last_lineno > lineno:
+            return []
+        for idx, (token_lineno, _, _) in enumerate(self.tokens[self.offset :]):
+            if token_lineno > lineno:
+                return self.find_backwards(self.offset + idx)
+        return self.find_backwards(len(self.tokens))
+
+
+def babel_extract(
+    fileobj: t.BinaryIO,
+    keywords: t.Sequence[str],
+    comment_tags: t.Sequence[str],
+    options: t.Dict[str, t.Any],
+) -> t.Iterator[
+    t.Tuple[
+        int, str, t.Union[t.Optional[str], t.Tuple[t.Optional[str], ...]], t.List[str]
+    ]
+]:
+    """Babel extraction method for Jinja templates.
+
+    .. versionchanged:: 2.3
+       Basic support for translation comments was added.  If `comment_tags`
+       is now set to a list of keywords for extraction, the extractor will
+       try to find the best preceding comment that begins with one of the
+       keywords.  For best results, make sure to not have more than one
+       gettext call in one line of code and the matching comment in the
+       same line or the line before.
+
+    .. versionchanged:: 2.5.1
+       The `newstyle_gettext` flag can be set to `True` to enable newstyle
+       gettext calls.
+
+    .. versionchanged:: 2.7
+       A `silent` option can now be provided.  If set to `False` template
+       syntax errors are propagated instead of being ignored.
+
+    :param fileobj: the file-like object the messages should be extracted from
+    :param keywords: a list of keywords (i.e. function names) that should be
+                     recognized as translation functions
+    :param comment_tags: a list of translator tags to search for and include
+                         in the results.
+    :param options: a dictionary of additional options (optional)
+    :return: an iterator over ``(lineno, funcname, message, comments)`` tuples.
+             (comments will be empty currently)
+    """
+    extensions: t.Dict[t.Type[Extension], None] = {}
+
+    for extension_name in options.get("extensions", "").split(","):
+        extension_name = extension_name.strip()
+
+        if not extension_name:
+            continue
+
+        extensions[import_string(extension_name)] = None
+
+    if InternationalizationExtension not in extensions:
+        extensions[InternationalizationExtension] = None
+
+    def getbool(options: t.Mapping[str, str], key: str, default: bool = False) -> bool:
+        return options.get(key, str(default)).lower() in {"1", "on", "yes", "true"}
+
+    silent = getbool(options, "silent", True)
+    environment = Environment(
+        options.get("block_start_string", defaults.BLOCK_START_STRING),
+        options.get("block_end_string", defaults.BLOCK_END_STRING),
+        options.get("variable_start_string", defaults.VARIABLE_START_STRING),
+        options.get("variable_end_string", defaults.VARIABLE_END_STRING),
+        options.get("comment_start_string", defaults.COMMENT_START_STRING),
+        options.get("comment_end_string", defaults.COMMENT_END_STRING),
+        options.get("line_statement_prefix") or defaults.LINE_STATEMENT_PREFIX,
+        options.get("line_comment_prefix") or defaults.LINE_COMMENT_PREFIX,
+        getbool(options, "trim_blocks", defaults.TRIM_BLOCKS),
+        getbool(options, "lstrip_blocks", defaults.LSTRIP_BLOCKS),
+        defaults.NEWLINE_SEQUENCE,
+        getbool(options, "keep_trailing_newline", defaults.KEEP_TRAILING_NEWLINE),
+        tuple(extensions),
+        cache_size=0,
+        auto_reload=False,
+    )
+
+    if getbool(options, "trimmed"):
+        environment.policies["ext.i18n.trimmed"] = True
+    if getbool(options, "newstyle_gettext"):
+        environment.newstyle_gettext = True  # type: ignore
+
+    source = fileobj.read().decode(options.get("encoding", "utf-8"))
+    try:
+        node = environment.parse(source)
+        tokens = list(environment.lex(environment.preprocess(source)))
+    except TemplateSyntaxError:
+        if not silent:
+            raise
+        # skip templates with syntax errors
+        return
+
+    finder = _CommentFinder(tokens, comment_tags)
+    for lineno, func, message in extract_from_ast(node, keywords):
+        yield lineno, func, message, finder.find_comments(lineno)
+
+
+#: nicer import names
+i18n = InternationalizationExtension
+do = ExprStmtExtension
+loopcontrols = LoopControlExtension
+debug = DebugExtension
diff --git a/lib/python3.11/site-packages/jinja2/filters.py b/lib/python3.11/site-packages/jinja2/filters.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed07c4c0e2ae1b6203b3468cda8a303ecf3d7832
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/filters.py
@@ -0,0 +1,1840 @@
+"""Built-in template filters used with the ``|`` operator."""
+import math
+import random
+import re
+import typing
+import typing as t
+from collections import abc
+from itertools import chain
+from itertools import groupby
+
+from markupsafe import escape
+from markupsafe import Markup
+from markupsafe import soft_str
+
+from .async_utils import async_variant
+from .async_utils import auto_aiter
+from .async_utils import auto_await
+from .async_utils import auto_to_list
+from .exceptions import FilterArgumentError
+from .runtime import Undefined
+from .utils import htmlsafe_json_dumps
+from .utils import pass_context
+from .utils import pass_environment
+from .utils import pass_eval_context
+from .utils import pformat
+from .utils import url_quote
+from .utils import urlize
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .environment import Environment
+    from .nodes import EvalContext
+    from .runtime import Context
+    from .sandbox import SandboxedEnvironment  # noqa: F401
+
+    class HasHTML(te.Protocol):
+        def __html__(self) -> str:
+            pass
+
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+K = t.TypeVar("K")
+V = t.TypeVar("V")
+
+
+def ignore_case(value: V) -> V:
+    """For use as a postprocessor for :func:`make_attrgetter`. Converts strings
+    to lowercase and returns other types as-is."""
+    if isinstance(value, str):
+        return t.cast(V, value.lower())
+
+    return value
+
+
+def make_attrgetter(
+    environment: "Environment",
+    attribute: t.Optional[t.Union[str, int]],
+    postprocess: t.Optional[t.Callable[[t.Any], t.Any]] = None,
+    default: t.Optional[t.Any] = None,
+) -> t.Callable[[t.Any], t.Any]:
+    """Returns a callable that looks up the given attribute from a
+    passed object with the rules of the environment.  Dots are allowed
+    to access attributes of attributes.  Integer parts in paths are
+    looked up as integers.
+    """
+    parts = _prepare_attribute_parts(attribute)
+
+    def attrgetter(item: t.Any) -> t.Any:
+        for part in parts:
+            item = environment.getitem(item, part)
+
+            if default is not None and isinstance(item, Undefined):
+                item = default
+
+        if postprocess is not None:
+            item = postprocess(item)
+
+        return item
+
+    return attrgetter
+
+
+def make_multi_attrgetter(
+    environment: "Environment",
+    attribute: t.Optional[t.Union[str, int]],
+    postprocess: t.Optional[t.Callable[[t.Any], t.Any]] = None,
+) -> t.Callable[[t.Any], t.List[t.Any]]:
+    """Returns a callable that looks up the given comma separated
+    attributes from a passed object with the rules of the environment.
+    Dots are allowed to access attributes of each attribute.  Integer
+    parts in paths are looked up as integers.
+
+    The value returned by the returned callable is a list of extracted
+    attribute values.
+
+    Examples of attribute: "attr1,attr2", "attr1.inner1.0,attr2.inner2.0", etc.
+    """
+    if isinstance(attribute, str):
+        split: t.Sequence[t.Union[str, int, None]] = attribute.split(",")
+    else:
+        split = [attribute]
+
+    parts = [_prepare_attribute_parts(item) for item in split]
+
+    def attrgetter(item: t.Any) -> t.List[t.Any]:
+        items = [None] * len(parts)
+
+        for i, attribute_part in enumerate(parts):
+            item_i = item
+
+            for part in attribute_part:
+                item_i = environment.getitem(item_i, part)
+
+            if postprocess is not None:
+                item_i = postprocess(item_i)
+
+            items[i] = item_i
+
+        return items
+
+    return attrgetter
+
+
+def _prepare_attribute_parts(
+    attr: t.Optional[t.Union[str, int]]
+) -> t.List[t.Union[str, int]]:
+    if attr is None:
+        return []
+
+    if isinstance(attr, str):
+        return [int(x) if x.isdigit() else x for x in attr.split(".")]
+
+    return [attr]
+
+
+def do_forceescape(value: "t.Union[str, HasHTML]") -> Markup:
+    """Enforce HTML escaping.  This will probably double escape variables."""
+    if hasattr(value, "__html__"):
+        value = t.cast("HasHTML", value).__html__()
+
+    return escape(str(value))
+
+
+def do_urlencode(
+    value: t.Union[str, t.Mapping[str, t.Any], t.Iterable[t.Tuple[str, t.Any]]]
+) -> str:
+    """Quote data for use in a URL path or query using UTF-8.
+
+    Basic wrapper around :func:`urllib.parse.quote` when given a
+    string, or :func:`urllib.parse.urlencode` for a dict or iterable.
+
+    :param value: Data to quote. A string will be quoted directly. A
+        dict or iterable of ``(key, value)`` pairs will be joined as a
+        query string.
+
+    When given a string, "/" is not quoted. HTTP servers treat "/" and
+    "%2F" equivalently in paths. If you need quoted slashes, use the
+    ``|replace("/", "%2F")`` filter.
+
+    .. versionadded:: 2.7
+    """
+    if isinstance(value, str) or not isinstance(value, abc.Iterable):
+        return url_quote(value)
+
+    if isinstance(value, dict):
+        items: t.Iterable[t.Tuple[str, t.Any]] = value.items()
+    else:
+        items = value  # type: ignore
+
+    return "&".join(
+        f"{url_quote(k, for_qs=True)}={url_quote(v, for_qs=True)}" for k, v in items
+    )
+
+
+@pass_eval_context
+def do_replace(
+    eval_ctx: "EvalContext", s: str, old: str, new: str, count: t.Optional[int] = None
+) -> str:
+    """Return a copy of the value with all occurrences of a substring
+    replaced with a new one. The first argument is the substring
+    that should be replaced, the second is the replacement string.
+    If the optional third argument ``count`` is given, only the first
+    ``count`` occurrences are replaced:
+
+    .. sourcecode:: jinja
+
+        {{ "Hello World"|replace("Hello", "Goodbye") }}
+            -> Goodbye World
+
+        {{ "aaaaargh"|replace("a", "d'oh, ", 2) }}
+            -> d'oh, d'oh, aaargh
+    """
+    if count is None:
+        count = -1
+
+    if not eval_ctx.autoescape:
+        return str(s).replace(str(old), str(new), count)
+
+    if (
+        hasattr(old, "__html__")
+        or hasattr(new, "__html__")
+        and not hasattr(s, "__html__")
+    ):
+        s = escape(s)
+    else:
+        s = soft_str(s)
+
+    return s.replace(soft_str(old), soft_str(new), count)
+
+
+def do_upper(s: str) -> str:
+    """Convert a value to uppercase."""
+    return soft_str(s).upper()
+
+
+def do_lower(s: str) -> str:
+    """Convert a value to lowercase."""
+    return soft_str(s).lower()
+
+
+def do_items(value: t.Union[t.Mapping[K, V], Undefined]) -> t.Iterator[t.Tuple[K, V]]:
+    """Return an iterator over the ``(key, value)`` items of a mapping.
+
+    ``x|items`` is the same as ``x.items()``, except if ``x`` is
+    undefined an empty iterator is returned.
+
+    This filter is useful if you expect the template to be rendered with
+    an implementation of Jinja in another programming language that does
+    not have a ``.items()`` method on its mapping type.
+
+    .. code-block:: html+jinja
+
+        <dl>
+        {% for key, value in my_dict|items %}
+            <dt>{{ key }}
+            <dd>{{ value }}
+        {% endfor %}
+        </dl>
+
+    .. versionadded:: 3.1
+    """
+    if isinstance(value, Undefined):
+        return
+
+    if not isinstance(value, abc.Mapping):
+        raise TypeError("Can only get item pairs from a mapping.")
+
+    yield from value.items()
+
+
+@pass_eval_context
+def do_xmlattr(
+    eval_ctx: "EvalContext", d: t.Mapping[str, t.Any], autospace: bool = True
+) -> str:
+    """Create an SGML/XML attribute string based on the items in a dict.
+    All values that are neither `none` nor `undefined` are automatically
+    escaped:
+
+    .. sourcecode:: html+jinja
+
+        <ul{{ {'class': 'my_list', 'missing': none,
+                'id': 'list-%d'|format(variable)}|xmlattr }}>
+        ...
+        </ul>
+
+    Results in something like this:
+
+    .. sourcecode:: html
+
+        <ul class="my_list" id="list-42">
+        ...
+        </ul>
+
+    As you can see it automatically prepends a space in front of the item
+    if the filter returned something unless the second parameter is false.
+    """
+    rv = " ".join(
+        f'{escape(key)}="{escape(value)}"'
+        for key, value in d.items()
+        if value is not None and not isinstance(value, Undefined)
+    )
+
+    if autospace and rv:
+        rv = " " + rv
+
+    if eval_ctx.autoescape:
+        rv = Markup(rv)
+
+    return rv
+
+
+def do_capitalize(s: str) -> str:
+    """Capitalize a value. The first character will be uppercase, all others
+    lowercase.
+    """
+    return soft_str(s).capitalize()
+
+
+_word_beginning_split_re = re.compile(r"([-\s({\[<]+)")
+
+
+def do_title(s: str) -> str:
+    """Return a titlecased version of the value. I.e. words will start with
+    uppercase letters, all remaining characters are lowercase.
+    """
+    return "".join(
+        [
+            item[0].upper() + item[1:].lower()
+            for item in _word_beginning_split_re.split(soft_str(s))
+            if item
+        ]
+    )
+
+
+def do_dictsort(
+    value: t.Mapping[K, V],
+    case_sensitive: bool = False,
+    by: 'te.Literal["key", "value"]' = "key",
+    reverse: bool = False,
+) -> t.List[t.Tuple[K, V]]:
+    """Sort a dict and yield (key, value) pairs. Python dicts may not
+    be in the order you want to display them in, so sort them first.
+
+    .. sourcecode:: jinja
+
+        {% for key, value in mydict|dictsort %}
+            sort the dict by key, case insensitive
+
+        {% for key, value in mydict|dictsort(reverse=true) %}
+            sort the dict by key, case insensitive, reverse order
+
+        {% for key, value in mydict|dictsort(true) %}
+            sort the dict by key, case sensitive
+
+        {% for key, value in mydict|dictsort(false, 'value') %}
+            sort the dict by value, case insensitive
+    """
+    if by == "key":
+        pos = 0
+    elif by == "value":
+        pos = 1
+    else:
+        raise FilterArgumentError('You can only sort by either "key" or "value"')
+
+    def sort_func(item: t.Tuple[t.Any, t.Any]) -> t.Any:
+        value = item[pos]
+
+        if not case_sensitive:
+            value = ignore_case(value)
+
+        return value
+
+    return sorted(value.items(), key=sort_func, reverse=reverse)
+
+
+@pass_environment
+def do_sort(
+    environment: "Environment",
+    value: "t.Iterable[V]",
+    reverse: bool = False,
+    case_sensitive: bool = False,
+    attribute: t.Optional[t.Union[str, int]] = None,
+) -> "t.List[V]":
+    """Sort an iterable using Python's :func:`sorted`.
+
+    .. sourcecode:: jinja
+
+        {% for city in cities|sort %}
+            ...
+        {% endfor %}
+
+    :param reverse: Sort descending instead of ascending.
+    :param case_sensitive: When sorting strings, sort upper and lower
+        case separately.
+    :param attribute: When sorting objects or dicts, an attribute or
+        key to sort by. Can use dot notation like ``"address.city"``.
+        Can be a list of attributes like ``"age,name"``.
+
+    The sort is stable, it does not change the relative order of
+    elements that compare equal. This makes it is possible to chain
+    sorts on different attributes and ordering.
+
+    .. sourcecode:: jinja
+
+        {% for user in users|sort(attribute="name")
+            |sort(reverse=true, attribute="age") %}
+            ...
+        {% endfor %}
+
+    As a shortcut to chaining when the direction is the same for all
+    attributes, pass a comma separate list of attributes.
+
+    .. sourcecode:: jinja
+
+        {% for user in users|sort(attribute="age,name") %}
+            ...
+        {% endfor %}
+
+    .. versionchanged:: 2.11.0
+        The ``attribute`` parameter can be a comma separated list of
+        attributes, e.g. ``"age,name"``.
+
+    .. versionchanged:: 2.6
+       The ``attribute`` parameter was added.
+    """
+    key_func = make_multi_attrgetter(
+        environment, attribute, postprocess=ignore_case if not case_sensitive else None
+    )
+    return sorted(value, key=key_func, reverse=reverse)
+
+
+@pass_environment
+def do_unique(
+    environment: "Environment",
+    value: "t.Iterable[V]",
+    case_sensitive: bool = False,
+    attribute: t.Optional[t.Union[str, int]] = None,
+) -> "t.Iterator[V]":
+    """Returns a list of unique items from the given iterable.
+
+    .. sourcecode:: jinja
+
+        {{ ['foo', 'bar', 'foobar', 'FooBar']|unique|list }}
+            -> ['foo', 'bar', 'foobar']
+
+    The unique items are yielded in the same order as their first occurrence in
+    the iterable passed to the filter.
+
+    :param case_sensitive: Treat upper and lower case strings as distinct.
+    :param attribute: Filter objects with unique values for this attribute.
+    """
+    getter = make_attrgetter(
+        environment, attribute, postprocess=ignore_case if not case_sensitive else None
+    )
+    seen = set()
+
+    for item in value:
+        key = getter(item)
+
+        if key not in seen:
+            seen.add(key)
+            yield item
+
+
+def _min_or_max(
+    environment: "Environment",
+    value: "t.Iterable[V]",
+    func: "t.Callable[..., V]",
+    case_sensitive: bool,
+    attribute: t.Optional[t.Union[str, int]],
+) -> "t.Union[V, Undefined]":
+    it = iter(value)
+
+    try:
+        first = next(it)
+    except StopIteration:
+        return environment.undefined("No aggregated item, sequence was empty.")
+
+    key_func = make_attrgetter(
+        environment, attribute, postprocess=ignore_case if not case_sensitive else None
+    )
+    return func(chain([first], it), key=key_func)
+
+
+@pass_environment
+def do_min(
+    environment: "Environment",
+    value: "t.Iterable[V]",
+    case_sensitive: bool = False,
+    attribute: t.Optional[t.Union[str, int]] = None,
+) -> "t.Union[V, Undefined]":
+    """Return the smallest item from the sequence.
+
+    .. sourcecode:: jinja
+
+        {{ [1, 2, 3]|min }}
+            -> 1
+
+    :param case_sensitive: Treat upper and lower case strings as distinct.
+    :param attribute: Get the object with the min value of this attribute.
+    """
+    return _min_or_max(environment, value, min, case_sensitive, attribute)
+
+
+@pass_environment
+def do_max(
+    environment: "Environment",
+    value: "t.Iterable[V]",
+    case_sensitive: bool = False,
+    attribute: t.Optional[t.Union[str, int]] = None,
+) -> "t.Union[V, Undefined]":
+    """Return the largest item from the sequence.
+
+    .. sourcecode:: jinja
+
+        {{ [1, 2, 3]|max }}
+            -> 3
+
+    :param case_sensitive: Treat upper and lower case strings as distinct.
+    :param attribute: Get the object with the max value of this attribute.
+    """
+    return _min_or_max(environment, value, max, case_sensitive, attribute)
+
+
+def do_default(
+    value: V,
+    default_value: V = "",  # type: ignore
+    boolean: bool = False,
+) -> V:
+    """If the value is undefined it will return the passed default value,
+    otherwise the value of the variable:
+
+    .. sourcecode:: jinja
+
+        {{ my_variable|default('my_variable is not defined') }}
+
+    This will output the value of ``my_variable`` if the variable was
+    defined, otherwise ``'my_variable is not defined'``. If you want
+    to use default with variables that evaluate to false you have to
+    set the second parameter to `true`:
+
+    .. sourcecode:: jinja
+
+        {{ ''|default('the string was empty', true) }}
+
+    .. versionchanged:: 2.11
+       It's now possible to configure the :class:`~jinja2.Environment` with
+       :class:`~jinja2.ChainableUndefined` to make the `default` filter work
+       on nested elements and attributes that may contain undefined values
+       in the chain without getting an :exc:`~jinja2.UndefinedError`.
+    """
+    if isinstance(value, Undefined) or (boolean and not value):
+        return default_value
+
+    return value
+
+
+@pass_eval_context
+def sync_do_join(
+    eval_ctx: "EvalContext",
+    value: t.Iterable,
+    d: str = "",
+    attribute: t.Optional[t.Union[str, int]] = None,
+) -> str:
+    """Return a string which is the concatenation of the strings in the
+    sequence. The separator between elements is an empty string per
+    default, you can define it with the optional parameter:
+
+    .. sourcecode:: jinja
+
+        {{ [1, 2, 3]|join('|') }}
+            -> 1|2|3
+
+        {{ [1, 2, 3]|join }}
+            -> 123
+
+    It is also possible to join certain attributes of an object:
+
+    .. sourcecode:: jinja
+
+        {{ users|join(', ', attribute='username') }}
+
+    .. versionadded:: 2.6
+       The `attribute` parameter was added.
+    """
+    if attribute is not None:
+        value = map(make_attrgetter(eval_ctx.environment, attribute), value)
+
+    # no automatic escaping?  joining is a lot easier then
+    if not eval_ctx.autoescape:
+        return str(d).join(map(str, value))
+
+    # if the delimiter doesn't have an html representation we check
+    # if any of the items has.  If yes we do a coercion to Markup
+    if not hasattr(d, "__html__"):
+        value = list(value)
+        do_escape = False
+
+        for idx, item in enumerate(value):
+            if hasattr(item, "__html__"):
+                do_escape = True
+            else:
+                value[idx] = str(item)
+
+        if do_escape:
+            d = escape(d)
+        else:
+            d = str(d)
+
+        return d.join(value)
+
+    # no html involved, to normal joining
+    return soft_str(d).join(map(soft_str, value))
+
+
+@async_variant(sync_do_join)  # type: ignore
+async def do_join(
+    eval_ctx: "EvalContext",
+    value: t.Union[t.AsyncIterable, t.Iterable],
+    d: str = "",
+    attribute: t.Optional[t.Union[str, int]] = None,
+) -> str:
+    return sync_do_join(eval_ctx, await auto_to_list(value), d, attribute)
+
+
+def do_center(value: str, width: int = 80) -> str:
+    """Centers the value in a field of a given width."""
+    return soft_str(value).center(width)
+
+
+@pass_environment
+def sync_do_first(
+    environment: "Environment", seq: "t.Iterable[V]"
+) -> "t.Union[V, Undefined]":
+    """Return the first item of a sequence."""
+    try:
+        return next(iter(seq))
+    except StopIteration:
+        return environment.undefined("No first item, sequence was empty.")
+
+
+@async_variant(sync_do_first)  # type: ignore
+async def do_first(
+    environment: "Environment", seq: "t.Union[t.AsyncIterable[V], t.Iterable[V]]"
+) -> "t.Union[V, Undefined]":
+    try:
+        return await auto_aiter(seq).__anext__()
+    except StopAsyncIteration:
+        return environment.undefined("No first item, sequence was empty.")
+
+
+@pass_environment
+def do_last(
+    environment: "Environment", seq: "t.Reversible[V]"
+) -> "t.Union[V, Undefined]":
+    """Return the last item of a sequence.
+
+    Note: Does not work with generators. You may want to explicitly
+    convert it to a list:
+
+    .. sourcecode:: jinja
+
+        {{ data | selectattr('name', '==', 'Jinja') | list | last }}
+    """
+    try:
+        return next(iter(reversed(seq)))
+    except StopIteration:
+        return environment.undefined("No last item, sequence was empty.")
+
+
+# No async do_last, it may not be safe in async mode.
+
+
+@pass_context
+def do_random(context: "Context", seq: "t.Sequence[V]") -> "t.Union[V, Undefined]":
+    """Return a random item from the sequence."""
+    try:
+        return random.choice(seq)
+    except IndexError:
+        return context.environment.undefined("No random item, sequence was empty.")
+
+
+def do_filesizeformat(value: t.Union[str, float, int], binary: bool = False) -> str:
+    """Format the value like a 'human-readable' file size (i.e. 13 kB,
+    4.1 MB, 102 Bytes, etc).  Per default decimal prefixes are used (Mega,
+    Giga, etc.), if the second parameter is set to `True` the binary
+    prefixes are used (Mebi, Gibi).
+    """
+    bytes = float(value)
+    base = 1024 if binary else 1000
+    prefixes = [
+        ("KiB" if binary else "kB"),
+        ("MiB" if binary else "MB"),
+        ("GiB" if binary else "GB"),
+        ("TiB" if binary else "TB"),
+        ("PiB" if binary else "PB"),
+        ("EiB" if binary else "EB"),
+        ("ZiB" if binary else "ZB"),
+        ("YiB" if binary else "YB"),
+    ]
+
+    if bytes == 1:
+        return "1 Byte"
+    elif bytes < base:
+        return f"{int(bytes)} Bytes"
+    else:
+        for i, prefix in enumerate(prefixes):
+            unit = base ** (i + 2)
+
+            if bytes < unit:
+                return f"{base * bytes / unit:.1f} {prefix}"
+
+        return f"{base * bytes / unit:.1f} {prefix}"
+
+
+def do_pprint(value: t.Any) -> str:
+    """Pretty print a variable. Useful for debugging."""
+    return pformat(value)
+
+
+_uri_scheme_re = re.compile(r"^([\w.+-]{2,}:(/){0,2})$")
+
+
+@pass_eval_context
+def do_urlize(
+    eval_ctx: "EvalContext",
+    value: str,
+    trim_url_limit: t.Optional[int] = None,
+    nofollow: bool = False,
+    target: t.Optional[str] = None,
+    rel: t.Optional[str] = None,
+    extra_schemes: t.Optional[t.Iterable[str]] = None,
+) -> str:
+    """Convert URLs in text into clickable links.
+
+    This may not recognize links in some situations. Usually, a more
+    comprehensive formatter, such as a Markdown library, is a better
+    choice.
+
+    Works on ``http://``, ``https://``, ``www.``, ``mailto:``, and email
+    addresses. Links with trailing punctuation (periods, commas, closing
+    parentheses) and leading punctuation (opening parentheses) are
+    recognized excluding the punctuation. Email addresses that include
+    header fields are not recognized (for example,
+    ``mailto:address@example.com?cc=copy@example.com``).
+
+    :param value: Original text containing URLs to link.
+    :param trim_url_limit: Shorten displayed URL values to this length.
+    :param nofollow: Add the ``rel=nofollow`` attribute to links.
+    :param target: Add the ``target`` attribute to links.
+    :param rel: Add the ``rel`` attribute to links.
+    :param extra_schemes: Recognize URLs that start with these schemes
+        in addition to the default behavior. Defaults to
+        ``env.policies["urlize.extra_schemes"]``, which defaults to no
+        extra schemes.
+
+    .. versionchanged:: 3.0
+        The ``extra_schemes`` parameter was added.
+
+    .. versionchanged:: 3.0
+        Generate ``https://`` links for URLs without a scheme.
+
+    .. versionchanged:: 3.0
+        The parsing rules were updated. Recognize email addresses with
+        or without the ``mailto:`` scheme. Validate IP addresses. Ignore
+        parentheses and brackets in more cases.
+
+    .. versionchanged:: 2.8
+       The ``target`` parameter was added.
+    """
+    policies = eval_ctx.environment.policies
+    rel_parts = set((rel or "").split())
+
+    if nofollow:
+        rel_parts.add("nofollow")
+
+    rel_parts.update((policies["urlize.rel"] or "").split())
+    rel = " ".join(sorted(rel_parts)) or None
+
+    if target is None:
+        target = policies["urlize.target"]
+
+    if extra_schemes is None:
+        extra_schemes = policies["urlize.extra_schemes"] or ()
+
+    for scheme in extra_schemes:
+        if _uri_scheme_re.fullmatch(scheme) is None:
+            raise FilterArgumentError(f"{scheme!r} is not a valid URI scheme prefix.")
+
+    rv = urlize(
+        value,
+        trim_url_limit=trim_url_limit,
+        rel=rel,
+        target=target,
+        extra_schemes=extra_schemes,
+    )
+
+    if eval_ctx.autoescape:
+        rv = Markup(rv)
+
+    return rv
+
+
+def do_indent(
+    s: str, width: t.Union[int, str] = 4, first: bool = False, blank: bool = False
+) -> str:
+    """Return a copy of the string with each line indented by 4 spaces. The
+    first line and blank lines are not indented by default.
+
+    :param width: Number of spaces, or a string, to indent by.
+    :param first: Don't skip indenting the first line.
+    :param blank: Don't skip indenting empty lines.
+
+    .. versionchanged:: 3.0
+        ``width`` can be a string.
+
+    .. versionchanged:: 2.10
+        Blank lines are not indented by default.
+
+        Rename the ``indentfirst`` argument to ``first``.
+    """
+    if isinstance(width, str):
+        indention = width
+    else:
+        indention = " " * width
+
+    newline = "\n"
+
+    if isinstance(s, Markup):
+        indention = Markup(indention)
+        newline = Markup(newline)
+
+    s += newline  # this quirk is necessary for splitlines method
+
+    if blank:
+        rv = (newline + indention).join(s.splitlines())
+    else:
+        lines = s.splitlines()
+        rv = lines.pop(0)
+
+        if lines:
+            rv += newline + newline.join(
+                indention + line if line else line for line in lines
+            )
+
+    if first:
+        rv = indention + rv
+
+    return rv
+
+
+@pass_environment
+def do_truncate(
+    env: "Environment",
+    s: str,
+    length: int = 255,
+    killwords: bool = False,
+    end: str = "...",
+    leeway: t.Optional[int] = None,
+) -> str:
+    """Return a truncated copy of the string. The length is specified
+    with the first parameter which defaults to ``255``. If the second
+    parameter is ``true`` the filter will cut the text at length. Otherwise
+    it will discard the last word. If the text was in fact
+    truncated it will append an ellipsis sign (``"..."``). If you want a
+    different ellipsis sign than ``"..."`` you can specify it using the
+    third parameter. Strings that only exceed the length by the tolerance
+    margin given in the fourth parameter will not be truncated.
+
+    .. sourcecode:: jinja
+
+        {{ "foo bar baz qux"|truncate(9) }}
+            -> "foo..."
+        {{ "foo bar baz qux"|truncate(9, True) }}
+            -> "foo ba..."
+        {{ "foo bar baz qux"|truncate(11) }}
+            -> "foo bar baz qux"
+        {{ "foo bar baz qux"|truncate(11, False, '...', 0) }}
+            -> "foo bar..."
+
+    The default leeway on newer Jinja versions is 5 and was 0 before but
+    can be reconfigured globally.
+    """
+    if leeway is None:
+        leeway = env.policies["truncate.leeway"]
+
+    assert length >= len(end), f"expected length >= {len(end)}, got {length}"
+    assert leeway >= 0, f"expected leeway >= 0, got {leeway}"
+
+    if len(s) <= length + leeway:
+        return s
+
+    if killwords:
+        return s[: length - len(end)] + end
+
+    result = s[: length - len(end)].rsplit(" ", 1)[0]
+    return result + end
+
+
+@pass_environment
+def do_wordwrap(
+    environment: "Environment",
+    s: str,
+    width: int = 79,
+    break_long_words: bool = True,
+    wrapstring: t.Optional[str] = None,
+    break_on_hyphens: bool = True,
+) -> str:
+    """Wrap a string to the given width. Existing newlines are treated
+    as paragraphs to be wrapped separately.
+
+    :param s: Original text to wrap.
+    :param width: Maximum length of wrapped lines.
+    :param break_long_words: If a word is longer than ``width``, break
+        it across lines.
+    :param break_on_hyphens: If a word contains hyphens, it may be split
+        across lines.
+    :param wrapstring: String to join each wrapped line. Defaults to
+        :attr:`Environment.newline_sequence`.
+
+    .. versionchanged:: 2.11
+        Existing newlines are treated as paragraphs wrapped separately.
+
+    .. versionchanged:: 2.11
+        Added the ``break_on_hyphens`` parameter.
+
+    .. versionchanged:: 2.7
+        Added the ``wrapstring`` parameter.
+    """
+    import textwrap
+
+    if wrapstring is None:
+        wrapstring = environment.newline_sequence
+
+    # textwrap.wrap doesn't consider existing newlines when wrapping.
+    # If the string has a newline before width, wrap will still insert
+    # a newline at width, resulting in a short line. Instead, split and
+    # wrap each paragraph individually.
+    return wrapstring.join(
+        [
+            wrapstring.join(
+                textwrap.wrap(
+                    line,
+                    width=width,
+                    expand_tabs=False,
+                    replace_whitespace=False,
+                    break_long_words=break_long_words,
+                    break_on_hyphens=break_on_hyphens,
+                )
+            )
+            for line in s.splitlines()
+        ]
+    )
+
+
+_word_re = re.compile(r"\w+")
+
+
+def do_wordcount(s: str) -> int:
+    """Count the words in that string."""
+    return len(_word_re.findall(soft_str(s)))
+
+
+def do_int(value: t.Any, default: int = 0, base: int = 10) -> int:
+    """Convert the value into an integer. If the
+    conversion doesn't work it will return ``0``. You can
+    override this default using the first parameter. You
+    can also override the default base (10) in the second
+    parameter, which handles input with prefixes such as
+    0b, 0o and 0x for bases 2, 8 and 16 respectively.
+    The base is ignored for decimal numbers and non-string values.
+    """
+    try:
+        if isinstance(value, str):
+            return int(value, base)
+
+        return int(value)
+    except (TypeError, ValueError):
+        # this quirk is necessary so that "42.23"|int gives 42.
+        try:
+            return int(float(value))
+        except (TypeError, ValueError):
+            return default
+
+
+def do_float(value: t.Any, default: float = 0.0) -> float:
+    """Convert the value into a floating point number. If the
+    conversion doesn't work it will return ``0.0``. You can
+    override this default using the first parameter.
+    """
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def do_format(value: str, *args: t.Any, **kwargs: t.Any) -> str:
+    """Apply the given values to a `printf-style`_ format string, like
+    ``string % values``.
+
+    .. sourcecode:: jinja
+
+        {{ "%s, %s!"|format(greeting, name) }}
+        Hello, World!
+
+    In most cases it should be more convenient and efficient to use the
+    ``%`` operator or :meth:`str.format`.
+
+    .. code-block:: text
+
+        {{ "%s, %s!" % (greeting, name) }}
+        {{ "{}, {}!".format(greeting, name) }}
+
+    .. _printf-style: https://docs.python.org/library/stdtypes.html
+        #printf-style-string-formatting
+    """
+    if args and kwargs:
+        raise FilterArgumentError(
+            "can't handle positional and keyword arguments at the same time"
+        )
+
+    return soft_str(value) % (kwargs or args)
+
+
+def do_trim(value: str, chars: t.Optional[str] = None) -> str:
+    """Strip leading and trailing characters, by default whitespace."""
+    return soft_str(value).strip(chars)
+
+
+def do_striptags(value: "t.Union[str, HasHTML]") -> str:
+    """Strip SGML/XML tags and replace adjacent whitespace by one space."""
+    if hasattr(value, "__html__"):
+        value = t.cast("HasHTML", value).__html__()
+
+    return Markup(str(value)).striptags()
+
+
+def sync_do_slice(
+    value: "t.Collection[V]", slices: int, fill_with: "t.Optional[V]" = None
+) -> "t.Iterator[t.List[V]]":
+    """Slice an iterator and return a list of lists containing
+    those items. Useful if you want to create a div containing
+    three ul tags that represent columns:
+
+    .. sourcecode:: html+jinja
+
+        <div class="columnwrapper">
+          {%- for column in items|slice(3) %}
+            <ul class="column-{{ loop.index }}">
+            {%- for item in column %}
+              <li>{{ item }}</li>
+            {%- endfor %}
+            </ul>
+          {%- endfor %}
+        </div>
+
+    If you pass it a second argument it's used to fill missing
+    values on the last iteration.
+    """
+    seq = list(value)
+    length = len(seq)
+    items_per_slice = length // slices
+    slices_with_extra = length % slices
+    offset = 0
+
+    for slice_number in range(slices):
+        start = offset + slice_number * items_per_slice
+
+        if slice_number < slices_with_extra:
+            offset += 1
+
+        end = offset + (slice_number + 1) * items_per_slice
+        tmp = seq[start:end]
+
+        if fill_with is not None and slice_number >= slices_with_extra:
+            tmp.append(fill_with)
+
+        yield tmp
+
+
+@async_variant(sync_do_slice)  # type: ignore
+async def do_slice(
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    slices: int,
+    fill_with: t.Optional[t.Any] = None,
+) -> "t.Iterator[t.List[V]]":
+    return sync_do_slice(await auto_to_list(value), slices, fill_with)
+
+
+def do_batch(
+    value: "t.Iterable[V]", linecount: int, fill_with: "t.Optional[V]" = None
+) -> "t.Iterator[t.List[V]]":
+    """
+    A filter that batches items. It works pretty much like `slice`
+    just the other way round. It returns a list of lists with the
+    given number of items. If you provide a second parameter this
+    is used to fill up missing items. See this example:
+
+    .. sourcecode:: html+jinja
+
+        <table>
+        {%- for row in items|batch(3, '&nbsp;') %}
+          <tr>
+          {%- for column in row %}
+            <td>{{ column }}</td>
+          {%- endfor %}
+          </tr>
+        {%- endfor %}
+        </table>
+    """
+    tmp: "t.List[V]" = []
+
+    for item in value:
+        if len(tmp) == linecount:
+            yield tmp
+            tmp = []
+
+        tmp.append(item)
+
+    if tmp:
+        if fill_with is not None and len(tmp) < linecount:
+            tmp += [fill_with] * (linecount - len(tmp))
+
+        yield tmp
+
+
+def do_round(
+    value: float,
+    precision: int = 0,
+    method: 'te.Literal["common", "ceil", "floor"]' = "common",
+) -> float:
+    """Round the number to a given precision. The first
+    parameter specifies the precision (default is ``0``), the
+    second the rounding method:
+
+    - ``'common'`` rounds either up or down
+    - ``'ceil'`` always rounds up
+    - ``'floor'`` always rounds down
+
+    If you don't specify a method ``'common'`` is used.
+
+    .. sourcecode:: jinja
+
+        {{ 42.55|round }}
+            -> 43.0
+        {{ 42.55|round(1, 'floor') }}
+            -> 42.5
+
+    Note that even if rounded to 0 precision, a float is returned.  If
+    you need a real integer, pipe it through `int`:
+
+    .. sourcecode:: jinja
+
+        {{ 42.55|round|int }}
+            -> 43
+    """
+    if method not in {"common", "ceil", "floor"}:
+        raise FilterArgumentError("method must be common, ceil or floor")
+
+    if method == "common":
+        return round(value, precision)
+
+    func = getattr(math, method)
+    return t.cast(float, func(value * (10**precision)) / (10**precision))
+
+
+class _GroupTuple(t.NamedTuple):
+    grouper: t.Any
+    list: t.List
+
+    # Use the regular tuple repr to hide this subclass if users print
+    # out the value during debugging.
+    def __repr__(self) -> str:
+        return tuple.__repr__(self)
+
+    def __str__(self) -> str:
+        return tuple.__str__(self)
+
+
+@pass_environment
+def sync_do_groupby(
+    environment: "Environment",
+    value: "t.Iterable[V]",
+    attribute: t.Union[str, int],
+    default: t.Optional[t.Any] = None,
+    case_sensitive: bool = False,
+) -> "t.List[_GroupTuple]":
+    """Group a sequence of objects by an attribute using Python's
+    :func:`itertools.groupby`. The attribute can use dot notation for
+    nested access, like ``"address.city"``. Unlike Python's ``groupby``,
+    the values are sorted first so only one group is returned for each
+    unique value.
+
+    For example, a list of ``User`` objects with a ``city`` attribute
+    can be rendered in groups. In this example, ``grouper`` refers to
+    the ``city`` value of the group.
+
+    .. sourcecode:: html+jinja
+
+        <ul>{% for city, items in users|groupby("city") %}
+          <li>{{ city }}
+            <ul>{% for user in items %}
+              <li>{{ user.name }}
+            {% endfor %}</ul>
+          </li>
+        {% endfor %}</ul>
+
+    ``groupby`` yields namedtuples of ``(grouper, list)``, which
+    can be used instead of the tuple unpacking above. ``grouper`` is the
+    value of the attribute, and ``list`` is the items with that value.
+
+    .. sourcecode:: html+jinja
+
+        <ul>{% for group in users|groupby("city") %}
+          <li>{{ group.grouper }}: {{ group.list|join(", ") }}
+        {% endfor %}</ul>
+
+    You can specify a ``default`` value to use if an object in the list
+    does not have the given attribute.
+
+    .. sourcecode:: jinja
+
+        <ul>{% for city, items in users|groupby("city", default="NY") %}
+          <li>{{ city }}: {{ items|map(attribute="name")|join(", ") }}</li>
+        {% endfor %}</ul>
+
+    Like the :func:`~jinja-filters.sort` filter, sorting and grouping is
+    case-insensitive by default. The ``key`` for each group will have
+    the case of the first item in that group of values. For example, if
+    a list of users has cities ``["CA", "NY", "ca"]``, the "CA" group
+    will have two values. This can be disabled by passing
+    ``case_sensitive=True``.
+
+    .. versionchanged:: 3.1
+        Added the ``case_sensitive`` parameter. Sorting and grouping is
+        case-insensitive by default, matching other filters that do
+        comparisons.
+
+    .. versionchanged:: 3.0
+        Added the ``default`` parameter.
+
+    .. versionchanged:: 2.6
+        The attribute supports dot notation for nested access.
+    """
+    expr = make_attrgetter(
+        environment,
+        attribute,
+        postprocess=ignore_case if not case_sensitive else None,
+        default=default,
+    )
+    out = [
+        _GroupTuple(key, list(values))
+        for key, values in groupby(sorted(value, key=expr), expr)
+    ]
+
+    if not case_sensitive:
+        # Return the real key from the first value instead of the lowercase key.
+        output_expr = make_attrgetter(environment, attribute, default=default)
+        out = [_GroupTuple(output_expr(values[0]), values) for _, values in out]
+
+    return out
+
+
+@async_variant(sync_do_groupby)  # type: ignore
+async def do_groupby(
+    environment: "Environment",
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    attribute: t.Union[str, int],
+    default: t.Optional[t.Any] = None,
+    case_sensitive: bool = False,
+) -> "t.List[_GroupTuple]":
+    expr = make_attrgetter(
+        environment,
+        attribute,
+        postprocess=ignore_case if not case_sensitive else None,
+        default=default,
+    )
+    out = [
+        _GroupTuple(key, await auto_to_list(values))
+        for key, values in groupby(sorted(await auto_to_list(value), key=expr), expr)
+    ]
+
+    if not case_sensitive:
+        # Return the real key from the first value instead of the lowercase key.
+        output_expr = make_attrgetter(environment, attribute, default=default)
+        out = [_GroupTuple(output_expr(values[0]), values) for _, values in out]
+
+    return out
+
+
+@pass_environment
+def sync_do_sum(
+    environment: "Environment",
+    iterable: "t.Iterable[V]",
+    attribute: t.Optional[t.Union[str, int]] = None,
+    start: V = 0,  # type: ignore
+) -> V:
+    """Returns the sum of a sequence of numbers plus the value of parameter
+    'start' (which defaults to 0).  When the sequence is empty it returns
+    start.
+
+    It is also possible to sum up only certain attributes:
+
+    .. sourcecode:: jinja
+
+        Total: {{ items|sum(attribute='price') }}
+
+    .. versionchanged:: 2.6
+       The ``attribute`` parameter was added to allow summing up over
+       attributes.  Also the ``start`` parameter was moved on to the right.
+    """
+    if attribute is not None:
+        iterable = map(make_attrgetter(environment, attribute), iterable)
+
+    return sum(iterable, start)  # type: ignore[no-any-return, call-overload]
+
+
+@async_variant(sync_do_sum)  # type: ignore
+async def do_sum(
+    environment: "Environment",
+    iterable: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    attribute: t.Optional[t.Union[str, int]] = None,
+    start: V = 0,  # type: ignore
+) -> V:
+    rv = start
+
+    if attribute is not None:
+        func = make_attrgetter(environment, attribute)
+    else:
+
+        def func(x: V) -> V:
+            return x
+
+    async for item in auto_aiter(iterable):
+        rv += func(item)
+
+    return rv
+
+
+def sync_do_list(value: "t.Iterable[V]") -> "t.List[V]":
+    """Convert the value into a list.  If it was a string the returned list
+    will be a list of characters.
+    """
+    return list(value)
+
+
+@async_variant(sync_do_list)  # type: ignore
+async def do_list(value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]") -> "t.List[V]":
+    return await auto_to_list(value)
+
+
+def do_mark_safe(value: str) -> Markup:
+    """Mark the value as safe which means that in an environment with automatic
+    escaping enabled this variable will not be escaped.
+    """
+    return Markup(value)
+
+
+def do_mark_unsafe(value: str) -> str:
+    """Mark a value as unsafe.  This is the reverse operation for :func:`safe`."""
+    return str(value)
+
+
+@typing.overload
+def do_reverse(value: str) -> str:
+    ...
+
+
+@typing.overload
+def do_reverse(value: "t.Iterable[V]") -> "t.Iterable[V]":
+    ...
+
+
+def do_reverse(value: t.Union[str, t.Iterable[V]]) -> t.Union[str, t.Iterable[V]]:
+    """Reverse the object or return an iterator that iterates over it the other
+    way round.
+    """
+    if isinstance(value, str):
+        return value[::-1]
+
+    try:
+        return reversed(value)  # type: ignore
+    except TypeError:
+        try:
+            rv = list(value)
+            rv.reverse()
+            return rv
+        except TypeError as e:
+            raise FilterArgumentError("argument must be iterable") from e
+
+
+@pass_environment
+def do_attr(
+    environment: "Environment", obj: t.Any, name: str
+) -> t.Union[Undefined, t.Any]:
+    """Get an attribute of an object.  ``foo|attr("bar")`` works like
+    ``foo.bar`` just that always an attribute is returned and items are not
+    looked up.
+
+    See :ref:`Notes on subscriptions <notes-on-subscriptions>` for more details.
+    """
+    try:
+        name = str(name)
+    except UnicodeError:
+        pass
+    else:
+        try:
+            value = getattr(obj, name)
+        except AttributeError:
+            pass
+        else:
+            if environment.sandboxed:
+                environment = t.cast("SandboxedEnvironment", environment)
+
+                if not environment.is_safe_attribute(obj, name, value):
+                    return environment.unsafe_undefined(obj, name)
+
+            return value
+
+    return environment.undefined(obj=obj, name=name)
+
+
+@typing.overload
+def sync_do_map(
+    context: "Context", value: t.Iterable, name: str, *args: t.Any, **kwargs: t.Any
+) -> t.Iterable:
+    ...
+
+
+@typing.overload
+def sync_do_map(
+    context: "Context",
+    value: t.Iterable,
+    *,
+    attribute: str = ...,
+    default: t.Optional[t.Any] = None,
+) -> t.Iterable:
+    ...
+
+
+@pass_context
+def sync_do_map(
+    context: "Context", value: t.Iterable, *args: t.Any, **kwargs: t.Any
+) -> t.Iterable:
+    """Applies a filter on a sequence of objects or looks up an attribute.
+    This is useful when dealing with lists of objects but you are really
+    only interested in a certain value of it.
+
+    The basic usage is mapping on an attribute.  Imagine you have a list
+    of users but you are only interested in a list of usernames:
+
+    .. sourcecode:: jinja
+
+        Users on this page: {{ users|map(attribute='username')|join(', ') }}
+
+    You can specify a ``default`` value to use if an object in the list
+    does not have the given attribute.
+
+    .. sourcecode:: jinja
+
+        {{ users|map(attribute="username", default="Anonymous")|join(", ") }}
+
+    Alternatively you can let it invoke a filter by passing the name of the
+    filter and the arguments afterwards.  A good example would be applying a
+    text conversion filter on a sequence:
+
+    .. sourcecode:: jinja
+
+        Users on this page: {{ titles|map('lower')|join(', ') }}
+
+    Similar to a generator comprehension such as:
+
+    .. code-block:: python
+
+        (u.username for u in users)
+        (getattr(u, "username", "Anonymous") for u in users)
+        (do_lower(x) for x in titles)
+
+    .. versionchanged:: 2.11.0
+        Added the ``default`` parameter.
+
+    .. versionadded:: 2.7
+    """
+    if value:
+        func = prepare_map(context, args, kwargs)
+
+        for item in value:
+            yield func(item)
+
+
+@typing.overload
+def do_map(
+    context: "Context",
+    value: t.Union[t.AsyncIterable, t.Iterable],
+    name: str,
+    *args: t.Any,
+    **kwargs: t.Any,
+) -> t.Iterable:
+    ...
+
+
+@typing.overload
+def do_map(
+    context: "Context",
+    value: t.Union[t.AsyncIterable, t.Iterable],
+    *,
+    attribute: str = ...,
+    default: t.Optional[t.Any] = None,
+) -> t.Iterable:
+    ...
+
+
+@async_variant(sync_do_map)  # type: ignore
+async def do_map(
+    context: "Context",
+    value: t.Union[t.AsyncIterable, t.Iterable],
+    *args: t.Any,
+    **kwargs: t.Any,
+) -> t.AsyncIterable:
+    if value:
+        func = prepare_map(context, args, kwargs)
+
+        async for item in auto_aiter(value):
+            yield await auto_await(func(item))
+
+
+@pass_context
+def sync_do_select(
+    context: "Context", value: "t.Iterable[V]", *args: t.Any, **kwargs: t.Any
+) -> "t.Iterator[V]":
+    """Filters a sequence of objects by applying a test to each object,
+    and only selecting the objects with the test succeeding.
+
+    If no test is specified, each object will be evaluated as a boolean.
+
+    Example usage:
+
+    .. sourcecode:: jinja
+
+        {{ numbers|select("odd") }}
+        {{ numbers|select("odd") }}
+        {{ numbers|select("divisibleby", 3) }}
+        {{ numbers|select("lessthan", 42) }}
+        {{ strings|select("equalto", "mystring") }}
+
+    Similar to a generator comprehension such as:
+
+    .. code-block:: python
+
+        (n for n in numbers if test_odd(n))
+        (n for n in numbers if test_divisibleby(n, 3))
+
+    .. versionadded:: 2.7
+    """
+    return select_or_reject(context, value, args, kwargs, lambda x: x, False)
+
+
+@async_variant(sync_do_select)  # type: ignore
+async def do_select(
+    context: "Context",
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    *args: t.Any,
+    **kwargs: t.Any,
+) -> "t.AsyncIterator[V]":
+    return async_select_or_reject(context, value, args, kwargs, lambda x: x, False)
+
+
+@pass_context
+def sync_do_reject(
+    context: "Context", value: "t.Iterable[V]", *args: t.Any, **kwargs: t.Any
+) -> "t.Iterator[V]":
+    """Filters a sequence of objects by applying a test to each object,
+    and rejecting the objects with the test succeeding.
+
+    If no test is specified, each object will be evaluated as a boolean.
+
+    Example usage:
+
+    .. sourcecode:: jinja
+
+        {{ numbers|reject("odd") }}
+
+    Similar to a generator comprehension such as:
+
+    .. code-block:: python
+
+        (n for n in numbers if not test_odd(n))
+
+    .. versionadded:: 2.7
+    """
+    return select_or_reject(context, value, args, kwargs, lambda x: not x, False)
+
+
+@async_variant(sync_do_reject)  # type: ignore
+async def do_reject(
+    context: "Context",
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    *args: t.Any,
+    **kwargs: t.Any,
+) -> "t.AsyncIterator[V]":
+    return async_select_or_reject(context, value, args, kwargs, lambda x: not x, False)
+
+
+@pass_context
+def sync_do_selectattr(
+    context: "Context", value: "t.Iterable[V]", *args: t.Any, **kwargs: t.Any
+) -> "t.Iterator[V]":
+    """Filters a sequence of objects by applying a test to the specified
+    attribute of each object, and only selecting the objects with the
+    test succeeding.
+
+    If no test is specified, the attribute's value will be evaluated as
+    a boolean.
+
+    Example usage:
+
+    .. sourcecode:: jinja
+
+        {{ users|selectattr("is_active") }}
+        {{ users|selectattr("email", "none") }}
+
+    Similar to a generator comprehension such as:
+
+    .. code-block:: python
+
+        (u for user in users if user.is_active)
+        (u for user in users if test_none(user.email))
+
+    .. versionadded:: 2.7
+    """
+    return select_or_reject(context, value, args, kwargs, lambda x: x, True)
+
+
+@async_variant(sync_do_selectattr)  # type: ignore
+async def do_selectattr(
+    context: "Context",
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    *args: t.Any,
+    **kwargs: t.Any,
+) -> "t.AsyncIterator[V]":
+    return async_select_or_reject(context, value, args, kwargs, lambda x: x, True)
+
+
+@pass_context
+def sync_do_rejectattr(
+    context: "Context", value: "t.Iterable[V]", *args: t.Any, **kwargs: t.Any
+) -> "t.Iterator[V]":
+    """Filters a sequence of objects by applying a test to the specified
+    attribute of each object, and rejecting the objects with the test
+    succeeding.
+
+    If no test is specified, the attribute's value will be evaluated as
+    a boolean.
+
+    .. sourcecode:: jinja
+
+        {{ users|rejectattr("is_active") }}
+        {{ users|rejectattr("email", "none") }}
+
+    Similar to a generator comprehension such as:
+
+    .. code-block:: python
+
+        (u for user in users if not user.is_active)
+        (u for user in users if not test_none(user.email))
+
+    .. versionadded:: 2.7
+    """
+    return select_or_reject(context, value, args, kwargs, lambda x: not x, True)
+
+
+@async_variant(sync_do_rejectattr)  # type: ignore
+async def do_rejectattr(
+    context: "Context",
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    *args: t.Any,
+    **kwargs: t.Any,
+) -> "t.AsyncIterator[V]":
+    return async_select_or_reject(context, value, args, kwargs, lambda x: not x, True)
+
+
+@pass_eval_context
+def do_tojson(
+    eval_ctx: "EvalContext", value: t.Any, indent: t.Optional[int] = None
+) -> Markup:
+    """Serialize an object to a string of JSON, and mark it safe to
+    render in HTML. This filter is only for use in HTML documents.
+
+    The returned string is safe to render in HTML documents and
+    ``<script>`` tags. The exception is in HTML attributes that are
+    double quoted; either use single quotes or the ``|forceescape``
+    filter.
+
+    :param value: The object to serialize to JSON.
+    :param indent: The ``indent`` parameter passed to ``dumps``, for
+        pretty-printing the value.
+
+    .. versionadded:: 2.9
+    """
+    policies = eval_ctx.environment.policies
+    dumps = policies["json.dumps_function"]
+    kwargs = policies["json.dumps_kwargs"]
+
+    if indent is not None:
+        kwargs = kwargs.copy()
+        kwargs["indent"] = indent
+
+    return htmlsafe_json_dumps(value, dumps=dumps, **kwargs)
+
+
+def prepare_map(
+    context: "Context", args: t.Tuple, kwargs: t.Dict[str, t.Any]
+) -> t.Callable[[t.Any], t.Any]:
+    if not args and "attribute" in kwargs:
+        attribute = kwargs.pop("attribute")
+        default = kwargs.pop("default", None)
+
+        if kwargs:
+            raise FilterArgumentError(
+                f"Unexpected keyword argument {next(iter(kwargs))!r}"
+            )
+
+        func = make_attrgetter(context.environment, attribute, default=default)
+    else:
+        try:
+            name = args[0]
+            args = args[1:]
+        except LookupError:
+            raise FilterArgumentError("map requires a filter argument") from None
+
+        def func(item: t.Any) -> t.Any:
+            return context.environment.call_filter(
+                name, item, args, kwargs, context=context
+            )
+
+    return func
+
+
+def prepare_select_or_reject(
+    context: "Context",
+    args: t.Tuple,
+    kwargs: t.Dict[str, t.Any],
+    modfunc: t.Callable[[t.Any], t.Any],
+    lookup_attr: bool,
+) -> t.Callable[[t.Any], t.Any]:
+    if lookup_attr:
+        try:
+            attr = args[0]
+        except LookupError:
+            raise FilterArgumentError("Missing parameter for attribute name") from None
+
+        transfunc = make_attrgetter(context.environment, attr)
+        off = 1
+    else:
+        off = 0
+
+        def transfunc(x: V) -> V:
+            return x
+
+    try:
+        name = args[off]
+        args = args[1 + off :]
+
+        def func(item: t.Any) -> t.Any:
+            return context.environment.call_test(name, item, args, kwargs)
+
+    except LookupError:
+        func = bool  # type: ignore
+
+    return lambda item: modfunc(func(transfunc(item)))
+
+
+def select_or_reject(
+    context: "Context",
+    value: "t.Iterable[V]",
+    args: t.Tuple,
+    kwargs: t.Dict[str, t.Any],
+    modfunc: t.Callable[[t.Any], t.Any],
+    lookup_attr: bool,
+) -> "t.Iterator[V]":
+    if value:
+        func = prepare_select_or_reject(context, args, kwargs, modfunc, lookup_attr)
+
+        for item in value:
+            if func(item):
+                yield item
+
+
+async def async_select_or_reject(
+    context: "Context",
+    value: "t.Union[t.AsyncIterable[V], t.Iterable[V]]",
+    args: t.Tuple,
+    kwargs: t.Dict[str, t.Any],
+    modfunc: t.Callable[[t.Any], t.Any],
+    lookup_attr: bool,
+) -> "t.AsyncIterator[V]":
+    if value:
+        func = prepare_select_or_reject(context, args, kwargs, modfunc, lookup_attr)
+
+        async for item in auto_aiter(value):
+            if func(item):
+                yield item
+
+
+FILTERS = {
+    "abs": abs,
+    "attr": do_attr,
+    "batch": do_batch,
+    "capitalize": do_capitalize,
+    "center": do_center,
+    "count": len,
+    "d": do_default,
+    "default": do_default,
+    "dictsort": do_dictsort,
+    "e": escape,
+    "escape": escape,
+    "filesizeformat": do_filesizeformat,
+    "first": do_first,
+    "float": do_float,
+    "forceescape": do_forceescape,
+    "format": do_format,
+    "groupby": do_groupby,
+    "indent": do_indent,
+    "int": do_int,
+    "join": do_join,
+    "last": do_last,
+    "length": len,
+    "list": do_list,
+    "lower": do_lower,
+    "items": do_items,
+    "map": do_map,
+    "min": do_min,
+    "max": do_max,
+    "pprint": do_pprint,
+    "random": do_random,
+    "reject": do_reject,
+    "rejectattr": do_rejectattr,
+    "replace": do_replace,
+    "reverse": do_reverse,
+    "round": do_round,
+    "safe": do_mark_safe,
+    "select": do_select,
+    "selectattr": do_selectattr,
+    "slice": do_slice,
+    "sort": do_sort,
+    "string": soft_str,
+    "striptags": do_striptags,
+    "sum": do_sum,
+    "title": do_title,
+    "trim": do_trim,
+    "truncate": do_truncate,
+    "unique": do_unique,
+    "upper": do_upper,
+    "urlencode": do_urlencode,
+    "urlize": do_urlize,
+    "wordcount": do_wordcount,
+    "wordwrap": do_wordwrap,
+    "xmlattr": do_xmlattr,
+    "tojson": do_tojson,
+}
diff --git a/lib/python3.11/site-packages/jinja2/idtracking.py b/lib/python3.11/site-packages/jinja2/idtracking.py
new file mode 100644
index 0000000000000000000000000000000000000000..995ebaa0c8178ddb9e0479e0e9f6d30ed863a785
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/idtracking.py
@@ -0,0 +1,318 @@
+import typing as t
+
+from . import nodes
+from .visitor import NodeVisitor
+
+VAR_LOAD_PARAMETER = "param"
+VAR_LOAD_RESOLVE = "resolve"
+VAR_LOAD_ALIAS = "alias"
+VAR_LOAD_UNDEFINED = "undefined"
+
+
+def find_symbols(
+    nodes: t.Iterable[nodes.Node], parent_symbols: t.Optional["Symbols"] = None
+) -> "Symbols":
+    sym = Symbols(parent=parent_symbols)
+    visitor = FrameSymbolVisitor(sym)
+    for node in nodes:
+        visitor.visit(node)
+    return sym
+
+
+def symbols_for_node(
+    node: nodes.Node, parent_symbols: t.Optional["Symbols"] = None
+) -> "Symbols":
+    sym = Symbols(parent=parent_symbols)
+    sym.analyze_node(node)
+    return sym
+
+
+class Symbols:
+    def __init__(
+        self, parent: t.Optional["Symbols"] = None, level: t.Optional[int] = None
+    ) -> None:
+        if level is None:
+            if parent is None:
+                level = 0
+            else:
+                level = parent.level + 1
+
+        self.level: int = level
+        self.parent = parent
+        self.refs: t.Dict[str, str] = {}
+        self.loads: t.Dict[str, t.Any] = {}
+        self.stores: t.Set[str] = set()
+
+    def analyze_node(self, node: nodes.Node, **kwargs: t.Any) -> None:
+        visitor = RootVisitor(self)
+        visitor.visit(node, **kwargs)
+
+    def _define_ref(
+        self, name: str, load: t.Optional[t.Tuple[str, t.Optional[str]]] = None
+    ) -> str:
+        ident = f"l_{self.level}_{name}"
+        self.refs[name] = ident
+        if load is not None:
+            self.loads[ident] = load
+        return ident
+
+    def find_load(self, target: str) -> t.Optional[t.Any]:
+        if target in self.loads:
+            return self.loads[target]
+
+        if self.parent is not None:
+            return self.parent.find_load(target)
+
+        return None
+
+    def find_ref(self, name: str) -> t.Optional[str]:
+        if name in self.refs:
+            return self.refs[name]
+
+        if self.parent is not None:
+            return self.parent.find_ref(name)
+
+        return None
+
+    def ref(self, name: str) -> str:
+        rv = self.find_ref(name)
+        if rv is None:
+            raise AssertionError(
+                "Tried to resolve a name to a reference that was"
+                f" unknown to the frame ({name!r})"
+            )
+        return rv
+
+    def copy(self) -> "Symbols":
+        rv = object.__new__(self.__class__)
+        rv.__dict__.update(self.__dict__)
+        rv.refs = self.refs.copy()
+        rv.loads = self.loads.copy()
+        rv.stores = self.stores.copy()
+        return rv
+
+    def store(self, name: str) -> None:
+        self.stores.add(name)
+
+        # If we have not see the name referenced yet, we need to figure
+        # out what to set it to.
+        if name not in self.refs:
+            # If there is a parent scope we check if the name has a
+            # reference there.  If it does it means we might have to alias
+            # to a variable there.
+            if self.parent is not None:
+                outer_ref = self.parent.find_ref(name)
+                if outer_ref is not None:
+                    self._define_ref(name, load=(VAR_LOAD_ALIAS, outer_ref))
+                    return
+
+            # Otherwise we can just set it to undefined.
+            self._define_ref(name, load=(VAR_LOAD_UNDEFINED, None))
+
+    def declare_parameter(self, name: str) -> str:
+        self.stores.add(name)
+        return self._define_ref(name, load=(VAR_LOAD_PARAMETER, None))
+
+    def load(self, name: str) -> None:
+        if self.find_ref(name) is None:
+            self._define_ref(name, load=(VAR_LOAD_RESOLVE, name))
+
+    def branch_update(self, branch_symbols: t.Sequence["Symbols"]) -> None:
+        stores: t.Dict[str, int] = {}
+        for branch in branch_symbols:
+            for target in branch.stores:
+                if target in self.stores:
+                    continue
+                stores[target] = stores.get(target, 0) + 1
+
+        for sym in branch_symbols:
+            self.refs.update(sym.refs)
+            self.loads.update(sym.loads)
+            self.stores.update(sym.stores)
+
+        for name, branch_count in stores.items():
+            if branch_count == len(branch_symbols):
+                continue
+
+            target = self.find_ref(name)  # type: ignore
+            assert target is not None, "should not happen"
+
+            if self.parent is not None:
+                outer_target = self.parent.find_ref(name)
+                if outer_target is not None:
+                    self.loads[target] = (VAR_LOAD_ALIAS, outer_target)
+                    continue
+            self.loads[target] = (VAR_LOAD_RESOLVE, name)
+
+    def dump_stores(self) -> t.Dict[str, str]:
+        rv: t.Dict[str, str] = {}
+        node: t.Optional["Symbols"] = self
+
+        while node is not None:
+            for name in sorted(node.stores):
+                if name not in rv:
+                    rv[name] = self.find_ref(name)  # type: ignore
+
+            node = node.parent
+
+        return rv
+
+    def dump_param_targets(self) -> t.Set[str]:
+        rv = set()
+        node: t.Optional["Symbols"] = self
+
+        while node is not None:
+            for target, (instr, _) in self.loads.items():
+                if instr == VAR_LOAD_PARAMETER:
+                    rv.add(target)
+
+            node = node.parent
+
+        return rv
+
+
+class RootVisitor(NodeVisitor):
+    def __init__(self, symbols: "Symbols") -> None:
+        self.sym_visitor = FrameSymbolVisitor(symbols)
+
+    def _simple_visit(self, node: nodes.Node, **kwargs: t.Any) -> None:
+        for child in node.iter_child_nodes():
+            self.sym_visitor.visit(child)
+
+    visit_Template = _simple_visit
+    visit_Block = _simple_visit
+    visit_Macro = _simple_visit
+    visit_FilterBlock = _simple_visit
+    visit_Scope = _simple_visit
+    visit_If = _simple_visit
+    visit_ScopedEvalContextModifier = _simple_visit
+
+    def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) -> None:
+        for child in node.body:
+            self.sym_visitor.visit(child)
+
+    def visit_CallBlock(self, node: nodes.CallBlock, **kwargs: t.Any) -> None:
+        for child in node.iter_child_nodes(exclude=("call",)):
+            self.sym_visitor.visit(child)
+
+    def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any) -> None:
+        for child in node.body:
+            self.sym_visitor.visit(child)
+
+    def visit_For(
+        self, node: nodes.For, for_branch: str = "body", **kwargs: t.Any
+    ) -> None:
+        if for_branch == "body":
+            self.sym_visitor.visit(node.target, store_as_param=True)
+            branch = node.body
+        elif for_branch == "else":
+            branch = node.else_
+        elif for_branch == "test":
+            self.sym_visitor.visit(node.target, store_as_param=True)
+            if node.test is not None:
+                self.sym_visitor.visit(node.test)
+            return
+        else:
+            raise RuntimeError("Unknown for branch")
+
+        if branch:
+            for item in branch:
+                self.sym_visitor.visit(item)
+
+    def visit_With(self, node: nodes.With, **kwargs: t.Any) -> None:
+        for target in node.targets:
+            self.sym_visitor.visit(target)
+        for child in node.body:
+            self.sym_visitor.visit(child)
+
+    def generic_visit(self, node: nodes.Node, *args: t.Any, **kwargs: t.Any) -> None:
+        raise NotImplementedError(f"Cannot find symbols for {type(node).__name__!r}")
+
+
+class FrameSymbolVisitor(NodeVisitor):
+    """A visitor for `Frame.inspect`."""
+
+    def __init__(self, symbols: "Symbols") -> None:
+        self.symbols = symbols
+
+    def visit_Name(
+        self, node: nodes.Name, store_as_param: bool = False, **kwargs: t.Any
+    ) -> None:
+        """All assignments to names go through this function."""
+        if store_as_param or node.ctx == "param":
+            self.symbols.declare_parameter(node.name)
+        elif node.ctx == "store":
+            self.symbols.store(node.name)
+        elif node.ctx == "load":
+            self.symbols.load(node.name)
+
+    def visit_NSRef(self, node: nodes.NSRef, **kwargs: t.Any) -> None:
+        self.symbols.load(node.name)
+
+    def visit_If(self, node: nodes.If, **kwargs: t.Any) -> None:
+        self.visit(node.test, **kwargs)
+        original_symbols = self.symbols
+
+        def inner_visit(nodes: t.Iterable[nodes.Node]) -> "Symbols":
+            self.symbols = rv = original_symbols.copy()
+
+            for subnode in nodes:
+                self.visit(subnode, **kwargs)
+
+            self.symbols = original_symbols
+            return rv
+
+        body_symbols = inner_visit(node.body)
+        elif_symbols = inner_visit(node.elif_)
+        else_symbols = inner_visit(node.else_ or ())
+        self.symbols.branch_update([body_symbols, elif_symbols, else_symbols])
+
+    def visit_Macro(self, node: nodes.Macro, **kwargs: t.Any) -> None:
+        self.symbols.store(node.name)
+
+    def visit_Import(self, node: nodes.Import, **kwargs: t.Any) -> None:
+        self.generic_visit(node, **kwargs)
+        self.symbols.store(node.target)
+
+    def visit_FromImport(self, node: nodes.FromImport, **kwargs: t.Any) -> None:
+        self.generic_visit(node, **kwargs)
+
+        for name in node.names:
+            if isinstance(name, tuple):
+                self.symbols.store(name[1])
+            else:
+                self.symbols.store(name)
+
+    def visit_Assign(self, node: nodes.Assign, **kwargs: t.Any) -> None:
+        """Visit assignments in the correct order."""
+        self.visit(node.node, **kwargs)
+        self.visit(node.target, **kwargs)
+
+    def visit_For(self, node: nodes.For, **kwargs: t.Any) -> None:
+        """Visiting stops at for blocks.  However the block sequence
+        is visited as part of the outer scope.
+        """
+        self.visit(node.iter, **kwargs)
+
+    def visit_CallBlock(self, node: nodes.CallBlock, **kwargs: t.Any) -> None:
+        self.visit(node.call, **kwargs)
+
+    def visit_FilterBlock(self, node: nodes.FilterBlock, **kwargs: t.Any) -> None:
+        self.visit(node.filter, **kwargs)
+
+    def visit_With(self, node: nodes.With, **kwargs: t.Any) -> None:
+        for target in node.values:
+            self.visit(target)
+
+    def visit_AssignBlock(self, node: nodes.AssignBlock, **kwargs: t.Any) -> None:
+        """Stop visiting at block assigns."""
+        self.visit(node.target, **kwargs)
+
+    def visit_Scope(self, node: nodes.Scope, **kwargs: t.Any) -> None:
+        """Stop visiting at scopes."""
+
+    def visit_Block(self, node: nodes.Block, **kwargs: t.Any) -> None:
+        """Stop visiting at blocks."""
+
+    def visit_OverlayScope(self, node: nodes.OverlayScope, **kwargs: t.Any) -> None:
+        """Do not visit into overlay scopes."""
diff --git a/lib/python3.11/site-packages/jinja2/lexer.py b/lib/python3.11/site-packages/jinja2/lexer.py
new file mode 100644
index 0000000000000000000000000000000000000000..aff7e9f993792e1ced39c93fc0d39dcb5bdd5fde
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/lexer.py
@@ -0,0 +1,866 @@
+"""Implements a Jinja / Python combination lexer. The ``Lexer`` class
+is used to do some preprocessing. It filters out invalid operators like
+the bitshift operators we don't allow in templates. It separates
+template code and python code in expressions.
+"""
+import re
+import typing as t
+from ast import literal_eval
+from collections import deque
+from sys import intern
+
+from ._identifier import pattern as name_re
+from .exceptions import TemplateSyntaxError
+from .utils import LRUCache
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .environment import Environment
+
+# cache for the lexers. Exists in order to be able to have multiple
+# environments with the same lexer
+_lexer_cache: t.MutableMapping[t.Tuple, "Lexer"] = LRUCache(50)  # type: ignore
+
+# static regular expressions
+whitespace_re = re.compile(r"\s+")
+newline_re = re.compile(r"(\r\n|\r|\n)")
+string_re = re.compile(
+    r"('([^'\\]*(?:\\.[^'\\]*)*)'" r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S
+)
+integer_re = re.compile(
+    r"""
+    (
+        0b(_?[0-1])+ # binary
+    |
+        0o(_?[0-7])+ # octal
+    |
+        0x(_?[\da-f])+ # hex
+    |
+        [1-9](_?\d)* # decimal
+    |
+        0(_?0)* # decimal zero
+    )
+    """,
+    re.IGNORECASE | re.VERBOSE,
+)
+float_re = re.compile(
+    r"""
+    (?<!\.)  # doesn't start with a .
+    (\d+_)*\d+  # digits, possibly _ separated
+    (
+        (\.(\d+_)*\d+)?  # optional fractional part
+        e[+\-]?(\d+_)*\d+  # exponent part
+    |
+        \.(\d+_)*\d+  # required fractional part
+    )
+    """,
+    re.IGNORECASE | re.VERBOSE,
+)
+
+# internal the tokens and keep references to them
+TOKEN_ADD = intern("add")
+TOKEN_ASSIGN = intern("assign")
+TOKEN_COLON = intern("colon")
+TOKEN_COMMA = intern("comma")
+TOKEN_DIV = intern("div")
+TOKEN_DOT = intern("dot")
+TOKEN_EQ = intern("eq")
+TOKEN_FLOORDIV = intern("floordiv")
+TOKEN_GT = intern("gt")
+TOKEN_GTEQ = intern("gteq")
+TOKEN_LBRACE = intern("lbrace")
+TOKEN_LBRACKET = intern("lbracket")
+TOKEN_LPAREN = intern("lparen")
+TOKEN_LT = intern("lt")
+TOKEN_LTEQ = intern("lteq")
+TOKEN_MOD = intern("mod")
+TOKEN_MUL = intern("mul")
+TOKEN_NE = intern("ne")
+TOKEN_PIPE = intern("pipe")
+TOKEN_POW = intern("pow")
+TOKEN_RBRACE = intern("rbrace")
+TOKEN_RBRACKET = intern("rbracket")
+TOKEN_RPAREN = intern("rparen")
+TOKEN_SEMICOLON = intern("semicolon")
+TOKEN_SUB = intern("sub")
+TOKEN_TILDE = intern("tilde")
+TOKEN_WHITESPACE = intern("whitespace")
+TOKEN_FLOAT = intern("float")
+TOKEN_INTEGER = intern("integer")
+TOKEN_NAME = intern("name")
+TOKEN_STRING = intern("string")
+TOKEN_OPERATOR = intern("operator")
+TOKEN_BLOCK_BEGIN = intern("block_begin")
+TOKEN_BLOCK_END = intern("block_end")
+TOKEN_VARIABLE_BEGIN = intern("variable_begin")
+TOKEN_VARIABLE_END = intern("variable_end")
+TOKEN_RAW_BEGIN = intern("raw_begin")
+TOKEN_RAW_END = intern("raw_end")
+TOKEN_COMMENT_BEGIN = intern("comment_begin")
+TOKEN_COMMENT_END = intern("comment_end")
+TOKEN_COMMENT = intern("comment")
+TOKEN_LINESTATEMENT_BEGIN = intern("linestatement_begin")
+TOKEN_LINESTATEMENT_END = intern("linestatement_end")
+TOKEN_LINECOMMENT_BEGIN = intern("linecomment_begin")
+TOKEN_LINECOMMENT_END = intern("linecomment_end")
+TOKEN_LINECOMMENT = intern("linecomment")
+TOKEN_DATA = intern("data")
+TOKEN_INITIAL = intern("initial")
+TOKEN_EOF = intern("eof")
+
+# bind operators to token types
+operators = {
+    "+": TOKEN_ADD,
+    "-": TOKEN_SUB,
+    "/": TOKEN_DIV,
+    "//": TOKEN_FLOORDIV,
+    "*": TOKEN_MUL,
+    "%": TOKEN_MOD,
+    "**": TOKEN_POW,
+    "~": TOKEN_TILDE,
+    "[": TOKEN_LBRACKET,
+    "]": TOKEN_RBRACKET,
+    "(": TOKEN_LPAREN,
+    ")": TOKEN_RPAREN,
+    "{": TOKEN_LBRACE,
+    "}": TOKEN_RBRACE,
+    "==": TOKEN_EQ,
+    "!=": TOKEN_NE,
+    ">": TOKEN_GT,
+    ">=": TOKEN_GTEQ,
+    "<": TOKEN_LT,
+    "<=": TOKEN_LTEQ,
+    "=": TOKEN_ASSIGN,
+    ".": TOKEN_DOT,
+    ":": TOKEN_COLON,
+    "|": TOKEN_PIPE,
+    ",": TOKEN_COMMA,
+    ";": TOKEN_SEMICOLON,
+}
+
+reverse_operators = {v: k for k, v in operators.items()}
+assert len(operators) == len(reverse_operators), "operators dropped"
+operator_re = re.compile(
+    f"({'|'.join(re.escape(x) for x in sorted(operators, key=lambda x: -len(x)))})"
+)
+
+ignored_tokens = frozenset(
+    [
+        TOKEN_COMMENT_BEGIN,
+        TOKEN_COMMENT,
+        TOKEN_COMMENT_END,
+        TOKEN_WHITESPACE,
+        TOKEN_LINECOMMENT_BEGIN,
+        TOKEN_LINECOMMENT_END,
+        TOKEN_LINECOMMENT,
+    ]
+)
+ignore_if_empty = frozenset(
+    [TOKEN_WHITESPACE, TOKEN_DATA, TOKEN_COMMENT, TOKEN_LINECOMMENT]
+)
+
+
+def _describe_token_type(token_type: str) -> str:
+    if token_type in reverse_operators:
+        return reverse_operators[token_type]
+
+    return {
+        TOKEN_COMMENT_BEGIN: "begin of comment",
+        TOKEN_COMMENT_END: "end of comment",
+        TOKEN_COMMENT: "comment",
+        TOKEN_LINECOMMENT: "comment",
+        TOKEN_BLOCK_BEGIN: "begin of statement block",
+        TOKEN_BLOCK_END: "end of statement block",
+        TOKEN_VARIABLE_BEGIN: "begin of print statement",
+        TOKEN_VARIABLE_END: "end of print statement",
+        TOKEN_LINESTATEMENT_BEGIN: "begin of line statement",
+        TOKEN_LINESTATEMENT_END: "end of line statement",
+        TOKEN_DATA: "template data / text",
+        TOKEN_EOF: "end of template",
+    }.get(token_type, token_type)
+
+
+def describe_token(token: "Token") -> str:
+    """Returns a description of the token."""
+    if token.type == TOKEN_NAME:
+        return token.value
+
+    return _describe_token_type(token.type)
+
+
+def describe_token_expr(expr: str) -> str:
+    """Like `describe_token` but for token expressions."""
+    if ":" in expr:
+        type, value = expr.split(":", 1)
+
+        if type == TOKEN_NAME:
+            return value
+    else:
+        type = expr
+
+    return _describe_token_type(type)
+
+
+def count_newlines(value: str) -> int:
+    """Count the number of newline characters in the string.  This is
+    useful for extensions that filter a stream.
+    """
+    return len(newline_re.findall(value))
+
+
+def compile_rules(environment: "Environment") -> t.List[t.Tuple[str, str]]:
+    """Compiles all the rules from the environment into a list of rules."""
+    e = re.escape
+    rules = [
+        (
+            len(environment.comment_start_string),
+            TOKEN_COMMENT_BEGIN,
+            e(environment.comment_start_string),
+        ),
+        (
+            len(environment.block_start_string),
+            TOKEN_BLOCK_BEGIN,
+            e(environment.block_start_string),
+        ),
+        (
+            len(environment.variable_start_string),
+            TOKEN_VARIABLE_BEGIN,
+            e(environment.variable_start_string),
+        ),
+    ]
+
+    if environment.line_statement_prefix is not None:
+        rules.append(
+            (
+                len(environment.line_statement_prefix),
+                TOKEN_LINESTATEMENT_BEGIN,
+                r"^[ \t\v]*" + e(environment.line_statement_prefix),
+            )
+        )
+    if environment.line_comment_prefix is not None:
+        rules.append(
+            (
+                len(environment.line_comment_prefix),
+                TOKEN_LINECOMMENT_BEGIN,
+                r"(?:^|(?<=\S))[^\S\r\n]*" + e(environment.line_comment_prefix),
+            )
+        )
+
+    return [x[1:] for x in sorted(rules, reverse=True)]
+
+
+class Failure:
+    """Class that raises a `TemplateSyntaxError` if called.
+    Used by the `Lexer` to specify known errors.
+    """
+
+    def __init__(
+        self, message: str, cls: t.Type[TemplateSyntaxError] = TemplateSyntaxError
+    ) -> None:
+        self.message = message
+        self.error_class = cls
+
+    def __call__(self, lineno: int, filename: str) -> "te.NoReturn":
+        raise self.error_class(self.message, lineno, filename)
+
+
+class Token(t.NamedTuple):
+    lineno: int
+    type: str
+    value: str
+
+    def __str__(self) -> str:
+        return describe_token(self)
+
+    def test(self, expr: str) -> bool:
+        """Test a token against a token expression.  This can either be a
+        token type or ``'token_type:token_value'``.  This can only test
+        against string values and types.
+        """
+        # here we do a regular string equality check as test_any is usually
+        # passed an iterable of not interned strings.
+        if self.type == expr:
+            return True
+
+        if ":" in expr:
+            return expr.split(":", 1) == [self.type, self.value]
+
+        return False
+
+    def test_any(self, *iterable: str) -> bool:
+        """Test against multiple token expressions."""
+        return any(self.test(expr) for expr in iterable)
+
+
+class TokenStreamIterator:
+    """The iterator for tokenstreams.  Iterate over the stream
+    until the eof token is reached.
+    """
+
+    def __init__(self, stream: "TokenStream") -> None:
+        self.stream = stream
+
+    def __iter__(self) -> "TokenStreamIterator":
+        return self
+
+    def __next__(self) -> Token:
+        token = self.stream.current
+
+        if token.type is TOKEN_EOF:
+            self.stream.close()
+            raise StopIteration
+
+        next(self.stream)
+        return token
+
+
+class TokenStream:
+    """A token stream is an iterable that yields :class:`Token`\\s.  The
+    parser however does not iterate over it but calls :meth:`next` to go
+    one token ahead.  The current active token is stored as :attr:`current`.
+    """
+
+    def __init__(
+        self,
+        generator: t.Iterable[Token],
+        name: t.Optional[str],
+        filename: t.Optional[str],
+    ):
+        self._iter = iter(generator)
+        self._pushed: "te.Deque[Token]" = deque()
+        self.name = name
+        self.filename = filename
+        self.closed = False
+        self.current = Token(1, TOKEN_INITIAL, "")
+        next(self)
+
+    def __iter__(self) -> TokenStreamIterator:
+        return TokenStreamIterator(self)
+
+    def __bool__(self) -> bool:
+        return bool(self._pushed) or self.current.type is not TOKEN_EOF
+
+    @property
+    def eos(self) -> bool:
+        """Are we at the end of the stream?"""
+        return not self
+
+    def push(self, token: Token) -> None:
+        """Push a token back to the stream."""
+        self._pushed.append(token)
+
+    def look(self) -> Token:
+        """Look at the next token."""
+        old_token = next(self)
+        result = self.current
+        self.push(result)
+        self.current = old_token
+        return result
+
+    def skip(self, n: int = 1) -> None:
+        """Got n tokens ahead."""
+        for _ in range(n):
+            next(self)
+
+    def next_if(self, expr: str) -> t.Optional[Token]:
+        """Perform the token test and return the token if it matched.
+        Otherwise the return value is `None`.
+        """
+        if self.current.test(expr):
+            return next(self)
+
+        return None
+
+    def skip_if(self, expr: str) -> bool:
+        """Like :meth:`next_if` but only returns `True` or `False`."""
+        return self.next_if(expr) is not None
+
+    def __next__(self) -> Token:
+        """Go one token ahead and return the old one.
+
+        Use the built-in :func:`next` instead of calling this directly.
+        """
+        rv = self.current
+
+        if self._pushed:
+            self.current = self._pushed.popleft()
+        elif self.current.type is not TOKEN_EOF:
+            try:
+                self.current = next(self._iter)
+            except StopIteration:
+                self.close()
+
+        return rv
+
+    def close(self) -> None:
+        """Close the stream."""
+        self.current = Token(self.current.lineno, TOKEN_EOF, "")
+        self._iter = iter(())
+        self.closed = True
+
+    def expect(self, expr: str) -> Token:
+        """Expect a given token type and return it.  This accepts the same
+        argument as :meth:`jinja2.lexer.Token.test`.
+        """
+        if not self.current.test(expr):
+            expr = describe_token_expr(expr)
+
+            if self.current.type is TOKEN_EOF:
+                raise TemplateSyntaxError(
+                    f"unexpected end of template, expected {expr!r}.",
+                    self.current.lineno,
+                    self.name,
+                    self.filename,
+                )
+
+            raise TemplateSyntaxError(
+                f"expected token {expr!r}, got {describe_token(self.current)!r}",
+                self.current.lineno,
+                self.name,
+                self.filename,
+            )
+
+        return next(self)
+
+
+def get_lexer(environment: "Environment") -> "Lexer":
+    """Return a lexer which is probably cached."""
+    key = (
+        environment.block_start_string,
+        environment.block_end_string,
+        environment.variable_start_string,
+        environment.variable_end_string,
+        environment.comment_start_string,
+        environment.comment_end_string,
+        environment.line_statement_prefix,
+        environment.line_comment_prefix,
+        environment.trim_blocks,
+        environment.lstrip_blocks,
+        environment.newline_sequence,
+        environment.keep_trailing_newline,
+    )
+    lexer = _lexer_cache.get(key)
+
+    if lexer is None:
+        _lexer_cache[key] = lexer = Lexer(environment)
+
+    return lexer
+
+
+class OptionalLStrip(tuple):
+    """A special tuple for marking a point in the state that can have
+    lstrip applied.
+    """
+
+    __slots__ = ()
+
+    # Even though it looks like a no-op, creating instances fails
+    # without this.
+    def __new__(cls, *members, **kwargs):  # type: ignore
+        return super().__new__(cls, members)
+
+
+class _Rule(t.NamedTuple):
+    pattern: t.Pattern[str]
+    tokens: t.Union[str, t.Tuple[str, ...], t.Tuple[Failure]]
+    command: t.Optional[str]
+
+
+class Lexer:
+    """Class that implements a lexer for a given environment. Automatically
+    created by the environment class, usually you don't have to do that.
+
+    Note that the lexer is not automatically bound to an environment.
+    Multiple environments can share the same lexer.
+    """
+
+    def __init__(self, environment: "Environment") -> None:
+        # shortcuts
+        e = re.escape
+
+        def c(x: str) -> t.Pattern[str]:
+            return re.compile(x, re.M | re.S)
+
+        # lexing rules for tags
+        tag_rules: t.List[_Rule] = [
+            _Rule(whitespace_re, TOKEN_WHITESPACE, None),
+            _Rule(float_re, TOKEN_FLOAT, None),
+            _Rule(integer_re, TOKEN_INTEGER, None),
+            _Rule(name_re, TOKEN_NAME, None),
+            _Rule(string_re, TOKEN_STRING, None),
+            _Rule(operator_re, TOKEN_OPERATOR, None),
+        ]
+
+        # assemble the root lexing rule. because "|" is ungreedy
+        # we have to sort by length so that the lexer continues working
+        # as expected when we have parsing rules like <% for block and
+        # <%= for variables. (if someone wants asp like syntax)
+        # variables are just part of the rules if variable processing
+        # is required.
+        root_tag_rules = compile_rules(environment)
+
+        block_start_re = e(environment.block_start_string)
+        block_end_re = e(environment.block_end_string)
+        comment_end_re = e(environment.comment_end_string)
+        variable_end_re = e(environment.variable_end_string)
+
+        # block suffix if trimming is enabled
+        block_suffix_re = "\\n?" if environment.trim_blocks else ""
+
+        self.lstrip_blocks = environment.lstrip_blocks
+
+        self.newline_sequence = environment.newline_sequence
+        self.keep_trailing_newline = environment.keep_trailing_newline
+
+        root_raw_re = (
+            rf"(?P<raw_begin>{block_start_re}(\-|\+|)\s*raw\s*"
+            rf"(?:\-{block_end_re}\s*|{block_end_re}))"
+        )
+        root_parts_re = "|".join(
+            [root_raw_re] + [rf"(?P<{n}>{r}(\-|\+|))" for n, r in root_tag_rules]
+        )
+
+        # global lexing rules
+        self.rules: t.Dict[str, t.List[_Rule]] = {
+            "root": [
+                # directives
+                _Rule(
+                    c(rf"(.*?)(?:{root_parts_re})"),
+                    OptionalLStrip(TOKEN_DATA, "#bygroup"),  # type: ignore
+                    "#bygroup",
+                ),
+                # data
+                _Rule(c(".+"), TOKEN_DATA, None),
+            ],
+            # comments
+            TOKEN_COMMENT_BEGIN: [
+                _Rule(
+                    c(
+                        rf"(.*?)((?:\+{comment_end_re}|\-{comment_end_re}\s*"
+                        rf"|{comment_end_re}{block_suffix_re}))"
+                    ),
+                    (TOKEN_COMMENT, TOKEN_COMMENT_END),
+                    "#pop",
+                ),
+                _Rule(c(r"(.)"), (Failure("Missing end of comment tag"),), None),
+            ],
+            # blocks
+            TOKEN_BLOCK_BEGIN: [
+                _Rule(
+                    c(
+                        rf"(?:\+{block_end_re}|\-{block_end_re}\s*"
+                        rf"|{block_end_re}{block_suffix_re})"
+                    ),
+                    TOKEN_BLOCK_END,
+                    "#pop",
+                ),
+            ]
+            + tag_rules,
+            # variables
+            TOKEN_VARIABLE_BEGIN: [
+                _Rule(
+                    c(rf"\-{variable_end_re}\s*|{variable_end_re}"),
+                    TOKEN_VARIABLE_END,
+                    "#pop",
+                )
+            ]
+            + tag_rules,
+            # raw block
+            TOKEN_RAW_BEGIN: [
+                _Rule(
+                    c(
+                        rf"(.*?)((?:{block_start_re}(\-|\+|))\s*endraw\s*"
+                        rf"(?:\+{block_end_re}|\-{block_end_re}\s*"
+                        rf"|{block_end_re}{block_suffix_re}))"
+                    ),
+                    OptionalLStrip(TOKEN_DATA, TOKEN_RAW_END),  # type: ignore
+                    "#pop",
+                ),
+                _Rule(c(r"(.)"), (Failure("Missing end of raw directive"),), None),
+            ],
+            # line statements
+            TOKEN_LINESTATEMENT_BEGIN: [
+                _Rule(c(r"\s*(\n|$)"), TOKEN_LINESTATEMENT_END, "#pop")
+            ]
+            + tag_rules,
+            # line comments
+            TOKEN_LINECOMMENT_BEGIN: [
+                _Rule(
+                    c(r"(.*?)()(?=\n|$)"),
+                    (TOKEN_LINECOMMENT, TOKEN_LINECOMMENT_END),
+                    "#pop",
+                )
+            ],
+        }
+
+    def _normalize_newlines(self, value: str) -> str:
+        """Replace all newlines with the configured sequence in strings
+        and template data.
+        """
+        return newline_re.sub(self.newline_sequence, value)
+
+    def tokenize(
+        self,
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        state: t.Optional[str] = None,
+    ) -> TokenStream:
+        """Calls tokeniter + tokenize and wraps it in a token stream."""
+        stream = self.tokeniter(source, name, filename, state)
+        return TokenStream(self.wrap(stream, name, filename), name, filename)
+
+    def wrap(
+        self,
+        stream: t.Iterable[t.Tuple[int, str, str]],
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+    ) -> t.Iterator[Token]:
+        """This is called with the stream as returned by `tokenize` and wraps
+        every token in a :class:`Token` and converts the value.
+        """
+        for lineno, token, value_str in stream:
+            if token in ignored_tokens:
+                continue
+
+            value: t.Any = value_str
+
+            if token == TOKEN_LINESTATEMENT_BEGIN:
+                token = TOKEN_BLOCK_BEGIN
+            elif token == TOKEN_LINESTATEMENT_END:
+                token = TOKEN_BLOCK_END
+            # we are not interested in those tokens in the parser
+            elif token in (TOKEN_RAW_BEGIN, TOKEN_RAW_END):
+                continue
+            elif token == TOKEN_DATA:
+                value = self._normalize_newlines(value_str)
+            elif token == "keyword":
+                token = value_str
+            elif token == TOKEN_NAME:
+                value = value_str
+
+                if not value.isidentifier():
+                    raise TemplateSyntaxError(
+                        "Invalid character in identifier", lineno, name, filename
+                    )
+            elif token == TOKEN_STRING:
+                # try to unescape string
+                try:
+                    value = (
+                        self._normalize_newlines(value_str[1:-1])
+                        .encode("ascii", "backslashreplace")
+                        .decode("unicode-escape")
+                    )
+                except Exception as e:
+                    msg = str(e).split(":")[-1].strip()
+                    raise TemplateSyntaxError(msg, lineno, name, filename) from e
+            elif token == TOKEN_INTEGER:
+                value = int(value_str.replace("_", ""), 0)
+            elif token == TOKEN_FLOAT:
+                # remove all "_" first to support more Python versions
+                value = literal_eval(value_str.replace("_", ""))
+            elif token == TOKEN_OPERATOR:
+                token = operators[value_str]
+
+            yield Token(lineno, token, value)
+
+    def tokeniter(
+        self,
+        source: str,
+        name: t.Optional[str],
+        filename: t.Optional[str] = None,
+        state: t.Optional[str] = None,
+    ) -> t.Iterator[t.Tuple[int, str, str]]:
+        """This method tokenizes the text and returns the tokens in a
+        generator. Use this method if you just want to tokenize a template.
+
+        .. versionchanged:: 3.0
+            Only ``\\n``, ``\\r\\n`` and ``\\r`` are treated as line
+            breaks.
+        """
+        lines = newline_re.split(source)[::2]
+
+        if not self.keep_trailing_newline and lines[-1] == "":
+            del lines[-1]
+
+        source = "\n".join(lines)
+        pos = 0
+        lineno = 1
+        stack = ["root"]
+
+        if state is not None and state != "root":
+            assert state in ("variable", "block"), "invalid state"
+            stack.append(state + "_begin")
+
+        statetokens = self.rules[stack[-1]]
+        source_length = len(source)
+        balancing_stack: t.List[str] = []
+        newlines_stripped = 0
+        line_starting = True
+
+        while True:
+            # tokenizer loop
+            for regex, tokens, new_state in statetokens:
+                m = regex.match(source, pos)
+
+                # if no match we try again with the next rule
+                if m is None:
+                    continue
+
+                # we only match blocks and variables if braces / parentheses
+                # are balanced. continue parsing with the lower rule which
+                # is the operator rule. do this only if the end tags look
+                # like operators
+                if balancing_stack and tokens in (
+                    TOKEN_VARIABLE_END,
+                    TOKEN_BLOCK_END,
+                    TOKEN_LINESTATEMENT_END,
+                ):
+                    continue
+
+                # tuples support more options
+                if isinstance(tokens, tuple):
+                    groups: t.Sequence[str] = m.groups()
+
+                    if isinstance(tokens, OptionalLStrip):
+                        # Rule supports lstrip. Match will look like
+                        # text, block type, whitespace control, type, control, ...
+                        text = groups[0]
+                        # Skipping the text and first type, every other group is the
+                        # whitespace control for each type. One of the groups will be
+                        # -, +, or empty string instead of None.
+                        strip_sign = next(g for g in groups[2::2] if g is not None)
+
+                        if strip_sign == "-":
+                            # Strip all whitespace between the text and the tag.
+                            stripped = text.rstrip()
+                            newlines_stripped = text[len(stripped) :].count("\n")
+                            groups = [stripped, *groups[1:]]
+                        elif (
+                            # Not marked for preserving whitespace.
+                            strip_sign != "+"
+                            # lstrip is enabled.
+                            and self.lstrip_blocks
+                            # Not a variable expression.
+                            and not m.groupdict().get(TOKEN_VARIABLE_BEGIN)
+                        ):
+                            # The start of text between the last newline and the tag.
+                            l_pos = text.rfind("\n") + 1
+
+                            if l_pos > 0 or line_starting:
+                                # If there's only whitespace between the newline and the
+                                # tag, strip it.
+                                if whitespace_re.fullmatch(text, l_pos):
+                                    groups = [text[:l_pos], *groups[1:]]
+
+                    for idx, token in enumerate(tokens):
+                        # failure group
+                        if token.__class__ is Failure:
+                            raise token(lineno, filename)
+                        # bygroup is a bit more complex, in that case we
+                        # yield for the current token the first named
+                        # group that matched
+                        elif token == "#bygroup":
+                            for key, value in m.groupdict().items():
+                                if value is not None:
+                                    yield lineno, key, value
+                                    lineno += value.count("\n")
+                                    break
+                            else:
+                                raise RuntimeError(
+                                    f"{regex!r} wanted to resolve the token dynamically"
+                                    " but no group matched"
+                                )
+                        # normal group
+                        else:
+                            data = groups[idx]
+
+                            if data or token not in ignore_if_empty:
+                                yield lineno, token, data
+
+                            lineno += data.count("\n") + newlines_stripped
+                            newlines_stripped = 0
+
+                # strings as token just are yielded as it.
+                else:
+                    data = m.group()
+
+                    # update brace/parentheses balance
+                    if tokens == TOKEN_OPERATOR:
+                        if data == "{":
+                            balancing_stack.append("}")
+                        elif data == "(":
+                            balancing_stack.append(")")
+                        elif data == "[":
+                            balancing_stack.append("]")
+                        elif data in ("}", ")", "]"):
+                            if not balancing_stack:
+                                raise TemplateSyntaxError(
+                                    f"unexpected '{data}'", lineno, name, filename
+                                )
+
+                            expected_op = balancing_stack.pop()
+
+                            if expected_op != data:
+                                raise TemplateSyntaxError(
+                                    f"unexpected '{data}', expected '{expected_op}'",
+                                    lineno,
+                                    name,
+                                    filename,
+                                )
+
+                    # yield items
+                    if data or tokens not in ignore_if_empty:
+                        yield lineno, tokens, data
+
+                    lineno += data.count("\n")
+
+                line_starting = m.group()[-1:] == "\n"
+                # fetch new position into new variable so that we can check
+                # if there is a internal parsing error which would result
+                # in an infinite loop
+                pos2 = m.end()
+
+                # handle state changes
+                if new_state is not None:
+                    # remove the uppermost state
+                    if new_state == "#pop":
+                        stack.pop()
+                    # resolve the new state by group checking
+                    elif new_state == "#bygroup":
+                        for key, value in m.groupdict().items():
+                            if value is not None:
+                                stack.append(key)
+                                break
+                        else:
+                            raise RuntimeError(
+                                f"{regex!r} wanted to resolve the new state dynamically"
+                                f" but no group matched"
+                            )
+                    # direct state name given
+                    else:
+                        stack.append(new_state)
+
+                    statetokens = self.rules[stack[-1]]
+                # we are still at the same position and no stack change.
+                # this means a loop without break condition, avoid that and
+                # raise error
+                elif pos2 == pos:
+                    raise RuntimeError(
+                        f"{regex!r} yielded empty string without stack change"
+                    )
+
+                # publish new function and start again
+                pos = pos2
+                break
+            # if loop terminated without break we haven't found a single match
+            # either we are at the end of the file or we have a problem
+            else:
+                # end of text
+                if pos >= source_length:
+                    return
+
+                # something went wrong
+                raise TemplateSyntaxError(
+                    f"unexpected char {source[pos]!r} at {pos}", lineno, name, filename
+                )
diff --git a/lib/python3.11/site-packages/jinja2/loaders.py b/lib/python3.11/site-packages/jinja2/loaders.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2f98093cde425fad2c4bbf2a07e383fce5e4a38
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/loaders.py
@@ -0,0 +1,661 @@
+"""API and implementations for loading templates from different data
+sources.
+"""
+import importlib.util
+import os
+import posixpath
+import sys
+import typing as t
+import weakref
+import zipimport
+from collections import abc
+from hashlib import sha1
+from importlib import import_module
+from types import ModuleType
+
+from .exceptions import TemplateNotFound
+from .utils import internalcode
+from .utils import open_if_exists
+
+if t.TYPE_CHECKING:
+    from .environment import Environment
+    from .environment import Template
+
+
+def split_template_path(template: str) -> t.List[str]:
+    """Split a path into segments and perform a sanity check.  If it detects
+    '..' in the path it will raise a `TemplateNotFound` error.
+    """
+    pieces = []
+    for piece in template.split("/"):
+        if (
+            os.path.sep in piece
+            or (os.path.altsep and os.path.altsep in piece)
+            or piece == os.path.pardir
+        ):
+            raise TemplateNotFound(template)
+        elif piece and piece != ".":
+            pieces.append(piece)
+    return pieces
+
+
+class BaseLoader:
+    """Baseclass for all loaders.  Subclass this and override `get_source` to
+    implement a custom loading mechanism.  The environment provides a
+    `get_template` method that calls the loader's `load` method to get the
+    :class:`Template` object.
+
+    A very basic example for a loader that looks up templates on the file
+    system could look like this::
+
+        from jinja2 import BaseLoader, TemplateNotFound
+        from os.path import join, exists, getmtime
+
+        class MyLoader(BaseLoader):
+
+            def __init__(self, path):
+                self.path = path
+
+            def get_source(self, environment, template):
+                path = join(self.path, template)
+                if not exists(path):
+                    raise TemplateNotFound(template)
+                mtime = getmtime(path)
+                with open(path) as f:
+                    source = f.read()
+                return source, path, lambda: mtime == getmtime(path)
+    """
+
+    #: if set to `False` it indicates that the loader cannot provide access
+    #: to the source of templates.
+    #:
+    #: .. versionadded:: 2.4
+    has_source_access = True
+
+    def get_source(
+        self, environment: "Environment", template: str
+    ) -> t.Tuple[str, t.Optional[str], t.Optional[t.Callable[[], bool]]]:
+        """Get the template source, filename and reload helper for a template.
+        It's passed the environment and template name and has to return a
+        tuple in the form ``(source, filename, uptodate)`` or raise a
+        `TemplateNotFound` error if it can't locate the template.
+
+        The source part of the returned tuple must be the source of the
+        template as a string. The filename should be the name of the
+        file on the filesystem if it was loaded from there, otherwise
+        ``None``. The filename is used by Python for the tracebacks
+        if no loader extension is used.
+
+        The last item in the tuple is the `uptodate` function.  If auto
+        reloading is enabled it's always called to check if the template
+        changed.  No arguments are passed so the function must store the
+        old state somewhere (for example in a closure).  If it returns `False`
+        the template will be reloaded.
+        """
+        if not self.has_source_access:
+            raise RuntimeError(
+                f"{type(self).__name__} cannot provide access to the source"
+            )
+        raise TemplateNotFound(template)
+
+    def list_templates(self) -> t.List[str]:
+        """Iterates over all templates.  If the loader does not support that
+        it should raise a :exc:`TypeError` which is the default behavior.
+        """
+        raise TypeError("this loader cannot iterate over all templates")
+
+    @internalcode
+    def load(
+        self,
+        environment: "Environment",
+        name: str,
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ) -> "Template":
+        """Loads a template.  This method looks up the template in the cache
+        or loads one by calling :meth:`get_source`.  Subclasses should not
+        override this method as loaders working on collections of other
+        loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
+        will not call this method but `get_source` directly.
+        """
+        code = None
+        if globals is None:
+            globals = {}
+
+        # first we try to get the source for this template together
+        # with the filename and the uptodate function.
+        source, filename, uptodate = self.get_source(environment, name)
+
+        # try to load the code from the bytecode cache if there is a
+        # bytecode cache configured.
+        bcc = environment.bytecode_cache
+        if bcc is not None:
+            bucket = bcc.get_bucket(environment, name, filename, source)
+            code = bucket.code
+
+        # if we don't have code so far (not cached, no longer up to
+        # date) etc. we compile the template
+        if code is None:
+            code = environment.compile(source, name, filename)
+
+        # if the bytecode cache is available and the bucket doesn't
+        # have a code so far, we give the bucket the new code and put
+        # it back to the bytecode cache.
+        if bcc is not None and bucket.code is None:
+            bucket.code = code
+            bcc.set_bucket(bucket)
+
+        return environment.template_class.from_code(
+            environment, code, globals, uptodate
+        )
+
+
+class FileSystemLoader(BaseLoader):
+    """Load templates from a directory in the file system.
+
+    The path can be relative or absolute. Relative paths are relative to
+    the current working directory.
+
+    .. code-block:: python
+
+        loader = FileSystemLoader("templates")
+
+    A list of paths can be given. The directories will be searched in
+    order, stopping at the first matching template.
+
+    .. code-block:: python
+
+        loader = FileSystemLoader(["/override/templates", "/default/templates"])
+
+    :param searchpath: A path, or list of paths, to the directory that
+        contains the templates.
+    :param encoding: Use this encoding to read the text from template
+        files.
+    :param followlinks: Follow symbolic links in the path.
+
+    .. versionchanged:: 2.8
+        Added the ``followlinks`` parameter.
+    """
+
+    def __init__(
+        self,
+        searchpath: t.Union[str, os.PathLike, t.Sequence[t.Union[str, os.PathLike]]],
+        encoding: str = "utf-8",
+        followlinks: bool = False,
+    ) -> None:
+        if not isinstance(searchpath, abc.Iterable) or isinstance(searchpath, str):
+            searchpath = [searchpath]
+
+        self.searchpath = [os.fspath(p) for p in searchpath]
+        self.encoding = encoding
+        self.followlinks = followlinks
+
+    def get_source(
+        self, environment: "Environment", template: str
+    ) -> t.Tuple[str, str, t.Callable[[], bool]]:
+        pieces = split_template_path(template)
+        for searchpath in self.searchpath:
+            # Use posixpath even on Windows to avoid "drive:" or UNC
+            # segments breaking out of the search directory.
+            filename = posixpath.join(searchpath, *pieces)
+            f = open_if_exists(filename)
+            if f is None:
+                continue
+            try:
+                contents = f.read().decode(self.encoding)
+            finally:
+                f.close()
+
+            mtime = os.path.getmtime(filename)
+
+            def uptodate() -> bool:
+                try:
+                    return os.path.getmtime(filename) == mtime
+                except OSError:
+                    return False
+
+            # Use normpath to convert Windows altsep to sep.
+            return contents, os.path.normpath(filename), uptodate
+        raise TemplateNotFound(template)
+
+    def list_templates(self) -> t.List[str]:
+        found = set()
+        for searchpath in self.searchpath:
+            walk_dir = os.walk(searchpath, followlinks=self.followlinks)
+            for dirpath, _, filenames in walk_dir:
+                for filename in filenames:
+                    template = (
+                        os.path.join(dirpath, filename)[len(searchpath) :]
+                        .strip(os.path.sep)
+                        .replace(os.path.sep, "/")
+                    )
+                    if template[:2] == "./":
+                        template = template[2:]
+                    if template not in found:
+                        found.add(template)
+        return sorted(found)
+
+
+class PackageLoader(BaseLoader):
+    """Load templates from a directory in a Python package.
+
+    :param package_name: Import name of the package that contains the
+        template directory.
+    :param package_path: Directory within the imported package that
+        contains the templates.
+    :param encoding: Encoding of template files.
+
+    The following example looks up templates in the ``pages`` directory
+    within the ``project.ui`` package.
+
+    .. code-block:: python
+
+        loader = PackageLoader("project.ui", "pages")
+
+    Only packages installed as directories (standard pip behavior) or
+    zip/egg files (less common) are supported. The Python API for
+    introspecting data in packages is too limited to support other
+    installation methods the way this loader requires.
+
+    There is limited support for :pep:`420` namespace packages. The
+    template directory is assumed to only be in one namespace
+    contributor. Zip files contributing to a namespace are not
+    supported.
+
+    .. versionchanged:: 3.0
+        No longer uses ``setuptools`` as a dependency.
+
+    .. versionchanged:: 3.0
+        Limited PEP 420 namespace package support.
+    """
+
+    def __init__(
+        self,
+        package_name: str,
+        package_path: "str" = "templates",
+        encoding: str = "utf-8",
+    ) -> None:
+        package_path = os.path.normpath(package_path).rstrip(os.path.sep)
+
+        # normpath preserves ".", which isn't valid in zip paths.
+        if package_path == os.path.curdir:
+            package_path = ""
+        elif package_path[:2] == os.path.curdir + os.path.sep:
+            package_path = package_path[2:]
+
+        self.package_path = package_path
+        self.package_name = package_name
+        self.encoding = encoding
+
+        # Make sure the package exists. This also makes namespace
+        # packages work, otherwise get_loader returns None.
+        import_module(package_name)
+        spec = importlib.util.find_spec(package_name)
+        assert spec is not None, "An import spec was not found for the package."
+        loader = spec.loader
+        assert loader is not None, "A loader was not found for the package."
+        self._loader = loader
+        self._archive = None
+        template_root = None
+
+        if isinstance(loader, zipimport.zipimporter):
+            self._archive = loader.archive
+            pkgdir = next(iter(spec.submodule_search_locations))  # type: ignore
+            template_root = os.path.join(pkgdir, package_path).rstrip(os.path.sep)
+        else:
+            roots: t.List[str] = []
+
+            # One element for regular packages, multiple for namespace
+            # packages, or None for single module file.
+            if spec.submodule_search_locations:
+                roots.extend(spec.submodule_search_locations)
+            # A single module file, use the parent directory instead.
+            elif spec.origin is not None:
+                roots.append(os.path.dirname(spec.origin))
+
+            for root in roots:
+                root = os.path.join(root, package_path)
+
+                if os.path.isdir(root):
+                    template_root = root
+                    break
+
+        if template_root is None:
+            raise ValueError(
+                f"The {package_name!r} package was not installed in a"
+                " way that PackageLoader understands."
+            )
+
+        self._template_root = template_root
+
+    def get_source(
+        self, environment: "Environment", template: str
+    ) -> t.Tuple[str, str, t.Optional[t.Callable[[], bool]]]:
+        # Use posixpath even on Windows to avoid "drive:" or UNC
+        # segments breaking out of the search directory. Use normpath to
+        # convert Windows altsep to sep.
+        p = os.path.normpath(
+            posixpath.join(self._template_root, *split_template_path(template))
+        )
+        up_to_date: t.Optional[t.Callable[[], bool]]
+
+        if self._archive is None:
+            # Package is a directory.
+            if not os.path.isfile(p):
+                raise TemplateNotFound(template)
+
+            with open(p, "rb") as f:
+                source = f.read()
+
+            mtime = os.path.getmtime(p)
+
+            def up_to_date() -> bool:
+                return os.path.isfile(p) and os.path.getmtime(p) == mtime
+
+        else:
+            # Package is a zip file.
+            try:
+                source = self._loader.get_data(p)  # type: ignore
+            except OSError as e:
+                raise TemplateNotFound(template) from e
+
+            # Could use the zip's mtime for all template mtimes, but
+            # would need to safely reload the module if it's out of
+            # date, so just report it as always current.
+            up_to_date = None
+
+        return source.decode(self.encoding), p, up_to_date
+
+    def list_templates(self) -> t.List[str]:
+        results: t.List[str] = []
+
+        if self._archive is None:
+            # Package is a directory.
+            offset = len(self._template_root)
+
+            for dirpath, _, filenames in os.walk(self._template_root):
+                dirpath = dirpath[offset:].lstrip(os.path.sep)
+                results.extend(
+                    os.path.join(dirpath, name).replace(os.path.sep, "/")
+                    for name in filenames
+                )
+        else:
+            if not hasattr(self._loader, "_files"):
+                raise TypeError(
+                    "This zip import does not have the required"
+                    " metadata to list templates."
+                )
+
+            # Package is a zip file.
+            prefix = (
+                self._template_root[len(self._archive) :].lstrip(os.path.sep)
+                + os.path.sep
+            )
+            offset = len(prefix)
+
+            for name in self._loader._files.keys():  # type: ignore
+                # Find names under the templates directory that aren't directories.
+                if name.startswith(prefix) and name[-1] != os.path.sep:
+                    results.append(name[offset:].replace(os.path.sep, "/"))
+
+        results.sort()
+        return results
+
+
+class DictLoader(BaseLoader):
+    """Loads a template from a Python dict mapping template names to
+    template source.  This loader is useful for unittesting:
+
+    >>> loader = DictLoader({'index.html': 'source here'})
+
+    Because auto reloading is rarely useful this is disabled per default.
+    """
+
+    def __init__(self, mapping: t.Mapping[str, str]) -> None:
+        self.mapping = mapping
+
+    def get_source(
+        self, environment: "Environment", template: str
+    ) -> t.Tuple[str, None, t.Callable[[], bool]]:
+        if template in self.mapping:
+            source = self.mapping[template]
+            return source, None, lambda: source == self.mapping.get(template)
+        raise TemplateNotFound(template)
+
+    def list_templates(self) -> t.List[str]:
+        return sorted(self.mapping)
+
+
+class FunctionLoader(BaseLoader):
+    """A loader that is passed a function which does the loading.  The
+    function receives the name of the template and has to return either
+    a string with the template source, a tuple in the form ``(source,
+    filename, uptodatefunc)`` or `None` if the template does not exist.
+
+    >>> def load_template(name):
+    ...     if name == 'index.html':
+    ...         return '...'
+    ...
+    >>> loader = FunctionLoader(load_template)
+
+    The `uptodatefunc` is a function that is called if autoreload is enabled
+    and has to return `True` if the template is still up to date.  For more
+    details have a look at :meth:`BaseLoader.get_source` which has the same
+    return value.
+    """
+
+    def __init__(
+        self,
+        load_func: t.Callable[
+            [str],
+            t.Optional[
+                t.Union[
+                    str, t.Tuple[str, t.Optional[str], t.Optional[t.Callable[[], bool]]]
+                ]
+            ],
+        ],
+    ) -> None:
+        self.load_func = load_func
+
+    def get_source(
+        self, environment: "Environment", template: str
+    ) -> t.Tuple[str, t.Optional[str], t.Optional[t.Callable[[], bool]]]:
+        rv = self.load_func(template)
+
+        if rv is None:
+            raise TemplateNotFound(template)
+
+        if isinstance(rv, str):
+            return rv, None, None
+
+        return rv
+
+
+class PrefixLoader(BaseLoader):
+    """A loader that is passed a dict of loaders where each loader is bound
+    to a prefix.  The prefix is delimited from the template by a slash per
+    default, which can be changed by setting the `delimiter` argument to
+    something else::
+
+        loader = PrefixLoader({
+            'app1':     PackageLoader('mypackage.app1'),
+            'app2':     PackageLoader('mypackage.app2')
+        })
+
+    By loading ``'app1/index.html'`` the file from the app1 package is loaded,
+    by loading ``'app2/index.html'`` the file from the second.
+    """
+
+    def __init__(
+        self, mapping: t.Mapping[str, BaseLoader], delimiter: str = "/"
+    ) -> None:
+        self.mapping = mapping
+        self.delimiter = delimiter
+
+    def get_loader(self, template: str) -> t.Tuple[BaseLoader, str]:
+        try:
+            prefix, name = template.split(self.delimiter, 1)
+            loader = self.mapping[prefix]
+        except (ValueError, KeyError) as e:
+            raise TemplateNotFound(template) from e
+        return loader, name
+
+    def get_source(
+        self, environment: "Environment", template: str
+    ) -> t.Tuple[str, t.Optional[str], t.Optional[t.Callable[[], bool]]]:
+        loader, name = self.get_loader(template)
+        try:
+            return loader.get_source(environment, name)
+        except TemplateNotFound as e:
+            # re-raise the exception with the correct filename here.
+            # (the one that includes the prefix)
+            raise TemplateNotFound(template) from e
+
+    @internalcode
+    def load(
+        self,
+        environment: "Environment",
+        name: str,
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ) -> "Template":
+        loader, local_name = self.get_loader(name)
+        try:
+            return loader.load(environment, local_name, globals)
+        except TemplateNotFound as e:
+            # re-raise the exception with the correct filename here.
+            # (the one that includes the prefix)
+            raise TemplateNotFound(name) from e
+
+    def list_templates(self) -> t.List[str]:
+        result = []
+        for prefix, loader in self.mapping.items():
+            for template in loader.list_templates():
+                result.append(prefix + self.delimiter + template)
+        return result
+
+
+class ChoiceLoader(BaseLoader):
+    """This loader works like the `PrefixLoader` just that no prefix is
+    specified.  If a template could not be found by one loader the next one
+    is tried.
+
+    >>> loader = ChoiceLoader([
+    ...     FileSystemLoader('/path/to/user/templates'),
+    ...     FileSystemLoader('/path/to/system/templates')
+    ... ])
+
+    This is useful if you want to allow users to override builtin templates
+    from a different location.
+    """
+
+    def __init__(self, loaders: t.Sequence[BaseLoader]) -> None:
+        self.loaders = loaders
+
+    def get_source(
+        self, environment: "Environment", template: str
+    ) -> t.Tuple[str, t.Optional[str], t.Optional[t.Callable[[], bool]]]:
+        for loader in self.loaders:
+            try:
+                return loader.get_source(environment, template)
+            except TemplateNotFound:
+                pass
+        raise TemplateNotFound(template)
+
+    @internalcode
+    def load(
+        self,
+        environment: "Environment",
+        name: str,
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ) -> "Template":
+        for loader in self.loaders:
+            try:
+                return loader.load(environment, name, globals)
+            except TemplateNotFound:
+                pass
+        raise TemplateNotFound(name)
+
+    def list_templates(self) -> t.List[str]:
+        found = set()
+        for loader in self.loaders:
+            found.update(loader.list_templates())
+        return sorted(found)
+
+
+class _TemplateModule(ModuleType):
+    """Like a normal module but with support for weak references"""
+
+
+class ModuleLoader(BaseLoader):
+    """This loader loads templates from precompiled templates.
+
+    Example usage:
+
+    >>> loader = ChoiceLoader([
+    ...     ModuleLoader('/path/to/compiled/templates'),
+    ...     FileSystemLoader('/path/to/templates')
+    ... ])
+
+    Templates can be precompiled with :meth:`Environment.compile_templates`.
+    """
+
+    has_source_access = False
+
+    def __init__(
+        self, path: t.Union[str, os.PathLike, t.Sequence[t.Union[str, os.PathLike]]]
+    ) -> None:
+        package_name = f"_jinja2_module_templates_{id(self):x}"
+
+        # create a fake module that looks for the templates in the
+        # path given.
+        mod = _TemplateModule(package_name)
+
+        if not isinstance(path, abc.Iterable) or isinstance(path, str):
+            path = [path]
+
+        mod.__path__ = [os.fspath(p) for p in path]
+
+        sys.modules[package_name] = weakref.proxy(
+            mod, lambda x: sys.modules.pop(package_name, None)
+        )
+
+        # the only strong reference, the sys.modules entry is weak
+        # so that the garbage collector can remove it once the
+        # loader that created it goes out of business.
+        self.module = mod
+        self.package_name = package_name
+
+    @staticmethod
+    def get_template_key(name: str) -> str:
+        return "tmpl_" + sha1(name.encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def get_module_filename(name: str) -> str:
+        return ModuleLoader.get_template_key(name) + ".py"
+
+    @internalcode
+    def load(
+        self,
+        environment: "Environment",
+        name: str,
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ) -> "Template":
+        key = self.get_template_key(name)
+        module = f"{self.package_name}.{key}"
+        mod = getattr(self.module, module, None)
+
+        if mod is None:
+            try:
+                mod = __import__(module, None, None, ["root"])
+            except ImportError as e:
+                raise TemplateNotFound(name) from e
+
+            # remove the entry from sys.modules, we only want the attribute
+            # on the module object we have stored on the loader.
+            sys.modules.pop(module, None)
+
+        if globals is None:
+            globals = {}
+
+        return environment.template_class.from_module_dict(
+            environment, mod.__dict__, globals
+        )
diff --git a/lib/python3.11/site-packages/jinja2/meta.py b/lib/python3.11/site-packages/jinja2/meta.py
new file mode 100644
index 0000000000000000000000000000000000000000..0057d6eabade5e964e6ef0e3ac8ed2dd67494b03
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/meta.py
@@ -0,0 +1,111 @@
+"""Functions that expose information about templates that might be
+interesting for introspection.
+"""
+import typing as t
+
+from . import nodes
+from .compiler import CodeGenerator
+from .compiler import Frame
+
+if t.TYPE_CHECKING:
+    from .environment import Environment
+
+
+class TrackingCodeGenerator(CodeGenerator):
+    """We abuse the code generator for introspection."""
+
+    def __init__(self, environment: "Environment") -> None:
+        super().__init__(environment, "<introspection>", "<introspection>")
+        self.undeclared_identifiers: t.Set[str] = set()
+
+    def write(self, x: str) -> None:
+        """Don't write."""
+
+    def enter_frame(self, frame: Frame) -> None:
+        """Remember all undeclared identifiers."""
+        super().enter_frame(frame)
+
+        for _, (action, param) in frame.symbols.loads.items():
+            if action == "resolve" and param not in self.environment.globals:
+                self.undeclared_identifiers.add(param)
+
+
+def find_undeclared_variables(ast: nodes.Template) -> t.Set[str]:
+    """Returns a set of all variables in the AST that will be looked up from
+    the context at runtime.  Because at compile time it's not known which
+    variables will be used depending on the path the execution takes at
+    runtime, all variables are returned.
+
+    >>> from jinja2 import Environment, meta
+    >>> env = Environment()
+    >>> ast = env.parse('{% set foo = 42 %}{{ bar + foo }}')
+    >>> meta.find_undeclared_variables(ast) == {'bar'}
+    True
+
+    .. admonition:: Implementation
+
+       Internally the code generator is used for finding undeclared variables.
+       This is good to know because the code generator might raise a
+       :exc:`TemplateAssertionError` during compilation and as a matter of
+       fact this function can currently raise that exception as well.
+    """
+    codegen = TrackingCodeGenerator(ast.environment)  # type: ignore
+    codegen.visit(ast)
+    return codegen.undeclared_identifiers
+
+
+_ref_types = (nodes.Extends, nodes.FromImport, nodes.Import, nodes.Include)
+_RefType = t.Union[nodes.Extends, nodes.FromImport, nodes.Import, nodes.Include]
+
+
+def find_referenced_templates(ast: nodes.Template) -> t.Iterator[t.Optional[str]]:
+    """Finds all the referenced templates from the AST.  This will return an
+    iterator over all the hardcoded template extensions, inclusions and
+    imports.  If dynamic inheritance or inclusion is used, `None` will be
+    yielded.
+
+    >>> from jinja2 import Environment, meta
+    >>> env = Environment()
+    >>> ast = env.parse('{% extends "layout.html" %}{% include helper %}')
+    >>> list(meta.find_referenced_templates(ast))
+    ['layout.html', None]
+
+    This function is useful for dependency tracking.  For example if you want
+    to rebuild parts of the website after a layout template has changed.
+    """
+    template_name: t.Any
+
+    for node in ast.find_all(_ref_types):
+        template: nodes.Expr = node.template  # type: ignore
+
+        if not isinstance(template, nodes.Const):
+            # a tuple with some non consts in there
+            if isinstance(template, (nodes.Tuple, nodes.List)):
+                for template_name in template.items:
+                    # something const, only yield the strings and ignore
+                    # non-string consts that really just make no sense
+                    if isinstance(template_name, nodes.Const):
+                        if isinstance(template_name.value, str):
+                            yield template_name.value
+                    # something dynamic in there
+                    else:
+                        yield None
+            # something dynamic we don't know about here
+            else:
+                yield None
+            continue
+        # constant is a basestring, direct template name
+        if isinstance(template.value, str):
+            yield template.value
+        # a tuple or list (latter *should* not happen) made of consts,
+        # yield the consts that are strings.  We could warn here for
+        # non string values
+        elif isinstance(node, nodes.Include) and isinstance(
+            template.value, (tuple, list)
+        ):
+            for template_name in template.value:
+                if isinstance(template_name, str):
+                    yield template_name
+        # something else we don't care about, we could warn here
+        else:
+            yield None
diff --git a/lib/python3.11/site-packages/jinja2/nativetypes.py b/lib/python3.11/site-packages/jinja2/nativetypes.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac0861034821772a50e53bfc3d3ff72e7aad5b1b
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/nativetypes.py
@@ -0,0 +1,130 @@
+import typing as t
+from ast import literal_eval
+from ast import parse
+from itertools import chain
+from itertools import islice
+from types import GeneratorType
+
+from . import nodes
+from .compiler import CodeGenerator
+from .compiler import Frame
+from .compiler import has_safe_repr
+from .environment import Environment
+from .environment import Template
+
+
+def native_concat(values: t.Iterable[t.Any]) -> t.Optional[t.Any]:
+    """Return a native Python type from the list of compiled nodes. If
+    the result is a single node, its value is returned. Otherwise, the
+    nodes are concatenated as strings. If the result can be parsed with
+    :func:`ast.literal_eval`, the parsed value is returned. Otherwise,
+    the string is returned.
+
+    :param values: Iterable of outputs to concatenate.
+    """
+    head = list(islice(values, 2))
+
+    if not head:
+        return None
+
+    if len(head) == 1:
+        raw = head[0]
+        if not isinstance(raw, str):
+            return raw
+    else:
+        if isinstance(values, GeneratorType):
+            values = chain(head, values)
+        raw = "".join([str(v) for v in values])
+
+    try:
+        return literal_eval(
+            # In Python 3.10+ ast.literal_eval removes leading spaces/tabs
+            # from the given string. For backwards compatibility we need to
+            # parse the string ourselves without removing leading spaces/tabs.
+            parse(raw, mode="eval")
+        )
+    except (ValueError, SyntaxError, MemoryError):
+        return raw
+
+
+class NativeCodeGenerator(CodeGenerator):
+    """A code generator which renders Python types by not adding
+    ``str()`` around output nodes.
+    """
+
+    @staticmethod
+    def _default_finalize(value: t.Any) -> t.Any:
+        return value
+
+    def _output_const_repr(self, group: t.Iterable[t.Any]) -> str:
+        return repr("".join([str(v) for v in group]))
+
+    def _output_child_to_const(
+        self, node: nodes.Expr, frame: Frame, finalize: CodeGenerator._FinalizeInfo
+    ) -> t.Any:
+        const = node.as_const(frame.eval_ctx)
+
+        if not has_safe_repr(const):
+            raise nodes.Impossible()
+
+        if isinstance(node, nodes.TemplateData):
+            return const
+
+        return finalize.const(const)  # type: ignore
+
+    def _output_child_pre(
+        self, node: nodes.Expr, frame: Frame, finalize: CodeGenerator._FinalizeInfo
+    ) -> None:
+        if finalize.src is not None:
+            self.write(finalize.src)
+
+    def _output_child_post(
+        self, node: nodes.Expr, frame: Frame, finalize: CodeGenerator._FinalizeInfo
+    ) -> None:
+        if finalize.src is not None:
+            self.write(")")
+
+
+class NativeEnvironment(Environment):
+    """An environment that renders templates to native Python types."""
+
+    code_generator_class = NativeCodeGenerator
+    concat = staticmethod(native_concat)  # type: ignore
+
+
+class NativeTemplate(Template):
+    environment_class = NativeEnvironment
+
+    def render(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        """Render the template to produce a native Python type. If the
+        result is a single node, its value is returned. Otherwise, the
+        nodes are concatenated as strings. If the result can be parsed
+        with :func:`ast.literal_eval`, the parsed value is returned.
+        Otherwise, the string is returned.
+        """
+        ctx = self.new_context(dict(*args, **kwargs))
+
+        try:
+            return self.environment_class.concat(  # type: ignore
+                self.root_render_func(ctx)  # type: ignore
+            )
+        except Exception:
+            return self.environment.handle_exception()
+
+    async def render_async(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        if not self.environment.is_async:
+            raise RuntimeError(
+                "The environment was not created with async mode enabled."
+            )
+
+        ctx = self.new_context(dict(*args, **kwargs))
+
+        try:
+            return self.environment_class.concat(  # type: ignore
+                [n async for n in self.root_render_func(ctx)]  # type: ignore
+            )
+        except Exception:
+            return self.environment.handle_exception()
+
+
+NativeEnvironment.template_class = NativeTemplate
diff --git a/lib/python3.11/site-packages/jinja2/nodes.py b/lib/python3.11/site-packages/jinja2/nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2f88d9d9c19a2cb5d03b0158c743c6b947a29ea
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/nodes.py
@@ -0,0 +1,1204 @@
+"""AST nodes generated by the parser for the compiler. Also provides
+some node tree helper functions used by the parser and compiler in order
+to normalize nodes.
+"""
+import inspect
+import operator
+import typing as t
+from collections import deque
+
+from markupsafe import Markup
+
+from .utils import _PassArg
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .environment import Environment
+
+_NodeBound = t.TypeVar("_NodeBound", bound="Node")
+
+_binop_to_func: t.Dict[str, t.Callable[[t.Any, t.Any], t.Any]] = {
+    "*": operator.mul,
+    "/": operator.truediv,
+    "//": operator.floordiv,
+    "**": operator.pow,
+    "%": operator.mod,
+    "+": operator.add,
+    "-": operator.sub,
+}
+
+_uaop_to_func: t.Dict[str, t.Callable[[t.Any], t.Any]] = {
+    "not": operator.not_,
+    "+": operator.pos,
+    "-": operator.neg,
+}
+
+_cmpop_to_func: t.Dict[str, t.Callable[[t.Any, t.Any], t.Any]] = {
+    "eq": operator.eq,
+    "ne": operator.ne,
+    "gt": operator.gt,
+    "gteq": operator.ge,
+    "lt": operator.lt,
+    "lteq": operator.le,
+    "in": lambda a, b: a in b,
+    "notin": lambda a, b: a not in b,
+}
+
+
+class Impossible(Exception):
+    """Raised if the node could not perform a requested action."""
+
+
+class NodeType(type):
+    """A metaclass for nodes that handles the field and attribute
+    inheritance.  fields and attributes from the parent class are
+    automatically forwarded to the child."""
+
+    def __new__(mcs, name, bases, d):  # type: ignore
+        for attr in "fields", "attributes":
+            storage = []
+            storage.extend(getattr(bases[0] if bases else object, attr, ()))
+            storage.extend(d.get(attr, ()))
+            assert len(bases) <= 1, "multiple inheritance not allowed"
+            assert len(storage) == len(set(storage)), "layout conflict"
+            d[attr] = tuple(storage)
+        d.setdefault("abstract", False)
+        return type.__new__(mcs, name, bases, d)
+
+
+class EvalContext:
+    """Holds evaluation time information.  Custom attributes can be attached
+    to it in extensions.
+    """
+
+    def __init__(
+        self, environment: "Environment", template_name: t.Optional[str] = None
+    ) -> None:
+        self.environment = environment
+        if callable(environment.autoescape):
+            self.autoescape = environment.autoescape(template_name)
+        else:
+            self.autoescape = environment.autoescape
+        self.volatile = False
+
+    def save(self) -> t.Mapping[str, t.Any]:
+        return self.__dict__.copy()
+
+    def revert(self, old: t.Mapping[str, t.Any]) -> None:
+        self.__dict__.clear()
+        self.__dict__.update(old)
+
+
+def get_eval_context(node: "Node", ctx: t.Optional[EvalContext]) -> EvalContext:
+    if ctx is None:
+        if node.environment is None:
+            raise RuntimeError(
+                "if no eval context is passed, the node must have an"
+                " attached environment."
+            )
+        return EvalContext(node.environment)
+    return ctx
+
+
+class Node(metaclass=NodeType):
+    """Baseclass for all Jinja nodes.  There are a number of nodes available
+    of different types.  There are four major types:
+
+    -   :class:`Stmt`: statements
+    -   :class:`Expr`: expressions
+    -   :class:`Helper`: helper nodes
+    -   :class:`Template`: the outermost wrapper node
+
+    All nodes have fields and attributes.  Fields may be other nodes, lists,
+    or arbitrary values.  Fields are passed to the constructor as regular
+    positional arguments, attributes as keyword arguments.  Each node has
+    two attributes: `lineno` (the line number of the node) and `environment`.
+    The `environment` attribute is set at the end of the parsing process for
+    all nodes automatically.
+    """
+
+    fields: t.Tuple[str, ...] = ()
+    attributes: t.Tuple[str, ...] = ("lineno", "environment")
+    abstract = True
+
+    lineno: int
+    environment: t.Optional["Environment"]
+
+    def __init__(self, *fields: t.Any, **attributes: t.Any) -> None:
+        if self.abstract:
+            raise TypeError("abstract nodes are not instantiable")
+        if fields:
+            if len(fields) != len(self.fields):
+                if not self.fields:
+                    raise TypeError(f"{type(self).__name__!r} takes 0 arguments")
+                raise TypeError(
+                    f"{type(self).__name__!r} takes 0 or {len(self.fields)}"
+                    f" argument{'s' if len(self.fields) != 1 else ''}"
+                )
+            for name, arg in zip(self.fields, fields):
+                setattr(self, name, arg)
+        for attr in self.attributes:
+            setattr(self, attr, attributes.pop(attr, None))
+        if attributes:
+            raise TypeError(f"unknown attribute {next(iter(attributes))!r}")
+
+    def iter_fields(
+        self,
+        exclude: t.Optional[t.Container[str]] = None,
+        only: t.Optional[t.Container[str]] = None,
+    ) -> t.Iterator[t.Tuple[str, t.Any]]:
+        """This method iterates over all fields that are defined and yields
+        ``(key, value)`` tuples.  Per default all fields are returned, but
+        it's possible to limit that to some fields by providing the `only`
+        parameter or to exclude some using the `exclude` parameter.  Both
+        should be sets or tuples of field names.
+        """
+        for name in self.fields:
+            if (
+                (exclude is None and only is None)
+                or (exclude is not None and name not in exclude)
+                or (only is not None and name in only)
+            ):
+                try:
+                    yield name, getattr(self, name)
+                except AttributeError:
+                    pass
+
+    def iter_child_nodes(
+        self,
+        exclude: t.Optional[t.Container[str]] = None,
+        only: t.Optional[t.Container[str]] = None,
+    ) -> t.Iterator["Node"]:
+        """Iterates over all direct child nodes of the node.  This iterates
+        over all fields and yields the values of they are nodes.  If the value
+        of a field is a list all the nodes in that list are returned.
+        """
+        for _, item in self.iter_fields(exclude, only):
+            if isinstance(item, list):
+                for n in item:
+                    if isinstance(n, Node):
+                        yield n
+            elif isinstance(item, Node):
+                yield item
+
+    def find(self, node_type: t.Type[_NodeBound]) -> t.Optional[_NodeBound]:
+        """Find the first node of a given type.  If no such node exists the
+        return value is `None`.
+        """
+        for result in self.find_all(node_type):
+            return result
+
+        return None
+
+    def find_all(
+        self, node_type: t.Union[t.Type[_NodeBound], t.Tuple[t.Type[_NodeBound], ...]]
+    ) -> t.Iterator[_NodeBound]:
+        """Find all the nodes of a given type.  If the type is a tuple,
+        the check is performed for any of the tuple items.
+        """
+        for child in self.iter_child_nodes():
+            if isinstance(child, node_type):
+                yield child  # type: ignore
+            yield from child.find_all(node_type)
+
+    def set_ctx(self, ctx: str) -> "Node":
+        """Reset the context of a node and all child nodes.  Per default the
+        parser will all generate nodes that have a 'load' context as it's the
+        most common one.  This method is used in the parser to set assignment
+        targets and other nodes to a store context.
+        """
+        todo = deque([self])
+        while todo:
+            node = todo.popleft()
+            if "ctx" in node.fields:
+                node.ctx = ctx  # type: ignore
+            todo.extend(node.iter_child_nodes())
+        return self
+
+    def set_lineno(self, lineno: int, override: bool = False) -> "Node":
+        """Set the line numbers of the node and children."""
+        todo = deque([self])
+        while todo:
+            node = todo.popleft()
+            if "lineno" in node.attributes:
+                if node.lineno is None or override:
+                    node.lineno = lineno
+            todo.extend(node.iter_child_nodes())
+        return self
+
+    def set_environment(self, environment: "Environment") -> "Node":
+        """Set the environment for all nodes."""
+        todo = deque([self])
+        while todo:
+            node = todo.popleft()
+            node.environment = environment
+            todo.extend(node.iter_child_nodes())
+        return self
+
+    def __eq__(self, other: t.Any) -> bool:
+        if type(self) is not type(other):
+            return NotImplemented
+
+        return tuple(self.iter_fields()) == tuple(other.iter_fields())
+
+    __hash__ = object.__hash__
+
+    def __repr__(self) -> str:
+        args_str = ", ".join(f"{a}={getattr(self, a, None)!r}" for a in self.fields)
+        return f"{type(self).__name__}({args_str})"
+
+    def dump(self) -> str:
+        def _dump(node: t.Union[Node, t.Any]) -> None:
+            if not isinstance(node, Node):
+                buf.append(repr(node))
+                return
+
+            buf.append(f"nodes.{type(node).__name__}(")
+            if not node.fields:
+                buf.append(")")
+                return
+            for idx, field in enumerate(node.fields):
+                if idx:
+                    buf.append(", ")
+                value = getattr(node, field)
+                if isinstance(value, list):
+                    buf.append("[")
+                    for idx, item in enumerate(value):
+                        if idx:
+                            buf.append(", ")
+                        _dump(item)
+                    buf.append("]")
+                else:
+                    _dump(value)
+            buf.append(")")
+
+        buf: t.List[str] = []
+        _dump(self)
+        return "".join(buf)
+
+
+class Stmt(Node):
+    """Base node for all statements."""
+
+    abstract = True
+
+
+class Helper(Node):
+    """Nodes that exist in a specific context only."""
+
+    abstract = True
+
+
+class Template(Node):
+    """Node that represents a template.  This must be the outermost node that
+    is passed to the compiler.
+    """
+
+    fields = ("body",)
+    body: t.List[Node]
+
+
+class Output(Stmt):
+    """A node that holds multiple expressions which are then printed out.
+    This is used both for the `print` statement and the regular template data.
+    """
+
+    fields = ("nodes",)
+    nodes: t.List["Expr"]
+
+
+class Extends(Stmt):
+    """Represents an extends statement."""
+
+    fields = ("template",)
+    template: "Expr"
+
+
+class For(Stmt):
+    """The for loop.  `target` is the target for the iteration (usually a
+    :class:`Name` or :class:`Tuple`), `iter` the iterable.  `body` is a list
+    of nodes that are used as loop-body, and `else_` a list of nodes for the
+    `else` block.  If no else node exists it has to be an empty list.
+
+    For filtered nodes an expression can be stored as `test`, otherwise `None`.
+    """
+
+    fields = ("target", "iter", "body", "else_", "test", "recursive")
+    target: Node
+    iter: Node
+    body: t.List[Node]
+    else_: t.List[Node]
+    test: t.Optional[Node]
+    recursive: bool
+
+
+class If(Stmt):
+    """If `test` is true, `body` is rendered, else `else_`."""
+
+    fields = ("test", "body", "elif_", "else_")
+    test: Node
+    body: t.List[Node]
+    elif_: t.List["If"]
+    else_: t.List[Node]
+
+
+class Macro(Stmt):
+    """A macro definition.  `name` is the name of the macro, `args` a list of
+    arguments and `defaults` a list of defaults if there are any.  `body` is
+    a list of nodes for the macro body.
+    """
+
+    fields = ("name", "args", "defaults", "body")
+    name: str
+    args: t.List["Name"]
+    defaults: t.List["Expr"]
+    body: t.List[Node]
+
+
+class CallBlock(Stmt):
+    """Like a macro without a name but a call instead.  `call` is called with
+    the unnamed macro as `caller` argument this node holds.
+    """
+
+    fields = ("call", "args", "defaults", "body")
+    call: "Call"
+    args: t.List["Name"]
+    defaults: t.List["Expr"]
+    body: t.List[Node]
+
+
+class FilterBlock(Stmt):
+    """Node for filter sections."""
+
+    fields = ("body", "filter")
+    body: t.List[Node]
+    filter: "Filter"
+
+
+class With(Stmt):
+    """Specific node for with statements.  In older versions of Jinja the
+    with statement was implemented on the base of the `Scope` node instead.
+
+    .. versionadded:: 2.9.3
+    """
+
+    fields = ("targets", "values", "body")
+    targets: t.List["Expr"]
+    values: t.List["Expr"]
+    body: t.List[Node]
+
+
+class Block(Stmt):
+    """A node that represents a block.
+
+    .. versionchanged:: 3.0.0
+        the `required` field was added.
+    """
+
+    fields = ("name", "body", "scoped", "required")
+    name: str
+    body: t.List[Node]
+    scoped: bool
+    required: bool
+
+
+class Include(Stmt):
+    """A node that represents the include tag."""
+
+    fields = ("template", "with_context", "ignore_missing")
+    template: "Expr"
+    with_context: bool
+    ignore_missing: bool
+
+
+class Import(Stmt):
+    """A node that represents the import tag."""
+
+    fields = ("template", "target", "with_context")
+    template: "Expr"
+    target: str
+    with_context: bool
+
+
+class FromImport(Stmt):
+    """A node that represents the from import tag.  It's important to not
+    pass unsafe names to the name attribute.  The compiler translates the
+    attribute lookups directly into getattr calls and does *not* use the
+    subscript callback of the interface.  As exported variables may not
+    start with double underscores (which the parser asserts) this is not a
+    problem for regular Jinja code, but if this node is used in an extension
+    extra care must be taken.
+
+    The list of names may contain tuples if aliases are wanted.
+    """
+
+    fields = ("template", "names", "with_context")
+    template: "Expr"
+    names: t.List[t.Union[str, t.Tuple[str, str]]]
+    with_context: bool
+
+
+class ExprStmt(Stmt):
+    """A statement that evaluates an expression and discards the result."""
+
+    fields = ("node",)
+    node: Node
+
+
+class Assign(Stmt):
+    """Assigns an expression to a target."""
+
+    fields = ("target", "node")
+    target: "Expr"
+    node: Node
+
+
+class AssignBlock(Stmt):
+    """Assigns a block to a target."""
+
+    fields = ("target", "filter", "body")
+    target: "Expr"
+    filter: t.Optional["Filter"]
+    body: t.List[Node]
+
+
+class Expr(Node):
+    """Baseclass for all expressions."""
+
+    abstract = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        """Return the value of the expression as constant or raise
+        :exc:`Impossible` if this was not possible.
+
+        An :class:`EvalContext` can be provided, if none is given
+        a default context is created which requires the nodes to have
+        an attached environment.
+
+        .. versionchanged:: 2.4
+           the `eval_ctx` parameter was added.
+        """
+        raise Impossible()
+
+    def can_assign(self) -> bool:
+        """Check if it's possible to assign something to this node."""
+        return False
+
+
+class BinExpr(Expr):
+    """Baseclass for all binary expressions."""
+
+    fields = ("left", "right")
+    left: Expr
+    right: Expr
+    operator: str
+    abstract = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        # intercepted operators cannot be folded at compile time
+        if (
+            eval_ctx.environment.sandboxed
+            and self.operator in eval_ctx.environment.intercepted_binops  # type: ignore
+        ):
+            raise Impossible()
+        f = _binop_to_func[self.operator]
+        try:
+            return f(self.left.as_const(eval_ctx), self.right.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+
+class UnaryExpr(Expr):
+    """Baseclass for all unary expressions."""
+
+    fields = ("node",)
+    node: Expr
+    operator: str
+    abstract = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        # intercepted operators cannot be folded at compile time
+        if (
+            eval_ctx.environment.sandboxed
+            and self.operator in eval_ctx.environment.intercepted_unops  # type: ignore
+        ):
+            raise Impossible()
+        f = _uaop_to_func[self.operator]
+        try:
+            return f(self.node.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Name(Expr):
+    """Looks up a name or stores a value in a name.
+    The `ctx` of the node can be one of the following values:
+
+    -   `store`: store a value in the name
+    -   `load`: load that name
+    -   `param`: like `store` but if the name was defined as function parameter.
+    """
+
+    fields = ("name", "ctx")
+    name: str
+    ctx: str
+
+    def can_assign(self) -> bool:
+        return self.name not in {"true", "false", "none", "True", "False", "None"}
+
+
+class NSRef(Expr):
+    """Reference to a namespace value assignment"""
+
+    fields = ("name", "attr")
+    name: str
+    attr: str
+
+    def can_assign(self) -> bool:
+        # We don't need any special checks here; NSRef assignments have a
+        # runtime check to ensure the target is a namespace object which will
+        # have been checked already as it is created using a normal assignment
+        # which goes through a `Name` node.
+        return True
+
+
+class Literal(Expr):
+    """Baseclass for literals."""
+
+    abstract = True
+
+
+class Const(Literal):
+    """All constant values.  The parser will return this node for simple
+    constants such as ``42`` or ``"foo"`` but it can be used to store more
+    complex values such as lists too.  Only constants with a safe
+    representation (objects where ``eval(repr(x)) == x`` is true).
+    """
+
+    fields = ("value",)
+    value: t.Any
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        return self.value
+
+    @classmethod
+    def from_untrusted(
+        cls,
+        value: t.Any,
+        lineno: t.Optional[int] = None,
+        environment: "t.Optional[Environment]" = None,
+    ) -> "Const":
+        """Return a const object if the value is representable as
+        constant value in the generated code, otherwise it will raise
+        an `Impossible` exception.
+        """
+        from .compiler import has_safe_repr
+
+        if not has_safe_repr(value):
+            raise Impossible()
+        return cls(value, lineno=lineno, environment=environment)
+
+
+class TemplateData(Literal):
+    """A constant template string."""
+
+    fields = ("data",)
+    data: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> str:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        if eval_ctx.volatile:
+            raise Impossible()
+        if eval_ctx.autoescape:
+            return Markup(self.data)
+        return self.data
+
+
+class Tuple(Literal):
+    """For loop unpacking and some other things like multiple arguments
+    for subscripts.  Like for :class:`Name` `ctx` specifies if the tuple
+    is used for loading the names or storing.
+    """
+
+    fields = ("items", "ctx")
+    items: t.List[Expr]
+    ctx: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Tuple[t.Any, ...]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return tuple(x.as_const(eval_ctx) for x in self.items)
+
+    def can_assign(self) -> bool:
+        for item in self.items:
+            if not item.can_assign():
+                return False
+        return True
+
+
+class List(Literal):
+    """Any list literal such as ``[1, 2, 3]``"""
+
+    fields = ("items",)
+    items: t.List[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.List[t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return [x.as_const(eval_ctx) for x in self.items]
+
+
+class Dict(Literal):
+    """Any dict literal such as ``{1: 2, 3: 4}``.  The items must be a list of
+    :class:`Pair` nodes.
+    """
+
+    fields = ("items",)
+    items: t.List["Pair"]
+
+    def as_const(
+        self, eval_ctx: t.Optional[EvalContext] = None
+    ) -> t.Dict[t.Any, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return dict(x.as_const(eval_ctx) for x in self.items)
+
+
+class Pair(Helper):
+    """A key, value pair for dicts."""
+
+    fields = ("key", "value")
+    key: Expr
+    value: Expr
+
+    def as_const(
+        self, eval_ctx: t.Optional[EvalContext] = None
+    ) -> t.Tuple[t.Any, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.key.as_const(eval_ctx), self.value.as_const(eval_ctx)
+
+
+class Keyword(Helper):
+    """A key, value pair for keyword arguments where key is a string."""
+
+    fields = ("key", "value")
+    key: str
+    value: Expr
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Tuple[str, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.key, self.value.as_const(eval_ctx)
+
+
+class CondExpr(Expr):
+    """A conditional expression (inline if expression).  (``{{
+    foo if bar else baz }}``)
+    """
+
+    fields = ("test", "expr1", "expr2")
+    test: Expr
+    expr1: Expr
+    expr2: t.Optional[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        if self.test.as_const(eval_ctx):
+            return self.expr1.as_const(eval_ctx)
+
+        # if we evaluate to an undefined object, we better do that at runtime
+        if self.expr2 is None:
+            raise Impossible()
+
+        return self.expr2.as_const(eval_ctx)
+
+
+def args_as_const(
+    node: t.Union["_FilterTestCommon", "Call"], eval_ctx: t.Optional[EvalContext]
+) -> t.Tuple[t.List[t.Any], t.Dict[t.Any, t.Any]]:
+    args = [x.as_const(eval_ctx) for x in node.args]
+    kwargs = dict(x.as_const(eval_ctx) for x in node.kwargs)
+
+    if node.dyn_args is not None:
+        try:
+            args.extend(node.dyn_args.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+    if node.dyn_kwargs is not None:
+        try:
+            kwargs.update(node.dyn_kwargs.as_const(eval_ctx))
+        except Exception as e:
+            raise Impossible() from e
+
+    return args, kwargs
+
+
+class _FilterTestCommon(Expr):
+    fields = ("node", "name", "args", "kwargs", "dyn_args", "dyn_kwargs")
+    node: Expr
+    name: str
+    args: t.List[Expr]
+    kwargs: t.List[Pair]
+    dyn_args: t.Optional[Expr]
+    dyn_kwargs: t.Optional[Expr]
+    abstract = True
+    _is_filter = True
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        if eval_ctx.volatile:
+            raise Impossible()
+
+        if self._is_filter:
+            env_map = eval_ctx.environment.filters
+        else:
+            env_map = eval_ctx.environment.tests
+
+        func = env_map.get(self.name)
+        pass_arg = _PassArg.from_obj(func)  # type: ignore
+
+        if func is None or pass_arg is _PassArg.context:
+            raise Impossible()
+
+        if eval_ctx.environment.is_async and (
+            getattr(func, "jinja_async_variant", False) is True
+            or inspect.iscoroutinefunction(func)
+        ):
+            raise Impossible()
+
+        args, kwargs = args_as_const(self, eval_ctx)
+        args.insert(0, self.node.as_const(eval_ctx))
+
+        if pass_arg is _PassArg.eval_context:
+            args.insert(0, eval_ctx)
+        elif pass_arg is _PassArg.environment:
+            args.insert(0, eval_ctx.environment)
+
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Filter(_FilterTestCommon):
+    """Apply a filter to an expression. ``name`` is the name of the
+    filter, the other fields are the same as :class:`Call`.
+
+    If ``node`` is ``None``, the filter is being used in a filter block
+    and is applied to the content of the block.
+    """
+
+    node: t.Optional[Expr]  # type: ignore
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        if self.node is None:
+            raise Impossible()
+
+        return super().as_const(eval_ctx=eval_ctx)
+
+
+class Test(_FilterTestCommon):
+    """Apply a test to an expression. ``name`` is the name of the test,
+    the other field are the same as :class:`Call`.
+
+    .. versionchanged:: 3.0
+        ``as_const`` shares the same logic for filters and tests. Tests
+        check for volatile, async, and ``@pass_context`` etc.
+        decorators.
+    """
+
+    _is_filter = False
+
+
+class Call(Expr):
+    """Calls an expression.  `args` is a list of arguments, `kwargs` a list
+    of keyword arguments (list of :class:`Keyword` nodes), and `dyn_args`
+    and `dyn_kwargs` has to be either `None` or a node that is used as
+    node for dynamic positional (``*args``) or keyword (``**kwargs``)
+    arguments.
+    """
+
+    fields = ("node", "args", "kwargs", "dyn_args", "dyn_kwargs")
+    node: Expr
+    args: t.List[Expr]
+    kwargs: t.List[Keyword]
+    dyn_args: t.Optional[Expr]
+    dyn_kwargs: t.Optional[Expr]
+
+
+class Getitem(Expr):
+    """Get an attribute or item from an expression and prefer the item."""
+
+    fields = ("node", "arg", "ctx")
+    node: Expr
+    arg: Expr
+    ctx: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        if self.ctx != "load":
+            raise Impossible()
+
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        try:
+            return eval_ctx.environment.getitem(
+                self.node.as_const(eval_ctx), self.arg.as_const(eval_ctx)
+            )
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Getattr(Expr):
+    """Get an attribute or item from an expression that is a ascii-only
+    bytestring and prefer the attribute.
+    """
+
+    fields = ("node", "attr", "ctx")
+    node: Expr
+    attr: str
+    ctx: str
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        if self.ctx != "load":
+            raise Impossible()
+
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        try:
+            return eval_ctx.environment.getattr(self.node.as_const(eval_ctx), self.attr)
+        except Exception as e:
+            raise Impossible() from e
+
+
+class Slice(Expr):
+    """Represents a slice object.  This must only be used as argument for
+    :class:`Subscript`.
+    """
+
+    fields = ("start", "stop", "step")
+    start: t.Optional[Expr]
+    stop: t.Optional[Expr]
+    step: t.Optional[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> slice:
+        eval_ctx = get_eval_context(self, eval_ctx)
+
+        def const(obj: t.Optional[Expr]) -> t.Optional[t.Any]:
+            if obj is None:
+                return None
+            return obj.as_const(eval_ctx)
+
+        return slice(const(self.start), const(self.stop), const(self.step))
+
+
+class Concat(Expr):
+    """Concatenates the list of expressions provided after converting
+    them to strings.
+    """
+
+    fields = ("nodes",)
+    nodes: t.List[Expr]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> str:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return "".join(str(x.as_const(eval_ctx)) for x in self.nodes)
+
+
+class Compare(Expr):
+    """Compares an expression with some other expressions.  `ops` must be a
+    list of :class:`Operand`\\s.
+    """
+
+    fields = ("expr", "ops")
+    expr: Expr
+    ops: t.List["Operand"]
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        result = value = self.expr.as_const(eval_ctx)
+
+        try:
+            for op in self.ops:
+                new_value = op.expr.as_const(eval_ctx)
+                result = _cmpop_to_func[op.op](value, new_value)
+
+                if not result:
+                    return False
+
+                value = new_value
+        except Exception as e:
+            raise Impossible() from e
+
+        return result
+
+
+class Operand(Helper):
+    """Holds an operator and an expression."""
+
+    fields = ("op", "expr")
+    op: str
+    expr: Expr
+
+
+class Mul(BinExpr):
+    """Multiplies the left with the right node."""
+
+    operator = "*"
+
+
+class Div(BinExpr):
+    """Divides the left by the right node."""
+
+    operator = "/"
+
+
+class FloorDiv(BinExpr):
+    """Divides the left by the right node and converts the
+    result into an integer by truncating.
+    """
+
+    operator = "//"
+
+
+class Add(BinExpr):
+    """Add the left to the right node."""
+
+    operator = "+"
+
+
+class Sub(BinExpr):
+    """Subtract the right from the left node."""
+
+    operator = "-"
+
+
+class Mod(BinExpr):
+    """Left modulo right."""
+
+    operator = "%"
+
+
+class Pow(BinExpr):
+    """Left to the power of right."""
+
+    operator = "**"
+
+
+class And(BinExpr):
+    """Short circuited AND."""
+
+    operator = "and"
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.left.as_const(eval_ctx) and self.right.as_const(eval_ctx)
+
+
+class Or(BinExpr):
+    """Short circuited OR."""
+
+    operator = "or"
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> t.Any:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return self.left.as_const(eval_ctx) or self.right.as_const(eval_ctx)
+
+
+class Not(UnaryExpr):
+    """Negate the expression."""
+
+    operator = "not"
+
+
+class Neg(UnaryExpr):
+    """Make the expression negative."""
+
+    operator = "-"
+
+
+class Pos(UnaryExpr):
+    """Make the expression positive (noop for most expressions)"""
+
+    operator = "+"
+
+
+# Helpers for extensions
+
+
+class EnvironmentAttribute(Expr):
+    """Loads an attribute from the environment object.  This is useful for
+    extensions that want to call a callback stored on the environment.
+    """
+
+    fields = ("name",)
+    name: str
+
+
+class ExtensionAttribute(Expr):
+    """Returns the attribute of an extension bound to the environment.
+    The identifier is the identifier of the :class:`Extension`.
+
+    This node is usually constructed by calling the
+    :meth:`~jinja2.ext.Extension.attr` method on an extension.
+    """
+
+    fields = ("identifier", "name")
+    identifier: str
+    name: str
+
+
+class ImportedName(Expr):
+    """If created with an import name the import name is returned on node
+    access.  For example ``ImportedName('cgi.escape')`` returns the `escape`
+    function from the cgi module on evaluation.  Imports are optimized by the
+    compiler so there is no need to assign them to local variables.
+    """
+
+    fields = ("importname",)
+    importname: str
+
+
+class InternalName(Expr):
+    """An internal name in the compiler.  You cannot create these nodes
+    yourself but the parser provides a
+    :meth:`~jinja2.parser.Parser.free_identifier` method that creates
+    a new identifier for you.  This identifier is not available from the
+    template and is not treated specially by the compiler.
+    """
+
+    fields = ("name",)
+    name: str
+
+    def __init__(self) -> None:
+        raise TypeError(
+            "Can't create internal names.  Use the "
+            "`free_identifier` method on a parser."
+        )
+
+
+class MarkSafe(Expr):
+    """Mark the wrapped expression as safe (wrap it as `Markup`)."""
+
+    fields = ("expr",)
+    expr: Expr
+
+    def as_const(self, eval_ctx: t.Optional[EvalContext] = None) -> Markup:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        return Markup(self.expr.as_const(eval_ctx))
+
+
+class MarkSafeIfAutoescape(Expr):
+    """Mark the wrapped expression as safe (wrap it as `Markup`) but
+    only if autoescaping is active.
+
+    .. versionadded:: 2.5
+    """
+
+    fields = ("expr",)
+    expr: Expr
+
+    def as_const(
+        self, eval_ctx: t.Optional[EvalContext] = None
+    ) -> t.Union[Markup, t.Any]:
+        eval_ctx = get_eval_context(self, eval_ctx)
+        if eval_ctx.volatile:
+            raise Impossible()
+        expr = self.expr.as_const(eval_ctx)
+        if eval_ctx.autoescape:
+            return Markup(expr)
+        return expr
+
+
+class ContextReference(Expr):
+    """Returns the current template context.  It can be used like a
+    :class:`Name` node, with a ``'load'`` ctx and will return the
+    current :class:`~jinja2.runtime.Context` object.
+
+    Here an example that assigns the current template name to a
+    variable named `foo`::
+
+        Assign(Name('foo', ctx='store'),
+               Getattr(ContextReference(), 'name'))
+
+    This is basically equivalent to using the
+    :func:`~jinja2.pass_context` decorator when using the high-level
+    API, which causes a reference to the context to be passed as the
+    first argument to a function.
+    """
+
+
+class DerivedContextReference(Expr):
+    """Return the current template context including locals. Behaves
+    exactly like :class:`ContextReference`, but includes local
+    variables, such as from a ``for`` loop.
+
+    .. versionadded:: 2.11
+    """
+
+
+class Continue(Stmt):
+    """Continue a loop."""
+
+
+class Break(Stmt):
+    """Break a loop."""
+
+
+class Scope(Stmt):
+    """An artificial scope."""
+
+    fields = ("body",)
+    body: t.List[Node]
+
+
+class OverlayScope(Stmt):
+    """An overlay scope for extensions.  This is a largely unoptimized scope
+    that however can be used to introduce completely arbitrary variables into
+    a sub scope from a dictionary or dictionary like object.  The `context`
+    field has to evaluate to a dictionary object.
+
+    Example usage::
+
+        OverlayScope(context=self.call_method('get_context'),
+                     body=[...])
+
+    .. versionadded:: 2.10
+    """
+
+    fields = ("context", "body")
+    context: Expr
+    body: t.List[Node]
+
+
+class EvalContextModifier(Stmt):
+    """Modifies the eval context.  For each option that should be modified,
+    a :class:`Keyword` has to be added to the :attr:`options` list.
+
+    Example to change the `autoescape` setting::
+
+        EvalContextModifier(options=[Keyword('autoescape', Const(True))])
+    """
+
+    fields = ("options",)
+    options: t.List[Keyword]
+
+
+class ScopedEvalContextModifier(EvalContextModifier):
+    """Modifies the eval context and reverts it later.  Works exactly like
+    :class:`EvalContextModifier` but will only modify the
+    :class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
+    """
+
+    fields = ("body",)
+    body: t.List[Node]
+
+
+# make sure nobody creates custom nodes
+def _failing_new(*args: t.Any, **kwargs: t.Any) -> "te.NoReturn":
+    raise TypeError("can't create custom node types")
+
+
+NodeType.__new__ = staticmethod(_failing_new)  # type: ignore
+del _failing_new
diff --git a/lib/python3.11/site-packages/jinja2/optimizer.py b/lib/python3.11/site-packages/jinja2/optimizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe1010705e7b29d4fa1900b3a0438ab93d7b582c
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/optimizer.py
@@ -0,0 +1,47 @@
+"""The optimizer tries to constant fold expressions and modify the AST
+in place so that it should be faster to evaluate.
+
+Because the AST does not contain all the scoping information and the
+compiler has to find that out, we cannot do all the optimizations we
+want. For example, loop unrolling doesn't work because unrolled loops
+would have a different scope. The solution would be a second syntax tree
+that stored the scoping rules.
+"""
+import typing as t
+
+from . import nodes
+from .visitor import NodeTransformer
+
+if t.TYPE_CHECKING:
+    from .environment import Environment
+
+
+def optimize(node: nodes.Node, environment: "Environment") -> nodes.Node:
+    """The context hint can be used to perform an static optimization
+    based on the context given."""
+    optimizer = Optimizer(environment)
+    return t.cast(nodes.Node, optimizer.visit(node))
+
+
+class Optimizer(NodeTransformer):
+    def __init__(self, environment: "t.Optional[Environment]") -> None:
+        self.environment = environment
+
+    def generic_visit(
+        self, node: nodes.Node, *args: t.Any, **kwargs: t.Any
+    ) -> nodes.Node:
+        node = super().generic_visit(node, *args, **kwargs)
+
+        # Do constant folding. Some other nodes besides Expr have
+        # as_const, but folding them causes errors later on.
+        if isinstance(node, nodes.Expr):
+            try:
+                return nodes.Const.from_untrusted(
+                    node.as_const(args[0] if args else None),
+                    lineno=node.lineno,
+                    environment=self.environment,
+                )
+            except nodes.Impossible:
+                pass
+
+        return node
diff --git a/lib/python3.11/site-packages/jinja2/parser.py b/lib/python3.11/site-packages/jinja2/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..cefce2dfa1d2a4171838b0d0135af8ea3ff7d62c
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/parser.py
@@ -0,0 +1,1032 @@
+"""Parse tokens from the lexer into nodes for the compiler."""
+import typing
+import typing as t
+
+from . import nodes
+from .exceptions import TemplateAssertionError
+from .exceptions import TemplateSyntaxError
+from .lexer import describe_token
+from .lexer import describe_token_expr
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+    from .environment import Environment
+
+_ImportInclude = t.TypeVar("_ImportInclude", nodes.Import, nodes.Include)
+_MacroCall = t.TypeVar("_MacroCall", nodes.Macro, nodes.CallBlock)
+
+_statement_keywords = frozenset(
+    [
+        "for",
+        "if",
+        "block",
+        "extends",
+        "print",
+        "macro",
+        "include",
+        "from",
+        "import",
+        "set",
+        "with",
+        "autoescape",
+    ]
+)
+_compare_operators = frozenset(["eq", "ne", "lt", "lteq", "gt", "gteq"])
+
+_math_nodes: t.Dict[str, t.Type[nodes.Expr]] = {
+    "add": nodes.Add,
+    "sub": nodes.Sub,
+    "mul": nodes.Mul,
+    "div": nodes.Div,
+    "floordiv": nodes.FloorDiv,
+    "mod": nodes.Mod,
+}
+
+
+class Parser:
+    """This is the central parsing class Jinja uses.  It's passed to
+    extensions and can be used to parse expressions or statements.
+    """
+
+    def __init__(
+        self,
+        environment: "Environment",
+        source: str,
+        name: t.Optional[str] = None,
+        filename: t.Optional[str] = None,
+        state: t.Optional[str] = None,
+    ) -> None:
+        self.environment = environment
+        self.stream = environment._tokenize(source, name, filename, state)
+        self.name = name
+        self.filename = filename
+        self.closed = False
+        self.extensions: t.Dict[
+            str, t.Callable[["Parser"], t.Union[nodes.Node, t.List[nodes.Node]]]
+        ] = {}
+        for extension in environment.iter_extensions():
+            for tag in extension.tags:
+                self.extensions[tag] = extension.parse
+        self._last_identifier = 0
+        self._tag_stack: t.List[str] = []
+        self._end_token_stack: t.List[t.Tuple[str, ...]] = []
+
+    def fail(
+        self,
+        msg: str,
+        lineno: t.Optional[int] = None,
+        exc: t.Type[TemplateSyntaxError] = TemplateSyntaxError,
+    ) -> "te.NoReturn":
+        """Convenience method that raises `exc` with the message, passed
+        line number or last line number as well as the current name and
+        filename.
+        """
+        if lineno is None:
+            lineno = self.stream.current.lineno
+        raise exc(msg, lineno, self.name, self.filename)
+
+    def _fail_ut_eof(
+        self,
+        name: t.Optional[str],
+        end_token_stack: t.List[t.Tuple[str, ...]],
+        lineno: t.Optional[int],
+    ) -> "te.NoReturn":
+        expected: t.Set[str] = set()
+        for exprs in end_token_stack:
+            expected.update(map(describe_token_expr, exprs))
+        if end_token_stack:
+            currently_looking: t.Optional[str] = " or ".join(
+                map(repr, map(describe_token_expr, end_token_stack[-1]))
+            )
+        else:
+            currently_looking = None
+
+        if name is None:
+            message = ["Unexpected end of template."]
+        else:
+            message = [f"Encountered unknown tag {name!r}."]
+
+        if currently_looking:
+            if name is not None and name in expected:
+                message.append(
+                    "You probably made a nesting mistake. Jinja is expecting this tag,"
+                    f" but currently looking for {currently_looking}."
+                )
+            else:
+                message.append(
+                    f"Jinja was looking for the following tags: {currently_looking}."
+                )
+
+        if self._tag_stack:
+            message.append(
+                "The innermost block that needs to be closed is"
+                f" {self._tag_stack[-1]!r}."
+            )
+
+        self.fail(" ".join(message), lineno)
+
+    def fail_unknown_tag(
+        self, name: str, lineno: t.Optional[int] = None
+    ) -> "te.NoReturn":
+        """Called if the parser encounters an unknown tag.  Tries to fail
+        with a human readable error message that could help to identify
+        the problem.
+        """
+        self._fail_ut_eof(name, self._end_token_stack, lineno)
+
+    def fail_eof(
+        self,
+        end_tokens: t.Optional[t.Tuple[str, ...]] = None,
+        lineno: t.Optional[int] = None,
+    ) -> "te.NoReturn":
+        """Like fail_unknown_tag but for end of template situations."""
+        stack = list(self._end_token_stack)
+        if end_tokens is not None:
+            stack.append(end_tokens)
+        self._fail_ut_eof(None, stack, lineno)
+
+    def is_tuple_end(
+        self, extra_end_rules: t.Optional[t.Tuple[str, ...]] = None
+    ) -> bool:
+        """Are we at the end of a tuple?"""
+        if self.stream.current.type in ("variable_end", "block_end", "rparen"):
+            return True
+        elif extra_end_rules is not None:
+            return self.stream.current.test_any(extra_end_rules)  # type: ignore
+        return False
+
+    def free_identifier(self, lineno: t.Optional[int] = None) -> nodes.InternalName:
+        """Return a new free identifier as :class:`~jinja2.nodes.InternalName`."""
+        self._last_identifier += 1
+        rv = object.__new__(nodes.InternalName)
+        nodes.Node.__init__(rv, f"fi{self._last_identifier}", lineno=lineno)
+        return rv
+
+    def parse_statement(self) -> t.Union[nodes.Node, t.List[nodes.Node]]:
+        """Parse a single statement."""
+        token = self.stream.current
+        if token.type != "name":
+            self.fail("tag name expected", token.lineno)
+        self._tag_stack.append(token.value)
+        pop_tag = True
+        try:
+            if token.value in _statement_keywords:
+                f = getattr(self, f"parse_{self.stream.current.value}")
+                return f()  # type: ignore
+            if token.value == "call":
+                return self.parse_call_block()
+            if token.value == "filter":
+                return self.parse_filter_block()
+            ext = self.extensions.get(token.value)
+            if ext is not None:
+                return ext(self)
+
+            # did not work out, remove the token we pushed by accident
+            # from the stack so that the unknown tag fail function can
+            # produce a proper error message.
+            self._tag_stack.pop()
+            pop_tag = False
+            self.fail_unknown_tag(token.value, token.lineno)
+        finally:
+            if pop_tag:
+                self._tag_stack.pop()
+
+    def parse_statements(
+        self, end_tokens: t.Tuple[str, ...], drop_needle: bool = False
+    ) -> t.List[nodes.Node]:
+        """Parse multiple statements into a list until one of the end tokens
+        is reached.  This is used to parse the body of statements as it also
+        parses template data if appropriate.  The parser checks first if the
+        current token is a colon and skips it if there is one.  Then it checks
+        for the block end and parses until if one of the `end_tokens` is
+        reached.  Per default the active token in the stream at the end of
+        the call is the matched end token.  If this is not wanted `drop_needle`
+        can be set to `True` and the end token is removed.
+        """
+        # the first token may be a colon for python compatibility
+        self.stream.skip_if("colon")
+
+        # in the future it would be possible to add whole code sections
+        # by adding some sort of end of statement token and parsing those here.
+        self.stream.expect("block_end")
+        result = self.subparse(end_tokens)
+
+        # we reached the end of the template too early, the subparser
+        # does not check for this, so we do that now
+        if self.stream.current.type == "eof":
+            self.fail_eof(end_tokens)
+
+        if drop_needle:
+            next(self.stream)
+        return result
+
+    def parse_set(self) -> t.Union[nodes.Assign, nodes.AssignBlock]:
+        """Parse an assign statement."""
+        lineno = next(self.stream).lineno
+        target = self.parse_assign_target(with_namespace=True)
+        if self.stream.skip_if("assign"):
+            expr = self.parse_tuple()
+            return nodes.Assign(target, expr, lineno=lineno)
+        filter_node = self.parse_filter(None)
+        body = self.parse_statements(("name:endset",), drop_needle=True)
+        return nodes.AssignBlock(target, filter_node, body, lineno=lineno)
+
+    def parse_for(self) -> nodes.For:
+        """Parse a for loop."""
+        lineno = self.stream.expect("name:for").lineno
+        target = self.parse_assign_target(extra_end_rules=("name:in",))
+        self.stream.expect("name:in")
+        iter = self.parse_tuple(
+            with_condexpr=False, extra_end_rules=("name:recursive",)
+        )
+        test = None
+        if self.stream.skip_if("name:if"):
+            test = self.parse_expression()
+        recursive = self.stream.skip_if("name:recursive")
+        body = self.parse_statements(("name:endfor", "name:else"))
+        if next(self.stream).value == "endfor":
+            else_ = []
+        else:
+            else_ = self.parse_statements(("name:endfor",), drop_needle=True)
+        return nodes.For(target, iter, body, else_, test, recursive, lineno=lineno)
+
+    def parse_if(self) -> nodes.If:
+        """Parse an if construct."""
+        node = result = nodes.If(lineno=self.stream.expect("name:if").lineno)
+        while True:
+            node.test = self.parse_tuple(with_condexpr=False)
+            node.body = self.parse_statements(("name:elif", "name:else", "name:endif"))
+            node.elif_ = []
+            node.else_ = []
+            token = next(self.stream)
+            if token.test("name:elif"):
+                node = nodes.If(lineno=self.stream.current.lineno)
+                result.elif_.append(node)
+                continue
+            elif token.test("name:else"):
+                result.else_ = self.parse_statements(("name:endif",), drop_needle=True)
+            break
+        return result
+
+    def parse_with(self) -> nodes.With:
+        node = nodes.With(lineno=next(self.stream).lineno)
+        targets: t.List[nodes.Expr] = []
+        values: t.List[nodes.Expr] = []
+        while self.stream.current.type != "block_end":
+            if targets:
+                self.stream.expect("comma")
+            target = self.parse_assign_target()
+            target.set_ctx("param")
+            targets.append(target)
+            self.stream.expect("assign")
+            values.append(self.parse_expression())
+        node.targets = targets
+        node.values = values
+        node.body = self.parse_statements(("name:endwith",), drop_needle=True)
+        return node
+
+    def parse_autoescape(self) -> nodes.Scope:
+        node = nodes.ScopedEvalContextModifier(lineno=next(self.stream).lineno)
+        node.options = [nodes.Keyword("autoescape", self.parse_expression())]
+        node.body = self.parse_statements(("name:endautoescape",), drop_needle=True)
+        return nodes.Scope([node])
+
+    def parse_block(self) -> nodes.Block:
+        node = nodes.Block(lineno=next(self.stream).lineno)
+        node.name = self.stream.expect("name").value
+        node.scoped = self.stream.skip_if("name:scoped")
+        node.required = self.stream.skip_if("name:required")
+
+        # common problem people encounter when switching from django
+        # to jinja.  we do not support hyphens in block names, so let's
+        # raise a nicer error message in that case.
+        if self.stream.current.type == "sub":
+            self.fail(
+                "Block names in Jinja have to be valid Python identifiers and may not"
+                " contain hyphens, use an underscore instead."
+            )
+
+        node.body = self.parse_statements(("name:endblock",), drop_needle=True)
+
+        # enforce that required blocks only contain whitespace or comments
+        # by asserting that the body, if not empty, is just TemplateData nodes
+        # with whitespace data
+        if node.required and not all(
+            isinstance(child, nodes.TemplateData) and child.data.isspace()
+            for body in node.body
+            for child in body.nodes  # type: ignore
+        ):
+            self.fail("Required blocks can only contain comments or whitespace")
+
+        self.stream.skip_if("name:" + node.name)
+        return node
+
+    def parse_extends(self) -> nodes.Extends:
+        node = nodes.Extends(lineno=next(self.stream).lineno)
+        node.template = self.parse_expression()
+        return node
+
+    def parse_import_context(
+        self, node: _ImportInclude, default: bool
+    ) -> _ImportInclude:
+        if self.stream.current.test_any(
+            "name:with", "name:without"
+        ) and self.stream.look().test("name:context"):
+            node.with_context = next(self.stream).value == "with"
+            self.stream.skip()
+        else:
+            node.with_context = default
+        return node
+
+    def parse_include(self) -> nodes.Include:
+        node = nodes.Include(lineno=next(self.stream).lineno)
+        node.template = self.parse_expression()
+        if self.stream.current.test("name:ignore") and self.stream.look().test(
+            "name:missing"
+        ):
+            node.ignore_missing = True
+            self.stream.skip(2)
+        else:
+            node.ignore_missing = False
+        return self.parse_import_context(node, True)
+
+    def parse_import(self) -> nodes.Import:
+        node = nodes.Import(lineno=next(self.stream).lineno)
+        node.template = self.parse_expression()
+        self.stream.expect("name:as")
+        node.target = self.parse_assign_target(name_only=True).name
+        return self.parse_import_context(node, False)
+
+    def parse_from(self) -> nodes.FromImport:
+        node = nodes.FromImport(lineno=next(self.stream).lineno)
+        node.template = self.parse_expression()
+        self.stream.expect("name:import")
+        node.names = []
+
+        def parse_context() -> bool:
+            if self.stream.current.value in {
+                "with",
+                "without",
+            } and self.stream.look().test("name:context"):
+                node.with_context = next(self.stream).value == "with"
+                self.stream.skip()
+                return True
+            return False
+
+        while True:
+            if node.names:
+                self.stream.expect("comma")
+            if self.stream.current.type == "name":
+                if parse_context():
+                    break
+                target = self.parse_assign_target(name_only=True)
+                if target.name.startswith("_"):
+                    self.fail(
+                        "names starting with an underline can not be imported",
+                        target.lineno,
+                        exc=TemplateAssertionError,
+                    )
+                if self.stream.skip_if("name:as"):
+                    alias = self.parse_assign_target(name_only=True)
+                    node.names.append((target.name, alias.name))
+                else:
+                    node.names.append(target.name)
+                if parse_context() or self.stream.current.type != "comma":
+                    break
+            else:
+                self.stream.expect("name")
+        if not hasattr(node, "with_context"):
+            node.with_context = False
+        return node
+
+    def parse_signature(self, node: _MacroCall) -> None:
+        args = node.args = []
+        defaults = node.defaults = []
+        self.stream.expect("lparen")
+        while self.stream.current.type != "rparen":
+            if args:
+                self.stream.expect("comma")
+            arg = self.parse_assign_target(name_only=True)
+            arg.set_ctx("param")
+            if self.stream.skip_if("assign"):
+                defaults.append(self.parse_expression())
+            elif defaults:
+                self.fail("non-default argument follows default argument")
+            args.append(arg)
+        self.stream.expect("rparen")
+
+    def parse_call_block(self) -> nodes.CallBlock:
+        node = nodes.CallBlock(lineno=next(self.stream).lineno)
+        if self.stream.current.type == "lparen":
+            self.parse_signature(node)
+        else:
+            node.args = []
+            node.defaults = []
+
+        call_node = self.parse_expression()
+        if not isinstance(call_node, nodes.Call):
+            self.fail("expected call", node.lineno)
+        node.call = call_node
+        node.body = self.parse_statements(("name:endcall",), drop_needle=True)
+        return node
+
+    def parse_filter_block(self) -> nodes.FilterBlock:
+        node = nodes.FilterBlock(lineno=next(self.stream).lineno)
+        node.filter = self.parse_filter(None, start_inline=True)  # type: ignore
+        node.body = self.parse_statements(("name:endfilter",), drop_needle=True)
+        return node
+
+    def parse_macro(self) -> nodes.Macro:
+        node = nodes.Macro(lineno=next(self.stream).lineno)
+        node.name = self.parse_assign_target(name_only=True).name
+        self.parse_signature(node)
+        node.body = self.parse_statements(("name:endmacro",), drop_needle=True)
+        return node
+
+    def parse_print(self) -> nodes.Output:
+        node = nodes.Output(lineno=next(self.stream).lineno)
+        node.nodes = []
+        while self.stream.current.type != "block_end":
+            if node.nodes:
+                self.stream.expect("comma")
+            node.nodes.append(self.parse_expression())
+        return node
+
+    @typing.overload
+    def parse_assign_target(
+        self, with_tuple: bool = ..., name_only: "te.Literal[True]" = ...
+    ) -> nodes.Name:
+        ...
+
+    @typing.overload
+    def parse_assign_target(
+        self,
+        with_tuple: bool = True,
+        name_only: bool = False,
+        extra_end_rules: t.Optional[t.Tuple[str, ...]] = None,
+        with_namespace: bool = False,
+    ) -> t.Union[nodes.NSRef, nodes.Name, nodes.Tuple]:
+        ...
+
+    def parse_assign_target(
+        self,
+        with_tuple: bool = True,
+        name_only: bool = False,
+        extra_end_rules: t.Optional[t.Tuple[str, ...]] = None,
+        with_namespace: bool = False,
+    ) -> t.Union[nodes.NSRef, nodes.Name, nodes.Tuple]:
+        """Parse an assignment target.  As Jinja allows assignments to
+        tuples, this function can parse all allowed assignment targets.  Per
+        default assignments to tuples are parsed, that can be disable however
+        by setting `with_tuple` to `False`.  If only assignments to names are
+        wanted `name_only` can be set to `True`.  The `extra_end_rules`
+        parameter is forwarded to the tuple parsing function.  If
+        `with_namespace` is enabled, a namespace assignment may be parsed.
+        """
+        target: nodes.Expr
+
+        if with_namespace and self.stream.look().type == "dot":
+            token = self.stream.expect("name")
+            next(self.stream)  # dot
+            attr = self.stream.expect("name")
+            target = nodes.NSRef(token.value, attr.value, lineno=token.lineno)
+        elif name_only:
+            token = self.stream.expect("name")
+            target = nodes.Name(token.value, "store", lineno=token.lineno)
+        else:
+            if with_tuple:
+                target = self.parse_tuple(
+                    simplified=True, extra_end_rules=extra_end_rules
+                )
+            else:
+                target = self.parse_primary()
+
+            target.set_ctx("store")
+
+        if not target.can_assign():
+            self.fail(
+                f"can't assign to {type(target).__name__.lower()!r}", target.lineno
+            )
+
+        return target  # type: ignore
+
+    def parse_expression(self, with_condexpr: bool = True) -> nodes.Expr:
+        """Parse an expression.  Per default all expressions are parsed, if
+        the optional `with_condexpr` parameter is set to `False` conditional
+        expressions are not parsed.
+        """
+        if with_condexpr:
+            return self.parse_condexpr()
+        return self.parse_or()
+
+    def parse_condexpr(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        expr1 = self.parse_or()
+        expr3: t.Optional[nodes.Expr]
+
+        while self.stream.skip_if("name:if"):
+            expr2 = self.parse_or()
+            if self.stream.skip_if("name:else"):
+                expr3 = self.parse_condexpr()
+            else:
+                expr3 = None
+            expr1 = nodes.CondExpr(expr2, expr1, expr3, lineno=lineno)
+            lineno = self.stream.current.lineno
+        return expr1
+
+    def parse_or(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        left = self.parse_and()
+        while self.stream.skip_if("name:or"):
+            right = self.parse_and()
+            left = nodes.Or(left, right, lineno=lineno)
+            lineno = self.stream.current.lineno
+        return left
+
+    def parse_and(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        left = self.parse_not()
+        while self.stream.skip_if("name:and"):
+            right = self.parse_not()
+            left = nodes.And(left, right, lineno=lineno)
+            lineno = self.stream.current.lineno
+        return left
+
+    def parse_not(self) -> nodes.Expr:
+        if self.stream.current.test("name:not"):
+            lineno = next(self.stream).lineno
+            return nodes.Not(self.parse_not(), lineno=lineno)
+        return self.parse_compare()
+
+    def parse_compare(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        expr = self.parse_math1()
+        ops = []
+        while True:
+            token_type = self.stream.current.type
+            if token_type in _compare_operators:
+                next(self.stream)
+                ops.append(nodes.Operand(token_type, self.parse_math1()))
+            elif self.stream.skip_if("name:in"):
+                ops.append(nodes.Operand("in", self.parse_math1()))
+            elif self.stream.current.test("name:not") and self.stream.look().test(
+                "name:in"
+            ):
+                self.stream.skip(2)
+                ops.append(nodes.Operand("notin", self.parse_math1()))
+            else:
+                break
+            lineno = self.stream.current.lineno
+        if not ops:
+            return expr
+        return nodes.Compare(expr, ops, lineno=lineno)
+
+    def parse_math1(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        left = self.parse_concat()
+        while self.stream.current.type in ("add", "sub"):
+            cls = _math_nodes[self.stream.current.type]
+            next(self.stream)
+            right = self.parse_concat()
+            left = cls(left, right, lineno=lineno)
+            lineno = self.stream.current.lineno
+        return left
+
+    def parse_concat(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        args = [self.parse_math2()]
+        while self.stream.current.type == "tilde":
+            next(self.stream)
+            args.append(self.parse_math2())
+        if len(args) == 1:
+            return args[0]
+        return nodes.Concat(args, lineno=lineno)
+
+    def parse_math2(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        left = self.parse_pow()
+        while self.stream.current.type in ("mul", "div", "floordiv", "mod"):
+            cls = _math_nodes[self.stream.current.type]
+            next(self.stream)
+            right = self.parse_pow()
+            left = cls(left, right, lineno=lineno)
+            lineno = self.stream.current.lineno
+        return left
+
+    def parse_pow(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        left = self.parse_unary()
+        while self.stream.current.type == "pow":
+            next(self.stream)
+            right = self.parse_unary()
+            left = nodes.Pow(left, right, lineno=lineno)
+            lineno = self.stream.current.lineno
+        return left
+
+    def parse_unary(self, with_filter: bool = True) -> nodes.Expr:
+        token_type = self.stream.current.type
+        lineno = self.stream.current.lineno
+        node: nodes.Expr
+
+        if token_type == "sub":
+            next(self.stream)
+            node = nodes.Neg(self.parse_unary(False), lineno=lineno)
+        elif token_type == "add":
+            next(self.stream)
+            node = nodes.Pos(self.parse_unary(False), lineno=lineno)
+        else:
+            node = self.parse_primary()
+        node = self.parse_postfix(node)
+        if with_filter:
+            node = self.parse_filter_expr(node)
+        return node
+
+    def parse_primary(self) -> nodes.Expr:
+        token = self.stream.current
+        node: nodes.Expr
+        if token.type == "name":
+            if token.value in ("true", "false", "True", "False"):
+                node = nodes.Const(token.value in ("true", "True"), lineno=token.lineno)
+            elif token.value in ("none", "None"):
+                node = nodes.Const(None, lineno=token.lineno)
+            else:
+                node = nodes.Name(token.value, "load", lineno=token.lineno)
+            next(self.stream)
+        elif token.type == "string":
+            next(self.stream)
+            buf = [token.value]
+            lineno = token.lineno
+            while self.stream.current.type == "string":
+                buf.append(self.stream.current.value)
+                next(self.stream)
+            node = nodes.Const("".join(buf), lineno=lineno)
+        elif token.type in ("integer", "float"):
+            next(self.stream)
+            node = nodes.Const(token.value, lineno=token.lineno)
+        elif token.type == "lparen":
+            next(self.stream)
+            node = self.parse_tuple(explicit_parentheses=True)
+            self.stream.expect("rparen")
+        elif token.type == "lbracket":
+            node = self.parse_list()
+        elif token.type == "lbrace":
+            node = self.parse_dict()
+        else:
+            self.fail(f"unexpected {describe_token(token)!r}", token.lineno)
+        return node
+
+    def parse_tuple(
+        self,
+        simplified: bool = False,
+        with_condexpr: bool = True,
+        extra_end_rules: t.Optional[t.Tuple[str, ...]] = None,
+        explicit_parentheses: bool = False,
+    ) -> t.Union[nodes.Tuple, nodes.Expr]:
+        """Works like `parse_expression` but if multiple expressions are
+        delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
+        This method could also return a regular expression instead of a tuple
+        if no commas where found.
+
+        The default parsing mode is a full tuple.  If `simplified` is `True`
+        only names and literals are parsed.  The `no_condexpr` parameter is
+        forwarded to :meth:`parse_expression`.
+
+        Because tuples do not require delimiters and may end in a bogus comma
+        an extra hint is needed that marks the end of a tuple.  For example
+        for loops support tuples between `for` and `in`.  In that case the
+        `extra_end_rules` is set to ``['name:in']``.
+
+        `explicit_parentheses` is true if the parsing was triggered by an
+        expression in parentheses.  This is used to figure out if an empty
+        tuple is a valid expression or not.
+        """
+        lineno = self.stream.current.lineno
+        if simplified:
+            parse = self.parse_primary
+        elif with_condexpr:
+            parse = self.parse_expression
+        else:
+
+            def parse() -> nodes.Expr:
+                return self.parse_expression(with_condexpr=False)
+
+        args: t.List[nodes.Expr] = []
+        is_tuple = False
+
+        while True:
+            if args:
+                self.stream.expect("comma")
+            if self.is_tuple_end(extra_end_rules):
+                break
+            args.append(parse())
+            if self.stream.current.type == "comma":
+                is_tuple = True
+            else:
+                break
+            lineno = self.stream.current.lineno
+
+        if not is_tuple:
+            if args:
+                return args[0]
+
+            # if we don't have explicit parentheses, an empty tuple is
+            # not a valid expression.  This would mean nothing (literally
+            # nothing) in the spot of an expression would be an empty
+            # tuple.
+            if not explicit_parentheses:
+                self.fail(
+                    "Expected an expression,"
+                    f" got {describe_token(self.stream.current)!r}"
+                )
+
+        return nodes.Tuple(args, "load", lineno=lineno)
+
+    def parse_list(self) -> nodes.List:
+        token = self.stream.expect("lbracket")
+        items: t.List[nodes.Expr] = []
+        while self.stream.current.type != "rbracket":
+            if items:
+                self.stream.expect("comma")
+            if self.stream.current.type == "rbracket":
+                break
+            items.append(self.parse_expression())
+        self.stream.expect("rbracket")
+        return nodes.List(items, lineno=token.lineno)
+
+    def parse_dict(self) -> nodes.Dict:
+        token = self.stream.expect("lbrace")
+        items: t.List[nodes.Pair] = []
+        while self.stream.current.type != "rbrace":
+            if items:
+                self.stream.expect("comma")
+            if self.stream.current.type == "rbrace":
+                break
+            key = self.parse_expression()
+            self.stream.expect("colon")
+            value = self.parse_expression()
+            items.append(nodes.Pair(key, value, lineno=key.lineno))
+        self.stream.expect("rbrace")
+        return nodes.Dict(items, lineno=token.lineno)
+
+    def parse_postfix(self, node: nodes.Expr) -> nodes.Expr:
+        while True:
+            token_type = self.stream.current.type
+            if token_type == "dot" or token_type == "lbracket":
+                node = self.parse_subscript(node)
+            # calls are valid both after postfix expressions (getattr
+            # and getitem) as well as filters and tests
+            elif token_type == "lparen":
+                node = self.parse_call(node)
+            else:
+                break
+        return node
+
+    def parse_filter_expr(self, node: nodes.Expr) -> nodes.Expr:
+        while True:
+            token_type = self.stream.current.type
+            if token_type == "pipe":
+                node = self.parse_filter(node)  # type: ignore
+            elif token_type == "name" and self.stream.current.value == "is":
+                node = self.parse_test(node)
+            # calls are valid both after postfix expressions (getattr
+            # and getitem) as well as filters and tests
+            elif token_type == "lparen":
+                node = self.parse_call(node)
+            else:
+                break
+        return node
+
+    def parse_subscript(
+        self, node: nodes.Expr
+    ) -> t.Union[nodes.Getattr, nodes.Getitem]:
+        token = next(self.stream)
+        arg: nodes.Expr
+
+        if token.type == "dot":
+            attr_token = self.stream.current
+            next(self.stream)
+            if attr_token.type == "name":
+                return nodes.Getattr(
+                    node, attr_token.value, "load", lineno=token.lineno
+                )
+            elif attr_token.type != "integer":
+                self.fail("expected name or number", attr_token.lineno)
+            arg = nodes.Const(attr_token.value, lineno=attr_token.lineno)
+            return nodes.Getitem(node, arg, "load", lineno=token.lineno)
+        if token.type == "lbracket":
+            args: t.List[nodes.Expr] = []
+            while self.stream.current.type != "rbracket":
+                if args:
+                    self.stream.expect("comma")
+                args.append(self.parse_subscribed())
+            self.stream.expect("rbracket")
+            if len(args) == 1:
+                arg = args[0]
+            else:
+                arg = nodes.Tuple(args, "load", lineno=token.lineno)
+            return nodes.Getitem(node, arg, "load", lineno=token.lineno)
+        self.fail("expected subscript expression", token.lineno)
+
+    def parse_subscribed(self) -> nodes.Expr:
+        lineno = self.stream.current.lineno
+        args: t.List[t.Optional[nodes.Expr]]
+
+        if self.stream.current.type == "colon":
+            next(self.stream)
+            args = [None]
+        else:
+            node = self.parse_expression()
+            if self.stream.current.type != "colon":
+                return node
+            next(self.stream)
+            args = [node]
+
+        if self.stream.current.type == "colon":
+            args.append(None)
+        elif self.stream.current.type not in ("rbracket", "comma"):
+            args.append(self.parse_expression())
+        else:
+            args.append(None)
+
+        if self.stream.current.type == "colon":
+            next(self.stream)
+            if self.stream.current.type not in ("rbracket", "comma"):
+                args.append(self.parse_expression())
+            else:
+                args.append(None)
+        else:
+            args.append(None)
+
+        return nodes.Slice(lineno=lineno, *args)
+
+    def parse_call_args(self) -> t.Tuple:
+        token = self.stream.expect("lparen")
+        args = []
+        kwargs = []
+        dyn_args = None
+        dyn_kwargs = None
+        require_comma = False
+
+        def ensure(expr: bool) -> None:
+            if not expr:
+                self.fail("invalid syntax for function call expression", token.lineno)
+
+        while self.stream.current.type != "rparen":
+            if require_comma:
+                self.stream.expect("comma")
+
+                # support for trailing comma
+                if self.stream.current.type == "rparen":
+                    break
+
+            if self.stream.current.type == "mul":
+                ensure(dyn_args is None and dyn_kwargs is None)
+                next(self.stream)
+                dyn_args = self.parse_expression()
+            elif self.stream.current.type == "pow":
+                ensure(dyn_kwargs is None)
+                next(self.stream)
+                dyn_kwargs = self.parse_expression()
+            else:
+                if (
+                    self.stream.current.type == "name"
+                    and self.stream.look().type == "assign"
+                ):
+                    # Parsing a kwarg
+                    ensure(dyn_kwargs is None)
+                    key = self.stream.current.value
+                    self.stream.skip(2)
+                    value = self.parse_expression()
+                    kwargs.append(nodes.Keyword(key, value, lineno=value.lineno))
+                else:
+                    # Parsing an arg
+                    ensure(dyn_args is None and dyn_kwargs is None and not kwargs)
+                    args.append(self.parse_expression())
+
+            require_comma = True
+
+        self.stream.expect("rparen")
+        return args, kwargs, dyn_args, dyn_kwargs
+
+    def parse_call(self, node: nodes.Expr) -> nodes.Call:
+        # The lparen will be expected in parse_call_args, but the lineno
+        # needs to be recorded before the stream is advanced.
+        token = self.stream.current
+        args, kwargs, dyn_args, dyn_kwargs = self.parse_call_args()
+        return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno)
+
+    def parse_filter(
+        self, node: t.Optional[nodes.Expr], start_inline: bool = False
+    ) -> t.Optional[nodes.Expr]:
+        while self.stream.current.type == "pipe" or start_inline:
+            if not start_inline:
+                next(self.stream)
+            token = self.stream.expect("name")
+            name = token.value
+            while self.stream.current.type == "dot":
+                next(self.stream)
+                name += "." + self.stream.expect("name").value
+            if self.stream.current.type == "lparen":
+                args, kwargs, dyn_args, dyn_kwargs = self.parse_call_args()
+            else:
+                args = []
+                kwargs = []
+                dyn_args = dyn_kwargs = None
+            node = nodes.Filter(
+                node, name, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno
+            )
+            start_inline = False
+        return node
+
+    def parse_test(self, node: nodes.Expr) -> nodes.Expr:
+        token = next(self.stream)
+        if self.stream.current.test("name:not"):
+            next(self.stream)
+            negated = True
+        else:
+            negated = False
+        name = self.stream.expect("name").value
+        while self.stream.current.type == "dot":
+            next(self.stream)
+            name += "." + self.stream.expect("name").value
+        dyn_args = dyn_kwargs = None
+        kwargs = []
+        if self.stream.current.type == "lparen":
+            args, kwargs, dyn_args, dyn_kwargs = self.parse_call_args()
+        elif self.stream.current.type in {
+            "name",
+            "string",
+            "integer",
+            "float",
+            "lparen",
+            "lbracket",
+            "lbrace",
+        } and not self.stream.current.test_any("name:else", "name:or", "name:and"):
+            if self.stream.current.test("name:is"):
+                self.fail("You cannot chain multiple tests with is")
+            arg_node = self.parse_primary()
+            arg_node = self.parse_postfix(arg_node)
+            args = [arg_node]
+        else:
+            args = []
+        node = nodes.Test(
+            node, name, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno
+        )
+        if negated:
+            node = nodes.Not(node, lineno=token.lineno)
+        return node
+
+    def subparse(
+        self, end_tokens: t.Optional[t.Tuple[str, ...]] = None
+    ) -> t.List[nodes.Node]:
+        body: t.List[nodes.Node] = []
+        data_buffer: t.List[nodes.Node] = []
+        add_data = data_buffer.append
+
+        if end_tokens is not None:
+            self._end_token_stack.append(end_tokens)
+
+        def flush_data() -> None:
+            if data_buffer:
+                lineno = data_buffer[0].lineno
+                body.append(nodes.Output(data_buffer[:], lineno=lineno))
+                del data_buffer[:]
+
+        try:
+            while self.stream:
+                token = self.stream.current
+                if token.type == "data":
+                    if token.value:
+                        add_data(nodes.TemplateData(token.value, lineno=token.lineno))
+                    next(self.stream)
+                elif token.type == "variable_begin":
+                    next(self.stream)
+                    add_data(self.parse_tuple(with_condexpr=True))
+                    self.stream.expect("variable_end")
+                elif token.type == "block_begin":
+                    flush_data()
+                    next(self.stream)
+                    if end_tokens is not None and self.stream.current.test_any(
+                        *end_tokens
+                    ):
+                        return body
+                    rv = self.parse_statement()
+                    if isinstance(rv, list):
+                        body.extend(rv)
+                    else:
+                        body.append(rv)
+                    self.stream.expect("block_end")
+                else:
+                    raise AssertionError("internal parsing error")
+
+            flush_data()
+        finally:
+            if end_tokens is not None:
+                self._end_token_stack.pop()
+        return body
+
+    def parse(self) -> nodes.Template:
+        """Parse the whole template into a `Template` node."""
+        result = nodes.Template(self.subparse(), lineno=1)
+        result.set_environment(self.environment)
+        return result
diff --git a/lib/python3.11/site-packages/jinja2/py.typed b/lib/python3.11/site-packages/jinja2/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/jinja2/runtime.py b/lib/python3.11/site-packages/jinja2/runtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..985842b284270bcd52855029f13d3da19d718349
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/runtime.py
@@ -0,0 +1,1053 @@
+"""The runtime functions and state used by compiled templates."""
+import functools
+import sys
+import typing as t
+from collections import abc
+from itertools import chain
+
+from markupsafe import escape  # noqa: F401
+from markupsafe import Markup
+from markupsafe import soft_str
+
+from .async_utils import auto_aiter
+from .async_utils import auto_await  # noqa: F401
+from .exceptions import TemplateNotFound  # noqa: F401
+from .exceptions import TemplateRuntimeError  # noqa: F401
+from .exceptions import UndefinedError
+from .nodes import EvalContext
+from .utils import _PassArg
+from .utils import concat
+from .utils import internalcode
+from .utils import missing
+from .utils import Namespace  # noqa: F401
+from .utils import object_type_repr
+from .utils import pass_eval_context
+
+V = t.TypeVar("V")
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+
+if t.TYPE_CHECKING:
+    import logging
+    import typing_extensions as te
+    from .environment import Environment
+
+    class LoopRenderFunc(te.Protocol):
+        def __call__(
+            self,
+            reciter: t.Iterable[V],
+            loop_render_func: "LoopRenderFunc",
+            depth: int = 0,
+        ) -> str:
+            ...
+
+
+# these variables are exported to the template runtime
+exported = [
+    "LoopContext",
+    "TemplateReference",
+    "Macro",
+    "Markup",
+    "TemplateRuntimeError",
+    "missing",
+    "escape",
+    "markup_join",
+    "str_join",
+    "identity",
+    "TemplateNotFound",
+    "Namespace",
+    "Undefined",
+    "internalcode",
+]
+async_exported = [
+    "AsyncLoopContext",
+    "auto_aiter",
+    "auto_await",
+]
+
+
+def identity(x: V) -> V:
+    """Returns its argument. Useful for certain things in the
+    environment.
+    """
+    return x
+
+
+def markup_join(seq: t.Iterable[t.Any]) -> str:
+    """Concatenation that escapes if necessary and converts to string."""
+    buf = []
+    iterator = map(soft_str, seq)
+    for arg in iterator:
+        buf.append(arg)
+        if hasattr(arg, "__html__"):
+            return Markup("").join(chain(buf, iterator))
+    return concat(buf)
+
+
+def str_join(seq: t.Iterable[t.Any]) -> str:
+    """Simple args to string conversion and concatenation."""
+    return concat(map(str, seq))
+
+
+def new_context(
+    environment: "Environment",
+    template_name: t.Optional[str],
+    blocks: t.Dict[str, t.Callable[["Context"], t.Iterator[str]]],
+    vars: t.Optional[t.Dict[str, t.Any]] = None,
+    shared: bool = False,
+    globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    locals: t.Optional[t.Mapping[str, t.Any]] = None,
+) -> "Context":
+    """Internal helper for context creation."""
+    if vars is None:
+        vars = {}
+    if shared:
+        parent = vars
+    else:
+        parent = dict(globals or (), **vars)
+    if locals:
+        # if the parent is shared a copy should be created because
+        # we don't want to modify the dict passed
+        if shared:
+            parent = dict(parent)
+        for key, value in locals.items():
+            if value is not missing:
+                parent[key] = value
+    return environment.context_class(
+        environment, parent, template_name, blocks, globals=globals
+    )
+
+
+class TemplateReference:
+    """The `self` in templates."""
+
+    def __init__(self, context: "Context") -> None:
+        self.__context = context
+
+    def __getitem__(self, name: str) -> t.Any:
+        blocks = self.__context.blocks[name]
+        return BlockReference(name, self.__context, blocks, 0)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.__context.name!r}>"
+
+
+def _dict_method_all(dict_method: F) -> F:
+    @functools.wraps(dict_method)
+    def f_all(self: "Context") -> t.Any:
+        return dict_method(self.get_all())
+
+    return t.cast(F, f_all)
+
+
+@abc.Mapping.register
+class Context:
+    """The template context holds the variables of a template.  It stores the
+    values passed to the template and also the names the template exports.
+    Creating instances is neither supported nor useful as it's created
+    automatically at various stages of the template evaluation and should not
+    be created by hand.
+
+    The context is immutable.  Modifications on :attr:`parent` **must not**
+    happen and modifications on :attr:`vars` are allowed from generated
+    template code only.  Template filters and global functions marked as
+    :func:`pass_context` get the active context passed as first argument
+    and are allowed to access the context read-only.
+
+    The template context supports read only dict operations (`get`,
+    `keys`, `values`, `items`, `iterkeys`, `itervalues`, `iteritems`,
+    `__getitem__`, `__contains__`).  Additionally there is a :meth:`resolve`
+    method that doesn't fail with a `KeyError` but returns an
+    :class:`Undefined` object for missing variables.
+    """
+
+    def __init__(
+        self,
+        environment: "Environment",
+        parent: t.Dict[str, t.Any],
+        name: t.Optional[str],
+        blocks: t.Dict[str, t.Callable[["Context"], t.Iterator[str]]],
+        globals: t.Optional[t.MutableMapping[str, t.Any]] = None,
+    ):
+        self.parent = parent
+        self.vars: t.Dict[str, t.Any] = {}
+        self.environment: "Environment" = environment
+        self.eval_ctx = EvalContext(self.environment, name)
+        self.exported_vars: t.Set[str] = set()
+        self.name = name
+        self.globals_keys = set() if globals is None else set(globals)
+
+        # create the initial mapping of blocks.  Whenever template inheritance
+        # takes place the runtime will update this mapping with the new blocks
+        # from the template.
+        self.blocks = {k: [v] for k, v in blocks.items()}
+
+    def super(
+        self, name: str, current: t.Callable[["Context"], t.Iterator[str]]
+    ) -> t.Union["BlockReference", "Undefined"]:
+        """Render a parent block."""
+        try:
+            blocks = self.blocks[name]
+            index = blocks.index(current) + 1
+            blocks[index]
+        except LookupError:
+            return self.environment.undefined(
+                f"there is no parent block called {name!r}.", name="super"
+            )
+        return BlockReference(name, self, blocks, index)
+
+    def get(self, key: str, default: t.Any = None) -> t.Any:
+        """Look up a variable by name, or return a default if the key is
+        not found.
+
+        :param key: The variable name to look up.
+        :param default: The value to return if the key is not found.
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def resolve(self, key: str) -> t.Union[t.Any, "Undefined"]:
+        """Look up a variable by name, or return an :class:`Undefined`
+        object if the key is not found.
+
+        If you need to add custom behavior, override
+        :meth:`resolve_or_missing`, not this method. The various lookup
+        functions use that method, not this one.
+
+        :param key: The variable name to look up.
+        """
+        rv = self.resolve_or_missing(key)
+
+        if rv is missing:
+            return self.environment.undefined(name=key)
+
+        return rv
+
+    def resolve_or_missing(self, key: str) -> t.Any:
+        """Look up a variable by name, or return a ``missing`` sentinel
+        if the key is not found.
+
+        Override this method to add custom lookup behavior.
+        :meth:`resolve`, :meth:`get`, and :meth:`__getitem__` use this
+        method. Don't call this method directly.
+
+        :param key: The variable name to look up.
+        """
+        if key in self.vars:
+            return self.vars[key]
+
+        if key in self.parent:
+            return self.parent[key]
+
+        return missing
+
+    def get_exported(self) -> t.Dict[str, t.Any]:
+        """Get a new dict with the exported variables."""
+        return {k: self.vars[k] for k in self.exported_vars}
+
+    def get_all(self) -> t.Dict[str, t.Any]:
+        """Return the complete context as dict including the exported
+        variables.  For optimizations reasons this might not return an
+        actual copy so be careful with using it.
+        """
+        if not self.vars:
+            return self.parent
+        if not self.parent:
+            return self.vars
+        return dict(self.parent, **self.vars)
+
+    @internalcode
+    def call(
+        __self, __obj: t.Callable, *args: t.Any, **kwargs: t.Any  # noqa: B902
+    ) -> t.Union[t.Any, "Undefined"]:
+        """Call the callable with the arguments and keyword arguments
+        provided but inject the active context or environment as first
+        argument if the callable has :func:`pass_context` or
+        :func:`pass_environment`.
+        """
+        if __debug__:
+            __traceback_hide__ = True  # noqa
+
+        # Allow callable classes to take a context
+        if (
+            hasattr(__obj, "__call__")  # noqa: B004
+            and _PassArg.from_obj(__obj.__call__) is not None  # type: ignore
+        ):
+            __obj = __obj.__call__  # type: ignore
+
+        pass_arg = _PassArg.from_obj(__obj)
+
+        if pass_arg is _PassArg.context:
+            # the active context should have access to variables set in
+            # loops and blocks without mutating the context itself
+            if kwargs.get("_loop_vars"):
+                __self = __self.derived(kwargs["_loop_vars"])
+            if kwargs.get("_block_vars"):
+                __self = __self.derived(kwargs["_block_vars"])
+            args = (__self,) + args
+        elif pass_arg is _PassArg.eval_context:
+            args = (__self.eval_ctx,) + args
+        elif pass_arg is _PassArg.environment:
+            args = (__self.environment,) + args
+
+        kwargs.pop("_block_vars", None)
+        kwargs.pop("_loop_vars", None)
+
+        try:
+            return __obj(*args, **kwargs)
+        except StopIteration:
+            return __self.environment.undefined(
+                "value was undefined because a callable raised a"
+                " StopIteration exception"
+            )
+
+    def derived(self, locals: t.Optional[t.Dict[str, t.Any]] = None) -> "Context":
+        """Internal helper function to create a derived context.  This is
+        used in situations where the system needs a new context in the same
+        template that is independent.
+        """
+        context = new_context(
+            self.environment, self.name, {}, self.get_all(), True, None, locals
+        )
+        context.eval_ctx = self.eval_ctx
+        context.blocks.update((k, list(v)) for k, v in self.blocks.items())
+        return context
+
+    keys = _dict_method_all(dict.keys)
+    values = _dict_method_all(dict.values)
+    items = _dict_method_all(dict.items)
+
+    def __contains__(self, name: str) -> bool:
+        return name in self.vars or name in self.parent
+
+    def __getitem__(self, key: str) -> t.Any:
+        """Look up a variable by name with ``[]`` syntax, or raise a
+        ``KeyError`` if the key is not found.
+        """
+        item = self.resolve_or_missing(key)
+
+        if item is missing:
+            raise KeyError(key)
+
+        return item
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.get_all()!r} of {self.name!r}>"
+
+
+class BlockReference:
+    """One block on a template reference."""
+
+    def __init__(
+        self,
+        name: str,
+        context: "Context",
+        stack: t.List[t.Callable[["Context"], t.Iterator[str]]],
+        depth: int,
+    ) -> None:
+        self.name = name
+        self._context = context
+        self._stack = stack
+        self._depth = depth
+
+    @property
+    def super(self) -> t.Union["BlockReference", "Undefined"]:
+        """Super the block."""
+        if self._depth + 1 >= len(self._stack):
+            return self._context.environment.undefined(
+                f"there is no parent block called {self.name!r}.", name="super"
+            )
+        return BlockReference(self.name, self._context, self._stack, self._depth + 1)
+
+    @internalcode
+    async def _async_call(self) -> str:
+        rv = concat(
+            [x async for x in self._stack[self._depth](self._context)]  # type: ignore
+        )
+
+        if self._context.eval_ctx.autoescape:
+            return Markup(rv)
+
+        return rv
+
+    @internalcode
+    def __call__(self) -> str:
+        if self._context.environment.is_async:
+            return self._async_call()  # type: ignore
+
+        rv = concat(self._stack[self._depth](self._context))
+
+        if self._context.eval_ctx.autoescape:
+            return Markup(rv)
+
+        return rv
+
+
+class LoopContext:
+    """A wrapper iterable for dynamic ``for`` loops, with information
+    about the loop and iteration.
+    """
+
+    #: Current iteration of the loop, starting at 0.
+    index0 = -1
+
+    _length: t.Optional[int] = None
+    _after: t.Any = missing
+    _current: t.Any = missing
+    _before: t.Any = missing
+    _last_changed_value: t.Any = missing
+
+    def __init__(
+        self,
+        iterable: t.Iterable[V],
+        undefined: t.Type["Undefined"],
+        recurse: t.Optional["LoopRenderFunc"] = None,
+        depth0: int = 0,
+    ) -> None:
+        """
+        :param iterable: Iterable to wrap.
+        :param undefined: :class:`Undefined` class to use for next and
+            previous items.
+        :param recurse: The function to render the loop body when the
+            loop is marked recursive.
+        :param depth0: Incremented when looping recursively.
+        """
+        self._iterable = iterable
+        self._iterator = self._to_iterator(iterable)
+        self._undefined = undefined
+        self._recurse = recurse
+        #: How many levels deep a recursive loop currently is, starting at 0.
+        self.depth0 = depth0
+
+    @staticmethod
+    def _to_iterator(iterable: t.Iterable[V]) -> t.Iterator[V]:
+        return iter(iterable)
+
+    @property
+    def length(self) -> int:
+        """Length of the iterable.
+
+        If the iterable is a generator or otherwise does not have a
+        size, it is eagerly evaluated to get a size.
+        """
+        if self._length is not None:
+            return self._length
+
+        try:
+            self._length = len(self._iterable)  # type: ignore
+        except TypeError:
+            iterable = list(self._iterator)
+            self._iterator = self._to_iterator(iterable)
+            self._length = len(iterable) + self.index + (self._after is not missing)
+
+        return self._length
+
+    def __len__(self) -> int:
+        return self.length
+
+    @property
+    def depth(self) -> int:
+        """How many levels deep a recursive loop currently is, starting at 1."""
+        return self.depth0 + 1
+
+    @property
+    def index(self) -> int:
+        """Current iteration of the loop, starting at 1."""
+        return self.index0 + 1
+
+    @property
+    def revindex0(self) -> int:
+        """Number of iterations from the end of the loop, ending at 0.
+
+        Requires calculating :attr:`length`.
+        """
+        return self.length - self.index
+
+    @property
+    def revindex(self) -> int:
+        """Number of iterations from the end of the loop, ending at 1.
+
+        Requires calculating :attr:`length`.
+        """
+        return self.length - self.index0
+
+    @property
+    def first(self) -> bool:
+        """Whether this is the first iteration of the loop."""
+        return self.index0 == 0
+
+    def _peek_next(self) -> t.Any:
+        """Return the next element in the iterable, or :data:`missing`
+        if the iterable is exhausted. Only peeks one item ahead, caching
+        the result in :attr:`_last` for use in subsequent checks. The
+        cache is reset when :meth:`__next__` is called.
+        """
+        if self._after is not missing:
+            return self._after
+
+        self._after = next(self._iterator, missing)
+        return self._after
+
+    @property
+    def last(self) -> bool:
+        """Whether this is the last iteration of the loop.
+
+        Causes the iterable to advance early. See
+        :func:`itertools.groupby` for issues this can cause.
+        The :func:`groupby` filter avoids that issue.
+        """
+        return self._peek_next() is missing
+
+    @property
+    def previtem(self) -> t.Union[t.Any, "Undefined"]:
+        """The item in the previous iteration. Undefined during the
+        first iteration.
+        """
+        if self.first:
+            return self._undefined("there is no previous item")
+
+        return self._before
+
+    @property
+    def nextitem(self) -> t.Union[t.Any, "Undefined"]:
+        """The item in the next iteration. Undefined during the last
+        iteration.
+
+        Causes the iterable to advance early. See
+        :func:`itertools.groupby` for issues this can cause.
+        The :func:`jinja-filters.groupby` filter avoids that issue.
+        """
+        rv = self._peek_next()
+
+        if rv is missing:
+            return self._undefined("there is no next item")
+
+        return rv
+
+    def cycle(self, *args: V) -> V:
+        """Return a value from the given args, cycling through based on
+        the current :attr:`index0`.
+
+        :param args: One or more values to cycle through.
+        """
+        if not args:
+            raise TypeError("no items for cycling given")
+
+        return args[self.index0 % len(args)]
+
+    def changed(self, *value: t.Any) -> bool:
+        """Return ``True`` if previously called with a different value
+        (including when called for the first time).
+
+        :param value: One or more values to compare to the last call.
+        """
+        if self._last_changed_value != value:
+            self._last_changed_value = value
+            return True
+
+        return False
+
+    def __iter__(self) -> "LoopContext":
+        return self
+
+    def __next__(self) -> t.Tuple[t.Any, "LoopContext"]:
+        if self._after is not missing:
+            rv = self._after
+            self._after = missing
+        else:
+            rv = next(self._iterator)
+
+        self.index0 += 1
+        self._before = self._current
+        self._current = rv
+        return rv, self
+
+    @internalcode
+    def __call__(self, iterable: t.Iterable[V]) -> str:
+        """When iterating over nested data, render the body of the loop
+        recursively with the given inner iterable data.
+
+        The loop must have the ``recursive`` marker for this to work.
+        """
+        if self._recurse is None:
+            raise TypeError(
+                "The loop must have the 'recursive' marker to be called recursively."
+            )
+
+        return self._recurse(iterable, self._recurse, depth=self.depth)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.index}/{self.length}>"
+
+
+class AsyncLoopContext(LoopContext):
+    _iterator: t.AsyncIterator[t.Any]  # type: ignore
+
+    @staticmethod
+    def _to_iterator(  # type: ignore
+        iterable: t.Union[t.Iterable[V], t.AsyncIterable[V]]
+    ) -> t.AsyncIterator[V]:
+        return auto_aiter(iterable)
+
+    @property
+    async def length(self) -> int:  # type: ignore
+        if self._length is not None:
+            return self._length
+
+        try:
+            self._length = len(self._iterable)  # type: ignore
+        except TypeError:
+            iterable = [x async for x in self._iterator]
+            self._iterator = self._to_iterator(iterable)
+            self._length = len(iterable) + self.index + (self._after is not missing)
+
+        return self._length
+
+    @property
+    async def revindex0(self) -> int:  # type: ignore
+        return await self.length - self.index
+
+    @property
+    async def revindex(self) -> int:  # type: ignore
+        return await self.length - self.index0
+
+    async def _peek_next(self) -> t.Any:
+        if self._after is not missing:
+            return self._after
+
+        try:
+            self._after = await self._iterator.__anext__()
+        except StopAsyncIteration:
+            self._after = missing
+
+        return self._after
+
+    @property
+    async def last(self) -> bool:  # type: ignore
+        return await self._peek_next() is missing
+
+    @property
+    async def nextitem(self) -> t.Union[t.Any, "Undefined"]:
+        rv = await self._peek_next()
+
+        if rv is missing:
+            return self._undefined("there is no next item")
+
+        return rv
+
+    def __aiter__(self) -> "AsyncLoopContext":
+        return self
+
+    async def __anext__(self) -> t.Tuple[t.Any, "AsyncLoopContext"]:
+        if self._after is not missing:
+            rv = self._after
+            self._after = missing
+        else:
+            rv = await self._iterator.__anext__()
+
+        self.index0 += 1
+        self._before = self._current
+        self._current = rv
+        return rv, self
+
+
+class Macro:
+    """Wraps a macro function."""
+
+    def __init__(
+        self,
+        environment: "Environment",
+        func: t.Callable[..., str],
+        name: str,
+        arguments: t.List[str],
+        catch_kwargs: bool,
+        catch_varargs: bool,
+        caller: bool,
+        default_autoescape: t.Optional[bool] = None,
+    ):
+        self._environment = environment
+        self._func = func
+        self._argument_count = len(arguments)
+        self.name = name
+        self.arguments = arguments
+        self.catch_kwargs = catch_kwargs
+        self.catch_varargs = catch_varargs
+        self.caller = caller
+        self.explicit_caller = "caller" in arguments
+
+        if default_autoescape is None:
+            if callable(environment.autoescape):
+                default_autoescape = environment.autoescape(None)
+            else:
+                default_autoescape = environment.autoescape
+
+        self._default_autoescape = default_autoescape
+
+    @internalcode
+    @pass_eval_context
+    def __call__(self, *args: t.Any, **kwargs: t.Any) -> str:
+        # This requires a bit of explanation,  In the past we used to
+        # decide largely based on compile-time information if a macro is
+        # safe or unsafe.  While there was a volatile mode it was largely
+        # unused for deciding on escaping.  This turns out to be
+        # problematic for macros because whether a macro is safe depends not
+        # on the escape mode when it was defined, but rather when it was used.
+        #
+        # Because however we export macros from the module system and
+        # there are historic callers that do not pass an eval context (and
+        # will continue to not pass one), we need to perform an instance
+        # check here.
+        #
+        # This is considered safe because an eval context is not a valid
+        # argument to callables otherwise anyway.  Worst case here is
+        # that if no eval context is passed we fall back to the compile
+        # time autoescape flag.
+        if args and isinstance(args[0], EvalContext):
+            autoescape = args[0].autoescape
+            args = args[1:]
+        else:
+            autoescape = self._default_autoescape
+
+        # try to consume the positional arguments
+        arguments = list(args[: self._argument_count])
+        off = len(arguments)
+
+        # For information why this is necessary refer to the handling
+        # of caller in the `macro_body` handler in the compiler.
+        found_caller = False
+
+        # if the number of arguments consumed is not the number of
+        # arguments expected we start filling in keyword arguments
+        # and defaults.
+        if off != self._argument_count:
+            for name in self.arguments[len(arguments) :]:
+                try:
+                    value = kwargs.pop(name)
+                except KeyError:
+                    value = missing
+                if name == "caller":
+                    found_caller = True
+                arguments.append(value)
+        else:
+            found_caller = self.explicit_caller
+
+        # it's important that the order of these arguments does not change
+        # if not also changed in the compiler's `function_scoping` method.
+        # the order is caller, keyword arguments, positional arguments!
+        if self.caller and not found_caller:
+            caller = kwargs.pop("caller", None)
+            if caller is None:
+                caller = self._environment.undefined("No caller defined", name="caller")
+            arguments.append(caller)
+
+        if self.catch_kwargs:
+            arguments.append(kwargs)
+        elif kwargs:
+            if "caller" in kwargs:
+                raise TypeError(
+                    f"macro {self.name!r} was invoked with two values for the special"
+                    " caller argument. This is most likely a bug."
+                )
+            raise TypeError(
+                f"macro {self.name!r} takes no keyword argument {next(iter(kwargs))!r}"
+            )
+        if self.catch_varargs:
+            arguments.append(args[self._argument_count :])
+        elif len(args) > self._argument_count:
+            raise TypeError(
+                f"macro {self.name!r} takes not more than"
+                f" {len(self.arguments)} argument(s)"
+            )
+
+        return self._invoke(arguments, autoescape)
+
+    async def _async_invoke(self, arguments: t.List[t.Any], autoescape: bool) -> str:
+        rv = await self._func(*arguments)  # type: ignore
+
+        if autoescape:
+            return Markup(rv)
+
+        return rv  # type: ignore
+
+    def _invoke(self, arguments: t.List[t.Any], autoescape: bool) -> str:
+        if self._environment.is_async:
+            return self._async_invoke(arguments, autoescape)  # type: ignore
+
+        rv = self._func(*arguments)
+
+        if autoescape:
+            rv = Markup(rv)
+
+        return rv
+
+    def __repr__(self) -> str:
+        name = "anonymous" if self.name is None else repr(self.name)
+        return f"<{type(self).__name__} {name}>"
+
+
+class Undefined:
+    """The default undefined type.  This undefined type can be printed and
+    iterated over, but every other access will raise an :exc:`UndefinedError`:
+
+    >>> foo = Undefined(name='foo')
+    >>> str(foo)
+    ''
+    >>> not foo
+    True
+    >>> foo + 42
+    Traceback (most recent call last):
+      ...
+    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    """
+
+    __slots__ = (
+        "_undefined_hint",
+        "_undefined_obj",
+        "_undefined_name",
+        "_undefined_exception",
+    )
+
+    def __init__(
+        self,
+        hint: t.Optional[str] = None,
+        obj: t.Any = missing,
+        name: t.Optional[str] = None,
+        exc: t.Type[TemplateRuntimeError] = UndefinedError,
+    ) -> None:
+        self._undefined_hint = hint
+        self._undefined_obj = obj
+        self._undefined_name = name
+        self._undefined_exception = exc
+
+    @property
+    def _undefined_message(self) -> str:
+        """Build a message about the undefined value based on how it was
+        accessed.
+        """
+        if self._undefined_hint:
+            return self._undefined_hint
+
+        if self._undefined_obj is missing:
+            return f"{self._undefined_name!r} is undefined"
+
+        if not isinstance(self._undefined_name, str):
+            return (
+                f"{object_type_repr(self._undefined_obj)} has no"
+                f" element {self._undefined_name!r}"
+            )
+
+        return (
+            f"{object_type_repr(self._undefined_obj)!r} has no"
+            f" attribute {self._undefined_name!r}"
+        )
+
+    @internalcode
+    def _fail_with_undefined_error(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> "te.NoReturn":
+        """Raise an :exc:`UndefinedError` when operations are performed
+        on the undefined value.
+        """
+        raise self._undefined_exception(self._undefined_message)
+
+    @internalcode
+    def __getattr__(self, name: str) -> t.Any:
+        if name[:2] == "__":
+            raise AttributeError(name)
+
+        return self._fail_with_undefined_error()
+
+    __add__ = __radd__ = __sub__ = __rsub__ = _fail_with_undefined_error
+    __mul__ = __rmul__ = __div__ = __rdiv__ = _fail_with_undefined_error
+    __truediv__ = __rtruediv__ = _fail_with_undefined_error
+    __floordiv__ = __rfloordiv__ = _fail_with_undefined_error
+    __mod__ = __rmod__ = _fail_with_undefined_error
+    __pos__ = __neg__ = _fail_with_undefined_error
+    __call__ = __getitem__ = _fail_with_undefined_error
+    __lt__ = __le__ = __gt__ = __ge__ = _fail_with_undefined_error
+    __int__ = __float__ = __complex__ = _fail_with_undefined_error
+    __pow__ = __rpow__ = _fail_with_undefined_error
+
+    def __eq__(self, other: t.Any) -> bool:
+        return type(self) is type(other)
+
+    def __ne__(self, other: t.Any) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return id(type(self))
+
+    def __str__(self) -> str:
+        return ""
+
+    def __len__(self) -> int:
+        return 0
+
+    def __iter__(self) -> t.Iterator[t.Any]:
+        yield from ()
+
+    async def __aiter__(self) -> t.AsyncIterator[t.Any]:
+        for _ in ():
+            yield
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __repr__(self) -> str:
+        return "Undefined"
+
+
+def make_logging_undefined(
+    logger: t.Optional["logging.Logger"] = None, base: t.Type[Undefined] = Undefined
+) -> t.Type[Undefined]:
+    """Given a logger object this returns a new undefined class that will
+    log certain failures.  It will log iterations and printing.  If no
+    logger is given a default logger is created.
+
+    Example::
+
+        logger = logging.getLogger(__name__)
+        LoggingUndefined = make_logging_undefined(
+            logger=logger,
+            base=Undefined
+        )
+
+    .. versionadded:: 2.8
+
+    :param logger: the logger to use.  If not provided, a default logger
+                   is created.
+    :param base: the base class to add logging functionality to.  This
+                 defaults to :class:`Undefined`.
+    """
+    if logger is None:
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.addHandler(logging.StreamHandler(sys.stderr))
+
+    def _log_message(undef: Undefined) -> None:
+        logger.warning(  # type: ignore
+            "Template variable warning: %s", undef._undefined_message
+        )
+
+    class LoggingUndefined(base):  # type: ignore
+        __slots__ = ()
+
+        def _fail_with_undefined_error(  # type: ignore
+            self, *args: t.Any, **kwargs: t.Any
+        ) -> "te.NoReturn":
+            try:
+                super()._fail_with_undefined_error(*args, **kwargs)
+            except self._undefined_exception as e:
+                logger.error("Template variable error: %s", e)  # type: ignore
+                raise e
+
+        def __str__(self) -> str:
+            _log_message(self)
+            return super().__str__()  # type: ignore
+
+        def __iter__(self) -> t.Iterator[t.Any]:
+            _log_message(self)
+            return super().__iter__()  # type: ignore
+
+        def __bool__(self) -> bool:
+            _log_message(self)
+            return super().__bool__()  # type: ignore
+
+    return LoggingUndefined
+
+
+class ChainableUndefined(Undefined):
+    """An undefined that is chainable, where both ``__getattr__`` and
+    ``__getitem__`` return itself rather than raising an
+    :exc:`UndefinedError`.
+
+    >>> foo = ChainableUndefined(name='foo')
+    >>> str(foo.bar['baz'])
+    ''
+    >>> foo.bar['baz'] + 42
+    Traceback (most recent call last):
+      ...
+    jinja2.exceptions.UndefinedError: 'foo' is undefined
+
+    .. versionadded:: 2.11.0
+    """
+
+    __slots__ = ()
+
+    def __html__(self) -> str:
+        return str(self)
+
+    def __getattr__(self, _: str) -> "ChainableUndefined":
+        return self
+
+    __getitem__ = __getattr__  # type: ignore
+
+
+class DebugUndefined(Undefined):
+    """An undefined that returns the debug info when printed.
+
+    >>> foo = DebugUndefined(name='foo')
+    >>> str(foo)
+    '{{ foo }}'
+    >>> not foo
+    True
+    >>> foo + 42
+    Traceback (most recent call last):
+      ...
+    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    """
+
+    __slots__ = ()
+
+    def __str__(self) -> str:
+        if self._undefined_hint:
+            message = f"undefined value printed: {self._undefined_hint}"
+
+        elif self._undefined_obj is missing:
+            message = self._undefined_name  # type: ignore
+
+        else:
+            message = (
+                f"no such element: {object_type_repr(self._undefined_obj)}"
+                f"[{self._undefined_name!r}]"
+            )
+
+        return f"{{{{ {message} }}}}"
+
+
+class StrictUndefined(Undefined):
+    """An undefined that barks on print and iteration as well as boolean
+    tests and all kinds of comparisons.  In other words: you can do nothing
+    with it except checking if it's defined using the `defined` test.
+
+    >>> foo = StrictUndefined(name='foo')
+    >>> str(foo)
+    Traceback (most recent call last):
+      ...
+    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    >>> not foo
+    Traceback (most recent call last):
+      ...
+    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    >>> foo + 42
+    Traceback (most recent call last):
+      ...
+    jinja2.exceptions.UndefinedError: 'foo' is undefined
+    """
+
+    __slots__ = ()
+    __iter__ = __str__ = __len__ = Undefined._fail_with_undefined_error
+    __eq__ = __ne__ = __bool__ = __hash__ = Undefined._fail_with_undefined_error
+    __contains__ = Undefined._fail_with_undefined_error
+
+
+# Remove slots attributes, after the metaclass is applied they are
+# unneeded and contain wrong data for subclasses.
+del (
+    Undefined.__slots__,
+    ChainableUndefined.__slots__,
+    DebugUndefined.__slots__,
+    StrictUndefined.__slots__,
+)
diff --git a/lib/python3.11/site-packages/jinja2/sandbox.py b/lib/python3.11/site-packages/jinja2/sandbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..06d74148eccea79d1f5a0ca2fb76ecc246f87d62
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/sandbox.py
@@ -0,0 +1,428 @@
+"""A sandbox layer that ensures unsafe operations cannot be performed.
+Useful when the template itself comes from an untrusted source.
+"""
+import operator
+import types
+import typing as t
+from _string import formatter_field_name_split  # type: ignore
+from collections import abc
+from collections import deque
+from string import Formatter
+
+from markupsafe import EscapeFormatter
+from markupsafe import Markup
+
+from .environment import Environment
+from .exceptions import SecurityError
+from .runtime import Context
+from .runtime import Undefined
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+
+#: maximum number of items a range may produce
+MAX_RANGE = 100000
+
+#: Unsafe function attributes.
+UNSAFE_FUNCTION_ATTRIBUTES: t.Set[str] = set()
+
+#: Unsafe method attributes. Function attributes are unsafe for methods too.
+UNSAFE_METHOD_ATTRIBUTES: t.Set[str] = set()
+
+#: unsafe generator attributes.
+UNSAFE_GENERATOR_ATTRIBUTES = {"gi_frame", "gi_code"}
+
+#: unsafe attributes on coroutines
+UNSAFE_COROUTINE_ATTRIBUTES = {"cr_frame", "cr_code"}
+
+#: unsafe attributes on async generators
+UNSAFE_ASYNC_GENERATOR_ATTRIBUTES = {"ag_code", "ag_frame"}
+
+_mutable_spec: t.Tuple[t.Tuple[t.Type, t.FrozenSet[str]], ...] = (
+    (
+        abc.MutableSet,
+        frozenset(
+            [
+                "add",
+                "clear",
+                "difference_update",
+                "discard",
+                "pop",
+                "remove",
+                "symmetric_difference_update",
+                "update",
+            ]
+        ),
+    ),
+    (
+        abc.MutableMapping,
+        frozenset(["clear", "pop", "popitem", "setdefault", "update"]),
+    ),
+    (
+        abc.MutableSequence,
+        frozenset(["append", "reverse", "insert", "sort", "extend", "remove"]),
+    ),
+    (
+        deque,
+        frozenset(
+            [
+                "append",
+                "appendleft",
+                "clear",
+                "extend",
+                "extendleft",
+                "pop",
+                "popleft",
+                "remove",
+                "rotate",
+            ]
+        ),
+    ),
+)
+
+
+def inspect_format_method(callable: t.Callable) -> t.Optional[str]:
+    if not isinstance(
+        callable, (types.MethodType, types.BuiltinMethodType)
+    ) or callable.__name__ not in ("format", "format_map"):
+        return None
+
+    obj = callable.__self__
+
+    if isinstance(obj, str):
+        return obj
+
+    return None
+
+
+def safe_range(*args: int) -> range:
+    """A range that can't generate ranges with a length of more than
+    MAX_RANGE items.
+    """
+    rng = range(*args)
+
+    if len(rng) > MAX_RANGE:
+        raise OverflowError(
+            "Range too big. The sandbox blocks ranges larger than"
+            f" MAX_RANGE ({MAX_RANGE})."
+        )
+
+    return rng
+
+
+def unsafe(f: F) -> F:
+    """Marks a function or method as unsafe.
+
+    .. code-block: python
+
+        @unsafe
+        def delete(self):
+            pass
+    """
+    f.unsafe_callable = True  # type: ignore
+    return f
+
+
+def is_internal_attribute(obj: t.Any, attr: str) -> bool:
+    """Test if the attribute given is an internal python attribute.  For
+    example this function returns `True` for the `func_code` attribute of
+    python objects.  This is useful if the environment method
+    :meth:`~SandboxedEnvironment.is_safe_attribute` is overridden.
+
+    >>> from jinja2.sandbox import is_internal_attribute
+    >>> is_internal_attribute(str, "mro")
+    True
+    >>> is_internal_attribute(str, "upper")
+    False
+    """
+    if isinstance(obj, types.FunctionType):
+        if attr in UNSAFE_FUNCTION_ATTRIBUTES:
+            return True
+    elif isinstance(obj, types.MethodType):
+        if attr in UNSAFE_FUNCTION_ATTRIBUTES or attr in UNSAFE_METHOD_ATTRIBUTES:
+            return True
+    elif isinstance(obj, type):
+        if attr == "mro":
+            return True
+    elif isinstance(obj, (types.CodeType, types.TracebackType, types.FrameType)):
+        return True
+    elif isinstance(obj, types.GeneratorType):
+        if attr in UNSAFE_GENERATOR_ATTRIBUTES:
+            return True
+    elif hasattr(types, "CoroutineType") and isinstance(obj, types.CoroutineType):
+        if attr in UNSAFE_COROUTINE_ATTRIBUTES:
+            return True
+    elif hasattr(types, "AsyncGeneratorType") and isinstance(
+        obj, types.AsyncGeneratorType
+    ):
+        if attr in UNSAFE_ASYNC_GENERATOR_ATTRIBUTES:
+            return True
+    return attr.startswith("__")
+
+
+def modifies_known_mutable(obj: t.Any, attr: str) -> bool:
+    """This function checks if an attribute on a builtin mutable object
+    (list, dict, set or deque) or the corresponding ABCs would modify it
+    if called.
+
+    >>> modifies_known_mutable({}, "clear")
+    True
+    >>> modifies_known_mutable({}, "keys")
+    False
+    >>> modifies_known_mutable([], "append")
+    True
+    >>> modifies_known_mutable([], "index")
+    False
+
+    If called with an unsupported object, ``False`` is returned.
+
+    >>> modifies_known_mutable("foo", "upper")
+    False
+    """
+    for typespec, unsafe in _mutable_spec:
+        if isinstance(obj, typespec):
+            return attr in unsafe
+    return False
+
+
+class SandboxedEnvironment(Environment):
+    """The sandboxed environment.  It works like the regular environment but
+    tells the compiler to generate sandboxed code.  Additionally subclasses of
+    this environment may override the methods that tell the runtime what
+    attributes or functions are safe to access.
+
+    If the template tries to access insecure code a :exc:`SecurityError` is
+    raised.  However also other exceptions may occur during the rendering so
+    the caller has to ensure that all exceptions are caught.
+    """
+
+    sandboxed = True
+
+    #: default callback table for the binary operators.  A copy of this is
+    #: available on each instance of a sandboxed environment as
+    #: :attr:`binop_table`
+    default_binop_table: t.Dict[str, t.Callable[[t.Any, t.Any], t.Any]] = {
+        "+": operator.add,
+        "-": operator.sub,
+        "*": operator.mul,
+        "/": operator.truediv,
+        "//": operator.floordiv,
+        "**": operator.pow,
+        "%": operator.mod,
+    }
+
+    #: default callback table for the unary operators.  A copy of this is
+    #: available on each instance of a sandboxed environment as
+    #: :attr:`unop_table`
+    default_unop_table: t.Dict[str, t.Callable[[t.Any], t.Any]] = {
+        "+": operator.pos,
+        "-": operator.neg,
+    }
+
+    #: a set of binary operators that should be intercepted.  Each operator
+    #: that is added to this set (empty by default) is delegated to the
+    #: :meth:`call_binop` method that will perform the operator.  The default
+    #: operator callback is specified by :attr:`binop_table`.
+    #:
+    #: The following binary operators are interceptable:
+    #: ``//``, ``%``, ``+``, ``*``, ``-``, ``/``, and ``**``
+    #:
+    #: The default operation form the operator table corresponds to the
+    #: builtin function.  Intercepted calls are always slower than the native
+    #: operator call, so make sure only to intercept the ones you are
+    #: interested in.
+    #:
+    #: .. versionadded:: 2.6
+    intercepted_binops: t.FrozenSet[str] = frozenset()
+
+    #: a set of unary operators that should be intercepted.  Each operator
+    #: that is added to this set (empty by default) is delegated to the
+    #: :meth:`call_unop` method that will perform the operator.  The default
+    #: operator callback is specified by :attr:`unop_table`.
+    #:
+    #: The following unary operators are interceptable: ``+``, ``-``
+    #:
+    #: The default operation form the operator table corresponds to the
+    #: builtin function.  Intercepted calls are always slower than the native
+    #: operator call, so make sure only to intercept the ones you are
+    #: interested in.
+    #:
+    #: .. versionadded:: 2.6
+    intercepted_unops: t.FrozenSet[str] = frozenset()
+
+    def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.globals["range"] = safe_range
+        self.binop_table = self.default_binop_table.copy()
+        self.unop_table = self.default_unop_table.copy()
+
+    def is_safe_attribute(self, obj: t.Any, attr: str, value: t.Any) -> bool:
+        """The sandboxed environment will call this method to check if the
+        attribute of an object is safe to access.  Per default all attributes
+        starting with an underscore are considered private as well as the
+        special attributes of internal python objects as returned by the
+        :func:`is_internal_attribute` function.
+        """
+        return not (attr.startswith("_") or is_internal_attribute(obj, attr))
+
+    def is_safe_callable(self, obj: t.Any) -> bool:
+        """Check if an object is safely callable. By default callables
+        are considered safe unless decorated with :func:`unsafe`.
+
+        This also recognizes the Django convention of setting
+        ``func.alters_data = True``.
+        """
+        return not (
+            getattr(obj, "unsafe_callable", False) or getattr(obj, "alters_data", False)
+        )
+
+    def call_binop(
+        self, context: Context, operator: str, left: t.Any, right: t.Any
+    ) -> t.Any:
+        """For intercepted binary operator calls (:meth:`intercepted_binops`)
+        this function is executed instead of the builtin operator.  This can
+        be used to fine tune the behavior of certain operators.
+
+        .. versionadded:: 2.6
+        """
+        return self.binop_table[operator](left, right)
+
+    def call_unop(self, context: Context, operator: str, arg: t.Any) -> t.Any:
+        """For intercepted unary operator calls (:meth:`intercepted_unops`)
+        this function is executed instead of the builtin operator.  This can
+        be used to fine tune the behavior of certain operators.
+
+        .. versionadded:: 2.6
+        """
+        return self.unop_table[operator](arg)
+
+    def getitem(
+        self, obj: t.Any, argument: t.Union[str, t.Any]
+    ) -> t.Union[t.Any, Undefined]:
+        """Subscribe an object from sandboxed code."""
+        try:
+            return obj[argument]
+        except (TypeError, LookupError):
+            if isinstance(argument, str):
+                try:
+                    attr = str(argument)
+                except Exception:
+                    pass
+                else:
+                    try:
+                        value = getattr(obj, attr)
+                    except AttributeError:
+                        pass
+                    else:
+                        if self.is_safe_attribute(obj, argument, value):
+                            return value
+                        return self.unsafe_undefined(obj, argument)
+        return self.undefined(obj=obj, name=argument)
+
+    def getattr(self, obj: t.Any, attribute: str) -> t.Union[t.Any, Undefined]:
+        """Subscribe an object from sandboxed code and prefer the
+        attribute.  The attribute passed *must* be a bytestring.
+        """
+        try:
+            value = getattr(obj, attribute)
+        except AttributeError:
+            try:
+                return obj[attribute]
+            except (TypeError, LookupError):
+                pass
+        else:
+            if self.is_safe_attribute(obj, attribute, value):
+                return value
+            return self.unsafe_undefined(obj, attribute)
+        return self.undefined(obj=obj, name=attribute)
+
+    def unsafe_undefined(self, obj: t.Any, attribute: str) -> Undefined:
+        """Return an undefined object for unsafe attributes."""
+        return self.undefined(
+            f"access to attribute {attribute!r} of"
+            f" {type(obj).__name__!r} object is unsafe.",
+            name=attribute,
+            obj=obj,
+            exc=SecurityError,
+        )
+
+    def format_string(
+        self,
+        s: str,
+        args: t.Tuple[t.Any, ...],
+        kwargs: t.Dict[str, t.Any],
+        format_func: t.Optional[t.Callable] = None,
+    ) -> str:
+        """If a format call is detected, then this is routed through this
+        method so that our safety sandbox can be used for it.
+        """
+        formatter: SandboxedFormatter
+        if isinstance(s, Markup):
+            formatter = SandboxedEscapeFormatter(self, escape=s.escape)
+        else:
+            formatter = SandboxedFormatter(self)
+
+        if format_func is not None and format_func.__name__ == "format_map":
+            if len(args) != 1 or kwargs:
+                raise TypeError(
+                    "format_map() takes exactly one argument"
+                    f" {len(args) + (kwargs is not None)} given"
+                )
+
+            kwargs = args[0]
+            args = ()
+
+        rv = formatter.vformat(s, args, kwargs)
+        return type(s)(rv)
+
+    def call(
+        __self,  # noqa: B902
+        __context: Context,
+        __obj: t.Any,
+        *args: t.Any,
+        **kwargs: t.Any,
+    ) -> t.Any:
+        """Call an object from sandboxed code."""
+        fmt = inspect_format_method(__obj)
+        if fmt is not None:
+            return __self.format_string(fmt, args, kwargs, __obj)
+
+        # the double prefixes are to avoid double keyword argument
+        # errors when proxying the call.
+        if not __self.is_safe_callable(__obj):
+            raise SecurityError(f"{__obj!r} is not safely callable")
+        return __context.call(__obj, *args, **kwargs)
+
+
+class ImmutableSandboxedEnvironment(SandboxedEnvironment):
+    """Works exactly like the regular `SandboxedEnvironment` but does not
+    permit modifications on the builtin mutable objects `list`, `set`, and
+    `dict` by using the :func:`modifies_known_mutable` function.
+    """
+
+    def is_safe_attribute(self, obj: t.Any, attr: str, value: t.Any) -> bool:
+        if not super().is_safe_attribute(obj, attr, value):
+            return False
+
+        return not modifies_known_mutable(obj, attr)
+
+
+class SandboxedFormatter(Formatter):
+    def __init__(self, env: Environment, **kwargs: t.Any) -> None:
+        self._env = env
+        super().__init__(**kwargs)
+
+    def get_field(
+        self, field_name: str, args: t.Sequence[t.Any], kwargs: t.Mapping[str, t.Any]
+    ) -> t.Tuple[t.Any, str]:
+        first, rest = formatter_field_name_split(field_name)
+        obj = self.get_value(first, args, kwargs)
+        for is_attr, i in rest:
+            if is_attr:
+                obj = self._env.getattr(obj, i)
+            else:
+                obj = self._env.getitem(obj, i)
+        return obj, first
+
+
+class SandboxedEscapeFormatter(SandboxedFormatter, EscapeFormatter):
+    pass
diff --git a/lib/python3.11/site-packages/jinja2/tests.py b/lib/python3.11/site-packages/jinja2/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..a467cf08b54879ee734617611aef72ed946d4566
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/tests.py
@@ -0,0 +1,255 @@
+"""Built-in template tests used with the ``is`` operator."""
+import operator
+import typing as t
+from collections import abc
+from numbers import Number
+
+from .runtime import Undefined
+from .utils import pass_environment
+
+if t.TYPE_CHECKING:
+    from .environment import Environment
+
+
+def test_odd(value: int) -> bool:
+    """Return true if the variable is odd."""
+    return value % 2 == 1
+
+
+def test_even(value: int) -> bool:
+    """Return true if the variable is even."""
+    return value % 2 == 0
+
+
+def test_divisibleby(value: int, num: int) -> bool:
+    """Check if a variable is divisible by a number."""
+    return value % num == 0
+
+
+def test_defined(value: t.Any) -> bool:
+    """Return true if the variable is defined:
+
+    .. sourcecode:: jinja
+
+        {% if variable is defined %}
+            value of variable: {{ variable }}
+        {% else %}
+            variable is not defined
+        {% endif %}
+
+    See the :func:`default` filter for a simple way to set undefined
+    variables.
+    """
+    return not isinstance(value, Undefined)
+
+
+def test_undefined(value: t.Any) -> bool:
+    """Like :func:`defined` but the other way round."""
+    return isinstance(value, Undefined)
+
+
+@pass_environment
+def test_filter(env: "Environment", value: str) -> bool:
+    """Check if a filter exists by name. Useful if a filter may be
+    optionally available.
+
+    .. code-block:: jinja
+
+        {% if 'markdown' is filter %}
+            {{ value | markdown }}
+        {% else %}
+            {{ value }}
+        {% endif %}
+
+    .. versionadded:: 3.0
+    """
+    return value in env.filters
+
+
+@pass_environment
+def test_test(env: "Environment", value: str) -> bool:
+    """Check if a test exists by name. Useful if a test may be
+    optionally available.
+
+    .. code-block:: jinja
+
+        {% if 'loud' is test %}
+            {% if value is loud %}
+                {{ value|upper }}
+            {% else %}
+                {{ value|lower }}
+            {% endif %}
+        {% else %}
+            {{ value }}
+        {% endif %}
+
+    .. versionadded:: 3.0
+    """
+    return value in env.tests
+
+
+def test_none(value: t.Any) -> bool:
+    """Return true if the variable is none."""
+    return value is None
+
+
+def test_boolean(value: t.Any) -> bool:
+    """Return true if the object is a boolean value.
+
+    .. versionadded:: 2.11
+    """
+    return value is True or value is False
+
+
+def test_false(value: t.Any) -> bool:
+    """Return true if the object is False.
+
+    .. versionadded:: 2.11
+    """
+    return value is False
+
+
+def test_true(value: t.Any) -> bool:
+    """Return true if the object is True.
+
+    .. versionadded:: 2.11
+    """
+    return value is True
+
+
+# NOTE: The existing 'number' test matches booleans and floats
+def test_integer(value: t.Any) -> bool:
+    """Return true if the object is an integer.
+
+    .. versionadded:: 2.11
+    """
+    return isinstance(value, int) and value is not True and value is not False
+
+
+# NOTE: The existing 'number' test matches booleans and integers
+def test_float(value: t.Any) -> bool:
+    """Return true if the object is a float.
+
+    .. versionadded:: 2.11
+    """
+    return isinstance(value, float)
+
+
+def test_lower(value: str) -> bool:
+    """Return true if the variable is lowercased."""
+    return str(value).islower()
+
+
+def test_upper(value: str) -> bool:
+    """Return true if the variable is uppercased."""
+    return str(value).isupper()
+
+
+def test_string(value: t.Any) -> bool:
+    """Return true if the object is a string."""
+    return isinstance(value, str)
+
+
+def test_mapping(value: t.Any) -> bool:
+    """Return true if the object is a mapping (dict etc.).
+
+    .. versionadded:: 2.6
+    """
+    return isinstance(value, abc.Mapping)
+
+
+def test_number(value: t.Any) -> bool:
+    """Return true if the variable is a number."""
+    return isinstance(value, Number)
+
+
+def test_sequence(value: t.Any) -> bool:
+    """Return true if the variable is a sequence. Sequences are variables
+    that are iterable.
+    """
+    try:
+        len(value)
+        value.__getitem__
+    except Exception:
+        return False
+
+    return True
+
+
+def test_sameas(value: t.Any, other: t.Any) -> bool:
+    """Check if an object points to the same memory address than another
+    object:
+
+    .. sourcecode:: jinja
+
+        {% if foo.attribute is sameas false %}
+            the foo attribute really is the `False` singleton
+        {% endif %}
+    """
+    return value is other
+
+
+def test_iterable(value: t.Any) -> bool:
+    """Check if it's possible to iterate over an object."""
+    try:
+        iter(value)
+    except TypeError:
+        return False
+
+    return True
+
+
+def test_escaped(value: t.Any) -> bool:
+    """Check if the value is escaped."""
+    return hasattr(value, "__html__")
+
+
+def test_in(value: t.Any, seq: t.Container) -> bool:
+    """Check if value is in seq.
+
+    .. versionadded:: 2.10
+    """
+    return value in seq
+
+
+TESTS = {
+    "odd": test_odd,
+    "even": test_even,
+    "divisibleby": test_divisibleby,
+    "defined": test_defined,
+    "undefined": test_undefined,
+    "filter": test_filter,
+    "test": test_test,
+    "none": test_none,
+    "boolean": test_boolean,
+    "false": test_false,
+    "true": test_true,
+    "integer": test_integer,
+    "float": test_float,
+    "lower": test_lower,
+    "upper": test_upper,
+    "string": test_string,
+    "mapping": test_mapping,
+    "number": test_number,
+    "sequence": test_sequence,
+    "iterable": test_iterable,
+    "callable": callable,
+    "sameas": test_sameas,
+    "escaped": test_escaped,
+    "in": test_in,
+    "==": operator.eq,
+    "eq": operator.eq,
+    "equalto": operator.eq,
+    "!=": operator.ne,
+    "ne": operator.ne,
+    ">": operator.gt,
+    "gt": operator.gt,
+    "greaterthan": operator.gt,
+    "ge": operator.ge,
+    ">=": operator.ge,
+    "<": operator.lt,
+    "lt": operator.lt,
+    "lessthan": operator.lt,
+    "<=": operator.le,
+    "le": operator.le,
+}
diff --git a/lib/python3.11/site-packages/jinja2/utils.py b/lib/python3.11/site-packages/jinja2/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b5f5a50eb6773c4085f8572a45b3fa351367565
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/utils.py
@@ -0,0 +1,755 @@
+import enum
+import json
+import os
+import re
+import typing as t
+from collections import abc
+from collections import deque
+from random import choice
+from random import randrange
+from threading import Lock
+from types import CodeType
+from urllib.parse import quote_from_bytes
+
+import markupsafe
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+
+# special singleton representing missing values for the runtime
+missing: t.Any = type("MissingType", (), {"__repr__": lambda x: "missing"})()
+
+internal_code: t.MutableSet[CodeType] = set()
+
+concat = "".join
+
+
+def pass_context(f: F) -> F:
+    """Pass the :class:`~jinja2.runtime.Context` as the first argument
+    to the decorated function when called while rendering a template.
+
+    Can be used on functions, filters, and tests.
+
+    If only ``Context.eval_context`` is needed, use
+    :func:`pass_eval_context`. If only ``Context.environment`` is
+    needed, use :func:`pass_environment`.
+
+    .. versionadded:: 3.0.0
+        Replaces ``contextfunction`` and ``contextfilter``.
+    """
+    f.jinja_pass_arg = _PassArg.context  # type: ignore
+    return f
+
+
+def pass_eval_context(f: F) -> F:
+    """Pass the :class:`~jinja2.nodes.EvalContext` as the first argument
+    to the decorated function when called while rendering a template.
+    See :ref:`eval-context`.
+
+    Can be used on functions, filters, and tests.
+
+    If only ``EvalContext.environment`` is needed, use
+    :func:`pass_environment`.
+
+    .. versionadded:: 3.0.0
+        Replaces ``evalcontextfunction`` and ``evalcontextfilter``.
+    """
+    f.jinja_pass_arg = _PassArg.eval_context  # type: ignore
+    return f
+
+
+def pass_environment(f: F) -> F:
+    """Pass the :class:`~jinja2.Environment` as the first argument to
+    the decorated function when called while rendering a template.
+
+    Can be used on functions, filters, and tests.
+
+    .. versionadded:: 3.0.0
+        Replaces ``environmentfunction`` and ``environmentfilter``.
+    """
+    f.jinja_pass_arg = _PassArg.environment  # type: ignore
+    return f
+
+
+class _PassArg(enum.Enum):
+    context = enum.auto()
+    eval_context = enum.auto()
+    environment = enum.auto()
+
+    @classmethod
+    def from_obj(cls, obj: F) -> t.Optional["_PassArg"]:
+        if hasattr(obj, "jinja_pass_arg"):
+            return obj.jinja_pass_arg  # type: ignore
+
+        return None
+
+
+def internalcode(f: F) -> F:
+    """Marks the function as internally used"""
+    internal_code.add(f.__code__)
+    return f
+
+
+def is_undefined(obj: t.Any) -> bool:
+    """Check if the object passed is undefined.  This does nothing more than
+    performing an instance check against :class:`Undefined` but looks nicer.
+    This can be used for custom filters or tests that want to react to
+    undefined variables.  For example a custom default filter can look like
+    this::
+
+        def default(var, default=''):
+            if is_undefined(var):
+                return default
+            return var
+    """
+    from .runtime import Undefined
+
+    return isinstance(obj, Undefined)
+
+
+def consume(iterable: t.Iterable[t.Any]) -> None:
+    """Consumes an iterable without doing anything with it."""
+    for _ in iterable:
+        pass
+
+
+def clear_caches() -> None:
+    """Jinja keeps internal caches for environments and lexers.  These are
+    used so that Jinja doesn't have to recreate environments and lexers all
+    the time.  Normally you don't have to care about that but if you are
+    measuring memory consumption you may want to clean the caches.
+    """
+    from .environment import get_spontaneous_environment
+    from .lexer import _lexer_cache
+
+    get_spontaneous_environment.cache_clear()
+    _lexer_cache.clear()
+
+
+def import_string(import_name: str, silent: bool = False) -> t.Any:
+    """Imports an object based on a string.  This is useful if you want to
+    use import paths as endpoints or something similar.  An import path can
+    be specified either in dotted notation (``xml.sax.saxutils.escape``)
+    or with a colon as object delimiter (``xml.sax.saxutils:escape``).
+
+    If the `silent` is True the return value will be `None` if the import
+    fails.
+
+    :return: imported object
+    """
+    try:
+        if ":" in import_name:
+            module, obj = import_name.split(":", 1)
+        elif "." in import_name:
+            module, _, obj = import_name.rpartition(".")
+        else:
+            return __import__(import_name)
+        return getattr(__import__(module, None, None, [obj]), obj)
+    except (ImportError, AttributeError):
+        if not silent:
+            raise
+
+
+def open_if_exists(filename: str, mode: str = "rb") -> t.Optional[t.IO]:
+    """Returns a file descriptor for the filename if that file exists,
+    otherwise ``None``.
+    """
+    if not os.path.isfile(filename):
+        return None
+
+    return open(filename, mode)
+
+
+def object_type_repr(obj: t.Any) -> str:
+    """Returns the name of the object's type.  For some recognized
+    singletons the name of the object is returned instead. (For
+    example for `None` and `Ellipsis`).
+    """
+    if obj is None:
+        return "None"
+    elif obj is Ellipsis:
+        return "Ellipsis"
+
+    cls = type(obj)
+
+    if cls.__module__ == "builtins":
+        return f"{cls.__name__} object"
+
+    return f"{cls.__module__}.{cls.__name__} object"
+
+
+def pformat(obj: t.Any) -> str:
+    """Format an object using :func:`pprint.pformat`."""
+    from pprint import pformat  # type: ignore
+
+    return pformat(obj)
+
+
+_http_re = re.compile(
+    r"""
+    ^
+    (
+        (https?://|www\.)  # scheme or www
+        (([\w%-]+\.)+)?  # subdomain
+        (
+            [a-z]{2,63}  # basic tld
+        |
+            xn--[\w%]{2,59}  # idna tld
+        )
+    |
+        ([\w%-]{2,63}\.)+  # basic domain
+        (com|net|int|edu|gov|org|info|mil)  # basic tld
+    |
+        (https?://)  # scheme
+        (
+            (([\d]{1,3})(\.[\d]{1,3}){3})  # IPv4
+        |
+            (\[([\da-f]{0,4}:){2}([\da-f]{0,4}:?){1,6}])  # IPv6
+        )
+    )
+    (?::[\d]{1,5})?  # port
+    (?:[/?#]\S*)?  # path, query, and fragment
+    $
+    """,
+    re.IGNORECASE | re.VERBOSE,
+)
+_email_re = re.compile(r"^\S+@\w[\w.-]*\.\w+$")
+
+
+def urlize(
+    text: str,
+    trim_url_limit: t.Optional[int] = None,
+    rel: t.Optional[str] = None,
+    target: t.Optional[str] = None,
+    extra_schemes: t.Optional[t.Iterable[str]] = None,
+) -> str:
+    """Convert URLs in text into clickable links.
+
+    This may not recognize links in some situations. Usually, a more
+    comprehensive formatter, such as a Markdown library, is a better
+    choice.
+
+    Works on ``http://``, ``https://``, ``www.``, ``mailto:``, and email
+    addresses. Links with trailing punctuation (periods, commas, closing
+    parentheses) and leading punctuation (opening parentheses) are
+    recognized excluding the punctuation. Email addresses that include
+    header fields are not recognized (for example,
+    ``mailto:address@example.com?cc=copy@example.com``).
+
+    :param text: Original text containing URLs to link.
+    :param trim_url_limit: Shorten displayed URL values to this length.
+    :param target: Add the ``target`` attribute to links.
+    :param rel: Add the ``rel`` attribute to links.
+    :param extra_schemes: Recognize URLs that start with these schemes
+        in addition to the default behavior.
+
+    .. versionchanged:: 3.0
+        The ``extra_schemes`` parameter was added.
+
+    .. versionchanged:: 3.0
+        Generate ``https://`` links for URLs without a scheme.
+
+    .. versionchanged:: 3.0
+        The parsing rules were updated. Recognize email addresses with
+        or without the ``mailto:`` scheme. Validate IP addresses. Ignore
+        parentheses and brackets in more cases.
+    """
+    if trim_url_limit is not None:
+
+        def trim_url(x: str) -> str:
+            if len(x) > trim_url_limit:  # type: ignore
+                return f"{x[:trim_url_limit]}..."
+
+            return x
+
+    else:
+
+        def trim_url(x: str) -> str:
+            return x
+
+    words = re.split(r"(\s+)", str(markupsafe.escape(text)))
+    rel_attr = f' rel="{markupsafe.escape(rel)}"' if rel else ""
+    target_attr = f' target="{markupsafe.escape(target)}"' if target else ""
+
+    for i, word in enumerate(words):
+        head, middle, tail = "", word, ""
+        match = re.match(r"^([(<]|&lt;)+", middle)
+
+        if match:
+            head = match.group()
+            middle = middle[match.end() :]
+
+        # Unlike lead, which is anchored to the start of the string,
+        # need to check that the string ends with any of the characters
+        # before trying to match all of them, to avoid backtracking.
+        if middle.endswith((")", ">", ".", ",", "\n", "&gt;")):
+            match = re.search(r"([)>.,\n]|&gt;)+$", middle)
+
+            if match:
+                tail = match.group()
+                middle = middle[: match.start()]
+
+        # Prefer balancing parentheses in URLs instead of ignoring a
+        # trailing character.
+        for start_char, end_char in ("(", ")"), ("<", ">"), ("&lt;", "&gt;"):
+            start_count = middle.count(start_char)
+
+            if start_count <= middle.count(end_char):
+                # Balanced, or lighter on the left
+                continue
+
+            # Move as many as possible from the tail to balance
+            for _ in range(min(start_count, tail.count(end_char))):
+                end_index = tail.index(end_char) + len(end_char)
+                # Move anything in the tail before the end char too
+                middle += tail[:end_index]
+                tail = tail[end_index:]
+
+        if _http_re.match(middle):
+            if middle.startswith("https://") or middle.startswith("http://"):
+                middle = (
+                    f'<a href="{middle}"{rel_attr}{target_attr}>{trim_url(middle)}</a>'
+                )
+            else:
+                middle = (
+                    f'<a href="https://{middle}"{rel_attr}{target_attr}>'
+                    f"{trim_url(middle)}</a>"
+                )
+
+        elif middle.startswith("mailto:") and _email_re.match(middle[7:]):
+            middle = f'<a href="{middle}">{middle[7:]}</a>'
+
+        elif (
+            "@" in middle
+            and not middle.startswith("www.")
+            and ":" not in middle
+            and _email_re.match(middle)
+        ):
+            middle = f'<a href="mailto:{middle}">{middle}</a>'
+
+        elif extra_schemes is not None:
+            for scheme in extra_schemes:
+                if middle != scheme and middle.startswith(scheme):
+                    middle = f'<a href="{middle}"{rel_attr}{target_attr}>{middle}</a>'
+
+        words[i] = f"{head}{middle}{tail}"
+
+    return "".join(words)
+
+
+def generate_lorem_ipsum(
+    n: int = 5, html: bool = True, min: int = 20, max: int = 100
+) -> str:
+    """Generate some lorem ipsum for the template."""
+    from .constants import LOREM_IPSUM_WORDS
+
+    words = LOREM_IPSUM_WORDS.split()
+    result = []
+
+    for _ in range(n):
+        next_capitalized = True
+        last_comma = last_fullstop = 0
+        word = None
+        last = None
+        p = []
+
+        # each paragraph contains out of 20 to 100 words.
+        for idx, _ in enumerate(range(randrange(min, max))):
+            while True:
+                word = choice(words)
+                if word != last:
+                    last = word
+                    break
+            if next_capitalized:
+                word = word.capitalize()
+                next_capitalized = False
+            # add commas
+            if idx - randrange(3, 8) > last_comma:
+                last_comma = idx
+                last_fullstop += 2
+                word += ","
+            # add end of sentences
+            if idx - randrange(10, 20) > last_fullstop:
+                last_comma = last_fullstop = idx
+                word += "."
+                next_capitalized = True
+            p.append(word)
+
+        # ensure that the paragraph ends with a dot.
+        p_str = " ".join(p)
+
+        if p_str.endswith(","):
+            p_str = p_str[:-1] + "."
+        elif not p_str.endswith("."):
+            p_str += "."
+
+        result.append(p_str)
+
+    if not html:
+        return "\n\n".join(result)
+    return markupsafe.Markup(
+        "\n".join(f"<p>{markupsafe.escape(x)}</p>" for x in result)
+    )
+
+
+def url_quote(obj: t.Any, charset: str = "utf-8", for_qs: bool = False) -> str:
+    """Quote a string for use in a URL using the given charset.
+
+    :param obj: String or bytes to quote. Other types are converted to
+        string then encoded to bytes using the given charset.
+    :param charset: Encode text to bytes using this charset.
+    :param for_qs: Quote "/" and use "+" for spaces.
+    """
+    if not isinstance(obj, bytes):
+        if not isinstance(obj, str):
+            obj = str(obj)
+
+        obj = obj.encode(charset)
+
+    safe = b"" if for_qs else b"/"
+    rv = quote_from_bytes(obj, safe)
+
+    if for_qs:
+        rv = rv.replace("%20", "+")
+
+    return rv
+
+
+@abc.MutableMapping.register
+class LRUCache:
+    """A simple LRU Cache implementation."""
+
+    # this is fast for small capacities (something below 1000) but doesn't
+    # scale.  But as long as it's only used as storage for templates this
+    # won't do any harm.
+
+    def __init__(self, capacity: int) -> None:
+        self.capacity = capacity
+        self._mapping: t.Dict[t.Any, t.Any] = {}
+        self._queue: "te.Deque[t.Any]" = deque()
+        self._postinit()
+
+    def _postinit(self) -> None:
+        # alias all queue methods for faster lookup
+        self._popleft = self._queue.popleft
+        self._pop = self._queue.pop
+        self._remove = self._queue.remove
+        self._wlock = Lock()
+        self._append = self._queue.append
+
+    def __getstate__(self) -> t.Mapping[str, t.Any]:
+        return {
+            "capacity": self.capacity,
+            "_mapping": self._mapping,
+            "_queue": self._queue,
+        }
+
+    def __setstate__(self, d: t.Mapping[str, t.Any]) -> None:
+        self.__dict__.update(d)
+        self._postinit()
+
+    def __getnewargs__(self) -> t.Tuple:
+        return (self.capacity,)
+
+    def copy(self) -> "LRUCache":
+        """Return a shallow copy of the instance."""
+        rv = self.__class__(self.capacity)
+        rv._mapping.update(self._mapping)
+        rv._queue.extend(self._queue)
+        return rv
+
+    def get(self, key: t.Any, default: t.Any = None) -> t.Any:
+        """Return an item from the cache dict or `default`"""
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def setdefault(self, key: t.Any, default: t.Any = None) -> t.Any:
+        """Set `default` if the key is not in the cache otherwise
+        leave unchanged. Return the value of this key.
+        """
+        try:
+            return self[key]
+        except KeyError:
+            self[key] = default
+            return default
+
+    def clear(self) -> None:
+        """Clear the cache."""
+        with self._wlock:
+            self._mapping.clear()
+            self._queue.clear()
+
+    def __contains__(self, key: t.Any) -> bool:
+        """Check if a key exists in this cache."""
+        return key in self._mapping
+
+    def __len__(self) -> int:
+        """Return the current size of the cache."""
+        return len(self._mapping)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self._mapping!r}>"
+
+    def __getitem__(self, key: t.Any) -> t.Any:
+        """Get an item from the cache. Moves the item up so that it has the
+        highest priority then.
+
+        Raise a `KeyError` if it does not exist.
+        """
+        with self._wlock:
+            rv = self._mapping[key]
+
+            if self._queue[-1] != key:
+                try:
+                    self._remove(key)
+                except ValueError:
+                    # if something removed the key from the container
+                    # when we read, ignore the ValueError that we would
+                    # get otherwise.
+                    pass
+
+                self._append(key)
+
+            return rv
+
+    def __setitem__(self, key: t.Any, value: t.Any) -> None:
+        """Sets the value for an item. Moves the item up so that it
+        has the highest priority then.
+        """
+        with self._wlock:
+            if key in self._mapping:
+                self._remove(key)
+            elif len(self._mapping) == self.capacity:
+                del self._mapping[self._popleft()]
+
+            self._append(key)
+            self._mapping[key] = value
+
+    def __delitem__(self, key: t.Any) -> None:
+        """Remove an item from the cache dict.
+        Raise a `KeyError` if it does not exist.
+        """
+        with self._wlock:
+            del self._mapping[key]
+
+            try:
+                self._remove(key)
+            except ValueError:
+                pass
+
+    def items(self) -> t.Iterable[t.Tuple[t.Any, t.Any]]:
+        """Return a list of items."""
+        result = [(key, self._mapping[key]) for key in list(self._queue)]
+        result.reverse()
+        return result
+
+    def values(self) -> t.Iterable[t.Any]:
+        """Return a list of all values."""
+        return [x[1] for x in self.items()]
+
+    def keys(self) -> t.Iterable[t.Any]:
+        """Return a list of all keys ordered by most recent usage."""
+        return list(self)
+
+    def __iter__(self) -> t.Iterator[t.Any]:
+        return reversed(tuple(self._queue))
+
+    def __reversed__(self) -> t.Iterator[t.Any]:
+        """Iterate over the keys in the cache dict, oldest items
+        coming first.
+        """
+        return iter(tuple(self._queue))
+
+    __copy__ = copy
+
+
+def select_autoescape(
+    enabled_extensions: t.Collection[str] = ("html", "htm", "xml"),
+    disabled_extensions: t.Collection[str] = (),
+    default_for_string: bool = True,
+    default: bool = False,
+) -> t.Callable[[t.Optional[str]], bool]:
+    """Intelligently sets the initial value of autoescaping based on the
+    filename of the template.  This is the recommended way to configure
+    autoescaping if you do not want to write a custom function yourself.
+
+    If you want to enable it for all templates created from strings or
+    for all templates with `.html` and `.xml` extensions::
+
+        from jinja2 import Environment, select_autoescape
+        env = Environment(autoescape=select_autoescape(
+            enabled_extensions=('html', 'xml'),
+            default_for_string=True,
+        ))
+
+    Example configuration to turn it on at all times except if the template
+    ends with `.txt`::
+
+        from jinja2 import Environment, select_autoescape
+        env = Environment(autoescape=select_autoescape(
+            disabled_extensions=('txt',),
+            default_for_string=True,
+            default=True,
+        ))
+
+    The `enabled_extensions` is an iterable of all the extensions that
+    autoescaping should be enabled for.  Likewise `disabled_extensions` is
+    a list of all templates it should be disabled for.  If a template is
+    loaded from a string then the default from `default_for_string` is used.
+    If nothing matches then the initial value of autoescaping is set to the
+    value of `default`.
+
+    For security reasons this function operates case insensitive.
+
+    .. versionadded:: 2.9
+    """
+    enabled_patterns = tuple(f".{x.lstrip('.').lower()}" for x in enabled_extensions)
+    disabled_patterns = tuple(f".{x.lstrip('.').lower()}" for x in disabled_extensions)
+
+    def autoescape(template_name: t.Optional[str]) -> bool:
+        if template_name is None:
+            return default_for_string
+        template_name = template_name.lower()
+        if template_name.endswith(enabled_patterns):
+            return True
+        if template_name.endswith(disabled_patterns):
+            return False
+        return default
+
+    return autoescape
+
+
+def htmlsafe_json_dumps(
+    obj: t.Any, dumps: t.Optional[t.Callable[..., str]] = None, **kwargs: t.Any
+) -> markupsafe.Markup:
+    """Serialize an object to a string of JSON with :func:`json.dumps`,
+    then replace HTML-unsafe characters with Unicode escapes and mark
+    the result safe with :class:`~markupsafe.Markup`.
+
+    This is available in templates as the ``|tojson`` filter.
+
+    The following characters are escaped: ``<``, ``>``, ``&``, ``'``.
+
+    The returned string is safe to render in HTML documents and
+    ``<script>`` tags. The exception is in HTML attributes that are
+    double quoted; either use single quotes or the ``|forceescape``
+    filter.
+
+    :param obj: The object to serialize to JSON.
+    :param dumps: The ``dumps`` function to use. Defaults to
+        ``env.policies["json.dumps_function"]``, which defaults to
+        :func:`json.dumps`.
+    :param kwargs: Extra arguments to pass to ``dumps``. Merged onto
+        ``env.policies["json.dumps_kwargs"]``.
+
+    .. versionchanged:: 3.0
+        The ``dumper`` parameter is renamed to ``dumps``.
+
+    .. versionadded:: 2.9
+    """
+    if dumps is None:
+        dumps = json.dumps
+
+    return markupsafe.Markup(
+        dumps(obj, **kwargs)
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace("&", "\\u0026")
+        .replace("'", "\\u0027")
+    )
+
+
+class Cycler:
+    """Cycle through values by yield them one at a time, then restarting
+    once the end is reached. Available as ``cycler`` in templates.
+
+    Similar to ``loop.cycle``, but can be used outside loops or across
+    multiple loops. For example, render a list of folders and files in a
+    list, alternating giving them "odd" and "even" classes.
+
+    .. code-block:: html+jinja
+
+        {% set row_class = cycler("odd", "even") %}
+        <ul class="browser">
+        {% for folder in folders %}
+          <li class="folder {{ row_class.next() }}">{{ folder }}
+        {% endfor %}
+        {% for file in files %}
+          <li class="file {{ row_class.next() }}">{{ file }}
+        {% endfor %}
+        </ul>
+
+    :param items: Each positional argument will be yielded in the order
+        given for each cycle.
+
+    .. versionadded:: 2.1
+    """
+
+    def __init__(self, *items: t.Any) -> None:
+        if not items:
+            raise RuntimeError("at least one item has to be provided")
+        self.items = items
+        self.pos = 0
+
+    def reset(self) -> None:
+        """Resets the current item to the first item."""
+        self.pos = 0
+
+    @property
+    def current(self) -> t.Any:
+        """Return the current item. Equivalent to the item that will be
+        returned next time :meth:`next` is called.
+        """
+        return self.items[self.pos]
+
+    def next(self) -> t.Any:
+        """Return the current item, then advance :attr:`current` to the
+        next item.
+        """
+        rv = self.current
+        self.pos = (self.pos + 1) % len(self.items)
+        return rv
+
+    __next__ = next
+
+
+class Joiner:
+    """A joining helper for templates."""
+
+    def __init__(self, sep: str = ", ") -> None:
+        self.sep = sep
+        self.used = False
+
+    def __call__(self) -> str:
+        if not self.used:
+            self.used = True
+            return ""
+        return self.sep
+
+
+class Namespace:
+    """A namespace object that can hold arbitrary attributes.  It may be
+    initialized from a dictionary or with keyword arguments."""
+
+    def __init__(*args: t.Any, **kwargs: t.Any) -> None:  # noqa: B902
+        self, args = args[0], args[1:]
+        self.__attrs = dict(*args, **kwargs)
+
+    def __getattribute__(self, name: str) -> t.Any:
+        # __class__ is needed for the awaitable check in async mode
+        if name in {"_Namespace__attrs", "__class__"}:
+            return object.__getattribute__(self, name)
+        try:
+            return self.__attrs[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+    def __setitem__(self, name: str, value: t.Any) -> None:
+        self.__attrs[name] = value
+
+    def __repr__(self) -> str:
+        return f"<Namespace {self.__attrs!r}>"
diff --git a/lib/python3.11/site-packages/jinja2/visitor.py b/lib/python3.11/site-packages/jinja2/visitor.py
new file mode 100644
index 0000000000000000000000000000000000000000..17c6aaba570742652f70bf1e7bf1a576c9d256ae
--- /dev/null
+++ b/lib/python3.11/site-packages/jinja2/visitor.py
@@ -0,0 +1,92 @@
+"""API for traversing the AST nodes. Implemented by the compiler and
+meta introspection.
+"""
+import typing as t
+
+from .nodes import Node
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    class VisitCallable(te.Protocol):
+        def __call__(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any:
+            ...
+
+
+class NodeVisitor:
+    """Walks the abstract syntax tree and call visitor functions for every
+    node found.  The visitor functions may return values which will be
+    forwarded by the `visit` method.
+
+    Per default the visitor functions for the nodes are ``'visit_'`` +
+    class name of the node.  So a `TryFinally` node visit function would
+    be `visit_TryFinally`.  This behavior can be changed by overriding
+    the `get_visitor` function.  If no visitor function exists for a node
+    (return value `None`) the `generic_visit` visitor is used instead.
+    """
+
+    def get_visitor(self, node: Node) -> "t.Optional[VisitCallable]":
+        """Return the visitor function for this node or `None` if no visitor
+        exists for this node.  In that case the generic visit function is
+        used instead.
+        """
+        return getattr(self, f"visit_{type(node).__name__}", None)
+
+    def visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        """Visit a node."""
+        f = self.get_visitor(node)
+
+        if f is not None:
+            return f(node, *args, **kwargs)
+
+        return self.generic_visit(node, *args, **kwargs)
+
+    def generic_visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        """Called if no explicit visitor function exists for a node."""
+        for child_node in node.iter_child_nodes():
+            self.visit(child_node, *args, **kwargs)
+
+
+class NodeTransformer(NodeVisitor):
+    """Walks the abstract syntax tree and allows modifications of nodes.
+
+    The `NodeTransformer` will walk the AST and use the return value of the
+    visitor functions to replace or remove the old node.  If the return
+    value of the visitor function is `None` the node will be removed
+    from the previous location otherwise it's replaced with the return
+    value.  The return value may be the original node in which case no
+    replacement takes place.
+    """
+
+    def generic_visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> Node:
+        for field, old_value in node.iter_fields():
+            if isinstance(old_value, list):
+                new_values = []
+                for value in old_value:
+                    if isinstance(value, Node):
+                        value = self.visit(value, *args, **kwargs)
+                        if value is None:
+                            continue
+                        elif not isinstance(value, Node):
+                            new_values.extend(value)
+                            continue
+                    new_values.append(value)
+                old_value[:] = new_values
+            elif isinstance(old_value, Node):
+                new_node = self.visit(old_value, *args, **kwargs)
+                if new_node is None:
+                    delattr(node, field)
+                else:
+                    setattr(node, field, new_node)
+        return node
+
+    def visit_list(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.List[Node]:
+        """As transformers may return lists in some places this method
+        can be used to enforce a list as return value.
+        """
+        rv = self.visit(node, *args, **kwargs)
+
+        if not isinstance(rv, list):
+            return [rv]
+
+        return rv
diff --git a/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/INSTALLER b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/LICENSE b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..8e94a0168f400c07fa64094adc17eae54b913fd1
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2014-, Continuum Analytics, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/METADATA b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..e12994ead07a08fe9dc2f6ce84ff04c824082d9d
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/METADATA
@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: llvmlite
+Version: 0.41.1
+Summary: lightweight wrapper around basic LLVM functionality
+Home-page: http://llvmlite.readthedocs.io
+License: BSD
+Project-URL: Source, https://github.com/numba/llvmlite
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.8
+License-File: LICENSE
+
+========
+llvmlite
+========
+
+.. image:: https://dev.azure.com/numba/numba/_apis/build/status/numba.llvmlite?branchName=main
+   :target: https://dev.azure.com/numba/numba/_build/latest?definitionId=2&branchName=main
+   :alt: Azure Pipelines
+.. image:: https://codeclimate.com/github/numba/llvmlite/badges/gpa.svg
+   :target: https://codeclimate.com/github/numba/llvmlite
+   :alt: Code Climate
+.. image:: https://coveralls.io/repos/github/numba/llvmlite/badge.svg
+   :target: https://coveralls.io/github/numba/llvmlite
+   :alt: Coveralls.io
+.. image:: https://readthedocs.org/projects/llvmlite/badge/
+   :target: https://llvmlite.readthedocs.io
+   :alt: Readthedocs.io
+
+A Lightweight LLVM Python Binding for Writing JIT Compilers
+-----------------------------------------------------------
+
+.. _llvmpy: https://github.com/llvmpy/llvmpy
+
+llvmlite is a project originally tailored for Numba_'s needs, using the
+following approach:
+
+* A small C wrapper around the parts of the LLVM C++ API we need that are
+  not already exposed by the LLVM C API.
+* A ctypes Python wrapper around the C API.
+* A pure Python implementation of the subset of the LLVM IR builder that we
+  need for Numba.
+
+Why llvmlite
+============
+
+The old llvmpy_  binding exposes a lot of LLVM APIs but the mapping of
+C++-style memory management to Python is error prone. Numba_ and many JIT
+compilers do not need a full LLVM API.  Only the IR builder, optimizer,
+and JIT compiler APIs are necessary.
+
+Key Benefits
+============
+
+* The IR builder is pure Python code and decoupled from LLVM's
+  frequently-changing C++ APIs.
+* Materializing a LLVM module calls LLVM's IR parser which provides
+  better error messages than step-by-step IR building through the C++
+  API (no more segfaults or process aborts).
+* Most of llvmlite uses the LLVM C API which is small but very stable
+  (low maintenance when changing LLVM version).
+* The binding is not a Python C-extension, but a plain DLL accessed using
+  ctypes (no need to wrestle with Python's compiler requirements and C++ 11
+  compatibility).
+* The Python binding layer has sane memory management.
+* llvmlite is faster than llvmpy thanks to a much simpler architecture
+  (the Numba_ test suite is twice faster than it was).
+
+Compatibility
+=============
+
+llvmlite works with Python 3.8 and greater. We attempt to test with the latest
+Python version, this can be checked by looking at the public CI builds.
+
+As of version 0.41.0, llvmlite requires LLVM 14.x.x on all architectures
+
+Historical compatibility table:
+
+=================  ========================
+llvmlite versions  compatible LLVM versions
+=================  ========================
+0.41.0 - ...       14.x.x
+0.40.0 - 0.40.1    11.x.x and 14.x.x (12.x.x and 13.x.x untested but may work)
+0.37.0 - 0.39.1    11.x.x
+0.34.0 - 0.36.0    10.0.x (9.0.x for  ``aarch64`` only)
+0.33.0             9.0.x
+0.29.0 - 0.32.0    7.0.x, 7.1.x, 8.0.x
+0.27.0 - 0.28.0    7.0.x
+0.23.0 - 0.26.0    6.0.x
+0.21.0 - 0.22.0    5.0.x
+0.17.0 - 0.20.0    4.0.x
+0.16.0 - 0.17.0    3.9.x
+0.13.0 - 0.15.0    3.8.x
+0.9.0 - 0.12.1     3.7.x
+0.6.0 - 0.8.0      3.6.x
+0.1.0 - 0.5.1      3.5.x
+=================  ========================
+
+Documentation
+=============
+
+You'll find the documentation at http://llvmlite.pydata.org
+
+
+Pre-built binaries
+==================
+
+We recommend you use the binaries provided by the Numba_ team for
+the Conda_ package manager.  You can find them in Numba's `anaconda.org
+channel <https://anaconda.org/numba>`_.  For example::
+
+   $ conda install --channel=numba llvmlite
+
+(or, simply, the official llvmlite package provided in the Anaconda_
+distribution)
+
+.. _Numba: http://numba.pydata.org/
+.. _Conda: http://conda.pydata.org/
+.. _Anaconda: http://docs.continuum.io/anaconda/index.html
+
+
+Other build methods
+===================
+
+If you don't want to use our pre-built packages, you can compile
+and install llvmlite yourself.  The documentation will teach you how:
+http://llvmlite.pydata.org/en/latest/install/index.html
diff --git a/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/RECORD b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..d320d3807cd1fad2ae5ed594d03102eea4d5b5b0
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/RECORD
@@ -0,0 +1,81 @@
+llvmlite-0.41.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+llvmlite-0.41.1.dist-info/LICENSE,sha256=S5pyZLAROnsybuhPwkS3OZG1NbSDPkpW1YdQ8qciUNw,1298
+llvmlite-0.41.1.dist-info/METADATA,sha256=ViL9FB2NBHKaVY4Ws8v41nBy-SKPB3-8PJ6HNIW8fTQ,4808
+llvmlite-0.41.1.dist-info/RECORD,,
+llvmlite-0.41.1.dist-info/WHEEL,sha256=eaDTbMedWofVq8IZjew9qeAkoA5Sw2MOU2ppdIRr1Jg,110
+llvmlite-0.41.1.dist-info/top_level.txt,sha256=WJi8Gq92jA2wv_aV1Oshp9iZ-zMa43Kcmw80kWeGYGA,9
+llvmlite/__init__.py,sha256=PiUSiFLCm0YX5rbHS4xOLGdqdPDC8j3etV3nmEaelzI,92
+llvmlite/__pycache__/__init__.cpython-311.pyc,,
+llvmlite/__pycache__/_version.cpython-311.pyc,,
+llvmlite/__pycache__/utils.cpython-311.pyc,,
+llvmlite/_version.py,sha256=fsnaBKvglYPJywrUAvzZsHhvixqEwJIDh0JKz4rwPtw,418
+llvmlite/binding/__init__.py,sha256=zjhFN8Ucg5Y_14kwn1OEyiH_X-wEnzwS_WVmkPoSChk,382
+llvmlite/binding/__pycache__/__init__.cpython-311.pyc,,
+llvmlite/binding/__pycache__/analysis.cpython-311.pyc,,
+llvmlite/binding/__pycache__/common.cpython-311.pyc,,
+llvmlite/binding/__pycache__/context.cpython-311.pyc,,
+llvmlite/binding/__pycache__/dylib.cpython-311.pyc,,
+llvmlite/binding/__pycache__/executionengine.cpython-311.pyc,,
+llvmlite/binding/__pycache__/ffi.cpython-311.pyc,,
+llvmlite/binding/__pycache__/initfini.cpython-311.pyc,,
+llvmlite/binding/__pycache__/linker.cpython-311.pyc,,
+llvmlite/binding/__pycache__/module.cpython-311.pyc,,
+llvmlite/binding/__pycache__/object_file.cpython-311.pyc,,
+llvmlite/binding/__pycache__/options.cpython-311.pyc,,
+llvmlite/binding/__pycache__/orcjit.cpython-311.pyc,,
+llvmlite/binding/__pycache__/passmanagers.cpython-311.pyc,,
+llvmlite/binding/__pycache__/targets.cpython-311.pyc,,
+llvmlite/binding/__pycache__/transforms.cpython-311.pyc,,
+llvmlite/binding/__pycache__/value.cpython-311.pyc,,
+llvmlite/binding/analysis.py,sha256=BbCcAAGY0GLAEUek6ZogHkBAmFA9kvpS7333XyIrbhc,2253
+llvmlite/binding/common.py,sha256=eCSnnY4sctgeqVwDv9PrH6jpMI45nJPmAz4rfjbPsf8,742
+llvmlite/binding/context.py,sha256=l2vdKsJ038PfSKzaU17FCSDYWtByzIFYREmx93JwKW8,657
+llvmlite/binding/dylib.py,sha256=ypfikOYKiWQZi8h00LhLBXwmPlJ5d86yLOUn01pDjmM,1300
+llvmlite/binding/executionengine.py,sha256=rJrBP9n0Hm-lo53KRoRssFBLS8XOuIoAp_XWetiesS4,10713
+llvmlite/binding/ffi.py,sha256=bQB6yudHJTlCGaCsnvrhNgWQzJYcvxwvULAo53j3oe4,11950
+llvmlite/binding/initfini.py,sha256=zF9tJXmCONabkP0d_IqmiU6M_Wn8N8ArkwfXBxf1TDo,1595
+llvmlite/binding/libllvmlite.dylib,sha256=M1fMZuZYLPJYUM6bH3EMvkFg-HGpDIu-ls_Yf-hX6jA,91363294
+llvmlite/binding/linker.py,sha256=M4bAkoxVAUgxqai5S0_iCHS5EcNRPBX_9zldVqFLV90,489
+llvmlite/binding/module.py,sha256=Zf9GcuCEFf1xtOmP-jXqKtJbj4dO8l9a2NEPKTwsimI,11174
+llvmlite/binding/object_file.py,sha256=qZMTAi6gcVQq2e3KghHNxVH3Ivzr7zxDPecfiZ1Riy8,2664
+llvmlite/binding/options.py,sha256=aDH4SFh6VZ11agtUJO9vAxhVhQkIGAByK9IHKeuRcAI,509
+llvmlite/binding/orcjit.py,sha256=HUWDKicxrYK5s2trdrM_KEmkfvwifrP4E9MxmCb8JSM,11856
+llvmlite/binding/passmanagers.py,sha256=zfn-iP-vi5j_1s8JPAnZjPpcahhz1IL98tSdZKCw40s,34412
+llvmlite/binding/targets.py,sha256=5nxDn73pK_ElQu86EU994Qcd-k5Ja2U127T_oLrW_kk,14802
+llvmlite/binding/transforms.py,sha256=C_Tp0XPV__aOHaVzLLL_QFa-yI9vkDx1gwZADk_KwG8,4947
+llvmlite/binding/value.py,sha256=21-PwkBgAl26g0sqP2mI_lckSIDvq_LkgoLmzJE_8K4,18845
+llvmlite/ir/__init__.py,sha256=rNPtrPLshsPJYO4GegWAU-rpbpiYo0xU-CQb3rt0JtE,258
+llvmlite/ir/__pycache__/__init__.cpython-311.pyc,,
+llvmlite/ir/__pycache__/_utils.cpython-311.pyc,,
+llvmlite/ir/__pycache__/builder.cpython-311.pyc,,
+llvmlite/ir/__pycache__/context.cpython-311.pyc,,
+llvmlite/ir/__pycache__/instructions.cpython-311.pyc,,
+llvmlite/ir/__pycache__/module.cpython-311.pyc,,
+llvmlite/ir/__pycache__/transforms.cpython-311.pyc,,
+llvmlite/ir/__pycache__/types.cpython-311.pyc,,
+llvmlite/ir/__pycache__/values.cpython-311.pyc,,
+llvmlite/ir/_utils.py,sha256=mkpyEMlQ9nHMcWmBMBsJm4S16Y0BfvxBf5brsdMmKio,2001
+llvmlite/ir/builder.py,sha256=t6ZCvkwXd1jmb-CGoTW12kLOSTnwjfS_eY9JJs6ij3g,33479
+llvmlite/ir/context.py,sha256=npgEbox0MzChmH7nfHpTdSsN_G4zU-XrpGx5AIYwafk,518
+llvmlite/ir/instructions.py,sha256=UbiK1Ja7JqZuEj0l6sm7-p-zgfu-fXEbhWqrQB43hbw,31753
+llvmlite/ir/module.py,sha256=pfpAh-73WMLptKqwgARwZ7aLMHpm88AcJA2GPfGvyVM,9074
+llvmlite/ir/transforms.py,sha256=pV79pB20m4N_HLmBEksw5VVP8cxyf7AYGDCbS1E7fOQ,1552
+llvmlite/ir/types.py,sha256=2GX-PIx_jDvt4GIfHkqiEkrJI_gPQqSktOsku2UZTgQ,16149
+llvmlite/ir/values.py,sha256=5YlGc90Yc7QuzDMcptoXmvfCjcAvhSk4fSnAwF1vSas,33987
+llvmlite/tests/__init__.py,sha256=TBHEOsEq-9M9rF94nES2HxefA-7GYwNE00Y7gTkHrD8,1378
+llvmlite/tests/__main__.py,sha256=10_On1rLj4CX1xsBJ9TbjULvNSp_K0qk9U1N6azUTUw,40
+llvmlite/tests/__pycache__/__init__.cpython-311.pyc,,
+llvmlite/tests/__pycache__/__main__.cpython-311.pyc,,
+llvmlite/tests/__pycache__/customize.cpython-311.pyc,,
+llvmlite/tests/__pycache__/refprune_proto.cpython-311.pyc,,
+llvmlite/tests/__pycache__/test_binding.cpython-311.pyc,,
+llvmlite/tests/__pycache__/test_ir.cpython-311.pyc,,
+llvmlite/tests/__pycache__/test_refprune.cpython-311.pyc,,
+llvmlite/tests/__pycache__/test_valuerepr.cpython-311.pyc,,
+llvmlite/tests/customize.py,sha256=85Af1gyZ5rtXXI3qpeTc2DXMrgETjv7hrLN-73A7Fhg,13268
+llvmlite/tests/refprune_proto.py,sha256=I5g0jWHYlsLCOX3Ct9-fA5_udLfkipzuBAsEkrNsFIk,8677
+llvmlite/tests/test_binding.py,sha256=Pvz7WxlxK_awXEXDAV30O4zTJ4PWY1-4SWwrRIGKMmA,80827
+llvmlite/tests/test_ir.py,sha256=tAE8Yruj8r1q6c8dk5I-oIJjnSVTADIwWGDKHUVUEo0,105472
+llvmlite/tests/test_refprune.py,sha256=oyk3HBLCOMPyRG-bj-omO3Ec_1lI66S8iNgZwl81Zs0,14235
+llvmlite/tests/test_valuerepr.py,sha256=57MaGznJUnqCf0etajnOCoBRue5-nmFTx1bds_5atlE,1989
+llvmlite/utils.py,sha256=BwgrA2JaYaZiHRafshoZBHiYSBskJQMG_K2F2jbW2-w,695
diff --git a/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/WHEEL b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..5feb1eeba52cffb96bc20980b20ca1eb17bea57f
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64
+
diff --git a/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/top_level.txt b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..454f54ec1099613577b38e16e4d840f482157738
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite-0.41.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+llvmlite
diff --git a/lib/python3.11/site-packages/llvmlite/__init__.py b/lib/python3.11/site-packages/llvmlite/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e44e9d156619faa3b3623f025a35d9e815fe4445
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/__init__.py
@@ -0,0 +1,3 @@
+from ._version import get_versions
+__version__ = get_versions()['version']
+del get_versions
diff --git a/lib/python3.11/site-packages/llvmlite/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aceab1505c186133e42e584bbf03905bfdb8f98d
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/__pycache__/_version.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/__pycache__/_version.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c72e4da84de996100ef925c79e89957603226ffd
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/__pycache__/_version.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/__pycache__/utils.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8b9c2e8e15771a999a71845f007c9bfdddaa9d71
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/__pycache__/utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/_version.py b/lib/python3.11/site-packages/llvmlite/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..448d617b91c2dd9201c0613a7ab035e08da874f6
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/_version.py
@@ -0,0 +1,11 @@
+
+# This file was generated by 'versioneer.py' (0.14) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+version_version = '0.41.1'
+version_full = '42db9b74c8e8ca012cb4394cbf941f2f9e4ae12b'
+def get_versions(default={}, verbose=False):
+    return {'version': version_version, 'full': version_full}
+
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__init__.py b/lib/python3.11/site-packages/llvmlite/binding/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ef0301a90279e235d10b54c786b0e07b2b93118
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/__init__.py
@@ -0,0 +1,17 @@
+"""
+Things that rely on the LLVM library
+"""
+from .dylib import *
+from .executionengine import *
+from .initfini import *
+from .linker import *
+from .module import *
+from .options import *
+from .passmanagers import *
+from .targets import *
+from .transforms import *
+from .value import *
+from .analysis import *
+from .object_file import *
+from .context import *
+from .orcjit import *
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..adec8e0a94fa7a4d4caa3f5d4304653473963b0b
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/analysis.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/analysis.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a82b12726acd2b36e21574e536495d80ad65c876
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/analysis.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/common.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/common.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dfa1be0a00f6264af377f4af963792f81e6ea57
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/common.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/context.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/context.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5702fce97a8e43ee6b1e2472792862e191608c79
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/context.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/dylib.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/dylib.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..173a320da028fadfc13856663dcf6d83de001d71
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/dylib.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/executionengine.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/executionengine.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c39815aace2b5a4666375c895fe124bc4741fdc8
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/executionengine.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/ffi.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/ffi.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cd9a7c675e36ab7e03f22f81b00db5af0695dd27
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/ffi.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/initfini.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/initfini.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a113433df3d0be377d325ac187fd5ad4c452a1ee
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/initfini.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/linker.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/linker.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa7e511fa3b49625618428e1ce58093f77eb7aef
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/linker.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/module.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/module.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c4bfae6799162a7b5e32ac1d6aed2884998eea2
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/module.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/object_file.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/object_file.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5221b05ec7907da483beb4cee0ae9b0cae7c6f47
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/object_file.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/options.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/options.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58d28c133d2c436ace42513aaf44d76eef4d5cbb
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/options.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/orcjit.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/orcjit.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ce04594c657a65ae0da70ae3400de838d43a11e3
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/orcjit.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/passmanagers.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/passmanagers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2bf2902d04302ba5d661486f540b8f621fd77b9
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/passmanagers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/targets.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/targets.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed85f58c32befac6f354ce6f284dde95660100e1
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/targets.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/transforms.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/transforms.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..840da6d23e9111302107e93be7519a1f03fd0fe9
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/transforms.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/__pycache__/value.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/value.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..70cb0ca90c022e21bfe7abad5308b38c4d09c243
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/binding/__pycache__/value.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/binding/analysis.py b/lib/python3.11/site-packages/llvmlite/binding/analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe2692bf9c58478972ba4d2ce7f4a9c55bc0a068
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/analysis.py
@@ -0,0 +1,69 @@
+"""
+A collection of analysis utilities
+"""
+
+from ctypes import POINTER, c_char_p, c_int
+
+from llvmlite.binding import ffi
+from llvmlite.binding.module import parse_assembly
+
+
+def get_function_cfg(func, show_inst=True):
+    """Return a string of the control-flow graph of the function in DOT
+    format. If the input `func` is not a materialized function, the module
+    containing the function is parsed to create an actual LLVM module.
+    The `show_inst` flag controls whether the instructions of each block
+    are printed.
+    """
+    assert func is not None
+    from llvmlite import ir
+    if isinstance(func, ir.Function):
+        mod = parse_assembly(str(func.module))
+        func = mod.get_function(func.name)
+
+    # Assume func is a materialized function
+    with ffi.OutputString() as dotstr:
+        ffi.lib.LLVMPY_WriteCFG(func, dotstr, show_inst)
+        return str(dotstr)
+
+
+def view_dot_graph(graph, filename=None, view=False):
+    """
+    View the given DOT source.  If view is True, the image is rendered
+    and viewed by the default application in the system.  The file path of
+    the output is returned.  If view is False, a graphviz.Source object is
+    returned.  If view is False and the environment is in a IPython session,
+    an IPython image object is returned and can be displayed inline in the
+    notebook.
+
+    This function requires the graphviz package.
+
+    Args
+    ----
+    - graph [str]: a DOT source code
+    - filename [str]: optional.  if given and view is True, this specifies
+                      the file path for the rendered output to write to.
+    - view [bool]: if True, opens the rendered output file.
+
+    """
+    # Optionally depends on graphviz package
+    import graphviz as gv
+
+    src = gv.Source(graph)
+    if view:
+        # Returns the output file path
+        return src.render(filename, view=view)
+    else:
+        # Attempts to show the graph in IPython notebook
+        try:
+            __IPYTHON__
+        except NameError:
+            return src
+        else:
+            import IPython.display as display
+            format = 'svg'
+            return display.SVG(data=src.pipe(format))
+
+
+# Ctypes binding
+ffi.lib.LLVMPY_WriteCFG.argtypes = [ffi.LLVMValueRef, POINTER(c_char_p), c_int]
diff --git a/lib/python3.11/site-packages/llvmlite/binding/common.py b/lib/python3.11/site-packages/llvmlite/binding/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f5746a5b057e76b1bf7b33c2892de1640919519
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/common.py
@@ -0,0 +1,34 @@
+import atexit
+
+
+def _encode_string(s):
+    encoded = s.encode('utf-8')
+    return encoded
+
+
+def _decode_string(b):
+    return b.decode('utf-8')
+
+
+_encode_string.__doc__ = """Encode a string for use by LLVM."""
+_decode_string.__doc__ = """Decode a LLVM character (byte)string."""
+
+
+_shutting_down = [False]
+
+
+def _at_shutdown():
+    _shutting_down[0] = True
+
+
+atexit.register(_at_shutdown)
+
+
+def _is_shutting_down(_shutting_down=_shutting_down):
+    """
+    Whether the interpreter is currently shutting down.
+    For use in finalizers, __del__ methods, and similar; it is advised
+    to early bind this function rather than look it up when calling it,
+    since at shutdown module globals may be cleared.
+    """
+    return _shutting_down[0]
diff --git a/lib/python3.11/site-packages/llvmlite/binding/context.py b/lib/python3.11/site-packages/llvmlite/binding/context.py
new file mode 100644
index 0000000000000000000000000000000000000000..7dffb82a71c1096490e80fb0031010a088cbcf0c
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/context.py
@@ -0,0 +1,29 @@
+from llvmlite.binding import ffi
+
+
+def create_context():
+    return ContextRef(ffi.lib.LLVMPY_ContextCreate())
+
+
+def get_global_context():
+    return GlobalContextRef(ffi.lib.LLVMPY_GetGlobalContext())
+
+
+class ContextRef(ffi.ObjectRef):
+    def __init__(self, context_ptr):
+        super(ContextRef, self).__init__(context_ptr)
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_ContextDispose(self)
+
+
+class GlobalContextRef(ContextRef):
+    def _dispose(self):
+        pass
+
+
+ffi.lib.LLVMPY_GetGlobalContext.restype = ffi.LLVMContextRef
+
+ffi.lib.LLVMPY_ContextCreate.restype = ffi.LLVMContextRef
+
+ffi.lib.LLVMPY_ContextDispose.argtypes = [ffi.LLVMContextRef]
diff --git a/lib/python3.11/site-packages/llvmlite/binding/dylib.py b/lib/python3.11/site-packages/llvmlite/binding/dylib.py
new file mode 100644
index 0000000000000000000000000000000000000000..e22542c496b7baadc002333f28e14a91e63a359a
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/dylib.py
@@ -0,0 +1,45 @@
+from ctypes import c_void_p, c_char_p, c_bool, POINTER
+
+from llvmlite.binding import ffi
+from llvmlite.binding.common import _encode_string
+
+
+def address_of_symbol(name):
+    """
+    Get the in-process address of symbol named *name*.
+    An integer is returned, or None if the symbol isn't found.
+    """
+    return ffi.lib.LLVMPY_SearchAddressOfSymbol(_encode_string(name))
+
+
+def add_symbol(name, address):
+    """
+    Register the *address* of global symbol *name*.  This will make
+    it usable (e.g. callable) from LLVM-compiled functions.
+    """
+    ffi.lib.LLVMPY_AddSymbol(_encode_string(name), c_void_p(address))
+
+
+def load_library_permanently(filename):
+    """
+    Load an external library
+    """
+    with ffi.OutputString() as outerr:
+        if ffi.lib.LLVMPY_LoadLibraryPermanently(
+                _encode_string(filename), outerr):
+            raise RuntimeError(str(outerr))
+
+# ============================================================================
+# FFI
+
+
+ffi.lib.LLVMPY_AddSymbol.argtypes = [
+    c_char_p,
+    c_void_p,
+]
+
+ffi.lib.LLVMPY_SearchAddressOfSymbol.argtypes = [c_char_p]
+ffi.lib.LLVMPY_SearchAddressOfSymbol.restype = c_void_p
+
+ffi.lib.LLVMPY_LoadLibraryPermanently.argtypes = [c_char_p, POINTER(c_char_p)]
+ffi.lib.LLVMPY_LoadLibraryPermanently.restype = c_bool
diff --git a/lib/python3.11/site-packages/llvmlite/binding/executionengine.py b/lib/python3.11/site-packages/llvmlite/binding/executionengine.py
new file mode 100644
index 0000000000000000000000000000000000000000..07cb8dab02056ea4d48b7a29ef20b6c8c0887b7a
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/executionengine.py
@@ -0,0 +1,322 @@
+from ctypes import (POINTER, c_char_p, c_bool, c_void_p,
+                    c_int, c_uint64, c_size_t, CFUNCTYPE, string_at, cast,
+                    py_object, Structure)
+
+from llvmlite.binding import ffi, targets, object_file
+
+
+# Just check these weren't optimized out of the DLL.
+ffi.lib.LLVMPY_LinkInMCJIT
+
+
+def create_mcjit_compiler(module, target_machine):
+    """
+    Create a MCJIT ExecutionEngine from the given *module* and
+    *target_machine*.
+    """
+    with ffi.OutputString() as outerr:
+        engine = ffi.lib.LLVMPY_CreateMCJITCompiler(
+            module, target_machine, outerr)
+        if not engine:
+            raise RuntimeError(str(outerr))
+
+    target_machine._owned = True
+    return ExecutionEngine(engine, module=module)
+
+
+def check_jit_execution():
+    """
+    Check the system allows execution of in-memory JITted functions.
+    An exception is raised otherwise.
+    """
+    errno = ffi.lib.LLVMPY_TryAllocateExecutableMemory()
+    if errno != 0:
+        raise OSError(errno,
+                      "cannot allocate executable memory. "
+                      "This may be due to security restrictions on your "
+                      "system, such as SELinux or similar mechanisms."
+                      )
+
+
+class ExecutionEngine(ffi.ObjectRef):
+    """An ExecutionEngine owns all Modules associated with it.
+    Deleting the engine will remove all associated modules.
+    It is an error to delete the associated modules.
+    """
+    _object_cache = None
+
+    def __init__(self, ptr, module):
+        """
+        Module ownership is transferred to the EE
+        """
+        self._modules = set([module])
+        self._td = None
+        module._owned = True
+        ffi.ObjectRef.__init__(self, ptr)
+
+    def get_function_address(self, name):
+        """
+        Return the address of the function named *name* as an integer.
+
+        It's a fatal error in LLVM if the symbol of *name* doesn't exist.
+        """
+        return ffi.lib.LLVMPY_GetFunctionAddress(self, name.encode("ascii"))
+
+    def get_global_value_address(self, name):
+        """
+        Return the address of the global value named *name* as an integer.
+
+        It's a fatal error in LLVM if the symbol of *name* doesn't exist.
+        """
+        return ffi.lib.LLVMPY_GetGlobalValueAddress(self, name.encode("ascii"))
+
+    def add_global_mapping(self, gv, addr):
+        # XXX unused?
+        ffi.lib.LLVMPY_AddGlobalMapping(self, gv, addr)
+
+    def add_module(self, module):
+        """
+        Ownership of module is transferred to the execution engine
+        """
+        if module in self._modules:
+            raise KeyError("module already added to this engine")
+        ffi.lib.LLVMPY_AddModule(self, module)
+        module._owned = True
+        self._modules.add(module)
+
+    def finalize_object(self):
+        """
+        Make sure all modules owned by the execution engine are fully processed
+        and "usable" for execution.
+        """
+        ffi.lib.LLVMPY_FinalizeObject(self)
+
+    def run_static_constructors(self):
+        """
+        Run static constructors which initialize module-level static objects.
+        """
+        ffi.lib.LLVMPY_RunStaticConstructors(self)
+
+    def run_static_destructors(self):
+        """
+        Run static destructors which perform module-level cleanup of static
+        resources.
+        """
+        ffi.lib.LLVMPY_RunStaticDestructors(self)
+
+    def remove_module(self, module):
+        """
+        Ownership of module is returned
+        """
+        with ffi.OutputString() as outerr:
+            if ffi.lib.LLVMPY_RemoveModule(self, module, outerr):
+                raise RuntimeError(str(outerr))
+        self._modules.remove(module)
+        module._owned = False
+
+    @property
+    def target_data(self):
+        """
+        The TargetData for this execution engine.
+        """
+        if self._td is not None:
+            return self._td
+        ptr = ffi.lib.LLVMPY_GetExecutionEngineTargetData(self)
+        self._td = targets.TargetData(ptr)
+        self._td._owned = True
+        return self._td
+
+    def enable_jit_events(self):
+        """
+        Enable JIT events for profiling of generated code.
+        Return value indicates whether connection to profiling tool
+        was successful.
+        """
+        ret = ffi.lib.LLVMPY_EnableJITEvents(self)
+        return ret
+
+    def _find_module_ptr(self, module_ptr):
+        """
+        Find the ModuleRef corresponding to the given pointer.
+        """
+        ptr = cast(module_ptr, c_void_p).value
+        for module in self._modules:
+            if cast(module._ptr, c_void_p).value == ptr:
+                return module
+        return None
+
+    def add_object_file(self, obj_file):
+        """
+        Add object file to the jit. object_file can be instance of
+        :class:ObjectFile or a string representing file system path
+        """
+        if isinstance(obj_file, str):
+            obj_file = object_file.ObjectFileRef.from_path(obj_file)
+
+        ffi.lib.LLVMPY_MCJITAddObjectFile(self, obj_file)
+
+    def set_object_cache(self, notify_func=None, getbuffer_func=None):
+        """
+        Set the object cache "notifyObjectCompiled" and "getBuffer"
+        callbacks to the given Python functions.
+        """
+        self._object_cache_notify = notify_func
+        self._object_cache_getbuffer = getbuffer_func
+        # Lifetime of the object cache is managed by us.
+        self._object_cache = _ObjectCacheRef(self)
+        # Note this doesn't keep a reference to self, to avoid reference
+        # cycles.
+        ffi.lib.LLVMPY_SetObjectCache(self, self._object_cache)
+
+    def _raw_object_cache_notify(self, data):
+        """
+        Low-level notify hook.
+        """
+        if self._object_cache_notify is None:
+            return
+        module_ptr = data.contents.module_ptr
+        buf_ptr = data.contents.buf_ptr
+        buf_len = data.contents.buf_len
+        buf = string_at(buf_ptr, buf_len)
+        module = self._find_module_ptr(module_ptr)
+        if module is None:
+            # The LLVM EE should only give notifications for modules
+            # known by us.
+            raise RuntimeError("object compilation notification "
+                               "for unknown module %s" % (module_ptr,))
+        self._object_cache_notify(module, buf)
+
+    def _raw_object_cache_getbuffer(self, data):
+        """
+        Low-level getbuffer hook.
+        """
+        if self._object_cache_getbuffer is None:
+            return
+        module_ptr = data.contents.module_ptr
+        module = self._find_module_ptr(module_ptr)
+        if module is None:
+            # The LLVM EE should only give notifications for modules
+            # known by us.
+            raise RuntimeError("object compilation notification "
+                               "for unknown module %s" % (module_ptr,))
+
+        buf = self._object_cache_getbuffer(module)
+        if buf is not None:
+            # Create a copy, which will be freed by the caller
+            data[0].buf_ptr = ffi.lib.LLVMPY_CreateByteString(buf, len(buf))
+            data[0].buf_len = len(buf)
+
+    def _dispose(self):
+        # The modules will be cleaned up by the EE
+        for mod in self._modules:
+            mod.detach()
+        if self._td is not None:
+            self._td.detach()
+        self._modules.clear()
+        self._object_cache = None
+        self._capi.LLVMPY_DisposeExecutionEngine(self)
+
+
+class _ObjectCacheRef(ffi.ObjectRef):
+    """
+    Internal: an ObjectCache instance for use within an ExecutionEngine.
+    """
+
+    def __init__(self, obj):
+        ptr = ffi.lib.LLVMPY_CreateObjectCache(_notify_c_hook,
+                                               _getbuffer_c_hook,
+                                               obj)
+        ffi.ObjectRef.__init__(self, ptr)
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeObjectCache(self)
+
+
+# ============================================================================
+# FFI
+
+
+ffi.lib.LLVMPY_CreateMCJITCompiler.argtypes = [
+    ffi.LLVMModuleRef,
+    ffi.LLVMTargetMachineRef,
+    POINTER(c_char_p),
+]
+ffi.lib.LLVMPY_CreateMCJITCompiler.restype = ffi.LLVMExecutionEngineRef
+
+ffi.lib.LLVMPY_RemoveModule.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    ffi.LLVMModuleRef,
+    POINTER(c_char_p),
+]
+ffi.lib.LLVMPY_RemoveModule.restype = c_bool
+
+ffi.lib.LLVMPY_AddModule.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    ffi.LLVMModuleRef
+]
+
+ffi.lib.LLVMPY_AddGlobalMapping.argtypes = [ffi.LLVMExecutionEngineRef,
+                                            ffi.LLVMValueRef,
+                                            c_void_p]
+
+ffi.lib.LLVMPY_FinalizeObject.argtypes = [ffi.LLVMExecutionEngineRef]
+
+ffi.lib.LLVMPY_GetExecutionEngineTargetData.argtypes = [
+    ffi.LLVMExecutionEngineRef
+]
+ffi.lib.LLVMPY_GetExecutionEngineTargetData.restype = ffi.LLVMTargetDataRef
+
+ffi.lib.LLVMPY_TryAllocateExecutableMemory.argtypes = []
+ffi.lib.LLVMPY_TryAllocateExecutableMemory.restype = c_int
+
+ffi.lib.LLVMPY_GetFunctionAddress.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    c_char_p
+]
+ffi.lib.LLVMPY_GetFunctionAddress.restype = c_uint64
+
+ffi.lib.LLVMPY_GetGlobalValueAddress.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    c_char_p
+]
+ffi.lib.LLVMPY_GetGlobalValueAddress.restype = c_uint64
+
+ffi.lib.LLVMPY_MCJITAddObjectFile.argtypes = [
+    ffi.LLVMExecutionEngineRef,
+    ffi.LLVMObjectFileRef
+]
+
+
+class _ObjectCacheData(Structure):
+    _fields_ = [
+        ('module_ptr', ffi.LLVMModuleRef),
+        ('buf_ptr', c_void_p),
+        ('buf_len', c_size_t),
+    ]
+
+
+_ObjectCacheNotifyFunc = CFUNCTYPE(None, py_object,
+                                   POINTER(_ObjectCacheData))
+_ObjectCacheGetBufferFunc = CFUNCTYPE(None, py_object,
+                                      POINTER(_ObjectCacheData))
+
+# XXX The ctypes function wrappers are created at the top-level, otherwise
+# there are issues when creating CFUNCTYPEs in child processes on CentOS 5
+# 32 bits.
+_notify_c_hook = _ObjectCacheNotifyFunc(
+    ExecutionEngine._raw_object_cache_notify)
+_getbuffer_c_hook = _ObjectCacheGetBufferFunc(
+    ExecutionEngine._raw_object_cache_getbuffer)
+
+ffi.lib.LLVMPY_CreateObjectCache.argtypes = [_ObjectCacheNotifyFunc,
+                                             _ObjectCacheGetBufferFunc,
+                                             py_object]
+ffi.lib.LLVMPY_CreateObjectCache.restype = ffi.LLVMObjectCacheRef
+
+ffi.lib.LLVMPY_DisposeObjectCache.argtypes = [ffi.LLVMObjectCacheRef]
+
+ffi.lib.LLVMPY_SetObjectCache.argtypes = [ffi.LLVMExecutionEngineRef,
+                                          ffi.LLVMObjectCacheRef]
+
+ffi.lib.LLVMPY_CreateByteString.restype = c_void_p
+ffi.lib.LLVMPY_CreateByteString.argtypes = [c_void_p, c_size_t]
diff --git a/lib/python3.11/site-packages/llvmlite/binding/ffi.py b/lib/python3.11/site-packages/llvmlite/binding/ffi.py
new file mode 100644
index 0000000000000000000000000000000000000000..58ab4efbcee9ace11ef5b37662c9c2bb8d542b81
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/ffi.py
@@ -0,0 +1,388 @@
+import sys
+import ctypes
+import threading
+import importlib.resources as _impres
+
+from llvmlite.binding.common import _decode_string, _is_shutting_down
+from llvmlite.utils import get_library_name
+
+
+def _make_opaque_ref(name):
+    newcls = type(name, (ctypes.Structure,), {})
+    return ctypes.POINTER(newcls)
+
+
+LLVMContextRef = _make_opaque_ref("LLVMContext")
+LLVMModuleRef = _make_opaque_ref("LLVMModule")
+LLVMValueRef = _make_opaque_ref("LLVMValue")
+LLVMTypeRef = _make_opaque_ref("LLVMType")
+LLVMExecutionEngineRef = _make_opaque_ref("LLVMExecutionEngine")
+LLVMPassManagerBuilderRef = _make_opaque_ref("LLVMPassManagerBuilder")
+LLVMPassManagerRef = _make_opaque_ref("LLVMPassManager")
+LLVMTargetDataRef = _make_opaque_ref("LLVMTargetData")
+LLVMTargetLibraryInfoRef = _make_opaque_ref("LLVMTargetLibraryInfo")
+LLVMTargetRef = _make_opaque_ref("LLVMTarget")
+LLVMTargetMachineRef = _make_opaque_ref("LLVMTargetMachine")
+LLVMMemoryBufferRef = _make_opaque_ref("LLVMMemoryBuffer")
+LLVMAttributeListIterator = _make_opaque_ref("LLVMAttributeListIterator")
+LLVMAttributeSetIterator = _make_opaque_ref("LLVMAttributeSetIterator")
+LLVMGlobalsIterator = _make_opaque_ref("LLVMGlobalsIterator")
+LLVMFunctionsIterator = _make_opaque_ref("LLVMFunctionsIterator")
+LLVMBlocksIterator = _make_opaque_ref("LLVMBlocksIterator")
+LLVMArgumentsIterator = _make_opaque_ref("LLVMArgumentsIterator")
+LLVMInstructionsIterator = _make_opaque_ref("LLVMInstructionsIterator")
+LLVMOperandsIterator = _make_opaque_ref("LLVMOperandsIterator")
+LLVMTypesIterator = _make_opaque_ref("LLVMTypesIterator")
+LLVMObjectCacheRef = _make_opaque_ref("LLVMObjectCache")
+LLVMObjectFileRef = _make_opaque_ref("LLVMObjectFile")
+LLVMSectionIteratorRef = _make_opaque_ref("LLVMSectionIterator")
+LLVMOrcLLJITRef = _make_opaque_ref("LLVMOrcLLJITRef")
+LLVMOrcDylibTrackerRef = _make_opaque_ref("LLVMOrcDylibTrackerRef")
+
+
+class _LLVMLock:
+    """A Lock to guarantee thread-safety for the LLVM C-API.
+
+    This class implements __enter__ and __exit__ for acquiring and releasing
+    the lock as a context manager.
+
+    Also, callbacks can be attached so that every time the lock is acquired
+    and released the corresponding callbacks will be invoked.
+    """
+    def __init__(self):
+        # The reentrant lock is needed for callbacks that re-enter
+        # the Python interpreter.
+        self._lock = threading.RLock()
+        self._cblist = []
+
+    def register(self, acq_fn, rel_fn):
+        """Register callbacks that are invoked immediately after the lock is
+        acquired (``acq_fn()``) and immediately before the lock is released
+        (``rel_fn()``).
+        """
+        self._cblist.append((acq_fn, rel_fn))
+
+    def unregister(self, acq_fn, rel_fn):
+        """Remove the registered callbacks.
+        """
+        self._cblist.remove((acq_fn, rel_fn))
+
+    def __enter__(self):
+        self._lock.acquire()
+        # Invoke all callbacks
+        for acq_fn, rel_fn in self._cblist:
+            acq_fn()
+
+    def __exit__(self, *exc_details):
+        # Invoke all callbacks
+        for acq_fn, rel_fn in self._cblist:
+            rel_fn()
+        self._lock.release()
+
+
+class _suppress_cleanup_errors:
+    def __init__(self, context):
+        self._context = context
+
+    def __enter__(self):
+        return self._context.__enter__()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        try:
+            return self._context.__exit__(exc_type, exc_value, traceback)
+        except PermissionError:
+            pass  # Resource dylibs can't be deleted on Windows.
+
+
+class _lib_wrapper(object):
+    """Wrap libllvmlite with a lock such that only one thread may access it at
+    a time.
+
+    This class duck-types a CDLL.
+    """
+    __slots__ = ['_lib_handle', '_fntab', '_lock']
+
+    def __init__(self):
+        self._lib_handle = None
+        self._fntab = {}
+        self._lock = _LLVMLock()
+
+    def _load_lib(self):
+        try:
+            with _suppress_cleanup_errors(_importlib_resources_path(
+                    __name__.rpartition(".")[0],
+                    get_library_name())) as lib_path:
+                self._lib_handle = ctypes.CDLL(str(lib_path))
+                # Check that we can look up expected symbols.
+                _ = self._lib_handle.LLVMPY_GetVersionInfo()
+        except (OSError, AttributeError) as e:
+            # OSError may be raised if the file cannot be opened, or is not
+            # a shared library.
+            # AttributeError is raised if LLVMPY_GetVersionInfo does not
+            # exist.
+            raise OSError("Could not find/load shared object file") from e
+
+    @property
+    def _lib(self):
+        # Not threadsafe.
+        if not self._lib_handle:
+            self._load_lib()
+        return self._lib_handle
+
+    def __getattr__(self, name):
+        try:
+            return self._fntab[name]
+        except KeyError:
+            # Lazily wraps new functions as they are requested
+            cfn = getattr(self._lib, name)
+            wrapped = _lib_fn_wrapper(self._lock, cfn)
+            self._fntab[name] = wrapped
+            return wrapped
+
+    @property
+    def _name(self):
+        """The name of the library passed in the CDLL constructor.
+
+        For duck-typing a ctypes.CDLL
+        """
+        return self._lib._name
+
+    @property
+    def _handle(self):
+        """The system handle used to access the library.
+
+        For duck-typing a ctypes.CDLL
+        """
+        return self._lib._handle
+
+
+class _lib_fn_wrapper(object):
+    """Wraps and duck-types a ctypes.CFUNCTYPE to provide
+    automatic locking when the wrapped function is called.
+
+    TODO: we can add methods to mark the function as threadsafe
+          and remove the locking-step on call when marked.
+    """
+    __slots__ = ['_lock', '_cfn']
+
+    def __init__(self, lock, cfn):
+        self._lock = lock
+        self._cfn = cfn
+
+    @property
+    def argtypes(self):
+        return self._cfn.argtypes
+
+    @argtypes.setter
+    def argtypes(self, argtypes):
+        self._cfn.argtypes = argtypes
+
+    @property
+    def restype(self):
+        return self._cfn.restype
+
+    @restype.setter
+    def restype(self, restype):
+        self._cfn.restype = restype
+
+    def __call__(self, *args, **kwargs):
+        with self._lock:
+            return self._cfn(*args, **kwargs)
+
+
+def _importlib_resources_path_repl(package, resource):
+    """Replacement implementation of `import.resources.path` to avoid
+    deprecation warning following code at importlib_resources/_legacy.py
+    as suggested by https://importlib-resources.readthedocs.io/en/latest/using.html#migrating-from-legacy
+
+    Notes on differences from importlib.resources implementation:
+
+    The `_common.normalize_path(resource)` call is skipped because it is an
+    internal API and it is unnecessary for the use here. What it does is
+    ensuring `resource` is a str and that it does not contain path separators.
+    """ # noqa E501
+    return _impres.as_file(_impres.files(package) / resource)
+
+
+_importlib_resources_path = (_importlib_resources_path_repl
+                             if sys.version_info[:2] >= (3, 9)
+                             else _impres.path)
+
+
+lib = _lib_wrapper()
+
+
+def register_lock_callback(acq_fn, rel_fn):
+    """Register callback functions for lock acquire and release.
+    *acq_fn* and *rel_fn* are callables that take no arguments.
+    """
+    lib._lock.register(acq_fn, rel_fn)
+
+
+def unregister_lock_callback(acq_fn, rel_fn):
+    """Remove the registered callback functions for lock acquire and release.
+    The arguments are the same as used in `register_lock_callback()`.
+    """
+    lib._lock.unregister(acq_fn, rel_fn)
+
+
+class _DeadPointer(object):
+    """
+    Dummy class to make error messages more helpful.
+    """
+
+
+class OutputString(object):
+    """
+    Object for managing the char* output of LLVM APIs.
+    """
+    _as_parameter_ = _DeadPointer()
+
+    @classmethod
+    def from_return(cls, ptr):
+        """Constructing from a pointer returned from the C-API.
+        The pointer must be allocated with LLVMPY_CreateString.
+
+        Note
+        ----
+        Because ctypes auto-converts *restype* of *c_char_p* into a python
+        string, we must use *c_void_p* to obtain the raw pointer.
+        """
+        return cls(init=ctypes.cast(ptr, ctypes.c_char_p))
+
+    def __init__(self, owned=True, init=None):
+        self._ptr = init if init is not None else ctypes.c_char_p(None)
+        self._as_parameter_ = ctypes.byref(self._ptr)
+        self._owned = owned
+
+    def close(self):
+        if self._ptr is not None:
+            if self._owned:
+                lib.LLVMPY_DisposeString(self._ptr)
+            self._ptr = None
+            del self._as_parameter_
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __del__(self, _is_shutting_down=_is_shutting_down):
+        # Avoid errors trying to rely on globals and modules at interpreter
+        # shutdown.
+        if not _is_shutting_down():
+            if self.close is not None:
+                self.close()
+
+    def __str__(self):
+        if self._ptr is None:
+            return "<dead OutputString>"
+        s = self._ptr.value
+        assert s is not None
+        return _decode_string(s)
+
+    def __bool__(self):
+        return bool(self._ptr)
+
+    __nonzero__ = __bool__
+
+    @property
+    def bytes(self):
+        """Get the raw bytes of content of the char pointer.
+        """
+        return self._ptr.value
+
+
+def ret_string(ptr):
+    """To wrap string return-value from C-API.
+    """
+    if ptr is not None:
+        return str(OutputString.from_return(ptr))
+
+
+def ret_bytes(ptr):
+    """To wrap bytes return-value from C-API.
+    """
+    if ptr is not None:
+        return OutputString.from_return(ptr).bytes
+
+
+class ObjectRef(object):
+    """
+    A wrapper around a ctypes pointer to a LLVM object ("resource").
+    """
+    _closed = False
+    _as_parameter_ = _DeadPointer()
+    # Whether this object pointer is owned by another one.
+    _owned = False
+
+    def __init__(self, ptr):
+        if ptr is None:
+            raise ValueError("NULL pointer")
+        self._ptr = ptr
+        self._as_parameter_ = ptr
+        self._capi = lib
+
+    def close(self):
+        """
+        Close this object and do any required clean-up actions.
+        """
+        try:
+            if not self._closed and not self._owned:
+                self._dispose()
+        finally:
+            self.detach()
+
+    def detach(self):
+        """
+        Detach the underlying LLVM resource without disposing of it.
+        """
+        if not self._closed:
+            del self._as_parameter_
+            self._closed = True
+            self._ptr = None
+
+    def _dispose(self):
+        """
+        Dispose of the underlying LLVM resource.  Should be overriden
+        by subclasses.  Automatically called by close(), __del__() and
+        __exit__() (unless the resource has been detached).
+        """
+
+    @property
+    def closed(self):
+        """
+        Whether this object has been closed.  A closed object can't
+        be used anymore.
+        """
+        return self._closed
+
+    def __enter__(self):
+        assert hasattr(self, "close")
+        if self._closed:
+            raise RuntimeError("%s instance already closed" % (self.__class__,))
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def __del__(self, _is_shutting_down=_is_shutting_down):
+        if not _is_shutting_down():
+            if self.close is not None:
+                self.close()
+
+    def __bool__(self):
+        return bool(self._ptr)
+
+    def __eq__(self, other):
+        if not hasattr(other, "_ptr"):
+            return False
+        return ctypes.addressof(self._ptr[0]) == \
+            ctypes.addressof(other._ptr[0])
+
+    __nonzero__ = __bool__
+
+    # XXX useful?
+    def __hash__(self):
+        return hash(ctypes.cast(self._ptr, ctypes.c_void_p).value)
diff --git a/lib/python3.11/site-packages/llvmlite/binding/initfini.py b/lib/python3.11/site-packages/llvmlite/binding/initfini.py
new file mode 100644
index 0000000000000000000000000000000000000000..4466d9da2f2c131b750a2a8ff61ed7381acb7363
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/initfini.py
@@ -0,0 +1,73 @@
+from ctypes import c_uint
+
+from llvmlite.binding import ffi
+
+
+def initialize():
+    """
+    Initialize the LLVM core.
+    """
+    ffi.lib.LLVMPY_InitializeCore()
+
+
+def initialize_all_targets():
+    """
+    Initialize all targets. Necessary before targets can be looked up
+    via the :class:`Target` class.
+    """
+    ffi.lib.LLVMPY_InitializeAllTargetInfos()
+    ffi.lib.LLVMPY_InitializeAllTargets()
+    ffi.lib.LLVMPY_InitializeAllTargetMCs()
+
+
+def initialize_all_asmprinters():
+    """
+    Initialize all code generators. Necessary before generating
+    any assembly or machine code via the :meth:`TargetMachine.emit_object`
+    and :meth:`TargetMachine.emit_assembly` methods.
+    """
+    ffi.lib.LLVMPY_InitializeAllAsmPrinters()
+
+
+def initialize_native_target():
+    """
+    Initialize the native (host) target.  Necessary before doing any
+    code generation.
+    """
+    ffi.lib.LLVMPY_InitializeNativeTarget()
+
+
+def initialize_native_asmprinter():
+    """
+    Initialize the native ASM printer.
+    """
+    ffi.lib.LLVMPY_InitializeNativeAsmPrinter()
+
+
+def initialize_native_asmparser():
+    """
+    Initialize the native ASM parser.
+    """
+    ffi.lib.LLVMPY_InitializeNativeAsmParser()
+
+
+def shutdown():
+    ffi.lib.LLVMPY_Shutdown()
+
+
+# =============================================================================
+# Set function FFI
+
+ffi.lib.LLVMPY_GetVersionInfo.restype = c_uint
+
+
+def _version_info():
+    v = []
+    x = ffi.lib.LLVMPY_GetVersionInfo()
+    while x:
+        v.append(x & 0xff)
+        x >>= 8
+    return tuple(reversed(v))
+
+
+llvm_version_info = _version_info()
diff --git a/lib/python3.11/site-packages/llvmlite/binding/libllvmlite.dylib b/lib/python3.11/site-packages/llvmlite/binding/libllvmlite.dylib
new file mode 100644
index 0000000000000000000000000000000000000000..9b78261765c88dc8dc590fcedf3e5ee9cfb54696
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/libllvmlite.dylib
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3357cc66e6582cf25850ce9b1f710cbe4160f871a90c8bbe96cfd87fe857ea30
+size 91363294
diff --git a/lib/python3.11/site-packages/llvmlite/binding/linker.py b/lib/python3.11/site-packages/llvmlite/binding/linker.py
new file mode 100644
index 0000000000000000000000000000000000000000..31d1e26ffb99763af367d07c30fd77770103dc79
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/linker.py
@@ -0,0 +1,20 @@
+from ctypes import c_int, c_char_p, POINTER
+from llvmlite.binding import ffi
+
+
+def link_modules(dst, src):
+    with ffi.OutputString() as outerr:
+        err = ffi.lib.LLVMPY_LinkModules(dst, src, outerr)
+        # The underlying module was destroyed
+        src.detach()
+        if err:
+            raise RuntimeError(str(outerr))
+
+
+ffi.lib.LLVMPY_LinkModules.argtypes = [
+    ffi.LLVMModuleRef,
+    ffi.LLVMModuleRef,
+    POINTER(c_char_p),
+]
+
+ffi.lib.LLVMPY_LinkModules.restype = c_int
diff --git a/lib/python3.11/site-packages/llvmlite/binding/module.py b/lib/python3.11/site-packages/llvmlite/binding/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..dcbb1faa6545718f9226133ccef42b03a098fd37
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/module.py
@@ -0,0 +1,349 @@
+from ctypes import (c_char_p, byref, POINTER, c_bool, create_string_buffer,
+                    c_size_t, string_at)
+
+from llvmlite.binding import ffi
+from llvmlite.binding.linker import link_modules
+from llvmlite.binding.common import _decode_string, _encode_string
+from llvmlite.binding.value import ValueRef, TypeRef
+from llvmlite.binding.context import get_global_context
+
+
+def parse_assembly(llvmir, context=None):
+    """
+    Create Module from a LLVM IR string
+    """
+    if context is None:
+        context = get_global_context()
+    llvmir = _encode_string(llvmir)
+    strbuf = c_char_p(llvmir)
+    with ffi.OutputString() as errmsg:
+        mod = ModuleRef(
+            ffi.lib.LLVMPY_ParseAssembly(context, strbuf, errmsg),
+            context)
+        if errmsg:
+            mod.close()
+            raise RuntimeError("LLVM IR parsing error\n{0}".format(errmsg))
+    return mod
+
+
+def parse_bitcode(bitcode, context=None):
+    """
+    Create Module from a LLVM *bitcode* (a bytes object).
+    """
+    if context is None:
+        context = get_global_context()
+    buf = c_char_p(bitcode)
+    bufsize = len(bitcode)
+    with ffi.OutputString() as errmsg:
+        mod = ModuleRef(ffi.lib.LLVMPY_ParseBitcode(
+            context, buf, bufsize, errmsg), context)
+        if errmsg:
+            mod.close()
+            raise RuntimeError(
+                "LLVM bitcode parsing error\n{0}".format(errmsg))
+    return mod
+
+
+class ModuleRef(ffi.ObjectRef):
+    """
+    A reference to a LLVM module.
+    """
+
+    def __init__(self, module_ptr, context):
+        super(ModuleRef, self).__init__(module_ptr)
+        self._context = context
+
+    def __str__(self):
+        with ffi.OutputString() as outstr:
+            ffi.lib.LLVMPY_PrintModuleToString(self, outstr)
+            return str(outstr)
+
+    def as_bitcode(self):
+        """
+        Return the module's LLVM bitcode, as a bytes object.
+        """
+        ptr = c_char_p(None)
+        size = c_size_t(-1)
+        ffi.lib.LLVMPY_WriteBitcodeToString(self, byref(ptr), byref(size))
+        if not ptr:
+            raise MemoryError
+        try:
+            assert size.value >= 0
+            return string_at(ptr, size.value)
+        finally:
+            ffi.lib.LLVMPY_DisposeString(ptr)
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeModule(self)
+
+    def get_function(self, name):
+        """
+        Get a ValueRef pointing to the function named *name*.
+        NameError is raised if the symbol isn't found.
+        """
+        p = ffi.lib.LLVMPY_GetNamedFunction(self, _encode_string(name))
+        if not p:
+            raise NameError(name)
+        return ValueRef(p, 'function', dict(module=self))
+
+    def get_global_variable(self, name):
+        """
+        Get a ValueRef pointing to the global variable named *name*.
+        NameError is raised if the symbol isn't found.
+        """
+        p = ffi.lib.LLVMPY_GetNamedGlobalVariable(self, _encode_string(name))
+        if not p:
+            raise NameError(name)
+        return ValueRef(p, 'global', dict(module=self))
+
+    def get_struct_type(self, name):
+        """
+        Get a TypeRef pointing to a structure type named *name*.
+        NameError is raised if the struct type isn't found.
+        """
+        p = ffi.lib.LLVMPY_GetNamedStructType(self, _encode_string(name))
+        if not p:
+            raise NameError(name)
+        return TypeRef(p)
+
+    def verify(self):
+        """
+        Verify the module IR's correctness.  RuntimeError is raised on error.
+        """
+        with ffi.OutputString() as outmsg:
+            if ffi.lib.LLVMPY_VerifyModule(self, outmsg):
+                raise RuntimeError(str(outmsg))
+
+    @property
+    def name(self):
+        """
+        The module's identifier.
+        """
+        return _decode_string(ffi.lib.LLVMPY_GetModuleName(self))
+
+    @name.setter
+    def name(self, value):
+        ffi.lib.LLVMPY_SetModuleName(self, _encode_string(value))
+
+    @property
+    def source_file(self):
+        """
+        The module's original source file name
+        """
+        return _decode_string(ffi.lib.LLVMPY_GetModuleSourceFileName(self))
+
+    @property
+    def data_layout(self):
+        """
+        This module's data layout specification, as a string.
+        """
+        # LLVMGetDataLayout() points inside a std::string managed by LLVM.
+        with ffi.OutputString(owned=False) as outmsg:
+            ffi.lib.LLVMPY_GetDataLayout(self, outmsg)
+            return str(outmsg)
+
+    @data_layout.setter
+    def data_layout(self, strrep):
+        ffi.lib.LLVMPY_SetDataLayout(self,
+                                     create_string_buffer(
+                                         strrep.encode('utf8')))
+
+    @property
+    def triple(self):
+        """
+        This module's target "triple" specification, as a string.
+        """
+        # LLVMGetTarget() points inside a std::string managed by LLVM.
+        with ffi.OutputString(owned=False) as outmsg:
+            ffi.lib.LLVMPY_GetTarget(self, outmsg)
+            return str(outmsg)
+
+    @triple.setter
+    def triple(self, strrep):
+        ffi.lib.LLVMPY_SetTarget(self,
+                                 create_string_buffer(
+                                     strrep.encode('utf8')))
+
+    def link_in(self, other, preserve=False):
+        """
+        Link the *other* module into this one.  The *other* module will
+        be destroyed unless *preserve* is true.
+        """
+        if preserve:
+            other = other.clone()
+        link_modules(self, other)
+
+    @property
+    def global_variables(self):
+        """
+        Return an iterator over this module's global variables.
+        The iterator will yield a ValueRef for each global variable.
+
+        Note that global variables don't include functions
+        (a function is a "global value" but not a "global variable" in
+         LLVM parlance)
+        """
+        it = ffi.lib.LLVMPY_ModuleGlobalsIter(self)
+        return _GlobalsIterator(it, dict(module=self))
+
+    @property
+    def functions(self):
+        """
+        Return an iterator over this module's functions.
+        The iterator will yield a ValueRef for each function.
+        """
+        it = ffi.lib.LLVMPY_ModuleFunctionsIter(self)
+        return _FunctionsIterator(it, dict(module=self))
+
+    @property
+    def struct_types(self):
+        """
+        Return an iterator over the struct types defined in
+        the module. The iterator will yield a TypeRef.
+        """
+        it = ffi.lib.LLVMPY_ModuleTypesIter(self)
+        return _TypesIterator(it, dict(module=self))
+
+    def clone(self):
+        return ModuleRef(ffi.lib.LLVMPY_CloneModule(self), self._context)
+
+
+class _Iterator(ffi.ObjectRef):
+
+    kind = None
+
+    def __init__(self, ptr, parents):
+        ffi.ObjectRef.__init__(self, ptr)
+        self._parents = parents
+        assert self.kind is not None
+
+    def __next__(self):
+        vp = self._next()
+        if vp:
+            return ValueRef(vp, self.kind, self._parents)
+        else:
+            raise StopIteration
+
+    next = __next__
+
+    def __iter__(self):
+        return self
+
+
+class _GlobalsIterator(_Iterator):
+
+    kind = 'global'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeGlobalsIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_GlobalsIterNext(self)
+
+
+class _FunctionsIterator(_Iterator):
+
+    kind = 'function'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeFunctionsIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_FunctionsIterNext(self)
+
+
+class _TypesIterator(_Iterator):
+
+    kind = 'type'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeTypesIter(self)
+
+    def __next__(self):
+        vp = self._next()
+        if vp:
+            return TypeRef(vp)
+        else:
+            raise StopIteration
+
+    def _next(self):
+        return ffi.lib.LLVMPY_TypesIterNext(self)
+
+    next = __next__
+
+
+# =============================================================================
+# Set function FFI
+
+ffi.lib.LLVMPY_ParseAssembly.argtypes = [ffi.LLVMContextRef,
+                                         c_char_p,
+                                         POINTER(c_char_p)]
+ffi.lib.LLVMPY_ParseAssembly.restype = ffi.LLVMModuleRef
+
+ffi.lib.LLVMPY_ParseBitcode.argtypes = [ffi.LLVMContextRef,
+                                        c_char_p, c_size_t,
+                                        POINTER(c_char_p)]
+ffi.lib.LLVMPY_ParseBitcode.restype = ffi.LLVMModuleRef
+
+ffi.lib.LLVMPY_DisposeModule.argtypes = [ffi.LLVMModuleRef]
+
+ffi.lib.LLVMPY_PrintModuleToString.argtypes = [ffi.LLVMModuleRef,
+                                               POINTER(c_char_p)]
+ffi.lib.LLVMPY_WriteBitcodeToString.argtypes = [ffi.LLVMModuleRef,
+                                                POINTER(c_char_p),
+                                                POINTER(c_size_t)]
+
+ffi.lib.LLVMPY_GetNamedFunction.argtypes = [ffi.LLVMModuleRef,
+                                            c_char_p]
+ffi.lib.LLVMPY_GetNamedFunction.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_VerifyModule.argtypes = [ffi.LLVMModuleRef,
+                                        POINTER(c_char_p)]
+ffi.lib.LLVMPY_VerifyModule.restype = c_bool
+
+ffi.lib.LLVMPY_GetDataLayout.argtypes = [ffi.LLVMModuleRef, POINTER(c_char_p)]
+ffi.lib.LLVMPY_SetDataLayout.argtypes = [ffi.LLVMModuleRef, c_char_p]
+
+ffi.lib.LLVMPY_GetTarget.argtypes = [ffi.LLVMModuleRef, POINTER(c_char_p)]
+ffi.lib.LLVMPY_SetTarget.argtypes = [ffi.LLVMModuleRef, c_char_p]
+
+ffi.lib.LLVMPY_GetNamedGlobalVariable.argtypes = [ffi.LLVMModuleRef, c_char_p]
+ffi.lib.LLVMPY_GetNamedGlobalVariable.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_GetNamedStructType.argtypes = [ffi.LLVMModuleRef, c_char_p]
+ffi.lib.LLVMPY_GetNamedStructType.restype = ffi.LLVMTypeRef
+
+ffi.lib.LLVMPY_ModuleGlobalsIter.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_ModuleGlobalsIter.restype = ffi.LLVMGlobalsIterator
+
+ffi.lib.LLVMPY_DisposeGlobalsIter.argtypes = [ffi.LLVMGlobalsIterator]
+
+ffi.lib.LLVMPY_GlobalsIterNext.argtypes = [ffi.LLVMGlobalsIterator]
+ffi.lib.LLVMPY_GlobalsIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_ModuleFunctionsIter.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_ModuleFunctionsIter.restype = ffi.LLVMFunctionsIterator
+
+ffi.lib.LLVMPY_ModuleTypesIter.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_ModuleTypesIter.restype = ffi.LLVMTypesIterator
+
+ffi.lib.LLVMPY_DisposeFunctionsIter.argtypes = [ffi.LLVMFunctionsIterator]
+
+ffi.lib.LLVMPY_DisposeTypesIter.argtypes = [ffi.LLVMTypesIterator]
+
+ffi.lib.LLVMPY_FunctionsIterNext.argtypes = [ffi.LLVMFunctionsIterator]
+ffi.lib.LLVMPY_FunctionsIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_TypesIterNext.argtypes = [ffi.LLVMTypesIterator]
+ffi.lib.LLVMPY_TypesIterNext.restype = ffi.LLVMTypeRef
+
+ffi.lib.LLVMPY_CloneModule.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_CloneModule.restype = ffi.LLVMModuleRef
+
+ffi.lib.LLVMPY_GetModuleName.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_GetModuleName.restype = c_char_p
+
+ffi.lib.LLVMPY_SetModuleName.argtypes = [ffi.LLVMModuleRef, c_char_p]
+
+ffi.lib.LLVMPY_GetModuleSourceFileName.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_GetModuleSourceFileName.restype = c_char_p
diff --git a/lib/python3.11/site-packages/llvmlite/binding/object_file.py b/lib/python3.11/site-packages/llvmlite/binding/object_file.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5961b079ef87393347436a8fd8e70fb0525b39d
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/object_file.py
@@ -0,0 +1,82 @@
+from llvmlite.binding import ffi
+from ctypes import (c_bool, c_char_p, c_char, c_size_t, string_at, c_uint64,
+                    POINTER)
+
+
+class SectionIteratorRef(ffi.ObjectRef):
+    def name(self):
+        return ffi.lib.LLVMPY_GetSectionName(self)
+
+    def is_text(self):
+        return ffi.lib.LLVMPY_IsSectionText(self)
+
+    def size(self):
+        return ffi.lib.LLVMPY_GetSectionSize(self)
+
+    def address(self):
+        return ffi.lib.LLVMPY_GetSectionAddress(self)
+
+    def data(self):
+        return string_at(ffi.lib.LLVMPY_GetSectionContents(self), self.size())
+
+    def is_end(self, object_file):
+        return ffi.lib.LLVMPY_IsSectionIteratorAtEnd(object_file, self)
+
+    def next(self):
+        ffi.lib.LLVMPY_MoveToNextSection(self)
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_DisposeSectionIterator(self)
+
+
+class ObjectFileRef(ffi.ObjectRef):
+    @classmethod
+    def from_data(cls, data):
+        return cls(ffi.lib.LLVMPY_CreateObjectFile(data, len(data)))
+
+    @classmethod
+    def from_path(cls, path):
+        with open(path, 'rb') as f:
+            data = f.read()
+        return cls(ffi.lib.LLVMPY_CreateObjectFile(data, len(data)))
+
+    def sections(self):
+        it = SectionIteratorRef(ffi.lib.LLVMPY_GetSections(self))
+        while not it.is_end(self):
+            yield it
+            it.next()
+
+    def _dispose(self):
+        ffi.lib.LLVMPY_DisposeObjectFile(self)
+
+
+ffi.lib.LLVMPY_CreateObjectFile.argtypes = [c_char_p, c_size_t]
+ffi.lib.LLVMPY_CreateObjectFile.restype = ffi.LLVMObjectFileRef
+
+ffi.lib.LLVMPY_DisposeObjectFile.argtypes = [ffi.LLVMObjectFileRef]
+
+ffi.lib.LLVMPY_GetSections.argtypes = [ffi.LLVMObjectFileRef]
+ffi.lib.LLVMPY_GetSections.restype = ffi.LLVMSectionIteratorRef
+
+ffi.lib.LLVMPY_DisposeSectionIterator.argtypes = [ffi.LLVMSectionIteratorRef]
+
+ffi.lib.LLVMPY_MoveToNextSection.argtypes = [ffi.LLVMSectionIteratorRef]
+
+ffi.lib.LLVMPY_IsSectionIteratorAtEnd.argtypes = [
+    ffi.LLVMObjectFileRef, ffi.LLVMSectionIteratorRef]
+ffi.lib.LLVMPY_IsSectionIteratorAtEnd.restype = c_bool
+
+ffi.lib.LLVMPY_GetSectionName.argtypes = [ffi.LLVMSectionIteratorRef]
+ffi.lib.LLVMPY_GetSectionName.restype = c_char_p
+
+ffi.lib.LLVMPY_GetSectionSize.argtypes = [ffi.LLVMSectionIteratorRef]
+ffi.lib.LLVMPY_GetSectionSize.restype = c_uint64
+
+ffi.lib.LLVMPY_GetSectionAddress.argtypes = [ffi.LLVMSectionIteratorRef]
+ffi.lib.LLVMPY_GetSectionAddress.restype = c_uint64
+
+ffi.lib.LLVMPY_GetSectionContents.argtypes = [ffi.LLVMSectionIteratorRef]
+ffi.lib.LLVMPY_GetSectionContents.restype = POINTER(c_char)
+
+ffi.lib.LLVMPY_IsSectionText.argtypes = [ffi.LLVMSectionIteratorRef]
+ffi.lib.LLVMPY_IsSectionText.restype = c_bool
diff --git a/lib/python3.11/site-packages/llvmlite/binding/options.py b/lib/python3.11/site-packages/llvmlite/binding/options.py
new file mode 100644
index 0000000000000000000000000000000000000000..15eedfaaf476938c97abcd7e75131e9590f34203
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/options.py
@@ -0,0 +1,17 @@
+from llvmlite.binding import ffi
+from llvmlite.binding.common import _encode_string
+from ctypes import c_char_p
+
+
+def set_option(name, option):
+    """
+    Set the given LLVM "command-line" option.
+
+    For example set_option("test", "-debug-pass=Structure") would display
+    all optimization passes when generating code.
+    """
+    ffi.lib.LLVMPY_SetCommandLine(_encode_string(name),
+                                  _encode_string(option))
+
+
+ffi.lib.LLVMPY_SetCommandLine.argtypes = [c_char_p, c_char_p]
diff --git a/lib/python3.11/site-packages/llvmlite/binding/orcjit.py b/lib/python3.11/site-packages/llvmlite/binding/orcjit.py
new file mode 100644
index 0000000000000000000000000000000000000000..82996f586bf688bce389db15d29b0c294f5cba67
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/orcjit.py
@@ -0,0 +1,342 @@
+import ctypes
+from ctypes import POINTER, c_bool, c_char_p, c_uint8, c_uint64, c_size_t
+
+from llvmlite.binding import ffi, targets
+
+
+class _LinkElement(ctypes.Structure):
+    _fields_ = [("element_kind", c_uint8),
+                ("value", c_char_p),
+                ("value_len", c_size_t)]
+
+
+class _SymbolAddress(ctypes.Structure):
+    _fields_ = [("name", c_char_p), ("address", c_uint64)]
+
+
+class JITLibraryBuilder:
+    """
+    Create a library for linking by OrcJIT
+
+    OrcJIT operates like a linker: a number of compilation units and
+    dependencies are collected together and linked into a single dynamic library
+    that can export functions to other libraries or to be consumed directly as
+    entry points into JITted code. The native OrcJIT has a lot of memory
+    management complications so this API is designed to work well with Python's
+    garbage collection.
+
+    The creation of a new library is a bit like a linker command line where
+    compilation units, mostly as LLVM IR, and previously constructed libraries
+    are linked together, then loaded into memory, and the addresses of exported
+    symbols are extracted. Any static initializers are run and the exported
+    addresses and a resource tracker is produced. As long as the resource
+    tracker is referenced somewhere in Python, the exported addresses will be
+    valid. Once the resource tracker is garbage collected, the static
+    destructors will run and library will be unloaded from memory.
+    """
+    def __init__(self):
+        self.__entries = []
+        self.__exports = set()
+        self.__imports = {}
+
+    def add_ir(self, llvmir):
+        """
+        Adds a compilation unit to the library using LLVM IR as the input
+        format.
+
+        This takes a string or an object that can be converted to a string,
+        including IRBuilder, that contains LLVM IR.
+        """
+        self.__entries.append((0, str(llvmir).encode('utf-8')))
+        return self
+
+    def add_native_assembly(self, asm):
+        """
+        Adds a compilation unit to the library using native assembly as the
+        input format.
+
+        This takes a string or an object that can be converted to a string that
+        contains native assembly, which will be
+        parsed by LLVM.
+        """
+        self.__entries.append((1, str(asm).encode('utf-8')))
+        return self
+
+    def add_object_img(self, data):
+        """
+        Adds a compilation unit to the library using pre-compiled object code.
+
+        This takes the bytes of the contents of an object artifact which will be
+        loaded by LLVM.
+        """
+        self.__entries.append((2, bytes(data)))
+        return self
+
+    def add_object_file(self, file_path):
+        """
+        Adds a compilation unit to the library using pre-compiled object file.
+
+        This takes a string or path-like object that references an object file
+        which will be loaded by LLVM.
+        """
+        with open(file_path, "rb") as f:
+            self.__entries.append((2, f.read()))
+        return self
+
+    def add_jit_library(self, name):
+        """
+        Adds an existing JIT library as prerequisite.
+
+        The name of the library must match the one provided in a previous link
+        command.
+        """
+        self.__entries.append((3, str(name).encode('utf-8')))
+        return self
+
+    def add_current_process(self):
+        """
+        Allows the JITted library to access symbols in the current binary.
+
+        That is, it allows exporting the current binary's symbols, including
+        loaded libraries, as imports to the JITted
+        library.
+        """
+        self.__entries.append((3, b''))
+        return self
+
+    def import_symbol(self, name, address):
+        """
+        Register the *address* of global symbol *name*.  This will make
+        it usable (e.g. callable) from LLVM-compiled functions.
+        """
+        self.__imports[str(name)] = c_uint64(address)
+        return self
+
+    def export_symbol(self, name):
+        """
+        During linking, extract the address of a symbol that was defined in one
+        of the compilation units.
+
+        This allows getting symbols, functions or global variables, out of the
+        JIT linked library. The addresses will be
+        available when the link method is called.
+        """
+        self.__exports.add(str(name))
+        return self
+
+    def link(self, lljit, library_name):
+        """
+        Link all the current compilation units into a JITted library and extract
+        the address of exported symbols.
+
+        An instance of the OrcJIT instance must be provided and this will be the
+        scope that is used to find other JITted libraries that are dependencies
+        and also be the place where this library will be defined.
+
+        After linking, the method will return a resource tracker that keeps the
+        library alive. This tracker also knows the addresses of any exported
+        symbols that were requested.
+
+        The addresses will be valid as long as the resource tracker is
+        referenced.
+
+        When the resource tracker is destroyed, the library will be cleaned up,
+        however, the name of the library cannot be reused.
+        """
+        assert not lljit.closed, "Cannot add to closed JIT"
+        encoded_library_name = str(library_name).encode('utf-8')
+        assert len(encoded_library_name) > 0, "Library cannot be empty"
+        elements = (_LinkElement * len(self.__entries))()
+        for idx, (kind, value) in enumerate(self.__entries):
+            elements[idx].element_kind = c_uint8(kind)
+            elements[idx].value = c_char_p(value)
+            elements[idx].value_len = c_size_t(len(value))
+        exports = (_SymbolAddress * len(self.__exports))()
+        for idx, name in enumerate(self.__exports):
+            exports[idx].name = name.encode('utf-8')
+
+        imports = (_SymbolAddress * len(self.__imports))()
+        for idx, (name, addr) in enumerate(self.__imports.items()):
+            imports[idx].name = name.encode('utf-8')
+            imports[idx].address = addr
+
+        with ffi.OutputString() as outerr:
+            tracker = lljit._capi.LLVMPY_LLJIT_Link(
+                lljit._ptr,
+                encoded_library_name,
+                elements,
+                len(self.__entries),
+                imports,
+                len(self.__imports),
+                exports,
+                len(self.__exports),
+                outerr)
+            if not tracker:
+                raise RuntimeError(str(outerr))
+        return ResourceTracker(tracker,
+                               library_name,
+                               {name: exports[idx].address
+                                for idx, name in enumerate(self.__exports)})
+
+
+class ResourceTracker(ffi.ObjectRef):
+    """
+    A resource tracker is created for each loaded JIT library and keeps the
+    module alive.
+
+    OrcJIT supports unloading libraries that are no longer used. This resource
+    tracker should be stored in any object that reference functions or constants
+    for a JITted library. When all references to the resource tracker are
+    dropped, this will trigger LLVM to unload the library and destroy any
+    functions.
+
+    Failure to keep resource trackers while calling a function or accessing a
+    symbol can result in crashes or memory corruption.
+
+    LLVM internally tracks references between different libraries, so only
+    "leaf" libraries need to be tracked.
+    """
+    def __init__(self, ptr, name, addresses):
+        self.__addresses = addresses
+        self.__name = name
+        ffi.ObjectRef.__init__(self, ptr)
+
+    def __getitem__(self, item):
+        """
+        Get the address of an exported symbol as an integer
+        """
+        return self.__addresses[item]
+
+    @property
+    def name(self):
+        return self.__name
+
+    def _dispose(self):
+        with ffi.OutputString() as outerr:
+            if self._capi.LLVMPY_LLJIT_Dylib_Tracker_Dispose(self, outerr):
+                raise RuntimeError(str(outerr))
+
+
+class LLJIT(ffi.ObjectRef):
+    """
+    A OrcJIT-based LLVM JIT engine that can compile and run LLVM IR as a
+    collection of JITted dynamic libraries
+
+    The C++ OrcJIT API has a lot of memory ownership patterns that do not work
+    with Python. This API attempts to provide ones that are safe at the expense
+    of some features. Each LLJIT instance is a collection of JIT-compiled
+    libraries. In the C++ API, there is a "main" library; this API does not
+    provide access to the main library. Use the JITLibraryBuilder to create a
+    new named library instead.
+    """
+    def __init__(self, ptr):
+        self._td = None
+        ffi.ObjectRef.__init__(self, ptr)
+
+    def lookup(self, dylib, fn):
+        """
+        Find a function in this dynamic library and construct a new tracking
+        object for it
+
+        If the library or function do not exist, an exception will occur.
+
+        Parameters
+        ----------
+        dylib : str or None
+           the name of the library containing the symbol
+        fn : str
+           the name of the function to get
+        """
+        assert not self.closed, "Cannot lookup in closed JIT"
+        address = ctypes.c_uint64()
+        with ffi.OutputString() as outerr:
+            tracker = ffi.lib.LLVMPY_LLJITLookup(self,
+                                                 dylib.encode("utf-8"),
+                                                 fn.encode("utf-8"),
+                                                 ctypes.byref(address),
+                                                 outerr)
+            if not tracker:
+                raise RuntimeError(str(outerr))
+
+        return ResourceTracker(tracker, dylib, {fn: address.value})
+
+    @property
+    def target_data(self):
+        """
+        The TargetData for this LLJIT instance.
+        """
+        if self._td is not None:
+            return self._td
+        ptr = ffi.lib.LLVMPY_LLJITGetDataLayout(self)
+        self._td = targets.TargetData(ptr)
+        self._td._owned = True
+        return self._td
+
+    def _dispose(self):
+        if self._td is not None:
+            self._td.detach()
+        self._capi.LLVMPY_LLJITDispose(self)
+
+
+def create_lljit_compiler(target_machine=None, *,
+                          use_jit_link=False,
+                          suppress_errors=False):
+    """
+    Create an LLJIT instance
+    """
+    with ffi.OutputString() as outerr:
+        lljit = ffi.lib.LLVMPY_CreateLLJITCompiler(target_machine,
+                                                   suppress_errors,
+                                                   use_jit_link,
+                                                   outerr)
+        if not lljit:
+            raise RuntimeError(str(outerr))
+
+    return LLJIT(lljit)
+
+
+ffi.lib.LLVMPY_LLJITLookup.argtypes = [
+    ffi.LLVMOrcLLJITRef,
+    c_char_p,
+    c_char_p,
+    POINTER(c_uint64),
+    POINTER(c_char_p),
+]
+ffi.lib.LLVMPY_LLJITLookup.restype = ffi.LLVMOrcDylibTrackerRef
+
+ffi.lib.LLVMPY_LLJITGetDataLayout.argtypes = [
+    ffi.LLVMOrcLLJITRef,
+]
+ffi.lib.LLVMPY_LLJITGetDataLayout.restype = ffi.LLVMTargetDataRef
+
+ffi.lib.LLVMPY_CreateLLJITCompiler.argtypes = [
+    ffi.LLVMTargetMachineRef,
+    c_bool,
+    c_bool,
+    POINTER(c_char_p),
+]
+ffi.lib.LLVMPY_CreateLLJITCompiler.restype = ffi.LLVMOrcLLJITRef
+
+ffi.lib.LLVMPY_LLJITDispose.argtypes = [
+    ffi.LLVMOrcLLJITRef,
+]
+
+
+ffi.lib.LLVMPY_LLJIT_Link.argtypes = [
+    ffi.LLVMOrcLLJITRef,
+    c_char_p,
+    POINTER(_LinkElement),
+    c_size_t,
+    POINTER(_SymbolAddress),
+    c_size_t,
+    POINTER(_SymbolAddress),
+    c_size_t,
+    POINTER(c_char_p)
+]
+ffi.lib.LLVMPY_LLJIT_Link.restype = ffi.LLVMOrcDylibTrackerRef
+
+ffi.lib.LLVMPY_LLJIT_Dylib_Tracker_Dispose.argtypes = [
+    ffi.LLVMOrcDylibTrackerRef,
+    POINTER(c_char_p)
+]
+ffi.lib.LLVMPY_LLJIT_Dylib_Tracker_Dispose.restype = c_bool
diff --git a/lib/python3.11/site-packages/llvmlite/binding/passmanagers.py b/lib/python3.11/site-packages/llvmlite/binding/passmanagers.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc9c07e1381c02f6b1b1b0131d54d0ad4e246b82
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/passmanagers.py
@@ -0,0 +1,923 @@
+from ctypes import (c_bool, c_char_p, c_int, c_size_t, c_uint, Structure, byref,
+                    POINTER)
+from collections import namedtuple
+from enum import IntFlag
+from llvmlite.binding import ffi
+import os
+from tempfile import mkstemp
+from llvmlite.binding.common import _encode_string
+
+_prunestats = namedtuple('PruneStats',
+                         ('basicblock diamond fanout fanout_raise'))
+
+
+class PruneStats(_prunestats):
+    """ Holds statistics from reference count pruning.
+    """
+
+    def __add__(self, other):
+        if not isinstance(other, PruneStats):
+            msg = 'PruneStats can only be added to another PruneStats, got {}.'
+            raise TypeError(msg.format(type(other)))
+        return PruneStats(self.basicblock + other.basicblock,
+                          self.diamond + other.diamond,
+                          self.fanout + other.fanout,
+                          self.fanout_raise + other.fanout_raise)
+
+    def __sub__(self, other):
+        if not isinstance(other, PruneStats):
+            msg = ('PruneStats can only be subtracted from another PruneStats, '
+                   'got {}.')
+            raise TypeError(msg.format(type(other)))
+        return PruneStats(self.basicblock - other.basicblock,
+                          self.diamond - other.diamond,
+                          self.fanout - other.fanout,
+                          self.fanout_raise - other.fanout_raise)
+
+
+class _c_PruneStats(Structure):
+    _fields_ = [
+        ('basicblock', c_size_t),
+        ('diamond', c_size_t),
+        ('fanout', c_size_t),
+        ('fanout_raise', c_size_t)]
+
+
+def dump_refprune_stats(printout=False):
+    """ Returns a namedtuple containing the current values for the refop pruning
+    statistics. If kwarg `printout` is True the stats are printed to stderr,
+    default is False.
+    """
+
+    stats = _c_PruneStats(0, 0, 0, 0)
+    do_print = c_bool(printout)
+
+    ffi.lib.LLVMPY_DumpRefPruneStats(byref(stats), do_print)
+    return PruneStats(stats.basicblock, stats.diamond, stats.fanout,
+                      stats.fanout_raise)
+
+
+def set_time_passes(enable):
+    """Enable or disable the pass timers.
+
+    Parameters
+    ----------
+    enable : bool
+        Set to True to enable the pass timers.
+        Set to False to disable the pass timers.
+    """
+    ffi.lib.LLVMPY_SetTimePasses(c_bool(enable))
+
+
+def report_and_reset_timings():
+    """Returns the pass timings report and resets the LLVM internal timers.
+
+    Pass timers are enabled by ``set_time_passes()``. If the timers are not
+    enabled, this function will return an empty string.
+
+    Returns
+    -------
+    res : str
+        LLVM generated timing report.
+    """
+    with ffi.OutputString() as buf:
+        ffi.lib.LLVMPY_ReportAndResetTimings(buf)
+        return str(buf)
+
+
+def create_module_pass_manager():
+    return ModulePassManager()
+
+
+def create_function_pass_manager(module):
+    return FunctionPassManager(module)
+
+
+class RefPruneSubpasses(IntFlag):
+    PER_BB       = 0b0001    # noqa: E221
+    DIAMOND      = 0b0010    # noqa: E221
+    FANOUT       = 0b0100    # noqa: E221
+    FANOUT_RAISE = 0b1000
+    ALL = PER_BB | DIAMOND | FANOUT | FANOUT_RAISE
+
+
+class PassManager(ffi.ObjectRef):
+    """PassManager
+    """
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposePassManager(self)
+
+    def add_aa_eval_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#aa-eval-exhaustive-alias-analysis-precision-evaluator
+
+        LLVM 14: `llvm::createAAEvalPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddAAEvalPass(self)
+
+    def add_basic_aa_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#basic-aa-basic-alias-analysis-stateless-aa-impl
+
+        LLVM 14: `llvm::createBasicAAWrapperPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddBasicAAWrapperPass(self)
+
+    def add_constant_merge_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#constmerge-merge-duplicate-global-constants
+
+        LLVM 14: `LLVMAddConstantMergePass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddConstantMergePass(self)
+
+    def add_dead_arg_elimination_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#deadargelim-dead-argument-elimination
+
+        LLVM 14: `LLVMAddDeadArgEliminationPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddDeadArgEliminationPass(self)
+
+    def add_dependence_analysis_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#da-dependence-analysis
+
+        LLVM 14: `llvm::createDependenceAnalysisWrapperPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddDependenceAnalysisPass(self)
+
+    def add_dot_call_graph_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#dot-callgraph-print-call-graph-to-dot-file
+
+        LLVM 14: `llvm::createCallGraphDOTPrinterPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddCallGraphDOTPrinterPass(self)
+
+    def add_dot_cfg_printer_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#dot-cfg-print-cfg-of-function-to-dot-file
+
+        LLVM 14: `llvm::createCFGPrinterLegacyPassPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddCFGPrinterPass(self)
+
+    def add_dot_dom_printer_pass(self, show_body=False):
+        """
+        See https://llvm.org/docs/Passes.html#dot-dom-print-dominance-tree-of-function-to-dot-file
+
+        LLVM 14: `llvm::createDomPrinterPass` and `llvm::createDomOnlyPrinterPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddDotDomPrinterPass(self, show_body)
+
+    def add_dot_postdom_printer_pass(self, show_body=False):
+        """
+        See https://llvm.org/docs/Passes.html#dot-postdom-print-postdominance-tree-of-function-to-dot-file
+
+        LLVM 14: `llvm::createPostDomPrinterPass` and `llvm::createPostDomOnlyPrinterPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddDotPostDomPrinterPass(self, show_body)
+
+    def add_globals_mod_ref_aa_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#globalsmodref-aa-simple-mod-ref-analysis-for-globals
+
+        LLVM 14: `llvm::createGlobalsAAWrapperPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddGlobalsModRefAAPass(self)
+
+    def add_iv_users_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#iv-users-induction-variable-users
+
+        LLVM 14: `llvm::createIVUsersPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddIVUsersPass(self)
+
+    def add_lint_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#lint-statically-lint-checks-llvm-ir
+
+        LLVM 14: `llvm::createLintLegacyPassPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLintPass(self)
+
+    def add_lazy_value_info_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#lazy-value-info-lazy-value-information-analysis
+
+        LLVM 14: `llvm::createLazyValueInfoPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLazyValueInfoPass(self)
+
+    def add_module_debug_info_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#module-debuginfo-decodes-module-level-debug-info
+
+        LLVM 14: `llvm::createModuleDebugInfoPrinterPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddModuleDebugInfoPrinterPass(self)
+
+    def add_region_info_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#regions-detect-single-entry-single-exit-regions
+
+        LLVM 14: `llvm::createRegionInfoPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddRegionInfoPass(self)
+
+    def add_scalar_evolution_aa_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#scev-aa-scalarevolution-based-alias-analysis
+
+        LLVM 14: `llvm::createSCEVAAWrapperPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddScalarEvolutionAAPass(self)
+
+    def add_aggressive_dead_code_elimination_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#adce-aggressive-dead-code-elimination
+
+        LLVM 14: `llvm::createAggressiveDCEPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddAggressiveDCEPass(self)
+
+    def add_always_inliner_pass(self, insert_lifetime=True):
+        """
+        See https://llvm.org/docs/Passes.html#always-inline-inliner-for-always-inline-functions
+
+        LLVM 14: `llvm::createAlwaysInlinerLegacyPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddAlwaysInlinerPass(self, insert_lifetime)
+
+    def add_arg_promotion_pass(self, max_elements=3):
+        """
+        See https://llvm.org/docs/Passes.html#argpromotion-promote-by-reference-arguments-to-scalars
+
+        LLVM 14: `llvm::createArgumentPromotionPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddArgPromotionPass(self, max_elements)
+
+    def add_break_critical_edges_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#break-crit-edges-break-critical-edges-in-cfg
+
+        LLVM 14: `llvm::createBreakCriticalEdgesPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddBreakCriticalEdgesPass(self)
+
+    def add_dead_store_elimination_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#dse-dead-store-elimination
+
+        LLVM 14: `llvm::createDeadStoreEliminationPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddDeadStoreEliminationPass(self)
+
+    def add_reverse_post_order_function_attrs_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#function-attrs-deduce-function-attributes
+
+        LLVM 14: `llvm::createReversePostOrderFunctionAttrsPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddReversePostOrderFunctionAttrsPass(self)
+
+    def add_function_attrs_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#functionattrs-deduce-function-attributes
+
+        LLVM 14: `LLVMAddFunctionAttrsPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddFunctionAttrsPass(self)
+
+    def add_function_inlining_pass(self, threshold):
+        """
+        See http://llvm.org/docs/Passes.html#inline-function-integration-inlining
+
+        LLVM 14: `createFunctionInliningPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddFunctionInliningPass(self, threshold)
+
+    def add_global_dce_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#globaldce-dead-global-elimination
+
+        LLVM 14: `LLVMAddGlobalDCEPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddGlobalDCEPass(self)
+
+    def add_global_optimizer_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#globalopt-global-variable-optimizer
+
+        LLVM 14: `LLVMAddGlobalOptimizerPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddGlobalOptimizerPass(self)
+
+    def add_ipsccp_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#ipsccp-interprocedural-sparse-conditional-constant-propagation
+
+        LLVM 14: `LLVMAddIPSCCPPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddIPSCCPPass(self)
+
+    def add_dead_code_elimination_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#dce-dead-code-elimination
+        LLVM 14: `llvm::createDeadCodeEliminationPass`
+        """
+        ffi.lib.LLVMPY_AddDeadCodeEliminationPass(self)
+
+    def add_aggressive_instruction_combining_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#aggressive-instcombine-combine-expression-patterns
+
+        LLVM 14: `llvm::createAggressiveInstCombinerPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddAggressiveInstructionCombiningPass(self)
+
+    def add_internalize_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#internalize-internalize-global-symbols
+
+        LLVM 14: `llvm::createInternalizePass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddInternalizePass(self)
+
+    def add_cfg_simplification_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#simplifycfg-simplify-the-cfg
+
+        LLVM 14: `LLVMAddCFGSimplificationPass`
+        """
+        ffi.lib.LLVMPY_AddCFGSimplificationPass(self)
+
+    def add_jump_threading_pass(self, threshold=-1):
+        """
+        See https://llvm.org/docs/Passes.html#jump-threading-jump-threading
+
+        LLVM 14: `llvm::createJumpThreadingPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddJumpThreadingPass(self, threshold)
+
+    def add_lcssa_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#lcssa-loop-closed-ssa-form-pass
+
+        LLVM 14: `llvm::createLCSSAPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLCSSAPass(self)
+
+    def add_gvn_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#gvn-global-value-numbering
+
+        LLVM 14: `LLVMAddGVNPass`
+        """
+        ffi.lib.LLVMPY_AddGVNPass(self)
+
+    def add_instruction_combining_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#passes-instcombine
+
+        LLVM 14: `LLVMAddInstructionCombiningPass`
+        """
+        ffi.lib.LLVMPY_AddInstructionCombiningPass(self)
+
+    def add_licm_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#licm-loop-invariant-code-motion
+
+        LLVM 14: `LLVMAddLICMPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLICMPass(self)
+
+    def add_loop_deletion_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loop-deletion-delete-dead-loops
+
+        LLVM 14: `llvm::createLoopDeletionPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLoopDeletionPass(self)
+
+    def add_loop_extractor_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loop-extract-extract-loops-into-new-functions
+
+        LLVM 14: `llvm::createLoopExtractorPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLoopExtractorPass(self)
+
+    def add_single_loop_extractor_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loop-extract-single-extract-at-most-one-loop-into-a-new-function
+
+        LLVM 14: `llvm::createSingleLoopExtractorPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddSingleLoopExtractorPass(self)
+
+    def add_sccp_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#sccp-sparse-conditional-constant-propagation
+
+        LLVM 14: `LLVMAddSCCPPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddSCCPPass(self)
+
+    def add_loop_strength_reduce_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loop-reduce-loop-strength-reduction
+
+        LLVM 14: `llvm::createLoopStrengthReducePass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLoopStrengthReducePass(self)
+
+    def add_loop_simplification_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loop-simplify-canonicalize-natural-loops
+
+        LLVM 14: `llvm::createLoopSimplifyPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLoopSimplificationPass(self)
+
+    def add_loop_unroll_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loop-unroll-unroll-loops
+
+        LLVM 14: `LLVMAddLoopUnrollPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLoopUnrollPass(self)
+
+    def add_loop_unroll_and_jam_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loop-unroll-and-jam-unroll-and-jam-loops
+
+        LLVM 14: `LLVMAddLoopUnrollAndJamPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLoopUnrollAndJamPass(self)
+
+    def add_loop_unswitch_pass(self,
+                               optimize_for_size=False,
+                               has_branch_divergence=False):
+        """
+        See https://llvm.org/docs/Passes.html#loop-unswitch-unswitch-loops
+
+        LLVM 14: `llvm::createLoopUnswitchPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLoopUnswitchPass(self,
+                                           optimize_for_size,
+                                           has_branch_divergence)
+
+    def add_lower_atomic_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#loweratomic-lower-atomic-intrinsics-to-non-atomic-form
+
+        LLVM 14: `llvm::createLowerAtomicPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLowerAtomicPass(self)
+
+    def add_lower_invoke_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#lowerinvoke-lower-invokes-to-calls-for-unwindless-code-generators
+
+        LLVM 14: `llvm::createLowerInvokePass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLowerInvokePass(self)
+
+    def add_lower_switch_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#lowerswitch-lower-switchinsts-to-branches
+
+        LLVM 14: `llvm::createLowerSwitchPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddLowerSwitchPass(self)
+
+    def add_memcpy_optimization_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#memcpyopt-memcpy-optimization
+
+        LLVM 14: `llvm::createMemCpyOptPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddMemCpyOptimizationPass(self)
+
+    def add_merge_functions_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#mergefunc-merge-functions
+
+        LLVM 14: `llvm::createMergeFunctionsPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddMergeFunctionsPass(self)
+
+    def add_merge_returns_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#mergereturn-unify-function-exit-nodes
+
+        LLVM 14: `llvm::createUnifyFunctionExitNodesPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddMergeReturnsPass(self)
+
+    def add_partial_inlining_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#partial-inliner-partial-inliner
+
+        LLVM 14: `llvm::createPartialInliningPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddPartialInliningPass(self)
+
+    def add_prune_exception_handling_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#prune-eh-remove-unused-exception-handling-info
+
+        LLVM 14: `llvm::createPruneEHPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddPruneExceptionHandlingPass(self)
+
+    def add_reassociate_expressions_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#reassociate-reassociate-expressions
+
+        LLVM 14: `llvm::createReassociatePass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddReassociatePass(self)
+
+    def add_demote_register_to_memory_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#rel-lookup-table-converter-relative-lookup-table-converter
+
+        LLVM 14: `llvm::createDemoteRegisterToMemoryPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddDemoteRegisterToMemoryPass(self)
+
+    def add_sroa_pass(self):
+        """
+        See http://llvm.org/docs/Passes.html#scalarrepl-scalar-replacement-of-aggregates-dt
+        Note that this pass corresponds to the ``opt -sroa`` command-line option,
+        despite the link above.
+
+        LLVM 14: `llvm::createSROAPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddSROAPass(self)
+
+    def add_sink_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#sink-code-sinking
+
+        LLVM 14: `llvm::createSinkingPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddSinkPass(self)
+
+    def add_strip_symbols_pass(self, only_debug=False):
+        """
+        See https://llvm.org/docs/Passes.html#strip-strip-all-symbols-from-a-module
+
+        LLVM 14: `llvm::createStripSymbolsPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddStripSymbolsPass(self, only_debug)
+
+    def add_strip_dead_debug_info_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#strip-dead-debug-info-strip-debug-info-for-unused-symbols
+
+        LLVM 14: `llvm::createStripDeadDebugInfoPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddStripDeadDebugInfoPass(self)
+
+    def add_strip_dead_prototypes_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#strip-dead-prototypes-strip-unused-function-prototypes
+
+        LLVM 14: `llvm::createStripDeadPrototypesPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddStripDeadPrototypesPass(self)
+
+    def add_strip_debug_declare_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#strip-debug-declare-strip-all-llvm-dbg-declare-intrinsics
+
+        LLVM 14: `llvm::createStripDebugDeclarePass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddStripDebugDeclarePrototypesPass(self)
+
+    def add_strip_nondebug_symbols_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#strip-nondebug-strip-all-symbols-except-dbg-symbols-from-a-module
+
+        LLVM 14: `llvm::createStripNonDebugSymbolsPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddStripNondebugSymbolsPass(self)
+
+    def add_tail_call_elimination_pass(self):
+        """
+        See https://llvm.org/docs/Passes.html#tailcallelim-tail-call-elimination
+
+        LLVM 14: `llvm::createTailCallEliminationPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddTailCallEliminationPass(self)
+
+    def add_type_based_alias_analysis_pass(self):
+        """
+        LLVM 14: `LLVMAddTypeBasedAliasAnalysisPass`
+        """  # noqa E501
+        ffi.lib.LLVMPY_AddTypeBasedAliasAnalysisPass(self)
+
+    def add_basic_alias_analysis_pass(self):
+        """
+        See http://llvm.org/docs/AliasAnalysis.html#the-basicaa-pass
+
+        LLVM 14: `LLVMAddBasicAliasAnalysisPass`
+        """
+        ffi.lib.LLVMPY_AddBasicAliasAnalysisPass(self)
+
+    def add_loop_rotate_pass(self):
+        """http://llvm.org/docs/Passes.html#loop-rotate-rotate-loops."""
+        ffi.lib.LLVMPY_LLVMAddLoopRotatePass(self)
+
+    def add_target_library_info(self, triple):
+        ffi.lib.LLVMPY_AddTargetLibraryInfoPass(self, _encode_string(triple))
+
+    # Non-standard LLVM passes
+
+    def add_refprune_pass(self, subpasses_flags=RefPruneSubpasses.ALL,
+                          subgraph_limit=1000):
+        """Add Numba specific Reference count pruning pass.
+
+        Parameters
+        ----------
+        subpasses_flags : RefPruneSubpasses
+            A bitmask to control the subpasses to be enabled.
+        subgraph_limit : int
+            Limit the fanout pruners to working on a subgraph no bigger than
+            this number of basic-blocks to avoid spending too much time in very
+            large graphs. Default is 1000. Subject to change in future
+            versions.
+        """
+        iflags = RefPruneSubpasses(subpasses_flags)
+        ffi.lib.LLVMPY_AddRefPrunePass(self, iflags, subgraph_limit)
+
+
+class ModulePassManager(PassManager):
+
+    def __init__(self, ptr=None):
+        if ptr is None:
+            ptr = ffi.lib.LLVMPY_CreatePassManager()
+        PassManager.__init__(self, ptr)
+
+    def run(self, module, remarks_file=None, remarks_format='yaml',
+            remarks_filter=''):
+        """
+        Run optimization passes on the given module.
+
+        Parameters
+        ----------
+        module : llvmlite.binding.ModuleRef
+            The module to be optimized inplace
+        remarks_file : str; optional
+            If not `None`, it is the file to store the optimization remarks.
+        remarks_format : str; optional
+            The format to write; YAML is default
+        remarks_filter : str; optional
+            The filter that should be applied to the remarks output.
+        """
+        if remarks_file is None:
+            return ffi.lib.LLVMPY_RunPassManager(self, module)
+        else:
+            r = ffi.lib.LLVMPY_RunPassManagerWithRemarks(
+                self, module, _encode_string(remarks_format),
+                _encode_string(remarks_filter),
+                _encode_string(remarks_file))
+            if r == -1:
+                raise IOError("Failed to initialize remarks file.")
+            return r > 0
+
+    def run_with_remarks(self, module, remarks_format='yaml',
+                         remarks_filter=''):
+        """
+        Run optimization passes on the given module and returns the result and
+        the remarks data.
+
+        Parameters
+        ----------
+        module : llvmlite.binding.ModuleRef
+            The module to be optimized
+        remarks_format : str
+            The remarks output; YAML is the default
+        remarks_filter : str; optional
+            The filter that should be applied to the remarks output.
+        """
+        remarkdesc, remarkfile = mkstemp()
+        try:
+            with os.fdopen(remarkdesc, 'r'):
+                pass
+            r = self.run(module, remarkfile, remarks_format, remarks_filter)
+            if r == -1:
+                raise IOError("Failed to initialize remarks file.")
+            with open(remarkfile) as f:
+                return bool(r), f.read()
+        finally:
+            os.unlink(remarkfile)
+
+
+class FunctionPassManager(PassManager):
+
+    def __init__(self, module):
+        ptr = ffi.lib.LLVMPY_CreateFunctionPassManager(module)
+        self._module = module
+        module._owned = True
+        PassManager.__init__(self, ptr)
+
+    def initialize(self):
+        """
+        Initialize the FunctionPassManager.  Returns True if it produced
+        any changes (?).
+        """
+        return ffi.lib.LLVMPY_InitializeFunctionPassManager(self)
+
+    def finalize(self):
+        """
+        Finalize the FunctionPassManager.  Returns True if it produced
+        any changes (?).
+        """
+        return ffi.lib.LLVMPY_FinalizeFunctionPassManager(self)
+
+    def run(self, function, remarks_file=None, remarks_format='yaml',
+            remarks_filter=''):
+        """
+        Run optimization passes on the given function.
+
+        Parameters
+        ----------
+        function : llvmlite.binding.FunctionRef
+            The function to be optimized inplace
+        remarks_file : str; optional
+            If not `None`, it is the file to store the optimization remarks.
+        remarks_format : str; optional
+            The format of the remarks file; the default is YAML
+        remarks_filter : str; optional
+            The filter that should be applied to the remarks output.
+        """
+        if remarks_file is None:
+            return ffi.lib.LLVMPY_RunFunctionPassManager(self, function)
+        else:
+            r = ffi.lib.LLVMPY_RunFunctionPassManagerWithRemarks(
+                self, function, _encode_string(remarks_format),
+                _encode_string(remarks_filter),
+                _encode_string(remarks_file))
+            if r == -1:
+                raise IOError("Failed to initialize remarks file.")
+            return bool(r)
+
+    def run_with_remarks(self, function, remarks_format='yaml',
+                         remarks_filter=''):
+        """
+        Run optimization passes on the given function and returns the result
+        and the remarks data.
+
+        Parameters
+        ----------
+        function : llvmlite.binding.FunctionRef
+            The function to be optimized inplace
+        remarks_format : str; optional
+            The format of the remarks file; the default is YAML
+        remarks_filter : str; optional
+            The filter that should be applied to the remarks output.
+        """
+        # LLVM is going to need to close this file and then reopen it, so we
+        # can't use an unlinked temporary file.
+        remarkdesc, remarkfile = mkstemp()
+        try:
+            # We get an open handle, but we need LLVM to write first, so close
+            # it.
+            with os.fdopen(remarkdesc, 'r'):
+                pass
+            r = self.run(function, remarkfile, remarks_format, remarks_filter)
+            if r == -1:
+                raise IOError("Failed to initialize remarks file.")
+            with open(remarkfile) as f:
+                return bool(r), f.read()
+        finally:
+            os.unlink(remarkfile)
+
+
+# ============================================================================
+# FFI
+
+ffi.lib.LLVMPY_CreatePassManager.restype = ffi.LLVMPassManagerRef
+
+ffi.lib.LLVMPY_CreateFunctionPassManager.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_CreateFunctionPassManager.restype = ffi.LLVMPassManagerRef
+
+ffi.lib.LLVMPY_DisposePassManager.argtypes = [ffi.LLVMPassManagerRef]
+
+ffi.lib.LLVMPY_RunPassManager.argtypes = [ffi.LLVMPassManagerRef,
+                                          ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_RunPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_RunPassManagerWithRemarks.argtypes = [ffi.LLVMPassManagerRef,
+                                                     ffi.LLVMModuleRef,
+                                                     c_char_p,
+                                                     c_char_p,
+                                                     c_char_p]
+ffi.lib.LLVMPY_RunPassManagerWithRemarks.restype = c_int
+
+ffi.lib.LLVMPY_InitializeFunctionPassManager.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_InitializeFunctionPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_FinalizeFunctionPassManager.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_FinalizeFunctionPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_RunFunctionPassManager.argtypes = [ffi.LLVMPassManagerRef,
+                                                  ffi.LLVMValueRef]
+ffi.lib.LLVMPY_RunFunctionPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_RunFunctionPassManagerWithRemarks.argtypes = [
+    ffi.LLVMPassManagerRef, ffi.LLVMValueRef, c_char_p, c_char_p, c_char_p
+]
+ffi.lib.LLVMPY_RunFunctionPassManagerWithRemarks.restype = c_int
+
+ffi.lib.LLVMPY_AddAAEvalPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddBasicAAWrapperPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddConstantMergePass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddDeadArgEliminationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddDependenceAnalysisPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddCallGraphDOTPrinterPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddCFGPrinterPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddDotDomPrinterPass.argtypes = [ffi.LLVMPassManagerRef, c_bool]
+ffi.lib.LLVMPY_AddDotPostDomPrinterPass.argtypes = [
+    ffi.LLVMPassManagerRef,
+    c_bool]
+ffi.lib.LLVMPY_AddGlobalsModRefAAPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddInstructionCountPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddIVUsersPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLazyValueInfoPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLintPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddModuleDebugInfoPrinterPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddRegionInfoPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddScalarEvolutionAAPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddAggressiveDCEPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddAlwaysInlinerPass.argtypes = [ffi.LLVMPassManagerRef, c_bool]
+ffi.lib.LLVMPY_AddArgPromotionPass.argtypes = [ffi.LLVMPassManagerRef, c_uint]
+ffi.lib.LLVMPY_AddBreakCriticalEdgesPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddDeadStoreEliminationPass.argtypes = [
+    ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddReversePostOrderFunctionAttrsPass.argtypes = [
+    ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddAggressiveInstructionCombiningPass.argtypes = [
+    ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddInternalizePass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLCSSAPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLoopDeletionPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLoopExtractorPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddSingleLoopExtractorPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLoopStrengthReducePass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLoopSimplificationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLoopUnrollPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLoopUnrollAndJamPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLoopUnswitchPass.argtypes = [
+    ffi.LLVMPassManagerRef,
+    c_bool,
+    c_bool]
+ffi.lib.LLVMPY_AddLowerAtomicPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLowerInvokePass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLowerSwitchPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddMemCpyOptimizationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddMergeFunctionsPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddMergeReturnsPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddPartialInliningPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddPruneExceptionHandlingPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddReassociatePass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddDemoteRegisterToMemoryPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddSinkPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddStripSymbolsPass.argtypes = [ffi.LLVMPassManagerRef, c_bool]
+ffi.lib.LLVMPY_AddStripDeadDebugInfoPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddStripDeadPrototypesPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddStripDebugDeclarePrototypesPass.argtypes = [
+    ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddStripNondebugSymbolsPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddTailCallEliminationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddJumpThreadingPass.argtypes = [ffi.LLVMPassManagerRef, c_int]
+ffi.lib.LLVMPY_AddFunctionAttrsPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddFunctionInliningPass.argtypes = [
+    ffi.LLVMPassManagerRef, c_int]
+ffi.lib.LLVMPY_AddGlobalDCEPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddGlobalOptimizerPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddIPSCCPPass.argtypes = [ffi.LLVMPassManagerRef]
+
+ffi.lib.LLVMPY_AddDeadCodeEliminationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddCFGSimplificationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddGVNPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddInstructionCombiningPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLICMPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddSCCPPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddSROAPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddTypeBasedAliasAnalysisPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddBasicAliasAnalysisPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddTargetLibraryInfoPass.argtypes = [ffi.LLVMPassManagerRef,
+                                                    c_char_p]
+
+ffi.lib.LLVMPY_AddRefPrunePass.argtypes = [ffi.LLVMPassManagerRef, c_int,
+                                           c_size_t]
+
+ffi.lib.LLVMPY_DumpRefPruneStats.argtypes = [POINTER(_c_PruneStats), c_bool]
diff --git a/lib/python3.11/site-packages/llvmlite/binding/targets.py b/lib/python3.11/site-packages/llvmlite/binding/targets.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7e6ffdc3e51e2d668f944ff6ca4f75fc5c6c612
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/targets.py
@@ -0,0 +1,450 @@
+import os
+from ctypes import (POINTER, c_char_p, c_longlong, c_int, c_size_t,
+                    c_void_p, string_at)
+
+from llvmlite.binding import ffi
+from llvmlite.binding.common import _decode_string, _encode_string
+
+
+def get_process_triple():
+    """
+    Return a target triple suitable for generating code for the current process.
+    An example when the default triple from ``get_default_triple()`` is not be
+    suitable is when LLVM is compiled for 32-bit but the process is executing
+    in 64-bit mode.
+    """
+    with ffi.OutputString() as out:
+        ffi.lib.LLVMPY_GetProcessTriple(out)
+        return str(out)
+
+
+class FeatureMap(dict):
+    """
+    Maps feature name to a boolean indicating the availability of the feature.
+    Extends ``dict`` to add `.flatten()` method.
+    """
+
+    def flatten(self, sort=True):
+        """
+        Args
+        ----
+        sort: bool
+            Optional.  If True, the features are sorted by name; otherwise,
+            the ordering is unstable between python session due to hash
+            randomization.  Defaults to True.
+
+        Returns a string suitable for use as the ``features`` argument to
+        ``Target.create_target_machine()``.
+
+        """
+        iterator = sorted(self.items()) if sort else iter(self.items())
+        flag_map = {True: '+', False: '-'}
+        return ','.join('{0}{1}'.format(flag_map[v], k)
+                        for k, v in iterator)
+
+
+def get_host_cpu_features():
+    """
+    Returns a dictionary-like object indicating the CPU features for current
+    architecture and whether they are enabled for this CPU.  The key-value pairs
+    are the feature name as string and a boolean indicating whether the feature
+    is available.  The returned value is an instance of ``FeatureMap`` class,
+    which adds a new method ``.flatten()`` for returning a string suitable for
+    use as the "features" argument to ``Target.create_target_machine()``.
+
+    If LLVM has not implemented this feature or it fails to get the information,
+    this function will raise a RuntimeError exception.
+    """
+    with ffi.OutputString() as out:
+        outdict = FeatureMap()
+        if not ffi.lib.LLVMPY_GetHostCPUFeatures(out):
+            return outdict
+        flag_map = {'+': True, '-': False}
+        content = str(out)
+        if content:  # protect against empty string
+            for feat in content.split(','):
+                if feat:  # protect against empty feature
+                    outdict[feat[1:]] = flag_map[feat[0]]
+        return outdict
+
+
+def get_default_triple():
+    """
+    Return the default target triple LLVM is configured to produce code for.
+    """
+    with ffi.OutputString() as out:
+        ffi.lib.LLVMPY_GetDefaultTargetTriple(out)
+        return str(out)
+
+
+def get_host_cpu_name():
+    """
+    Get the name of the host's CPU, suitable for using with
+    :meth:`Target.create_target_machine()`.
+    """
+    with ffi.OutputString() as out:
+        ffi.lib.LLVMPY_GetHostCPUName(out)
+        return str(out)
+
+
+_object_formats = {
+    1: "COFF",
+    2: "ELF",
+    3: "MachO",
+}
+
+
+def get_object_format(triple=None):
+    """
+    Get the object format for the given *triple* string (or the default
+    triple if omitted).
+    A string is returned
+    """
+    if triple is None:
+        triple = get_default_triple()
+    res = ffi.lib.LLVMPY_GetTripleObjectFormat(_encode_string(triple))
+    return _object_formats[res]
+
+
+def create_target_data(layout):
+    """
+    Create a TargetData instance for the given *layout* string.
+    """
+    return TargetData(ffi.lib.LLVMPY_CreateTargetData(_encode_string(layout)))
+
+
+class TargetData(ffi.ObjectRef):
+    """
+    A TargetData provides structured access to a data layout.
+    Use :func:`create_target_data` to create instances.
+    """
+
+    def __str__(self):
+        if self._closed:
+            return "<dead TargetData>"
+        with ffi.OutputString() as out:
+            ffi.lib.LLVMPY_CopyStringRepOfTargetData(self, out)
+            return str(out)
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeTargetData(self)
+
+    def get_abi_size(self, ty):
+        """
+        Get ABI size of LLVM type *ty*.
+        """
+        return ffi.lib.LLVMPY_ABISizeOfType(self, ty)
+
+    def get_element_offset(self, ty, position):
+        """
+        Get byte offset of type's ty element at the given position
+        """
+
+        offset = ffi.lib.LLVMPY_OffsetOfElement(self, ty, position)
+        if offset == -1:
+            raise ValueError("Could not determined offset of {}th "
+                             "element of the type '{}'. Is it a struct"
+                             "type?".format(position, str(ty)))
+        return offset
+
+    def get_pointee_abi_size(self, ty):
+        """
+        Get ABI size of pointee type of LLVM pointer type *ty*.
+        """
+        size = ffi.lib.LLVMPY_ABISizeOfElementType(self, ty)
+        if size == -1:
+            raise RuntimeError("Not a pointer type: %s" % (ty,))
+        return size
+
+    def get_pointee_abi_alignment(self, ty):
+        """
+        Get minimum ABI alignment of pointee type of LLVM pointer type *ty*.
+        """
+        size = ffi.lib.LLVMPY_ABIAlignmentOfElementType(self, ty)
+        if size == -1:
+            raise RuntimeError("Not a pointer type: %s" % (ty,))
+        return size
+
+
+RELOC = frozenset(['default', 'static', 'pic', 'dynamicnopic'])
+CODEMODEL = frozenset(['default', 'jitdefault', 'small', 'kernel', 'medium',
+                       'large'])
+
+
+class Target(ffi.ObjectRef):
+    _triple = ''
+
+    # No _dispose() method since LLVMGetTargetFromTriple() returns a
+    # persistent object.
+
+    @classmethod
+    def from_default_triple(cls):
+        """
+        Create a Target instance for the default triple.
+        """
+        triple = get_default_triple()
+        return cls.from_triple(triple)
+
+    @classmethod
+    def from_triple(cls, triple):
+        """
+        Create a Target instance for the given triple (a string).
+        """
+        with ffi.OutputString() as outerr:
+            target = ffi.lib.LLVMPY_GetTargetFromTriple(triple.encode('utf8'),
+                                                        outerr)
+            if not target:
+                raise RuntimeError(str(outerr))
+            target = cls(target)
+            target._triple = triple
+            return target
+
+    @property
+    def name(self):
+        s = ffi.lib.LLVMPY_GetTargetName(self)
+        return _decode_string(s)
+
+    @property
+    def description(self):
+        s = ffi.lib.LLVMPY_GetTargetDescription(self)
+        return _decode_string(s)
+
+    @property
+    def triple(self):
+        return self._triple
+
+    def __str__(self):
+        return "<Target {0} ({1})>".format(self.name, self.description)
+
+    def create_target_machine(self, cpu='', features='',
+                              opt=2, reloc='default', codemodel='jitdefault',
+                              printmc=False, jit=False, abiname=''):
+        """
+        Create a new TargetMachine for this target and the given options.
+
+        Specifying codemodel='default' will result in the use of the "small"
+        code model. Specifying codemodel='jitdefault' will result in the code
+        model being picked based on platform bitness (32="small", 64="large").
+
+        The `printmc` option corresponds to llvm's `-print-machineinstrs`.
+
+        The `jit` option should be set when the target-machine is to be used
+        in a JIT engine.
+
+        The `abiname` option specifies the ABI. RISC-V targets with hard-float
+        needs to pass the ABI name to LLVM.
+        """
+        assert 0 <= opt <= 3
+        assert reloc in RELOC
+        assert codemodel in CODEMODEL
+        triple = self._triple
+        # MCJIT under Windows only supports ELF objects, see
+        # http://lists.llvm.org/pipermail/llvm-dev/2013-December/068341.html
+        # Note we still want to produce regular COFF files in AOT mode.
+        if os.name == 'nt' and codemodel == 'jitdefault':
+            triple += '-elf'
+        tm = ffi.lib.LLVMPY_CreateTargetMachine(self,
+                                                _encode_string(triple),
+                                                _encode_string(cpu),
+                                                _encode_string(features),
+                                                opt,
+                                                _encode_string(reloc),
+                                                _encode_string(codemodel),
+                                                int(printmc),
+                                                int(jit),
+                                                _encode_string(abiname),
+                                                )
+        if tm:
+            return TargetMachine(tm)
+        else:
+            raise RuntimeError("Cannot create target machine")
+
+
+class TargetMachine(ffi.ObjectRef):
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeTargetMachine(self)
+
+    def add_analysis_passes(self, pm):
+        """
+        Register analysis passes for this target machine with a pass manager.
+        """
+        ffi.lib.LLVMPY_AddAnalysisPasses(self, pm)
+
+    def set_asm_verbosity(self, verbose):
+        """
+        Set whether this target machine will emit assembly with human-readable
+        comments describing control flow, debug information, and so on.
+        """
+        ffi.lib.LLVMPY_SetTargetMachineAsmVerbosity(self, verbose)
+
+    def emit_object(self, module):
+        """
+        Represent the module as a code object, suitable for use with
+        the platform's linker.  Returns a byte string.
+        """
+        return self._emit_to_memory(module, use_object=True)
+
+    def emit_assembly(self, module):
+        """
+        Return the raw assembler of the module, as a string.
+
+        llvm.initialize_native_asmprinter() must have been called first.
+        """
+        return _decode_string(self._emit_to_memory(module, use_object=False))
+
+    def _emit_to_memory(self, module, use_object=False):
+        """Returns bytes of object code of the module.
+
+        Args
+        ----
+        use_object : bool
+            Emit object code or (if False) emit assembly code.
+        """
+        with ffi.OutputString() as outerr:
+            mb = ffi.lib.LLVMPY_TargetMachineEmitToMemory(self, module,
+                                                          int(use_object),
+                                                          outerr)
+            if not mb:
+                raise RuntimeError(str(outerr))
+
+        bufptr = ffi.lib.LLVMPY_GetBufferStart(mb)
+        bufsz = ffi.lib.LLVMPY_GetBufferSize(mb)
+        try:
+            return string_at(bufptr, bufsz)
+        finally:
+            ffi.lib.LLVMPY_DisposeMemoryBuffer(mb)
+
+    @property
+    def target_data(self):
+        return TargetData(ffi.lib.LLVMPY_CreateTargetMachineData(self))
+
+    @property
+    def triple(self):
+        with ffi.OutputString() as out:
+            ffi.lib.LLVMPY_GetTargetMachineTriple(self, out)
+            return str(out)
+
+
+def has_svml():
+    """
+    Returns True if SVML was enabled at FFI support compile time.
+    """
+    if ffi.lib.LLVMPY_HasSVMLSupport() == 0:
+        return False
+    else:
+        return True
+
+
+# ============================================================================
+# FFI
+
+ffi.lib.LLVMPY_GetProcessTriple.argtypes = [POINTER(c_char_p)]
+
+ffi.lib.LLVMPY_GetHostCPUFeatures.argtypes = [POINTER(c_char_p)]
+ffi.lib.LLVMPY_GetHostCPUFeatures.restype = c_int
+
+ffi.lib.LLVMPY_GetDefaultTargetTriple.argtypes = [POINTER(c_char_p)]
+
+ffi.lib.LLVMPY_GetHostCPUName.argtypes = [POINTER(c_char_p)]
+
+ffi.lib.LLVMPY_GetTripleObjectFormat.argtypes = [c_char_p]
+ffi.lib.LLVMPY_GetTripleObjectFormat.restype = c_int
+
+ffi.lib.LLVMPY_CreateTargetData.argtypes = [c_char_p]
+ffi.lib.LLVMPY_CreateTargetData.restype = ffi.LLVMTargetDataRef
+
+ffi.lib.LLVMPY_CopyStringRepOfTargetData.argtypes = [
+    ffi.LLVMTargetDataRef,
+    POINTER(c_char_p),
+]
+
+ffi.lib.LLVMPY_DisposeTargetData.argtypes = [
+    ffi.LLVMTargetDataRef,
+]
+
+ffi.lib.LLVMPY_ABISizeOfType.argtypes = [ffi.LLVMTargetDataRef,
+                                         ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_ABISizeOfType.restype = c_longlong
+
+ffi.lib.LLVMPY_OffsetOfElement.argtypes = [ffi.LLVMTargetDataRef,
+                                           ffi.LLVMTypeRef,
+                                           c_int]
+ffi.lib.LLVMPY_OffsetOfElement.restype = c_longlong
+
+ffi.lib.LLVMPY_ABISizeOfElementType.argtypes = [ffi.LLVMTargetDataRef,
+                                                ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_ABISizeOfElementType.restype = c_longlong
+
+ffi.lib.LLVMPY_ABIAlignmentOfElementType.argtypes = [ffi.LLVMTargetDataRef,
+                                                     ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_ABIAlignmentOfElementType.restype = c_longlong
+
+ffi.lib.LLVMPY_GetTargetFromTriple.argtypes = [c_char_p, POINTER(c_char_p)]
+ffi.lib.LLVMPY_GetTargetFromTriple.restype = ffi.LLVMTargetRef
+
+ffi.lib.LLVMPY_GetTargetName.argtypes = [ffi.LLVMTargetRef]
+ffi.lib.LLVMPY_GetTargetName.restype = c_char_p
+
+ffi.lib.LLVMPY_GetTargetDescription.argtypes = [ffi.LLVMTargetRef]
+ffi.lib.LLVMPY_GetTargetDescription.restype = c_char_p
+
+ffi.lib.LLVMPY_CreateTargetMachine.argtypes = [
+    ffi.LLVMTargetRef,
+    # Triple
+    c_char_p,
+    # CPU
+    c_char_p,
+    # Features
+    c_char_p,
+    # OptLevel
+    c_int,
+    # Reloc
+    c_char_p,
+    # CodeModel
+    c_char_p,
+    # PrintMC
+    c_int,
+    # JIT
+    c_int,
+    # ABIName
+    c_char_p,
+]
+ffi.lib.LLVMPY_CreateTargetMachine.restype = ffi.LLVMTargetMachineRef
+
+ffi.lib.LLVMPY_DisposeTargetMachine.argtypes = [ffi.LLVMTargetMachineRef]
+
+ffi.lib.LLVMPY_GetTargetMachineTriple.argtypes = [ffi.LLVMTargetMachineRef,
+                                                  POINTER(c_char_p)]
+
+ffi.lib.LLVMPY_SetTargetMachineAsmVerbosity.argtypes = [
+    ffi.LLVMTargetMachineRef, c_int]
+
+ffi.lib.LLVMPY_AddAnalysisPasses.argtypes = [
+    ffi.LLVMTargetMachineRef,
+    ffi.LLVMPassManagerRef,
+]
+
+ffi.lib.LLVMPY_TargetMachineEmitToMemory.argtypes = [
+    ffi.LLVMTargetMachineRef,
+    ffi.LLVMModuleRef,
+    c_int,
+    POINTER(c_char_p),
+]
+ffi.lib.LLVMPY_TargetMachineEmitToMemory.restype = ffi.LLVMMemoryBufferRef
+
+ffi.lib.LLVMPY_GetBufferStart.argtypes = [ffi.LLVMMemoryBufferRef]
+ffi.lib.LLVMPY_GetBufferStart.restype = c_void_p
+
+ffi.lib.LLVMPY_GetBufferSize.argtypes = [ffi.LLVMMemoryBufferRef]
+ffi.lib.LLVMPY_GetBufferSize.restype = c_size_t
+
+ffi.lib.LLVMPY_DisposeMemoryBuffer.argtypes = [ffi.LLVMMemoryBufferRef]
+
+ffi.lib.LLVMPY_CreateTargetMachineData.argtypes = [
+    ffi.LLVMTargetMachineRef,
+]
+ffi.lib.LLVMPY_CreateTargetMachineData.restype = ffi.LLVMTargetDataRef
+
+ffi.lib.LLVMPY_HasSVMLSupport.argtypes = []
+ffi.lib.LLVMPY_HasSVMLSupport.restype = c_int
diff --git a/lib/python3.11/site-packages/llvmlite/binding/transforms.py b/lib/python3.11/site-packages/llvmlite/binding/transforms.py
new file mode 100644
index 0000000000000000000000000000000000000000..82c5dc157a54d7cb1730dadb9b453cc684640cbf
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/transforms.py
@@ -0,0 +1,151 @@
+from ctypes import c_uint, c_bool
+from llvmlite.binding import ffi
+from llvmlite.binding import passmanagers
+
+
+def create_pass_manager_builder():
+    return PassManagerBuilder()
+
+
+class PassManagerBuilder(ffi.ObjectRef):
+    __slots__ = ()
+
+    def __init__(self, ptr=None):
+        if ptr is None:
+            ptr = ffi.lib.LLVMPY_PassManagerBuilderCreate()
+        ffi.ObjectRef.__init__(self, ptr)
+
+    @property
+    def opt_level(self):
+        """
+        The general optimization level as an integer between 0 and 3.
+        """
+        return ffi.lib.LLVMPY_PassManagerBuilderGetOptLevel(self)
+
+    @opt_level.setter
+    def opt_level(self, level):
+        ffi.lib.LLVMPY_PassManagerBuilderSetOptLevel(self, level)
+
+    @property
+    def size_level(self):
+        """
+        Whether and how much to optimize for size.  An integer between 0 and 2.
+        """
+        return ffi.lib.LLVMPY_PassManagerBuilderGetSizeLevel(self)
+
+    @size_level.setter
+    def size_level(self, size):
+        ffi.lib.LLVMPY_PassManagerBuilderSetSizeLevel(self, size)
+
+    @property
+    def inlining_threshold(self):
+        """
+        The integer threshold for inlining a function into another.  The higher,
+        the more likely inlining a function is.  This attribute is write-only.
+        """
+        raise NotImplementedError("inlining_threshold is write-only")
+
+    @inlining_threshold.setter
+    def inlining_threshold(self, threshold):
+        ffi.lib.LLVMPY_PassManagerBuilderUseInlinerWithThreshold(
+            self, threshold)
+
+    @property
+    def disable_unroll_loops(self):
+        """
+        If true, disable loop unrolling.
+        """
+        return ffi.lib.LLVMPY_PassManagerBuilderGetDisableUnrollLoops(self)
+
+    @disable_unroll_loops.setter
+    def disable_unroll_loops(self, disable=True):
+        ffi.lib.LLVMPY_PassManagerBuilderSetDisableUnrollLoops(self, disable)
+
+    @property
+    def loop_vectorize(self):
+        """
+        If true, allow vectorizing loops.
+        """
+        return ffi.lib.LLVMPY_PassManagerBuilderGetLoopVectorize(self)
+
+    @loop_vectorize.setter
+    def loop_vectorize(self, enable=True):
+        return ffi.lib.LLVMPY_PassManagerBuilderSetLoopVectorize(self, enable)
+
+    @property
+    def slp_vectorize(self):
+        """
+        If true, enable the "SLP vectorizer", which uses a different algorithm
+        from the loop vectorizer.  Both may be enabled at the same time.
+        """
+        return ffi.lib.LLVMPY_PassManagerBuilderGetSLPVectorize(self)
+
+    @slp_vectorize.setter
+    def slp_vectorize(self, enable=True):
+        return ffi.lib.LLVMPY_PassManagerBuilderSetSLPVectorize(self, enable)
+
+    def _populate_module_pm(self, pm):
+        ffi.lib.LLVMPY_PassManagerBuilderPopulateModulePassManager(self, pm)
+
+    def _populate_function_pm(self, pm):
+        ffi.lib.LLVMPY_PassManagerBuilderPopulateFunctionPassManager(self, pm)
+
+    def populate(self, pm):
+        if isinstance(pm, passmanagers.ModulePassManager):
+            self._populate_module_pm(pm)
+        elif isinstance(pm, passmanagers.FunctionPassManager):
+            self._populate_function_pm(pm)
+        else:
+            raise TypeError(pm)
+
+    def _dispose(self):
+        self._capi.LLVMPY_PassManagerBuilderDispose(self)
+
+
+# ============================================================================
+# FFI
+
+ffi.lib.LLVMPY_PassManagerBuilderCreate.restype = ffi.LLVMPassManagerBuilderRef
+
+ffi.lib.LLVMPY_PassManagerBuilderDispose.argtypes = [
+    ffi.LLVMPassManagerBuilderRef,
+]
+
+ffi.lib.LLVMPY_PassManagerBuilderPopulateModulePassManager.argtypes = [
+    ffi.LLVMPassManagerBuilderRef,
+    ffi.LLVMPassManagerRef,
+]
+
+ffi.lib.LLVMPY_PassManagerBuilderPopulateFunctionPassManager.argtypes = [
+    ffi.LLVMPassManagerBuilderRef,
+    ffi.LLVMPassManagerRef,
+]
+
+# Unsigned int PassManagerBuilder properties
+
+for _func in (ffi.lib.LLVMPY_PassManagerBuilderSetOptLevel,
+              ffi.lib.LLVMPY_PassManagerBuilderSetSizeLevel,
+              ffi.lib.LLVMPY_PassManagerBuilderUseInlinerWithThreshold,
+              ):
+    _func.argtypes = [ffi.LLVMPassManagerBuilderRef, c_uint]
+
+for _func in (ffi.lib.LLVMPY_PassManagerBuilderGetOptLevel,
+              ffi.lib.LLVMPY_PassManagerBuilderGetSizeLevel,
+              ):
+    _func.argtypes = [ffi.LLVMPassManagerBuilderRef]
+    _func.restype = c_uint
+
+# Boolean PassManagerBuilder properties
+
+for _func in (ffi.lib.LLVMPY_PassManagerBuilderSetDisableUnrollLoops,
+              ffi.lib.LLVMPY_PassManagerBuilderSetLoopVectorize,
+              ffi.lib.LLVMPY_PassManagerBuilderSetSLPVectorize,
+              ):
+    _func.argtypes = [ffi.LLVMPassManagerBuilderRef, c_bool]
+
+for _func in (ffi.lib.LLVMPY_PassManagerBuilderGetDisableUnrollLoops,
+              ffi.lib.LLVMPY_PassManagerBuilderGetLoopVectorize,
+              ffi.lib.LLVMPY_PassManagerBuilderGetSLPVectorize,
+              ):
+    _func.argtypes = [ffi.LLVMPassManagerBuilderRef]
+    _func.restype = c_bool
diff --git a/lib/python3.11/site-packages/llvmlite/binding/value.py b/lib/python3.11/site-packages/llvmlite/binding/value.py
new file mode 100644
index 0000000000000000000000000000000000000000..9411c7b238e23fd7394f807e5915c5745a7e4c9a
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/binding/value.py
@@ -0,0 +1,624 @@
+from ctypes import (POINTER, byref, cast, c_char_p, c_double, c_int, c_size_t,
+                    c_uint, c_uint64, c_bool, c_void_p)
+import enum
+
+from llvmlite.binding import ffi
+from llvmlite.binding.common import _decode_string, _encode_string
+
+
+class Linkage(enum.IntEnum):
+    # The LLVMLinkage enum from llvm-c/Core.h
+
+    external = 0
+    available_externally = 1
+    linkonce_any = 2
+    linkonce_odr = 3
+    linkonce_odr_autohide = 4
+    weak_any = 5
+    weak_odr = 6
+    appending = 7
+    internal = 8
+    private = 9
+    dllimport = 10
+    dllexport = 11
+    external_weak = 12
+    ghost = 13
+    common = 14
+    linker_private = 15
+    linker_private_weak = 16
+
+
+class Visibility(enum.IntEnum):
+    # The LLVMVisibility enum from llvm-c/Core.h
+
+    default = 0
+    hidden = 1
+    protected = 2
+
+
+class StorageClass(enum.IntEnum):
+    # The LLVMDLLStorageClass enum from llvm-c/Core.h
+
+    default = 0
+    dllimport = 1
+    dllexport = 2
+
+
+class ValueKind(enum.IntEnum):
+    # The LLVMValueKind enum from llvm-c/Core.h
+
+    argument = 0
+    basic_block = 1
+    memory_use = 2
+    memory_def = 3
+    memory_phi = 4
+
+    function = 5
+    global_alias = 6
+    global_ifunc = 7
+    global_variable = 8
+    block_address = 9
+    constant_expr = 10
+    constant_array = 11
+    constant_struct = 12
+    constant_vector = 13
+
+    undef_value = 14
+    constant_aggregate_zero = 15
+    constant_data_array = 16
+    constant_data_vector = 17
+    constant_int = 18
+    constant_fp = 19
+    constant_pointer_null = 20
+    constant_token_none = 21
+
+    metadata_as_value = 22
+    inline_asm = 23
+
+    instruction = 24
+    poison_value = 25
+
+
+class TypeRef(ffi.ObjectRef):
+    """A weak reference to a LLVM type
+    """
+    @property
+    def name(self):
+        """
+        Get type name
+        """
+        return ffi.ret_string(ffi.lib.LLVMPY_GetTypeName(self))
+
+    @property
+    def is_pointer(self):
+        """
+        Returns true is the type is a pointer type.
+        """
+        return ffi.lib.LLVMPY_TypeIsPointer(self)
+
+    @property
+    def element_type(self):
+        """
+        Returns the pointed-to type. When the type is not a pointer,
+        raises exception.
+        """
+        if not self.is_pointer:
+            raise ValueError("Type {} is not a pointer".format(self))
+        return TypeRef(ffi.lib.LLVMPY_GetElementType(self))
+
+    def __str__(self):
+        return ffi.ret_string(ffi.lib.LLVMPY_PrintType(self))
+
+
+class ValueRef(ffi.ObjectRef):
+    """A weak reference to a LLVM value.
+    """
+
+    def __init__(self, ptr, kind, parents):
+        self._kind = kind
+        self._parents = parents
+        ffi.ObjectRef.__init__(self, ptr)
+
+    def __str__(self):
+        with ffi.OutputString() as outstr:
+            ffi.lib.LLVMPY_PrintValueToString(self, outstr)
+            return str(outstr)
+
+    @property
+    def module(self):
+        """
+        The module this function or global variable value was obtained from.
+        """
+        return self._parents.get('module')
+
+    @property
+    def function(self):
+        """
+        The function this argument or basic block value was obtained from.
+        """
+        return self._parents.get('function')
+
+    @property
+    def block(self):
+        """
+        The block this instruction value was obtained from.
+        """
+        return self._parents.get('block')
+
+    @property
+    def instruction(self):
+        """
+        The instruction this operand value was obtained from.
+        """
+        return self._parents.get('instruction')
+
+    @property
+    def is_global(self):
+        return self._kind == 'global'
+
+    @property
+    def is_function(self):
+        return self._kind == 'function'
+
+    @property
+    def is_block(self):
+        return self._kind == 'block'
+
+    @property
+    def is_argument(self):
+        return self._kind == 'argument'
+
+    @property
+    def is_instruction(self):
+        return self._kind == 'instruction'
+
+    @property
+    def is_operand(self):
+        return self._kind == 'operand'
+
+    @property
+    def is_constant(self):
+        return bool(ffi.lib.LLVMPY_IsConstant(self))
+
+    @property
+    def value_kind(self):
+        return ValueKind(ffi.lib.LLVMPY_GetValueKind(self))
+
+    @property
+    def name(self):
+        return _decode_string(ffi.lib.LLVMPY_GetValueName(self))
+
+    @name.setter
+    def name(self, val):
+        ffi.lib.LLVMPY_SetValueName(self, _encode_string(val))
+
+    @property
+    def linkage(self):
+        return Linkage(ffi.lib.LLVMPY_GetLinkage(self))
+
+    @linkage.setter
+    def linkage(self, value):
+        if not isinstance(value, Linkage):
+            value = Linkage[value]
+        ffi.lib.LLVMPY_SetLinkage(self, value)
+
+    @property
+    def visibility(self):
+        return Visibility(ffi.lib.LLVMPY_GetVisibility(self))
+
+    @visibility.setter
+    def visibility(self, value):
+        if not isinstance(value, Visibility):
+            value = Visibility[value]
+        ffi.lib.LLVMPY_SetVisibility(self, value)
+
+    @property
+    def storage_class(self):
+        return StorageClass(ffi.lib.LLVMPY_GetDLLStorageClass(self))
+
+    @storage_class.setter
+    def storage_class(self, value):
+        if not isinstance(value, StorageClass):
+            value = StorageClass[value]
+        ffi.lib.LLVMPY_SetDLLStorageClass(self, value)
+
+    def add_function_attribute(self, attr):
+        """Only works on function value
+
+        Parameters
+        -----------
+        attr : str
+            attribute name
+        """
+        if not self.is_function:
+            raise ValueError('expected function value, got %s' % (self._kind,))
+        attrname = str(attr)
+        attrval = ffi.lib.LLVMPY_GetEnumAttributeKindForName(
+            _encode_string(attrname), len(attrname))
+        if attrval == 0:
+            raise ValueError('no such attribute {!r}'.format(attrname))
+        ffi.lib.LLVMPY_AddFunctionAttr(self, attrval)
+
+    @property
+    def type(self):
+        """
+        This value's LLVM type.
+        """
+        # XXX what does this return?
+        return TypeRef(ffi.lib.LLVMPY_TypeOf(self))
+
+    @property
+    def is_declaration(self):
+        """
+        Whether this value (presumably global) is defined in the current
+        module.
+        """
+        if not (self.is_global or self.is_function):
+            raise ValueError('expected global or function value, got %s'
+                             % (self._kind,))
+        return ffi.lib.LLVMPY_IsDeclaration(self)
+
+    @property
+    def attributes(self):
+        """
+        Return an iterator over this value's attributes.
+        The iterator will yield a string for each attribute.
+        """
+        itr = iter(())
+        if self.is_function:
+            it = ffi.lib.LLVMPY_FunctionAttributesIter(self)
+            itr = _AttributeListIterator(it)
+        elif self.is_instruction:
+            if self.opcode == 'call':
+                it = ffi.lib.LLVMPY_CallInstAttributesIter(self)
+                itr = _AttributeListIterator(it)
+            elif self.opcode == 'invoke':
+                it = ffi.lib.LLVMPY_InvokeInstAttributesIter(self)
+                itr = _AttributeListIterator(it)
+        elif self.is_global:
+            it = ffi.lib.LLVMPY_GlobalAttributesIter(self)
+            itr = _AttributeSetIterator(it)
+        elif self.is_argument:
+            it = ffi.lib.LLVMPY_ArgumentAttributesIter(self)
+            itr = _AttributeSetIterator(it)
+        return itr
+
+    @property
+    def blocks(self):
+        """
+        Return an iterator over this function's blocks.
+        The iterator will yield a ValueRef for each block.
+        """
+        if not self.is_function:
+            raise ValueError('expected function value, got %s' % (self._kind,))
+        it = ffi.lib.LLVMPY_FunctionBlocksIter(self)
+        parents = self._parents.copy()
+        parents.update(function=self)
+        return _BlocksIterator(it, parents)
+
+    @property
+    def arguments(self):
+        """
+        Return an iterator over this function's arguments.
+        The iterator will yield a ValueRef for each argument.
+        """
+        if not self.is_function:
+            raise ValueError('expected function value, got %s' % (self._kind,))
+        it = ffi.lib.LLVMPY_FunctionArgumentsIter(self)
+        parents = self._parents.copy()
+        parents.update(function=self)
+        return _ArgumentsIterator(it, parents)
+
+    @property
+    def instructions(self):
+        """
+        Return an iterator over this block's instructions.
+        The iterator will yield a ValueRef for each instruction.
+        """
+        if not self.is_block:
+            raise ValueError('expected block value, got %s' % (self._kind,))
+        it = ffi.lib.LLVMPY_BlockInstructionsIter(self)
+        parents = self._parents.copy()
+        parents.update(block=self)
+        return _InstructionsIterator(it, parents)
+
+    @property
+    def operands(self):
+        """
+        Return an iterator over this instruction's operands.
+        The iterator will yield a ValueRef for each operand.
+        """
+        if not self.is_instruction:
+            raise ValueError('expected instruction value, got %s'
+                             % (self._kind,))
+        it = ffi.lib.LLVMPY_InstructionOperandsIter(self)
+        parents = self._parents.copy()
+        parents.update(instruction=self)
+        return _OperandsIterator(it, parents)
+
+    @property
+    def opcode(self):
+        if not self.is_instruction:
+            raise ValueError('expected instruction value, got %s'
+                             % (self._kind,))
+        return ffi.ret_string(ffi.lib.LLVMPY_GetOpcodeName(self))
+
+    def get_constant_value(self, signed_int=False, round_fp=False):
+        """
+        Return the constant value, either as a literal (when supported)
+        or as a string.
+
+        Parameters
+        -----------
+        signed_int : bool
+            if True and the constant is an integer, returns a signed version
+        round_fp : bool
+            if True and the constant is a floating point value, rounds the
+            result upon accuracy loss (e.g., when querying an fp128 value).
+            By default, raises an exception on accuracy loss
+        """
+        if not self.is_constant:
+            raise ValueError('expected constant value, got %s'
+                             % (self._kind,))
+
+        if self.value_kind == ValueKind.constant_int:
+            # Python integers are also arbitrary-precision
+            little_endian = c_bool(False)
+            words = ffi.lib.LLVMPY_GetConstantIntNumWords(self)
+            ptr = ffi.lib.LLVMPY_GetConstantIntRawValue(
+                self, byref(little_endian))
+            asbytes = bytes(cast(ptr, POINTER(c_uint64 * words)).contents)
+            return int.from_bytes(
+                asbytes,
+                ('little' if little_endian.value else 'big'),
+                signed=signed_int,
+            )
+        elif self.value_kind == ValueKind.constant_fp:
+            # Convert floating-point values to double-precision (Python float)
+            accuracy_loss = c_bool(False)
+            value = ffi.lib.LLVMPY_GetConstantFPValue(self,
+                                                      byref(accuracy_loss))
+            if accuracy_loss.value and not round_fp:
+                raise ValueError(
+                    'Accuracy loss encountered in conversion of constant '
+                    f'value {str(self)}')
+
+            return value
+
+        # Otherwise, return the IR string
+        return str(self)
+
+
+class _ValueIterator(ffi.ObjectRef):
+
+    kind = None  # derived classes must specify the Value kind value
+    # as class attribute
+
+    def __init__(self, ptr, parents):
+        ffi.ObjectRef.__init__(self, ptr)
+        # Keep parent objects (module, function, etc) alive
+        self._parents = parents
+        if self.kind is None:
+            raise NotImplementedError('%s must specify kind attribute'
+                                      % (type(self).__name__,))
+
+    def __next__(self):
+        vp = self._next()
+        if vp:
+            return ValueRef(vp, self.kind, self._parents)
+        else:
+            raise StopIteration
+
+    next = __next__
+
+    def __iter__(self):
+        return self
+
+
+class _AttributeIterator(ffi.ObjectRef):
+
+    def __next__(self):
+        vp = self._next()
+        if vp:
+            return vp
+        else:
+            raise StopIteration
+
+    next = __next__
+
+    def __iter__(self):
+        return self
+
+
+class _AttributeListIterator(_AttributeIterator):
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeAttributeListIter(self)
+
+    def _next(self):
+        return ffi.ret_bytes(ffi.lib.LLVMPY_AttributeListIterNext(self))
+
+
+class _AttributeSetIterator(_AttributeIterator):
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeAttributeSetIter(self)
+
+    def _next(self):
+        return ffi.ret_bytes(ffi.lib.LLVMPY_AttributeSetIterNext(self))
+
+
+class _BlocksIterator(_ValueIterator):
+
+    kind = 'block'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeBlocksIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_BlocksIterNext(self)
+
+
+class _ArgumentsIterator(_ValueIterator):
+
+    kind = 'argument'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeArgumentsIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_ArgumentsIterNext(self)
+
+
+class _InstructionsIterator(_ValueIterator):
+
+    kind = 'instruction'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeInstructionsIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_InstructionsIterNext(self)
+
+
+class _OperandsIterator(_ValueIterator):
+
+    kind = 'operand'
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposeOperandsIter(self)
+
+    def _next(self):
+        return ffi.lib.LLVMPY_OperandsIterNext(self)
+
+
+# FFI
+
+ffi.lib.LLVMPY_PrintValueToString.argtypes = [
+    ffi.LLVMValueRef,
+    POINTER(c_char_p)
+]
+
+ffi.lib.LLVMPY_GetGlobalParent.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetGlobalParent.restype = ffi.LLVMModuleRef
+
+ffi.lib.LLVMPY_GetValueName.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetValueName.restype = c_char_p
+
+ffi.lib.LLVMPY_SetValueName.argtypes = [ffi.LLVMValueRef, c_char_p]
+
+ffi.lib.LLVMPY_TypeOf.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_TypeOf.restype = ffi.LLVMTypeRef
+
+
+ffi.lib.LLVMPY_PrintType.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_PrintType.restype = c_void_p
+
+ffi.lib.LLVMPY_TypeIsPointer.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_TypeIsPointer.restype = c_bool
+
+ffi.lib.LLVMPY_GetElementType.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_GetElementType.restype = ffi.LLVMTypeRef
+
+
+ffi.lib.LLVMPY_GetTypeName.argtypes = [ffi.LLVMTypeRef]
+ffi.lib.LLVMPY_GetTypeName.restype = c_void_p
+
+ffi.lib.LLVMPY_GetLinkage.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetLinkage.restype = c_int
+
+ffi.lib.LLVMPY_SetLinkage.argtypes = [ffi.LLVMValueRef, c_int]
+
+ffi.lib.LLVMPY_GetVisibility.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetVisibility.restype = c_int
+
+ffi.lib.LLVMPY_SetVisibility.argtypes = [ffi.LLVMValueRef, c_int]
+
+ffi.lib.LLVMPY_GetDLLStorageClass.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetDLLStorageClass.restype = c_int
+
+ffi.lib.LLVMPY_SetDLLStorageClass.argtypes = [ffi.LLVMValueRef, c_int]
+
+ffi.lib.LLVMPY_GetEnumAttributeKindForName.argtypes = [c_char_p, c_size_t]
+ffi.lib.LLVMPY_GetEnumAttributeKindForName.restype = c_uint
+
+ffi.lib.LLVMPY_AddFunctionAttr.argtypes = [ffi.LLVMValueRef, c_uint]
+
+ffi.lib.LLVMPY_IsDeclaration.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_IsDeclaration.restype = c_int
+
+ffi.lib.LLVMPY_FunctionAttributesIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_FunctionAttributesIter.restype = ffi.LLVMAttributeListIterator
+
+ffi.lib.LLVMPY_CallInstAttributesIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_CallInstAttributesIter.restype = ffi.LLVMAttributeListIterator
+
+ffi.lib.LLVMPY_InvokeInstAttributesIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_InvokeInstAttributesIter.restype = ffi.LLVMAttributeListIterator
+
+ffi.lib.LLVMPY_GlobalAttributesIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GlobalAttributesIter.restype = ffi.LLVMAttributeSetIterator
+
+ffi.lib.LLVMPY_ArgumentAttributesIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_ArgumentAttributesIter.restype = ffi.LLVMAttributeSetIterator
+
+ffi.lib.LLVMPY_FunctionBlocksIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_FunctionBlocksIter.restype = ffi.LLVMBlocksIterator
+
+ffi.lib.LLVMPY_FunctionArgumentsIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_FunctionArgumentsIter.restype = ffi.LLVMArgumentsIterator
+
+ffi.lib.LLVMPY_BlockInstructionsIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_BlockInstructionsIter.restype = ffi.LLVMInstructionsIterator
+
+ffi.lib.LLVMPY_InstructionOperandsIter.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_InstructionOperandsIter.restype = ffi.LLVMOperandsIterator
+
+ffi.lib.LLVMPY_DisposeAttributeListIter.argtypes = [
+    ffi.LLVMAttributeListIterator]
+
+ffi.lib.LLVMPY_DisposeAttributeSetIter.argtypes = [ffi.LLVMAttributeSetIterator]
+
+ffi.lib.LLVMPY_DisposeBlocksIter.argtypes = [ffi.LLVMBlocksIterator]
+
+ffi.lib.LLVMPY_DisposeInstructionsIter.argtypes = [ffi.LLVMInstructionsIterator]
+
+ffi.lib.LLVMPY_DisposeOperandsIter.argtypes = [ffi.LLVMOperandsIterator]
+
+ffi.lib.LLVMPY_AttributeListIterNext.argtypes = [ffi.LLVMAttributeListIterator]
+ffi.lib.LLVMPY_AttributeListIterNext.restype = c_void_p
+
+ffi.lib.LLVMPY_AttributeSetIterNext.argtypes = [ffi.LLVMAttributeSetIterator]
+ffi.lib.LLVMPY_AttributeSetIterNext.restype = c_void_p
+
+ffi.lib.LLVMPY_BlocksIterNext.argtypes = [ffi.LLVMBlocksIterator]
+ffi.lib.LLVMPY_BlocksIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_ArgumentsIterNext.argtypes = [ffi.LLVMArgumentsIterator]
+ffi.lib.LLVMPY_ArgumentsIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_InstructionsIterNext.argtypes = [ffi.LLVMInstructionsIterator]
+ffi.lib.LLVMPY_InstructionsIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_OperandsIterNext.argtypes = [ffi.LLVMOperandsIterator]
+ffi.lib.LLVMPY_OperandsIterNext.restype = ffi.LLVMValueRef
+
+ffi.lib.LLVMPY_GetOpcodeName.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetOpcodeName.restype = c_void_p
+
+ffi.lib.LLVMPY_IsConstant.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_IsConstant.restype = c_bool
+
+ffi.lib.LLVMPY_GetValueKind.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetValueKind.restype = c_int
+
+ffi.lib.LLVMPY_GetConstantIntRawValue.argtypes = [ffi.LLVMValueRef,
+                                                  POINTER(c_bool)]
+ffi.lib.LLVMPY_GetConstantIntRawValue.restype = POINTER(c_uint64)
+
+ffi.lib.LLVMPY_GetConstantIntNumWords.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetConstantIntNumWords.restype = c_uint
+
+ffi.lib.LLVMPY_GetConstantFPValue.argtypes = [ffi.LLVMValueRef,
+                                              POINTER(c_bool)]
+ffi.lib.LLVMPY_GetConstantFPValue.restype = c_double
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__init__.py b/lib/python3.11/site-packages/llvmlite/ir/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7a0737b2d5325d5c40a8953520a260c013ed48f
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/__init__.py
@@ -0,0 +1,11 @@
+"""
+This subpackage implements the LLVM IR classes in pure python
+"""
+
+from .types import *
+from .values import *
+from .module import *
+from .builder import *
+from .instructions import *
+from .transforms import *
+from .context import Context, global_context
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1b612ea043ab6c1baa10df1e43b0817f6e3951cc
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/_utils.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af602161849e5462d8abd33f289b0d38f7f3dee5
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/_utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/builder.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/builder.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6800014fe3cc534cac5ad6aa9fb53aeebdad5794
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/builder.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/context.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/context.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f790e4cb4edc3d3f27036ab4d5a81bd3e5aa34ba
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/context.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/instructions.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/instructions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..896e6b564014605f80e7fc86918babbf0b48e55a
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/instructions.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/module.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/module.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..413094cd43efc429d4f08fd98664002f119074c1
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/module.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/transforms.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/transforms.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69bc9699d89db2f066029962b7c2e5e0fb68208e
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/transforms.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/types.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/types.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f014da152872d585a88868f2031f8845f99d60aa
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/types.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/__pycache__/values.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/values.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e606ed2fe893d907345ddedd511a7ec694bf314e
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/ir/__pycache__/values.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/ir/_utils.py b/lib/python3.11/site-packages/llvmlite/ir/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..8287d77afb84f750be00ef0b001a175507c59da4
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/_utils.py
@@ -0,0 +1,80 @@
+from collections import defaultdict
+
+
+class DuplicatedNameError(NameError):
+    pass
+
+
+class NameScope(object):
+    def __init__(self):
+        self._useset = set([''])
+        self._basenamemap = defaultdict(int)
+
+    def is_used(self, name):
+        return name in self._useset
+
+    def register(self, name, deduplicate=False):
+        if deduplicate:
+            name = self.deduplicate(name)
+        elif self.is_used(name):
+            raise DuplicatedNameError(name)
+        self._useset.add(name)
+        return name
+
+    def deduplicate(self, name):
+        basename = name
+        while self.is_used(name):
+            ident = self._basenamemap[basename] + 1
+            self._basenamemap[basename] = ident
+            name = "{0}.{1}".format(basename, ident)
+        return name
+
+    def get_child(self):
+        return type(self)(parent=self)
+
+
+class _StrCaching(object):
+
+    def _clear_string_cache(self):
+        try:
+            del self.__cached_str
+        except AttributeError:
+            pass
+
+    def __str__(self):
+        try:
+            return self.__cached_str
+        except AttributeError:
+            s = self.__cached_str = self._to_string()
+            return s
+
+
+class _StringReferenceCaching(object):
+
+    def get_reference(self):
+        try:
+            return self.__cached_refstr
+        except AttributeError:
+            s = self.__cached_refstr = self._get_reference()
+            return s
+
+
+class _HasMetadata(object):
+
+    def set_metadata(self, name, node):
+        """
+        Attach unnamed metadata *node* to the metadata slot *name* of this
+        value.
+        """
+        self.metadata[name] = node
+
+    def _stringify_metadata(self, leading_comma=False):
+        if self.metadata:
+            buf = []
+            if leading_comma:
+                buf.append("")
+            buf += ["!{0} {1}".format(k, v.get_reference())
+                    for k, v in self.metadata.items()]
+            return ', '.join(buf)
+        else:
+            return ''
diff --git a/lib/python3.11/site-packages/llvmlite/ir/builder.py b/lib/python3.11/site-packages/llvmlite/ir/builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..f62476ca8a4c470d7256bf9d20cf90b2bfe4682b
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/builder.py
@@ -0,0 +1,1119 @@
+import contextlib
+import functools
+
+from llvmlite.ir import instructions, types, values
+
+_CMP_MAP = {
+    '>': 'gt',
+    '<': 'lt',
+    '==': 'eq',
+    '!=': 'ne',
+    '>=': 'ge',
+    '<=': 'le',
+}
+
+
+def _unop(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, arg, name='', flags=()):
+            instr = cls(self.block, arg.type, opname, [arg], name, flags)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _binop(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, lhs, rhs, name='', flags=()):
+            if lhs.type != rhs.type:
+                raise ValueError("Operands must be the same type, got (%s, %s)"
+                                 % (lhs.type, rhs.type))
+            instr = cls(self.block, lhs.type, opname, (lhs, rhs), name, flags)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _binop_with_overflow(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, lhs, rhs, name=''):
+            if lhs.type != rhs.type:
+                raise ValueError("Operands must be the same type, got (%s, %s)"
+                                 % (lhs.type, rhs.type))
+            ty = lhs.type
+            if not isinstance(ty, types.IntType):
+                raise TypeError("expected an integer type, got %s" % (ty,))
+            bool_ty = types.IntType(1)
+
+            mod = self.module
+            fnty = types.FunctionType(types.LiteralStructType([ty, bool_ty]),
+                                      [ty, ty])
+            fn = mod.declare_intrinsic("llvm.%s.with.overflow" % (opname,),
+                                       [ty], fnty)
+            ret = self.call(fn, [lhs, rhs], name=name)
+            return ret
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop(opname, cls=instructions.Instruction):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, name=''):
+            instr = cls(self.block, operand.type, opname, [operand], name)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop_intrinsic_int(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, name=''):
+            if not isinstance(operand.type, types.IntType):
+                raise TypeError(
+                    "expected an integer type, got %s" %
+                    operand.type)
+            fn = self.module.declare_intrinsic(opname, [operand.type])
+            return self.call(fn, [operand], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop_intrinsic_float(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, name=''):
+            if not isinstance(
+                    operand.type, (types.FloatType, types.DoubleType)):
+                raise TypeError("expected a float type, got %s" % operand.type)
+            fn = self.module.declare_intrinsic(opname, [operand.type])
+            return self.call(fn, [operand], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _uniop_intrinsic_with_flag(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, operand, flag, name=''):
+            if not isinstance(operand.type, types.IntType):
+                raise TypeError(
+                    "expected an integer type, got %s" %
+                    operand.type)
+            if not (isinstance(flag.type, types.IntType) and
+                    flag.type.width == 1):
+                raise TypeError("expected an i1 type, got %s" % flag.type)
+            fn = self.module.declare_intrinsic(
+                opname, [operand.type, flag.type])
+            return self.call(fn, [operand, flag], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _triop_intrinsic(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, a, b, c, name=''):
+            if a.type != b.type or b.type != c.type:
+                raise TypeError(
+                    "expected types to be the same, got %s, %s, %s" % (
+                        a.type,
+                        b.type,
+                        c.type))
+            elif not isinstance(
+                    a.type,
+                    (types.HalfType, types.FloatType, types.DoubleType)):
+                raise TypeError(
+                    "expected an floating point type, got %s" %
+                    a.type)
+            fn = self.module.declare_intrinsic(opname, [a.type, b.type, c.type])
+            return self.call(fn, [a, b, c], name)
+
+        return wrapped
+
+    return wrap
+
+
+def _castop(opname, cls=instructions.CastInstr):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, val, typ, name=''):
+            if val.type == typ:
+                return val
+            instr = cls(self.block, opname, val, typ, name)
+            self._insert(instr)
+            return instr
+
+        return wrapped
+
+    return wrap
+
+
+def _label_suffix(label, suffix):
+    """Returns (label + suffix) or a truncated version if it's too long.
+    Parameters
+    ----------
+    label : str
+        Label name
+    suffix : str
+        Label suffix
+    """
+    if len(label) > 50:
+        nhead = 25
+        return ''.join([label[:nhead], '..', suffix])
+    else:
+        return label + suffix
+
+
+class IRBuilder(object):
+    def __init__(self, block=None):
+        self._block = block
+        self._anchor = len(block.instructions) if block else 0
+        self.debug_metadata = None
+
+    @property
+    def block(self):
+        """
+        The current basic block.
+        """
+        return self._block
+
+    basic_block = block
+
+    @property
+    def function(self):
+        """
+        The current function.
+        """
+        return self.block.parent
+
+    @property
+    def module(self):
+        """
+        The current module.
+        """
+        return self.block.parent.module
+
+    def position_before(self, instr):
+        """
+        Position immediately before the given instruction.  The current block
+        is also changed to the instruction's basic block.
+        """
+        self._block = instr.parent
+        self._anchor = self._block.instructions.index(instr)
+
+    def position_after(self, instr):
+        """
+        Position immediately after the given instruction.  The current block
+        is also changed to the instruction's basic block.
+        """
+        self._block = instr.parent
+        self._anchor = self._block.instructions.index(instr) + 1
+
+    def position_at_start(self, block):
+        """
+        Position at the start of the basic *block*.
+        """
+        self._block = block
+        self._anchor = 0
+
+    def position_at_end(self, block):
+        """
+        Position at the end of the basic *block*.
+        """
+        self._block = block
+        self._anchor = len(block.instructions)
+
+    def append_basic_block(self, name=''):
+        """
+        Append a basic block, with the given optional *name*, to the current
+        function.  The current block is not changed.  The new block is returned.
+        """
+        return self.function.append_basic_block(name)
+
+    def remove(self, instr):
+        """Remove the given instruction."""
+        idx = self._block.instructions.index(instr)
+        del self._block.instructions[idx]
+        if self._block.terminator == instr:
+            self._block.terminator = None
+        if self._anchor > idx:
+            self._anchor -= 1
+
+    @contextlib.contextmanager
+    def goto_block(self, block):
+        """
+        A context manager which temporarily positions the builder at the end
+        of basic block *bb* (but before any terminator).
+        """
+        old_block = self.basic_block
+        term = block.terminator
+        if term is not None:
+            self.position_before(term)
+        else:
+            self.position_at_end(block)
+        try:
+            yield
+        finally:
+            self.position_at_end(old_block)
+
+    @contextlib.contextmanager
+    def goto_entry_block(self):
+        """
+        A context manager which temporarily positions the builder at the
+        end of the function's entry block.
+        """
+        with self.goto_block(self.function.entry_basic_block):
+            yield
+
+    @contextlib.contextmanager
+    def _branch_helper(self, bbenter, bbexit):
+        self.position_at_end(bbenter)
+        yield bbexit
+        if self.basic_block.terminator is None:
+            self.branch(bbexit)
+
+    @contextlib.contextmanager
+    def if_then(self, pred, likely=None):
+        """
+        A context manager which sets up a conditional basic block based
+        on the given predicate (a i1 value).  If the conditional block
+        is not explicitly terminated, a branch will be added to the next
+        block.
+        If *likely* is given, its boolean value indicates whether the
+        predicate is likely to be true or not, and metadata is issued
+        for LLVM's optimizers to account for that.
+        """
+        bb = self.basic_block
+        bbif = self.append_basic_block(name=_label_suffix(bb.name, '.if'))
+        bbend = self.append_basic_block(name=_label_suffix(bb.name, '.endif'))
+        br = self.cbranch(pred, bbif, bbend)
+        if likely is not None:
+            br.set_weights([99, 1] if likely else [1, 99])
+
+        with self._branch_helper(bbif, bbend):
+            yield bbend
+
+        self.position_at_end(bbend)
+
+    @contextlib.contextmanager
+    def if_else(self, pred, likely=None):
+        """
+        A context manager which sets up two conditional basic blocks based
+        on the given predicate (a i1 value).
+        A tuple of context managers is yield'ed.  Each context manager
+        acts as a if_then() block.
+        *likely* has the same meaning as in if_then().
+
+        Typical use::
+            with builder.if_else(pred) as (then, otherwise):
+                with then:
+                    # emit instructions for when the predicate is true
+                with otherwise:
+                    # emit instructions for when the predicate is false
+        """
+        bb = self.basic_block
+        bbif = self.append_basic_block(name=_label_suffix(bb.name, '.if'))
+        bbelse = self.append_basic_block(name=_label_suffix(bb.name, '.else'))
+        bbend = self.append_basic_block(name=_label_suffix(bb.name, '.endif'))
+        br = self.cbranch(pred, bbif, bbelse)
+        if likely is not None:
+            br.set_weights([99, 1] if likely else [1, 99])
+
+        then = self._branch_helper(bbif, bbend)
+        otherwise = self._branch_helper(bbelse, bbend)
+
+        yield then, otherwise
+
+        self.position_at_end(bbend)
+
+    def _insert(self, instr):
+        if self.debug_metadata is not None and 'dbg' not in instr.metadata:
+            instr.metadata['dbg'] = self.debug_metadata
+        self._block.instructions.insert(self._anchor, instr)
+        self._anchor += 1
+
+    def _set_terminator(self, term):
+        assert not self.block.is_terminated
+        self._insert(term)
+        self.block.terminator = term
+        return term
+
+    #
+    # Arithmetic APIs
+    #
+
+    @_binop('shl')
+    def shl(self, lhs, rhs, name=''):
+        """
+        Left integer shift:
+            name = lhs << rhs
+        """
+
+    @_binop('lshr')
+    def lshr(self, lhs, rhs, name=''):
+        """
+        Logical (unsigned) right integer shift:
+            name = lhs >> rhs
+        """
+
+    @_binop('ashr')
+    def ashr(self, lhs, rhs, name=''):
+        """
+        Arithmetic (signed) right integer shift:
+            name = lhs >> rhs
+        """
+
+    @_binop('add')
+    def add(self, lhs, rhs, name=''):
+        """
+        Integer addition:
+            name = lhs + rhs
+        """
+
+    @_binop('fadd')
+    def fadd(self, lhs, rhs, name=''):
+        """
+        Floating-point addition:
+            name = lhs + rhs
+        """
+
+    @_binop('sub')
+    def sub(self, lhs, rhs, name=''):
+        """
+        Integer subtraction:
+            name = lhs - rhs
+        """
+
+    @_binop('fsub')
+    def fsub(self, lhs, rhs, name=''):
+        """
+        Floating-point subtraction:
+            name = lhs - rhs
+        """
+
+    @_binop('mul')
+    def mul(self, lhs, rhs, name=''):
+        """
+        Integer multiplication:
+            name = lhs * rhs
+        """
+
+    @_binop('fmul')
+    def fmul(self, lhs, rhs, name=''):
+        """
+        Floating-point multiplication:
+            name = lhs * rhs
+        """
+
+    @_binop('udiv')
+    def udiv(self, lhs, rhs, name=''):
+        """
+        Unsigned integer division:
+            name = lhs / rhs
+        """
+
+    @_binop('sdiv')
+    def sdiv(self, lhs, rhs, name=''):
+        """
+        Signed integer division:
+            name = lhs / rhs
+        """
+
+    @_binop('fdiv')
+    def fdiv(self, lhs, rhs, name=''):
+        """
+        Floating-point division:
+            name = lhs / rhs
+        """
+
+    @_binop('urem')
+    def urem(self, lhs, rhs, name=''):
+        """
+        Unsigned integer remainder:
+            name = lhs % rhs
+        """
+
+    @_binop('srem')
+    def srem(self, lhs, rhs, name=''):
+        """
+        Signed integer remainder:
+            name = lhs % rhs
+        """
+
+    @_binop('frem')
+    def frem(self, lhs, rhs, name=''):
+        """
+        Floating-point remainder:
+            name = lhs % rhs
+        """
+
+    @_binop('or')
+    def or_(self, lhs, rhs, name=''):
+        """
+        Bitwise integer OR:
+            name = lhs | rhs
+        """
+
+    @_binop('and')
+    def and_(self, lhs, rhs, name=''):
+        """
+        Bitwise integer AND:
+            name = lhs & rhs
+        """
+
+    @_binop('xor')
+    def xor(self, lhs, rhs, name=''):
+        """
+        Bitwise integer XOR:
+            name = lhs ^ rhs
+        """
+
+    @_binop_with_overflow('sadd')
+    def sadd_with_overflow(self, lhs, rhs, name=''):
+        """
+        Signed integer addition with overflow:
+            name = {result, overflow bit} = lhs + rhs
+        """
+
+    @_binop_with_overflow('smul')
+    def smul_with_overflow(self, lhs, rhs, name=''):
+        """
+        Signed integer multiplication with overflow:
+            name = {result, overflow bit} = lhs * rhs
+        """
+
+    @_binop_with_overflow('ssub')
+    def ssub_with_overflow(self, lhs, rhs, name=''):
+        """
+        Signed integer subtraction with overflow:
+            name = {result, overflow bit} = lhs - rhs
+        """
+
+    @_binop_with_overflow('uadd')
+    def uadd_with_overflow(self, lhs, rhs, name=''):
+        """
+        Unsigned integer addition with overflow:
+            name = {result, overflow bit} = lhs + rhs
+        """
+
+    @_binop_with_overflow('umul')
+    def umul_with_overflow(self, lhs, rhs, name=''):
+        """
+        Unsigned integer multiplication with overflow:
+            name = {result, overflow bit} = lhs * rhs
+        """
+
+    @_binop_with_overflow('usub')
+    def usub_with_overflow(self, lhs, rhs, name=''):
+        """
+        Unsigned integer subtraction with overflow:
+            name = {result, overflow bit} = lhs - rhs
+        """
+
+    #
+    # Unary APIs
+    #
+
+    def not_(self, value, name=''):
+        """
+        Bitwise integer complement:
+            name = ~value
+        """
+        if isinstance(value.type, types.VectorType):
+            rhs = values.Constant(value.type, (-1,) * value.type.count)
+        else:
+            rhs = values.Constant(value.type, -1)
+        return self.xor(value, rhs, name=name)
+
+    def neg(self, value, name=''):
+        """
+        Integer negative:
+            name = -value
+        """
+        return self.sub(values.Constant(value.type, 0), value, name=name)
+
+    @_unop('fneg')
+    def fneg(self, arg, name='', flags=()):
+        """
+        Floating-point negative:
+            name = -arg
+        """
+
+    #
+    # Comparison APIs
+    #
+
+    def _icmp(self, prefix, cmpop, lhs, rhs, name):
+        try:
+            op = _CMP_MAP[cmpop]
+        except KeyError:
+            raise ValueError("invalid comparison %r for icmp" % (cmpop,))
+        if cmpop not in ('==', '!='):
+            op = prefix + op
+        instr = instructions.ICMPInstr(self.block, op, lhs, rhs, name=name)
+        self._insert(instr)
+        return instr
+
+    def icmp_signed(self, cmpop, lhs, rhs, name=''):
+        """
+        Signed integer comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._icmp('s', cmpop, lhs, rhs, name)
+
+    def icmp_unsigned(self, cmpop, lhs, rhs, name=''):
+        """
+        Unsigned integer (or pointer) comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._icmp('u', cmpop, lhs, rhs, name)
+
+    def fcmp_ordered(self, cmpop, lhs, rhs, name='', flags=()):
+        """
+        Floating-point ordered comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        if cmpop in _CMP_MAP:
+            op = 'o' + _CMP_MAP[cmpop]
+        else:
+            op = cmpop
+        instr = instructions.FCMPInstr(
+            self.block, op, lhs, rhs, name=name, flags=flags)
+        self._insert(instr)
+        return instr
+
+    def fcmp_unordered(self, cmpop, lhs, rhs, name='', flags=()):
+        """
+        Floating-point unordered comparison:
+            name = lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        if cmpop in _CMP_MAP:
+            op = 'u' + _CMP_MAP[cmpop]
+        else:
+            op = cmpop
+        instr = instructions.FCMPInstr(
+            self.block, op, lhs, rhs, name=name, flags=flags)
+        self._insert(instr)
+        return instr
+
+    def select(self, cond, lhs, rhs, name='', flags=()):
+        """
+        Ternary select operator:
+            name = cond ? lhs : rhs
+        """
+        instr = instructions.SelectInstr(self.block, cond, lhs, rhs, name=name,
+                                         flags=flags)
+        self._insert(instr)
+        return instr
+
+    #
+    # Cast APIs
+    #
+
+    @_castop('trunc')
+    def trunc(self, value, typ, name=''):
+        """
+        Truncating integer downcast to a smaller type:
+            name = (typ) value
+        """
+
+    @_castop('zext')
+    def zext(self, value, typ, name=''):
+        """
+        Zero-extending integer upcast to a larger type:
+            name = (typ) value
+        """
+
+    @_castop('sext')
+    def sext(self, value, typ, name=''):
+        """
+        Sign-extending integer upcast to a larger type:
+            name = (typ) value
+        """
+
+    @_castop('fptrunc')
+    def fptrunc(self, value, typ, name=''):
+        """
+        Floating-point downcast to a less precise type:
+            name = (typ) value
+        """
+
+    @_castop('fpext')
+    def fpext(self, value, typ, name=''):
+        """
+        Floating-point upcast to a more precise type:
+            name = (typ) value
+        """
+
+    @_castop('bitcast')
+    def bitcast(self, value, typ, name=''):
+        """
+        Pointer cast to a different pointer type:
+            name = (typ) value
+        """
+
+    @_castop('addrspacecast')
+    def addrspacecast(self, value, typ, name=''):
+        """
+        Pointer cast to a different address space:
+            name = (typ) value
+        """
+
+    @_castop('fptoui')
+    def fptoui(self, value, typ, name=''):
+        """
+        Convert floating-point to unsigned integer:
+            name = (typ) value
+        """
+
+    @_castop('uitofp')
+    def uitofp(self, value, typ, name=''):
+        """
+        Convert unsigned integer to floating-point:
+            name = (typ) value
+        """
+
+    @_castop('fptosi')
+    def fptosi(self, value, typ, name=''):
+        """
+        Convert floating-point to signed integer:
+            name = (typ) value
+        """
+
+    @_castop('sitofp')
+    def sitofp(self, value, typ, name=''):
+        """
+        Convert signed integer to floating-point:
+            name = (typ) value
+        """
+
+    @_castop('ptrtoint')
+    def ptrtoint(self, value, typ, name=''):
+        """
+        Cast pointer to integer:
+            name = (typ) value
+        """
+
+    @_castop('inttoptr')
+    def inttoptr(self, value, typ, name=''):
+        """
+        Cast integer to pointer:
+            name = (typ) value
+        """
+
+    #
+    # Memory APIs
+    #
+
+    def alloca(self, typ, size=None, name=''):
+        """
+        Stack-allocate a slot for *size* elements of the given type.
+        (default one element)
+        """
+        if size is None:
+            pass
+        elif isinstance(size, (values.Value, values.Constant)):
+            assert isinstance(size.type, types.IntType)
+        else:
+            # If it is not a Value instance,
+            # assume to be a Python integer.
+            size = values.Constant(types.IntType(32), size)
+
+        al = instructions.AllocaInstr(self.block, typ, size, name)
+        self._insert(al)
+        return al
+
+    def load(self, ptr, name='', align=None):
+        """
+        Load value from pointer, with optional guaranteed alignment:
+            name = *ptr
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot load from value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        ld = instructions.LoadInstr(self.block, ptr, name)
+        ld.align = align
+        self._insert(ld)
+        return ld
+
+    def store(self, value, ptr, align=None):
+        """
+        Store value to pointer, with optional guaranteed alignment:
+            *ptr = name
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot store to value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        if ptr.type.pointee != value.type:
+            raise TypeError("cannot store %s to %s: mismatching types"
+                            % (value.type, ptr.type))
+        st = instructions.StoreInstr(self.block, value, ptr)
+        st.align = align
+        self._insert(st)
+        return st
+
+    def load_atomic(self, ptr, ordering, align, name=''):
+        """
+        Load value from pointer, with optional guaranteed alignment:
+            name = *ptr
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot load from value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        ld = instructions.LoadAtomicInstr(
+            self.block, ptr, ordering, align, name)
+        self._insert(ld)
+        return ld
+
+    def store_atomic(self, value, ptr, ordering, align):
+        """
+        Store value to pointer, with optional guaranteed alignment:
+            *ptr = name
+        """
+        if not isinstance(ptr.type, types.PointerType):
+            msg = "cannot store to value of type %s (%r): not a pointer"
+            raise TypeError(msg % (ptr.type, str(ptr)))
+        if ptr.type.pointee != value.type:
+            raise TypeError("cannot store %s to %s: mismatching types"
+                            % (value.type, ptr.type))
+        st = instructions.StoreAtomicInstr(
+            self.block, value, ptr, ordering, align)
+        self._insert(st)
+        return st
+
+    #
+    # Terminators APIs
+    #
+
+    def switch(self, value, default):
+        """
+        Create a switch-case with a single *default* target.
+        """
+        swt = instructions.SwitchInstr(self.block, 'switch', value, default)
+        self._set_terminator(swt)
+        return swt
+
+    def branch(self, target):
+        """
+        Unconditional branch to *target*.
+        """
+        br = instructions.Branch(self.block, "br", [target])
+        self._set_terminator(br)
+        return br
+
+    def cbranch(self, cond, truebr, falsebr):
+        """
+        Conditional branch to *truebr* if *cond* is true, else to *falsebr*.
+        """
+        br = instructions.ConditionalBranch(self.block, "br",
+                                            [cond, truebr, falsebr])
+        self._set_terminator(br)
+        return br
+
+    def branch_indirect(self, addr):
+        """
+        Indirect branch to target *addr*.
+        """
+        br = instructions.IndirectBranch(self.block, "indirectbr", addr)
+        self._set_terminator(br)
+        return br
+
+    def ret_void(self):
+        """
+        Return from function without a value.
+        """
+        return self._set_terminator(
+            instructions.Ret(self.block, "ret void"))
+
+    def ret(self, value):
+        """
+        Return from function with the given *value*.
+        """
+        return self._set_terminator(
+            instructions.Ret(self.block, "ret", value))
+
+    def resume(self, landingpad):
+        """
+        Resume an in-flight exception.
+        """
+        br = instructions.Branch(self.block, "resume", [landingpad])
+        self._set_terminator(br)
+        return br
+
+    # Call APIs
+
+    def call(self, fn, args, name='', cconv=None, tail=False, fastmath=(),
+             attrs=(), arg_attrs=None):
+        """
+        Call function *fn* with *args*:
+            name = fn(args...)
+        """
+        inst = instructions.CallInstr(self.block, fn, args, name=name,
+                                      cconv=cconv, tail=tail, fastmath=fastmath,
+                                      attrs=attrs, arg_attrs=arg_attrs)
+        self._insert(inst)
+        return inst
+
+    def asm(self, ftype, asm, constraint, args, side_effect, name=''):
+        """
+        Inline assembler.
+        """
+        asm = instructions.InlineAsm(ftype, asm, constraint, side_effect)
+        return self.call(asm, args, name)
+
+    def load_reg(self, reg_type, reg_name, name=''):
+        """
+        Load a register value into an LLVM value.
+          Example: v = load_reg(IntType(32), "eax")
+        """
+        ftype = types.FunctionType(reg_type, [])
+        return self.asm(ftype, "", "={%s}" % reg_name, [], False, name)
+
+    def store_reg(self, value, reg_type, reg_name, name=''):
+        """
+        Store an LLVM value inside a register
+        Example:
+          store_reg(Constant(IntType(32), 0xAAAAAAAA), IntType(32), "eax")
+        """
+        ftype = types.FunctionType(types.VoidType(), [reg_type])
+        return self.asm(ftype, "", "{%s}" % reg_name, [value], True, name)
+
+    def invoke(self, fn, args, normal_to, unwind_to,
+               name='', cconv=None, fastmath=(), attrs=(), arg_attrs=None):
+        inst = instructions.InvokeInstr(self.block, fn, args, normal_to,
+                                        unwind_to, name=name, cconv=cconv,
+                                        fastmath=fastmath, attrs=attrs,
+                                        arg_attrs=arg_attrs)
+        self._set_terminator(inst)
+        return inst
+
+    # GEP APIs
+
+    def gep(self, ptr, indices, inbounds=False, name=''):
+        """
+        Compute effective address (getelementptr):
+            name = getelementptr ptr, <indices...>
+        """
+        instr = instructions.GEPInstr(self.block, ptr, indices,
+                                      inbounds=inbounds, name=name)
+        self._insert(instr)
+        return instr
+
+    # Vector Operations APIs
+
+    def extract_element(self, vector, idx, name=''):
+        """
+        Returns the value at position idx.
+        """
+        instr = instructions.ExtractElement(self.block, vector, idx, name=name)
+        self._insert(instr)
+        return instr
+
+    def insert_element(self, vector, value, idx, name=''):
+        """
+        Returns vector with vector[idx] replaced by value.
+        The result is undefined if the idx is larger or equal the vector length.
+        """
+        instr = instructions.InsertElement(self.block, vector, value, idx,
+                                           name=name)
+        self._insert(instr)
+        return instr
+
+    def shuffle_vector(self, vector1, vector2, mask, name=''):
+        """
+        Constructs a permutation of elements from *vector1* and *vector2*.
+        Returns a new vector in the same length of *mask*.
+
+        * *vector1* and *vector2* must have the same element type.
+        * *mask* must be a constant vector of integer types.
+        """
+        instr = instructions.ShuffleVector(self.block, vector1, vector2, mask,
+                                           name=name)
+        self._insert(instr)
+        return instr
+
+    # Aggregate APIs
+
+    def extract_value(self, agg, idx, name=''):
+        """
+        Extract member number *idx* from aggregate.
+        """
+        if not isinstance(idx, (tuple, list)):
+            idx = [idx]
+        instr = instructions.ExtractValue(self.block, agg, idx, name=name)
+        self._insert(instr)
+        return instr
+
+    def insert_value(self, agg, value, idx, name=''):
+        """
+        Insert *value* into member number *idx* from aggregate.
+        """
+        if not isinstance(idx, (tuple, list)):
+            idx = [idx]
+        instr = instructions.InsertValue(self.block, agg, value, idx, name=name)
+        self._insert(instr)
+        return instr
+
+    # PHI APIs
+
+    def phi(self, typ, name='', flags=()):
+        inst = instructions.PhiInstr(self.block, typ, name=name, flags=flags)
+        self._insert(inst)
+        return inst
+
+    # Special API
+
+    def unreachable(self):
+        inst = instructions.Unreachable(self.block)
+        self._set_terminator(inst)
+        return inst
+
+    def atomic_rmw(self, op, ptr, val, ordering, name=''):
+        inst = instructions.AtomicRMW(
+            self.block, op, ptr, val, ordering, name=name)
+        self._insert(inst)
+        return inst
+
+    def cmpxchg(self, ptr, cmp, val, ordering, failordering=None, name=''):
+        """
+        Atomic compared-and-set:
+            atomic {
+                old = *ptr
+                success = (old == cmp)
+                if (success)
+                    *ptr = val
+                }
+            name = { old, success }
+
+        If failordering is `None`, the value of `ordering` is used.
+        """
+        failordering = ordering if failordering is None else failordering
+        inst = instructions.CmpXchg(self.block, ptr, cmp, val, ordering,
+                                    failordering, name=name)
+        self._insert(inst)
+        return inst
+
+    def landingpad(self, typ, name='', cleanup=False):
+        inst = instructions.LandingPadInstr(self.block, typ, name, cleanup)
+        self._insert(inst)
+        return inst
+
+    def assume(self, cond):
+        """
+        Optimizer hint: assume *cond* is always true.
+        """
+        fn = self.module.declare_intrinsic("llvm.assume")
+        return self.call(fn, [cond])
+
+    def fence(self, ordering, targetscope=None, name=''):
+        """
+        Add a memory barrier, preventing certain reorderings of load and/or
+        store accesses with
+        respect to other processors and devices.
+        """
+        inst = instructions.Fence(self.block, ordering, targetscope, name=name)
+        self._insert(inst)
+        return inst
+
+    def comment(self, text):
+        """
+        Puts a single-line comment into the generated IR. This will be ignored
+        by LLVM, but can be useful for debugging the output of a compiler. Adds
+        a comment to the source file.
+
+        * *text* is a string that does not contain new line characters.
+        """
+        inst = instructions.Comment(self.block, text)
+        self._insert(inst)
+        return inst
+
+    @_uniop_intrinsic_int("llvm.bswap")
+    def bswap(self, cond):
+        """
+        Used to byte swap integer values with an even number of bytes (positive
+        multiple of 16 bits)
+        """
+
+    @_uniop_intrinsic_int("llvm.bitreverse")
+    def bitreverse(self, cond):
+        """
+        Reverse the bitpattern of an integer value; for example 0b10110110
+        becomes 0b01101101.
+        """
+
+    @_uniop_intrinsic_int("llvm.ctpop")
+    def ctpop(self, cond):
+        """
+        Counts the number of bits set in a value.
+        """
+
+    @_uniop_intrinsic_with_flag("llvm.ctlz")
+    def ctlz(self, cond, flag):
+        """
+        Counts leading zero bits in *value*. Boolean *flag* indicates whether
+        the result is defined for ``0``.
+        """
+
+    @_uniop_intrinsic_with_flag("llvm.cttz")
+    def cttz(self, cond, flag):
+        """
+        Counts trailing zero bits in *value*. Boolean *flag* indicates whether
+        the result is defined for ``0``.
+        """
+
+    @_triop_intrinsic("llvm.fma")
+    def fma(self, a, b, c):
+        """
+        Perform the fused multiply-add operation.
+        """
+
+    def convert_from_fp16(self, a, to=None, name=''):
+        """
+        Convert from an i16 to the given FP type
+        """
+        if not to:
+            raise TypeError("expected a float return type")
+        if not isinstance(to, (types.FloatType, types.DoubleType)):
+            raise TypeError("expected a float type, got %s" % to)
+        if not (isinstance(a.type, types.IntType) and a.type.width == 16):
+            raise TypeError("expected an i16 type, got %s" % a.type)
+
+        opname = 'llvm.convert.from.fp16'
+        fn = self.module.declare_intrinsic(opname, [to])
+        return self.call(fn, [a], name)
+
+    @_uniop_intrinsic_float("llvm.convert.to.fp16")
+    def convert_to_fp16(self, a):
+        """
+        Convert the given FP number to an i16
+        """
diff --git a/lib/python3.11/site-packages/llvmlite/ir/context.py b/lib/python3.11/site-packages/llvmlite/ir/context.py
new file mode 100644
index 0000000000000000000000000000000000000000..47d1ebbe2953d160f4dbb38b846b6d1d46582861
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/context.py
@@ -0,0 +1,20 @@
+from llvmlite.ir import _utils
+from llvmlite.ir import types
+
+
+class Context(object):
+    def __init__(self):
+        self.scope = _utils.NameScope()
+        self.identified_types = {}
+
+    def get_identified_type(self, name):
+        if name not in self.identified_types:
+            self.scope.register(name)
+            ty = types.IdentifiedStructType(self, name)
+            self.identified_types[name] = ty
+        else:
+            ty = self.identified_types[name]
+        return ty
+
+
+global_context = Context()
diff --git a/lib/python3.11/site-packages/llvmlite/ir/instructions.py b/lib/python3.11/site-packages/llvmlite/ir/instructions.py
new file mode 100644
index 0000000000000000000000000000000000000000..044d434536f6e31f69673bbeca47bcb2f4f8b487
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/instructions.py
@@ -0,0 +1,893 @@
+"""
+Implementation of LLVM IR instructions.
+"""
+
+from llvmlite.ir import types
+from llvmlite.ir.values import (Block, Function, Value, NamedValue, Constant,
+                                MetaDataArgument, MetaDataString, AttributeSet,
+                                Undefined, ArgumentAttributes)
+from llvmlite.ir._utils import _HasMetadata
+
+
+class Instruction(NamedValue, _HasMetadata):
+    def __init__(self, parent, typ, opname, operands, name='', flags=()):
+        super(Instruction, self).__init__(parent, typ, name=name)
+        assert isinstance(parent, Block)
+        assert isinstance(flags, (tuple, list))
+        self.opname = opname
+        self.operands = operands
+        self.flags = list(flags)
+        self.metadata = {}
+
+    @property
+    def function(self):
+        return self.parent.function
+
+    @property
+    def module(self):
+        return self.parent.function.module
+
+    def descr(self, buf):
+        opname = self.opname
+        if self.flags:
+            opname = ' '.join([opname] + self.flags)
+        operands = ', '.join([op.get_reference() for op in self.operands])
+        typ = self.type
+        metadata = self._stringify_metadata(leading_comma=True)
+        buf.append("{0} {1} {2}{3}\n"
+                   .format(opname, typ, operands, metadata))
+
+    def replace_usage(self, old, new):
+        if old in self.operands:
+            ops = []
+            for op in self.operands:
+                ops.append(new if op is old else op)
+            self.operands = tuple(ops)
+            self._clear_string_cache()
+
+    def __repr__(self):
+        return "<ir.%s %r of type '%s', opname %r, operands %r>" % (
+            self.__class__.__name__, self.name, self.type,
+            self.opname, self.operands)
+
+
+class CallInstrAttributes(AttributeSet):
+    _known = frozenset(['noreturn', 'nounwind', 'readonly', 'readnone',
+                        'noinline', 'alwaysinline'])
+
+
+TailMarkerOptions = frozenset(['tail', 'musttail', 'notail'])
+
+
+class FastMathFlags(AttributeSet):
+    _known = frozenset(['fast', 'nnan', 'ninf', 'nsz', 'arcp', 'contract',
+                        'afn', 'reassoc'])
+
+
+class CallInstr(Instruction):
+    def __init__(self, parent, func, args, name='', cconv=None, tail=None,
+                 fastmath=(), attrs=(), arg_attrs=None):
+        self.cconv = (func.calling_convention
+                      if cconv is None and isinstance(func, Function)
+                      else cconv)
+
+        # For backwards compatibility with previous API of accepting a "truthy"
+        # value for a hint to the optimizer to potentially tail optimize.
+        if isinstance(tail, str) and tail in TailMarkerOptions:
+            pass
+        elif tail:
+            tail = "tail"
+        else:
+            tail = ""
+
+        self.tail = tail
+        self.fastmath = FastMathFlags(fastmath)
+        self.attributes = CallInstrAttributes(attrs)
+        self.arg_attributes = {}
+        if arg_attrs:
+            for idx, attrs in arg_attrs.items():
+                if not (0 <= idx < len(args)):
+                    raise ValueError("Invalid argument index {}"
+                                     .format(idx))
+                self.arg_attributes[idx] = ArgumentAttributes(attrs)
+
+        # Fix and validate arguments
+        args = list(args)
+        for i in range(len(func.function_type.args)):
+            arg = args[i]
+            expected_type = func.function_type.args[i]
+            if (isinstance(expected_type, types.MetaDataType) and
+                    arg.type != expected_type):
+                arg = MetaDataArgument(arg)
+            if arg.type != expected_type:
+                msg = ("Type of #{0} arg mismatch: {1} != {2}"
+                       .format(1 + i, expected_type, arg.type))
+                raise TypeError(msg)
+            args[i] = arg
+
+        super(CallInstr, self).__init__(parent, func.function_type.return_type,
+                                        "call", [func] + list(args), name=name)
+
+    @property
+    def callee(self):
+        return self.operands[0]
+
+    @callee.setter
+    def callee(self, newcallee):
+        self.operands[0] = newcallee
+
+    @property
+    def args(self):
+        return self.operands[1:]
+
+    def replace_callee(self, newfunc):
+        if newfunc.function_type != self.callee.function_type:
+            raise TypeError("New function has incompatible type")
+        self.callee = newfunc
+
+    @property
+    def called_function(self):
+        """The callee function"""
+        return self.callee
+
+    def _descr(self, buf, add_metadata):
+        def descr_arg(i, a):
+            if i in self.arg_attributes:
+                attrs = ' '.join(self.arg_attributes[i]._to_list(a.type)) + ' '
+            else:
+                attrs = ''
+            return '{0} {1}{2}'.format(a.type, attrs, a.get_reference())
+        args = ', '.join([descr_arg(i, a) for i, a in enumerate(self.args)])
+
+        fnty = self.callee.function_type
+        # Only print function type if variable-argument
+        if fnty.var_arg:
+            ty = fnty
+        # Otherwise, just print the return type.
+        else:
+            # Fastmath flag work only in this case
+            ty = fnty.return_type
+        callee_ref = "{0} {1}".format(ty, self.callee.get_reference())
+        if self.cconv:
+            callee_ref = "{0} {1}".format(self.cconv, callee_ref)
+
+        tail_marker = ""
+        if self.tail:
+            tail_marker = "{0} ".format(self.tail)
+
+        fn_attrs = ' ' + ' '.join(self.attributes._to_list(fnty.return_type))\
+            if self.attributes else ''
+
+        fm_attrs = ' ' + ' '.join(self.fastmath._to_list(fnty.return_type))\
+            if self.fastmath else ''
+
+        buf.append("{tail}{op}{fastmath} {callee}({args}){attr}{meta}\n".format(
+            tail=tail_marker,
+            op=self.opname,
+            callee=callee_ref,
+            fastmath=fm_attrs,
+            args=args,
+            attr=fn_attrs,
+            meta=(self._stringify_metadata(leading_comma=True)
+                  if add_metadata else ""),
+        ))
+
+    def descr(self, buf):
+        self._descr(buf, add_metadata=True)
+
+
+class InvokeInstr(CallInstr):
+    def __init__(self, parent, func, args, normal_to, unwind_to, name='',
+                 cconv=None, fastmath=(), attrs=(), arg_attrs=None):
+        assert isinstance(normal_to, Block)
+        assert isinstance(unwind_to, Block)
+        super(InvokeInstr, self).__init__(parent, func, args, name, cconv,
+                                          tail=False, fastmath=fastmath,
+                                          attrs=attrs, arg_attrs=arg_attrs)
+        self.opname = "invoke"
+        self.normal_to = normal_to
+        self.unwind_to = unwind_to
+
+    def descr(self, buf):
+        super(InvokeInstr, self)._descr(buf, add_metadata=False)
+        buf.append("      to label {0} unwind label {1}{metadata}\n".format(
+            self.normal_to.get_reference(),
+            self.unwind_to.get_reference(),
+            metadata=self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class Terminator(Instruction):
+    def __init__(self, parent, opname, operands):
+        super(Terminator, self).__init__(parent, types.VoidType(), opname,
+                                         operands)
+
+    def descr(self, buf):
+        opname = self.opname
+        operands = ', '.join(["{0} {1}".format(op.type, op.get_reference())
+                              for op in self.operands])
+        metadata = self._stringify_metadata(leading_comma=True)
+        buf.append("{0} {1}{2}".format(opname, operands, metadata))
+
+
+class PredictableInstr(Instruction):
+
+    def set_weights(self, weights):
+        operands = [MetaDataString(self.module, "branch_weights")]
+        for w in weights:
+            if w < 0:
+                raise ValueError("branch weight must be a positive integer")
+            operands.append(Constant(types.IntType(32), w))
+        md = self.module.add_metadata(operands)
+        self.set_metadata("prof", md)
+
+
+class Ret(Terminator):
+    def __init__(self, parent, opname, return_value=None):
+        operands = [return_value] if return_value is not None else []
+        super(Ret, self).__init__(parent, opname, operands)
+
+    @property
+    def return_value(self):
+        if self.operands:
+            return self.operands[0]
+        else:
+            return None
+
+    def descr(self, buf):
+        return_value = self.return_value
+        metadata = self._stringify_metadata(leading_comma=True)
+        if return_value is not None:
+            buf.append("{0} {1} {2}{3}\n"
+                       .format(self.opname, return_value.type,
+                               return_value.get_reference(),
+                               metadata))
+        else:
+            buf.append("{0}{1}\n".format(self.opname, metadata))
+
+
+class Branch(Terminator):
+    pass
+
+
+class ConditionalBranch(PredictableInstr, Terminator):
+    pass
+
+
+class IndirectBranch(PredictableInstr, Terminator):
+    def __init__(self, parent, opname, addr):
+        super(IndirectBranch, self).__init__(parent, opname, [addr])
+        self.destinations = []
+
+    @property
+    def address(self):
+        return self.operands[0]
+
+    def add_destination(self, block):
+        assert isinstance(block, Block)
+        self.destinations.append(block)
+
+    def descr(self, buf):
+        destinations = ["label {0}".format(blk.get_reference())
+                        for blk in self.destinations]
+        buf.append("indirectbr {0} {1}, [{2}]  {3}\n".format(
+            self.address.type,
+            self.address.get_reference(),
+            ', '.join(destinations),
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class SwitchInstr(PredictableInstr, Terminator):
+
+    def __init__(self, parent, opname, val, default):
+        super(SwitchInstr, self).__init__(parent, opname, [val])
+        self.default = default
+        self.cases = []
+
+    @property
+    def value(self):
+        return self.operands[0]
+
+    def add_case(self, val, block):
+        assert isinstance(block, Block)
+        if not isinstance(val, Value):
+            val = Constant(self.value.type, val)
+        self.cases.append((val, block))
+
+    def descr(self, buf):
+        cases = ["{0} {1}, label {2}".format(val.type, val.get_reference(),
+                                             blk.get_reference())
+                 for val, blk in self.cases]
+        buf.append("switch {0} {1}, label {2} [{3}]  {4}\n".format(
+            self.value.type,
+            self.value.get_reference(),
+            self.default.get_reference(),
+            ' '.join(cases),
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class Resume(Terminator):
+    pass
+
+
+class SelectInstr(Instruction):
+    def __init__(self, parent, cond, lhs, rhs, name='', flags=()):
+        assert lhs.type == rhs.type
+        super(SelectInstr, self).__init__(parent, lhs.type, "select",
+                                          [cond, lhs, rhs], name=name,
+                                          flags=flags)
+
+    @property
+    def cond(self):
+        return self.operands[0]
+
+    @property
+    def lhs(self):
+        return self.operands[1]
+
+    @property
+    def rhs(self):
+        return self.operands[2]
+
+    def descr(self, buf):
+        buf.append("select {0} {1} {2}, {3} {4}, {5} {6} {7}\n".format(
+            ' '.join(self.flags),
+            self.cond.type, self.cond.get_reference(),
+            self.lhs.type, self.lhs.get_reference(),
+            self.rhs.type, self.rhs.get_reference(),
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class CompareInstr(Instruction):
+    # Define the following in subclasses
+    OPNAME = 'invalid-compare'
+    VALID_OP = {}
+
+    def __init__(self, parent, op, lhs, rhs, name='', flags=[]):
+        if op not in self.VALID_OP:
+            raise ValueError("invalid comparison %r for %s" % (op, self.OPNAME))
+        for flag in flags:
+            if flag not in self.VALID_FLAG:
+                raise ValueError("invalid flag %r for %s" % (flag, self.OPNAME))
+        opname = self.OPNAME
+        if isinstance(lhs.type, types.VectorType):
+            typ = types.VectorType(types.IntType(1), lhs.type.count)
+        else:
+            typ = types.IntType(1)
+        super(CompareInstr, self).__init__(parent, typ,
+                                           opname, [lhs, rhs], flags=flags,
+                                           name=name)
+        self.op = op
+
+    def descr(self, buf):
+        buf.append("{opname}{flags} {op} {ty} {lhs}, {rhs} {meta}\n".format(
+            opname=self.opname,
+            flags=''.join(' ' + it for it in self.flags),
+            op=self.op,
+            ty=self.operands[0].type,
+            lhs=self.operands[0].get_reference(),
+            rhs=self.operands[1].get_reference(),
+            meta=self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class ICMPInstr(CompareInstr):
+    OPNAME = 'icmp'
+    VALID_OP = {
+        'eq': 'equal',
+        'ne': 'not equal',
+        'ugt': 'unsigned greater than',
+        'uge': 'unsigned greater or equal',
+        'ult': 'unsigned less than',
+        'ule': 'unsigned less or equal',
+        'sgt': 'signed greater than',
+        'sge': 'signed greater or equal',
+        'slt': 'signed less than',
+        'sle': 'signed less or equal',
+    }
+    VALID_FLAG = set()
+
+
+class FCMPInstr(CompareInstr):
+    OPNAME = 'fcmp'
+    VALID_OP = {
+        'false': 'no comparison, always returns false',
+        'oeq': 'ordered and equal',
+        'ogt': 'ordered and greater than',
+        'oge': 'ordered and greater than or equal',
+        'olt': 'ordered and less than',
+        'ole': 'ordered and less than or equal',
+        'one': 'ordered and not equal',
+        'ord': 'ordered (no nans)',
+        'ueq': 'unordered or equal',
+        'ugt': 'unordered or greater than',
+        'uge': 'unordered or greater than or equal',
+        'ult': 'unordered or less than',
+        'ule': 'unordered or less than or equal',
+        'une': 'unordered or not equal',
+        'uno': 'unordered (either nans)',
+        'true': 'no comparison, always returns true',
+    }
+    VALID_FLAG = {'nnan', 'ninf', 'nsz', 'arcp', 'contract', 'afn', 'reassoc',
+                  'fast'}
+
+
+class CastInstr(Instruction):
+    def __init__(self, parent, op, val, typ, name=''):
+        super(CastInstr, self).__init__(parent, typ, op, [val], name=name)
+
+    def descr(self, buf):
+        buf.append("{0} {1} {2} to {3} {4}\n".format(
+            self.opname,
+            self.operands[0].type,
+            self.operands[0].get_reference(),
+            self.type,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class LoadInstr(Instruction):
+
+    def __init__(self, parent, ptr, name=''):
+        super(LoadInstr, self).__init__(parent, ptr.type.pointee, "load",
+                                        [ptr], name=name)
+        self.align = None
+
+    def descr(self, buf):
+        [val] = self.operands
+        if self.align is not None:
+            align = ', align %d' % (self.align)
+        else:
+            align = ''
+        buf.append("load {0}, {1} {2}{3}{4}\n".format(
+            val.type.pointee,
+            val.type,
+            val.get_reference(),
+            align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class StoreInstr(Instruction):
+    def __init__(self, parent, val, ptr):
+        super(StoreInstr, self).__init__(parent, types.VoidType(), "store",
+                                         [val, ptr])
+
+    def descr(self, buf):
+        val, ptr = self.operands
+        if self.align is not None:
+            align = ', align %d' % (self.align)
+        else:
+            align = ''
+        buf.append("store {0} {1}, {2} {3}{4}{5}\n".format(
+            val.type,
+            val.get_reference(),
+            ptr.type,
+            ptr.get_reference(),
+            align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class LoadAtomicInstr(Instruction):
+    def __init__(self, parent, ptr, ordering, align, name=''):
+        super(LoadAtomicInstr, self).__init__(parent, ptr.type.pointee,
+                                              "load atomic", [ptr], name=name)
+        self.ordering = ordering
+        self.align = align
+
+    def descr(self, buf):
+        [val] = self.operands
+        buf.append("load atomic {0}, {1} {2} {3}, align {4}{5}\n".format(
+            val.type.pointee,
+            val.type,
+            val.get_reference(),
+            self.ordering,
+            self.align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class StoreAtomicInstr(Instruction):
+    def __init__(self, parent, val, ptr, ordering, align):
+        super(StoreAtomicInstr, self).__init__(parent, types.VoidType(),
+                                               "store atomic", [val, ptr])
+        self.ordering = ordering
+        self.align = align
+
+    def descr(self, buf):
+        val, ptr = self.operands
+        buf.append("store atomic {0} {1}, {2} {3} {4}, align {5}{6}\n".format(
+            val.type,
+            val.get_reference(),
+            ptr.type,
+            ptr.get_reference(),
+            self.ordering,
+            self.align,
+            self._stringify_metadata(leading_comma=True),
+        ))
+
+
+class AllocaInstr(Instruction):
+    def __init__(self, parent, typ, count, name):
+        operands = [count] if count else ()
+        super(AllocaInstr, self).__init__(parent, typ.as_pointer(), "alloca",
+                                          operands, name)
+        self.align = None
+
+    def descr(self, buf):
+        buf.append("{0} {1}".format(self.opname, self.type.pointee))
+        if self.operands:
+            op, = self.operands
+            buf.append(", {0} {1}".format(op.type, op.get_reference()))
+        if self.align is not None:
+            buf.append(", align {0}".format(self.align))
+        if self.metadata:
+            buf.append(self._stringify_metadata(leading_comma=True))
+
+
+class GEPInstr(Instruction):
+    def __init__(self, parent, ptr, indices, inbounds, name):
+        typ = ptr.type
+        lasttyp = None
+        lastaddrspace = 0
+        for i in indices:
+            lasttyp, typ = typ, typ.gep(i)
+            # inherit the addrspace from the last seen pointer
+            if isinstance(lasttyp, types.PointerType):
+                lastaddrspace = lasttyp.addrspace
+
+        if (not isinstance(typ, types.PointerType) and
+                isinstance(lasttyp, types.PointerType)):
+            typ = lasttyp
+        else:
+            typ = typ.as_pointer(lastaddrspace)
+
+        super(GEPInstr, self).__init__(parent, typ, "getelementptr",
+                                       [ptr] + list(indices), name=name)
+        self.pointer = ptr
+        self.indices = indices
+        self.inbounds = inbounds
+
+    def descr(self, buf):
+        indices = ['{0} {1}'.format(i.type, i.get_reference())
+                   for i in self.indices]
+        op = "getelementptr inbounds" if self.inbounds else "getelementptr"
+        buf.append("{0} {1}, {2} {3}, {4} {5}\n".format(
+                   op,
+                   self.pointer.type.pointee,
+                   self.pointer.type,
+                   self.pointer.get_reference(),
+                   ', '.join(indices),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class PhiInstr(Instruction):
+    def __init__(self, parent, typ, name, flags=()):
+        super(PhiInstr, self).__init__(parent, typ, "phi", (), name=name,
+                                       flags=flags)
+        self.incomings = []
+
+    def descr(self, buf):
+        incs = ', '.join('[{0}, {1}]'.format(v.get_reference(),
+                                             b.get_reference())
+                         for v, b in self.incomings)
+        buf.append("phi {0} {1} {2} {3}\n".format(
+                   ' '.join(self.flags),
+                   self.type,
+                   incs,
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+    def add_incoming(self, value, block):
+        assert isinstance(block, Block)
+        self.incomings.append((value, block))
+
+    def replace_usage(self, old, new):
+        self.incomings = [((new if val is old else val), blk)
+                          for (val, blk) in self.incomings]
+
+
+class ExtractElement(Instruction):
+    def __init__(self, parent, vector, index, name=''):
+        if not isinstance(vector.type, types.VectorType):
+            raise TypeError("vector needs to be of VectorType.")
+        if not isinstance(index.type, types.IntType):
+            raise TypeError("index needs to be of IntType.")
+        typ = vector.type.element
+        super(ExtractElement, self).__init__(parent, typ, "extractelement",
+                                             [vector, index], name=name)
+
+    def descr(self, buf):
+        operands = ", ".join("{0} {1}".format(
+                   op.type, op.get_reference()) for op in self.operands)
+        buf.append("{opname} {operands}\n".format(
+                   opname=self.opname, operands=operands))
+
+
+class InsertElement(Instruction):
+    def __init__(self, parent, vector, value, index, name=''):
+        if not isinstance(vector.type, types.VectorType):
+            raise TypeError("vector needs to be of VectorType.")
+        if not value.type == vector.type.element:
+            raise TypeError(
+                "value needs to be of type {} not {}.".format(
+                    vector.type.element, value.type))
+        if not isinstance(index.type, types.IntType):
+            raise TypeError("index needs to be of IntType.")
+        typ = vector.type
+        super(InsertElement, self).__init__(parent, typ, "insertelement",
+                                            [vector, value, index], name=name)
+
+    def descr(self, buf):
+        operands = ", ".join("{0} {1}".format(
+                   op.type, op.get_reference()) for op in self.operands)
+        buf.append("{opname} {operands}\n".format(
+                   opname=self.opname, operands=operands))
+
+
+class ShuffleVector(Instruction):
+    def __init__(self, parent, vector1, vector2, mask, name=''):
+        if not isinstance(vector1.type, types.VectorType):
+            raise TypeError("vector1 needs to be of VectorType.")
+        if vector2 != Undefined:
+            if vector2.type != vector1.type:
+                raise TypeError("vector2 needs to be " +
+                                "Undefined or of the same type as vector1.")
+        if (not isinstance(mask, Constant) or
+            not isinstance(mask.type, types.VectorType) or
+            not (isinstance(mask.type.element, types.IntType) and
+                 mask.type.element.width == 32)):
+            raise TypeError("mask needs to be a constant i32 vector.")
+        typ = types.VectorType(vector1.type.element, mask.type.count)
+        index_range = range(vector1.type.count
+                            if vector2 == Undefined
+                            else 2 * vector1.type.count)
+        if not all(ii.constant in index_range for ii in mask.constant):
+            raise IndexError(
+                "mask values need to be in {0}".format(index_range),
+            )
+        super(ShuffleVector, self).__init__(parent, typ, "shufflevector",
+                                            [vector1, vector2, mask], name=name)
+
+    def descr(self, buf):
+        buf.append("shufflevector {0} {1}\n".format(
+                   ", ".join("{0} {1}".format(op.type, op.get_reference())
+                             for op in self.operands),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class ExtractValue(Instruction):
+    def __init__(self, parent, agg, indices, name=''):
+        typ = agg.type
+        try:
+            for i in indices:
+                typ = typ.elements[i]
+        except (AttributeError, IndexError):
+            raise TypeError("Can't index at %r in %s"
+                            % (list(indices), agg.type))
+
+        super(ExtractValue, self).__init__(parent, typ, "extractvalue",
+                                           [agg], name=name)
+
+        self.aggregate = agg
+        self.indices = indices
+
+    def descr(self, buf):
+        indices = [str(i) for i in self.indices]
+
+        buf.append("extractvalue {0} {1}, {2} {3}\n".format(
+                   self.aggregate.type,
+                   self.aggregate.get_reference(),
+                   ', '.join(indices),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class InsertValue(Instruction):
+    def __init__(self, parent, agg, elem, indices, name=''):
+        typ = agg.type
+        try:
+            for i in indices:
+                typ = typ.elements[i]
+        except (AttributeError, IndexError):
+            raise TypeError("Can't index at %r in %s"
+                            % (list(indices), agg.type))
+        if elem.type != typ:
+            raise TypeError("Can only insert %s at %r in %s: got %s"
+                            % (typ, list(indices), agg.type, elem.type))
+        super(InsertValue, self).__init__(parent, agg.type, "insertvalue",
+                                          [agg, elem], name=name)
+
+        self.aggregate = agg
+        self.value = elem
+        self.indices = indices
+
+    def descr(self, buf):
+        indices = [str(i) for i in self.indices]
+
+        buf.append("insertvalue {0} {1}, {2} {3}, {4} {5}\n".format(
+                   self.aggregate.type, self.aggregate.get_reference(),
+                   self.value.type, self.value.get_reference(),
+                   ', '.join(indices),
+                   self._stringify_metadata(leading_comma=True),
+                   ))
+
+
+class Unreachable(Instruction):
+    def __init__(self, parent):
+        super(Unreachable, self).__init__(parent, types.VoidType(),
+                                          "unreachable", (), name='')
+
+    def descr(self, buf):
+        buf += (self.opname, "\n")
+
+
+class InlineAsm(object):
+    def __init__(self, ftype, asm, constraint, side_effect=False):
+        self.type = ftype.return_type
+        self.function_type = ftype
+        self.asm = asm
+        self.constraint = constraint
+        self.side_effect = side_effect
+
+    def descr(self, buf):
+        sideeffect = 'sideeffect' if self.side_effect else ''
+        fmt = 'asm {sideeffect} "{asm}", "{constraint}"\n'
+        buf.append(fmt.format(sideeffect=sideeffect, asm=self.asm,
+                              constraint=self.constraint))
+
+    def get_reference(self):
+        buf = []
+        self.descr(buf)
+        return "".join(buf)
+
+    def __str__(self):
+        return "{0} {1}".format(self.type, self.get_reference())
+
+
+class AtomicRMW(Instruction):
+    def __init__(self, parent, op, ptr, val, ordering, name):
+        super(AtomicRMW, self).__init__(parent, val.type, "atomicrmw",
+                                        (ptr, val), name=name)
+        self.operation = op
+        self.ordering = ordering
+
+    def descr(self, buf):
+        ptr, val = self.operands
+        fmt = ("atomicrmw {op} {ptrty} {ptr}, {valty} {val} {ordering} "
+               "{metadata}\n")
+        buf.append(fmt.format(op=self.operation,
+                              ptrty=ptr.type,
+                              ptr=ptr.get_reference(),
+                              valty=val.type,
+                              val=val.get_reference(),
+                              ordering=self.ordering,
+                              metadata=self._stringify_metadata(
+                                  leading_comma=True),
+                              ))
+
+
+class CmpXchg(Instruction):
+    """This instruction has changed since llvm3.5.  It is not compatible with
+    older llvm versions.
+    """
+
+    def __init__(self, parent, ptr, cmp, val, ordering, failordering, name):
+        outtype = types.LiteralStructType([val.type, types.IntType(1)])
+        super(CmpXchg, self).__init__(parent, outtype, "cmpxchg",
+                                      (ptr, cmp, val), name=name)
+        self.ordering = ordering
+        self.failordering = failordering
+
+    def descr(self, buf):
+        ptr, cmpval, val = self.operands
+        fmt = "cmpxchg {ptrty} {ptr}, {ty} {cmp}, {ty} {val} {ordering} " \
+              "{failordering} {metadata}\n"
+        buf.append(fmt.format(ptrty=ptr.type,
+                              ptr=ptr.get_reference(),
+                              ty=cmpval.type,
+                              cmp=cmpval.get_reference(),
+                              val=val.get_reference(),
+                              ordering=self.ordering,
+                              failordering=self.failordering,
+                              metadata=self._stringify_metadata(
+                                  leading_comma=True),
+                              ))
+
+
+class _LandingPadClause(object):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return "{kind} {type} {value}".format(
+            kind=self.kind,
+            type=self.value.type,
+            value=self.value.get_reference())
+
+
+class CatchClause(_LandingPadClause):
+    kind = 'catch'
+
+
+class FilterClause(_LandingPadClause):
+    kind = 'filter'
+
+    def __init__(self, value):
+        assert isinstance(value, Constant)
+        assert isinstance(value.type, types.ArrayType)
+        super(FilterClause, self).__init__(value)
+
+
+class LandingPadInstr(Instruction):
+    def __init__(self, parent, typ, name='', cleanup=False):
+        super(LandingPadInstr, self).__init__(parent, typ, "landingpad", [],
+                                              name=name)
+        self.cleanup = cleanup
+        self.clauses = []
+
+    def add_clause(self, clause):
+        assert isinstance(clause, _LandingPadClause)
+        self.clauses.append(clause)
+
+    def descr(self, buf):
+        fmt = "landingpad {type}{cleanup}{clauses}\n"
+        buf.append(fmt.format(type=self.type,
+                              cleanup=' cleanup' if self.cleanup else '',
+                              clauses=''.join(["\n      {0}".format(clause)
+                                               for clause in self.clauses]),
+                              ))
+
+
+class Fence(Instruction):
+    """
+    The `fence` instruction.
+
+    As of LLVM 5.0.1:
+
+    fence [syncscope("<target-scope>")] <ordering>  ; yields void
+    """
+
+    VALID_FENCE_ORDERINGS = {"acquire", "release", "acq_rel", "seq_cst"}
+
+    def __init__(self, parent, ordering, targetscope=None, name=''):
+        super(Fence, self).__init__(parent, types.VoidType(), "fence", (),
+                                    name=name)
+        if ordering not in self.VALID_FENCE_ORDERINGS:
+            msg = "Invalid fence ordering \"{0}\"! Should be one of {1}."
+            raise ValueError(msg .format(ordering,
+                                         ", ".join(self.VALID_FENCE_ORDERINGS)))
+        self.ordering = ordering
+        self.targetscope = targetscope
+
+    def descr(self, buf):
+        if self.targetscope is None:
+            syncscope = ""
+        else:
+            syncscope = 'syncscope("{0}") '.format(self.targetscope)
+
+        fmt = "fence {syncscope}{ordering}\n"
+        buf.append(fmt.format(syncscope=syncscope,
+                              ordering=self.ordering,
+                              ))
+
+
+class Comment(Instruction):
+    """
+    A line comment.
+    """
+
+    def __init__(self, parent, text):
+        super(Comment, self).__init__(parent, types.VoidType(), ";", (),
+                                      name='')
+        assert "\n" not in text, "Comment cannot contain new line"
+        self.text = text
+
+    def descr(self, buf):
+        buf.append(f"; {self.text}")
diff --git a/lib/python3.11/site-packages/llvmlite/ir/module.py b/lib/python3.11/site-packages/llvmlite/ir/module.py
new file mode 100644
index 0000000000000000000000000000000000000000..464f91ec34344e02bd9fb7e5f6dec46803407f00
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/module.py
@@ -0,0 +1,246 @@
+import collections
+
+from llvmlite.ir import context, values, types, _utils
+
+
+class Module(object):
+    def __init__(self, name='', context=context.global_context):
+        self.context = context
+        self.name = name   # name is for debugging/informational
+        self.data_layout = ""
+        self.scope = _utils.NameScope()
+        self.triple = 'unknown-unknown-unknown'
+        self.globals = collections.OrderedDict()
+        # Innamed metadata nodes.
+        self.metadata = []
+        # Named metadata nodes
+        self.namedmetadata = {}
+        # Cache for metadata node deduplication
+        self._metadatacache = {}
+
+    def _fix_metadata_operands(self, operands):
+        fixed_ops = []
+        for op in operands:
+            if op is None:
+                # A literal None creates a null metadata value
+                op = types.MetaDataType()(None)
+            elif isinstance(op, str):
+                # A literal string creates a metadata string value
+                op = values.MetaDataString(self, op)
+            elif isinstance(op, (list, tuple)):
+                # A sequence creates a metadata node reference
+                op = self.add_metadata(op)
+            fixed_ops.append(op)
+        return fixed_ops
+
+    def _fix_di_operands(self, operands):
+        fixed_ops = []
+        for name, op in operands:
+            if isinstance(op, (list, tuple)):
+                # A sequence creates a metadata node reference
+                op = self.add_metadata(op)
+            fixed_ops.append((name, op))
+        return fixed_ops
+
+    def add_metadata(self, operands):
+        """
+        Add an unnamed metadata to the module with the given *operands*
+        (a sequence of values) or return a previous equivalent metadata.
+        A MDValue instance is returned, it can then be associated to
+        e.g. an instruction.
+        """
+        if not isinstance(operands, (list, tuple)):
+            raise TypeError("expected a list or tuple of metadata values, "
+                            "got %r" % (operands,))
+        operands = self._fix_metadata_operands(operands)
+        key = tuple(operands)
+        if key not in self._metadatacache:
+            n = len(self.metadata)
+            md = values.MDValue(self, operands, name=str(n))
+            self._metadatacache[key] = md
+        else:
+            md = self._metadatacache[key]
+        return md
+
+    def add_debug_info(self, kind, operands, is_distinct=False):
+        """
+        Add debug information metadata to the module with the given
+        *operands* (a dict of values with string keys) or return
+        a previous equivalent metadata.  *kind* is a string of the
+        debug information kind (e.g. "DICompileUnit").
+
+        A DIValue instance is returned, it can then be associated to e.g.
+        an instruction.
+        """
+        operands = tuple(sorted(self._fix_di_operands(operands.items())))
+        key = (kind, operands, is_distinct)
+        if key not in self._metadatacache:
+            n = len(self.metadata)
+            di = values.DIValue(self, is_distinct, kind, operands, name=str(n))
+            self._metadatacache[key] = di
+        else:
+            di = self._metadatacache[key]
+        return di
+
+    def add_named_metadata(self, name, element=None):
+        """
+        Add a named metadata node to the module, if it doesn't exist,
+        or return the existing node.
+        If *element* is given, it will append a new element to
+        the named metadata node.  If *element* is a sequence of values
+        (rather than a metadata value), a new unnamed node will first be
+        created.
+
+        Example::
+            module.add_named_metadata("llvm.ident", ["llvmlite/1.0"])
+        """
+        if name in self.namedmetadata:
+            nmd = self.namedmetadata[name]
+        else:
+            nmd = self.namedmetadata[name] = values.NamedMetaData(self)
+        if element is not None:
+            if not isinstance(element, values.Value):
+                element = self.add_metadata(element)
+            if not isinstance(element.type, types.MetaDataType):
+                raise TypeError("wrong type for metadata element: got %r"
+                                % (element,))
+            nmd.add(element)
+        return nmd
+
+    def get_named_metadata(self, name):
+        """
+        Return the metadata node with the given *name*.  KeyError is raised
+        if no such node exists (contrast with add_named_metadata()).
+        """
+        return self.namedmetadata[name]
+
+    @property
+    def functions(self):
+        """
+        A list of functions declared or defined in this module.
+        """
+        return [v for v in self.globals.values()
+                if isinstance(v, values.Function)]
+
+    @property
+    def global_values(self):
+        """
+        An iterable of global values in this module.
+        """
+        return self.globals.values()
+
+    def get_global(self, name):
+        """
+        Get a global value by name.
+        """
+        return self.globals[name]
+
+    def add_global(self, globalvalue):
+        """
+        Add a new global value.
+        """
+        assert globalvalue.name not in self.globals
+        self.globals[globalvalue.name] = globalvalue
+
+    def get_unique_name(self, name=''):
+        """
+        Get a unique global name with the following *name* hint.
+        """
+        return self.scope.deduplicate(name)
+
+    def declare_intrinsic(self, intrinsic, tys=(), fnty=None):
+        def _error():
+            raise NotImplementedError("unknown intrinsic %r with %d types"
+                                      % (intrinsic, len(tys)))
+
+        if intrinsic in {'llvm.cttz', 'llvm.ctlz', 'llvm.fma'}:
+            suffixes = [tys[0].intrinsic_name]
+        else:
+            suffixes = [t.intrinsic_name for t in tys]
+        name = '.'.join([intrinsic] + suffixes)
+        if name in self.globals:
+            return self.globals[name]
+
+        if fnty is not None:
+            # General case: function type is given
+            pass
+        # Compute function type if omitted for common cases
+        elif len(tys) == 0 and intrinsic == 'llvm.assume':
+            fnty = types.FunctionType(types.VoidType(), [types.IntType(1)])
+        elif len(tys) == 1:
+            if intrinsic == 'llvm.powi':
+                fnty = types.FunctionType(tys[0], [tys[0], types.IntType(32)])
+            elif intrinsic == 'llvm.pow':
+                fnty = types.FunctionType(tys[0], tys * 2)
+            elif intrinsic == 'llvm.convert.from.fp16':
+                fnty = types.FunctionType(tys[0], [types.IntType(16)])
+            elif intrinsic == 'llvm.convert.to.fp16':
+                fnty = types.FunctionType(types.IntType(16), tys)
+            else:
+                fnty = types.FunctionType(tys[0], tys)
+        elif len(tys) == 2:
+            if intrinsic == 'llvm.memset':
+                tys = [tys[0], types.IntType(8), tys[1],
+                       types.IntType(1)]
+                fnty = types.FunctionType(types.VoidType(), tys)
+            elif intrinsic in {'llvm.cttz', 'llvm.ctlz'}:
+                tys = [tys[0], types.IntType(1)]
+                fnty = types.FunctionType(tys[0], tys)
+            else:
+                _error()
+        elif len(tys) == 3:
+            if intrinsic in ('llvm.memcpy', 'llvm.memmove'):
+                tys = tys + [types.IntType(1)]
+                fnty = types.FunctionType(types.VoidType(), tys)
+            elif intrinsic == 'llvm.fma':
+                tys = [tys[0]] * 3
+                fnty = types.FunctionType(tys[0], tys)
+            else:
+                _error()
+        else:
+            _error()
+        return values.Function(self, fnty, name=name)
+
+    def get_identified_types(self):
+        return self.context.identified_types
+
+    def _get_body_lines(self):
+        # Type declarations
+        lines = [it.get_declaration()
+                 for it in self.get_identified_types().values()]
+        # Global values (including function definitions)
+        lines += [str(v) for v in self.globals.values()]
+        return lines
+
+    def _get_metadata_lines(self):
+        mdbuf = []
+        for k, v in self.namedmetadata.items():
+            mdbuf.append("!{name} = !{{ {operands} }}".format(
+                name=k, operands=', '.join(i.get_reference()
+                                           for i in v.operands)))
+        for md in self.metadata:
+            mdbuf.append(str(md))
+        return mdbuf
+
+    def _stringify_body(self):
+        # For testing
+        return "\n".join(self._get_body_lines())
+
+    def _stringify_metadata(self):
+        # For testing
+        return "\n".join(self._get_metadata_lines())
+
+    def __repr__(self):
+        lines = []
+        # Header
+        lines += [
+            '; ModuleID = "%s"' % (self.name,),
+            'target triple = "%s"' % (self.triple,),
+            'target datalayout = "%s"' % (self.data_layout,),
+            '']
+        # Body
+        lines += self._get_body_lines()
+        # Metadata
+        lines += self._get_metadata_lines()
+
+        return "\n".join(lines)
diff --git a/lib/python3.11/site-packages/llvmlite/ir/transforms.py b/lib/python3.11/site-packages/llvmlite/ir/transforms.py
new file mode 100644
index 0000000000000000000000000000000000000000..a69113d36e93b6b9e42a2a15119697375cff62e5
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/transforms.py
@@ -0,0 +1,64 @@
+from llvmlite.ir import CallInstr
+
+
+class Visitor(object):
+    def visit(self, module):
+        self._module = module
+        for func in module.functions:
+            self.visit_Function(func)
+
+    def visit_Function(self, func):
+        self._function = func
+        for bb in func.blocks:
+            self.visit_BasicBlock(bb)
+
+    def visit_BasicBlock(self, bb):
+        self._basic_block = bb
+        for instr in bb.instructions:
+            self.visit_Instruction(instr)
+
+    def visit_Instruction(self, instr):
+        raise NotImplementedError
+
+    @property
+    def module(self):
+        return self._module
+
+    @property
+    def function(self):
+        return self._function
+
+    @property
+    def basic_block(self):
+        return self._basic_block
+
+
+class CallVisitor(Visitor):
+    def visit_Instruction(self, instr):
+        if isinstance(instr, CallInstr):
+            self.visit_Call(instr)
+
+    def visit_Call(self, instr):
+        raise NotImplementedError
+
+
+class ReplaceCalls(CallVisitor):
+    def __init__(self, orig, repl):
+        super(ReplaceCalls, self).__init__()
+        self.orig = orig
+        self.repl = repl
+        self.calls = []
+
+    def visit_Call(self, instr):
+        if instr.callee == self.orig:
+            instr.replace_callee(self.repl)
+            self.calls.append(instr)
+
+
+def replace_all_calls(mod, orig, repl):
+    """Replace all calls to `orig` to `repl` in module `mod`.
+    Returns the references to the returned calls
+    """
+    rc = ReplaceCalls(orig, repl)
+    rc.visit(mod)
+    return rc.calls
diff --git a/lib/python3.11/site-packages/llvmlite/ir/types.py b/lib/python3.11/site-packages/llvmlite/ir/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..707246e617f04c2636b0098c6cb4b58f63873522
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/types.py
@@ -0,0 +1,614 @@
+"""
+Classes that are LLVM types
+"""
+
+import struct
+
+from llvmlite.ir._utils import _StrCaching
+
+
+def _wrapname(x):
+    return '"{0}"'.format(x.replace('\\', '\\5c').replace('"', '\\22'))
+
+
+class Type(_StrCaching):
+    """
+    The base class for all LLVM types.
+    """
+    is_pointer = False
+    null = 'zeroinitializer'
+
+    def __repr__(self):
+        return "<%s %s>" % (type(self), str(self))
+
+    def _to_string(self):
+        raise NotImplementedError
+
+    def as_pointer(self, addrspace=0):
+        return PointerType(self, addrspace)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def _get_ll_pointer_type(self, target_data, context=None):
+        """
+        Convert this type object to an LLVM type.
+        """
+        from llvmlite.ir import Module, GlobalVariable
+        from llvmlite.binding import parse_assembly
+
+        if context is None:
+            m = Module()
+        else:
+            m = Module(context=context)
+        foo = GlobalVariable(m, self, name="foo")
+        with parse_assembly(str(m)) as llmod:
+            return llmod.get_global_variable(foo.name).type
+
+    def get_abi_size(self, target_data, context=None):
+        """
+        Get the ABI size of this type according to data layout *target_data*.
+        """
+        llty = self._get_ll_pointer_type(target_data, context)
+        return target_data.get_pointee_abi_size(llty)
+
+    def get_abi_alignment(self, target_data, context=None):
+        """
+        Get the minimum ABI alignment of this type according to data layout
+        *target_data*.
+        """
+        llty = self._get_ll_pointer_type(target_data, context)
+        return target_data.get_pointee_abi_alignment(llty)
+
+    def format_constant(self, value):
+        """
+        Format constant *value* of this type.  This method may be overriden
+        by subclasses.
+        """
+        return str(value)
+
+    def wrap_constant_value(self, value):
+        """
+        Wrap constant *value* if necessary.  This method may be overriden
+        by subclasses (especially aggregate types).
+        """
+        return value
+
+    def __call__(self, value):
+        """
+        Create a LLVM constant of this type with the given Python value.
+        """
+        from llvmlite.ir import Constant
+        return Constant(self, value)
+
+
+class MetaDataType(Type):
+
+    def _to_string(self):
+        return "metadata"
+
+    def as_pointer(self):
+        raise TypeError
+
+    def __eq__(self, other):
+        return isinstance(other, MetaDataType)
+
+    def __hash__(self):
+        return hash(MetaDataType)
+
+
+class LabelType(Type):
+    """
+    The label type is the type of e.g. basic blocks.
+    """
+
+    def _to_string(self):
+        return "label"
+
+
+class PointerType(Type):
+    """
+    The type of all pointer values.
+    """
+    is_pointer = True
+    null = 'null'
+
+    def __init__(self, pointee, addrspace=0):
+        assert not isinstance(pointee, VoidType)
+        self.pointee = pointee
+        self.addrspace = addrspace
+
+    def _to_string(self):
+        if self.addrspace != 0:
+            return "{0} addrspace({1})*".format(self.pointee, self.addrspace)
+        else:
+            return "{0}*".format(self.pointee)
+
+    def __eq__(self, other):
+        if isinstance(other, PointerType):
+            return (self.pointee, self.addrspace) == (other.pointee,
+                                                      other.addrspace)
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(PointerType)
+
+    def gep(self, i):
+        """
+        Resolve the type of the i-th element (for getelementptr lookups).
+        """
+        if not isinstance(i.type, IntType):
+            raise TypeError(i.type)
+        return self.pointee
+
+    @property
+    def intrinsic_name(self):
+        return 'p%d%s' % (self.addrspace, self.pointee.intrinsic_name)
+
+
+class VoidType(Type):
+    """
+    The type for empty values (e.g. a function returning no value).
+    """
+
+    def _to_string(self):
+        return 'void'
+
+    def __eq__(self, other):
+        return isinstance(other, VoidType)
+
+    def __hash__(self):
+        return hash(VoidType)
+
+
+class FunctionType(Type):
+    """
+    The type for functions.
+    """
+
+    def __init__(self, return_type, args, var_arg=False):
+        self.return_type = return_type
+        self.args = tuple(args)
+        self.var_arg = var_arg
+
+    def _to_string(self):
+        if self.args:
+            strargs = ', '.join([str(a) for a in self.args])
+            if self.var_arg:
+                return '{0} ({1}, ...)'.format(self.return_type, strargs)
+            else:
+                return '{0} ({1})'.format(self.return_type, strargs)
+        elif self.var_arg:
+            return '{0} (...)'.format(self.return_type)
+        else:
+            return '{0} ()'.format(self.return_type)
+
+    def __eq__(self, other):
+        if isinstance(other, FunctionType):
+            return (self.return_type == other.return_type and
+                    self.args == other.args and self.var_arg == other.var_arg)
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(FunctionType)
+
+
+class IntType(Type):
+    """
+    The type for integers.
+    """
+    null = '0'
+    _instance_cache = {}
+    width: int
+
+    def __new__(cls, bits):
+        # Cache all common integer types
+        if 0 <= bits <= 128:
+            try:
+                return cls._instance_cache[bits]
+            except KeyError:
+                inst = cls._instance_cache[bits] = cls.__new(bits)
+                return inst
+        return cls.__new(bits)
+
+    @classmethod
+    def __new(cls, bits):
+        assert isinstance(bits, int) and bits >= 0
+        self = super(IntType, cls).__new__(cls)
+        self.width = bits
+        return self
+
+    def __getnewargs__(self):
+        return self.width,
+
+    def __copy__(self):
+        return self
+
+    def _to_string(self):
+        return 'i%u' % (self.width,)
+
+    def __eq__(self, other):
+        if isinstance(other, IntType):
+            return self.width == other.width
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(IntType)
+
+    def format_constant(self, val):
+        if isinstance(val, bool):
+            return str(val).lower()
+        else:
+            return str(val)
+
+    def wrap_constant_value(self, val):
+        if val is None:
+            return 0
+        return val
+
+    @property
+    def intrinsic_name(self):
+        return str(self)
+
+
+def _as_float(value):
+    """
+    Truncate to single-precision float.
+    """
+    return struct.unpack('f', struct.pack('f', value))[0]
+
+
+def _as_half(value):
+    """
+    Truncate to half-precision float.
+    """
+    try:
+        return struct.unpack('e', struct.pack('e', value))[0]
+    except struct.error:
+        # 'e' only added in Python 3.6+
+        return _as_float(value)
+
+
+def _format_float_as_hex(value, packfmt, unpackfmt, numdigits):
+    raw = struct.pack(packfmt, float(value))
+    intrep = struct.unpack(unpackfmt, raw)[0]
+    out = '{{0:#{0}x}}'.format(numdigits).format(intrep)
+    return out
+
+
+def _format_double(value):
+    """
+    Format *value* as a hexadecimal string of its IEEE double precision
+    representation.
+    """
+    return _format_float_as_hex(value, 'd', 'Q', 16)
+
+
+class _BaseFloatType(Type):
+
+    def __new__(cls):
+        return cls._instance_cache
+
+    def __eq__(self, other):
+        return isinstance(other, type(self))
+
+    def __hash__(self):
+        return hash(type(self))
+
+    @classmethod
+    def _create_instance(cls):
+        cls._instance_cache = super(_BaseFloatType, cls).__new__(cls)
+
+
+class HalfType(_BaseFloatType):
+    """
+    The type for single-precision floats.
+    """
+    null = '0.0'
+    intrinsic_name = 'f16'
+
+    def __str__(self):
+        return 'half'
+
+    def format_constant(self, value):
+        return _format_double(_as_half(value))
+
+
+class FloatType(_BaseFloatType):
+    """
+    The type for single-precision floats.
+    """
+    null = '0.0'
+    intrinsic_name = 'f32'
+
+    def __str__(self):
+        return 'float'
+
+    def format_constant(self, value):
+        return _format_double(_as_float(value))
+
+
+class DoubleType(_BaseFloatType):
+    """
+    The type for double-precision floats.
+    """
+    null = '0.0'
+    intrinsic_name = 'f64'
+
+    def __str__(self):
+        return 'double'
+
+    def format_constant(self, value):
+        return _format_double(value)
+
+
+for _cls in (HalfType, FloatType, DoubleType):
+    _cls._create_instance()
+
+
+class _Repeat(object):
+    def __init__(self, value, size):
+        self.value = value
+        self.size = size
+
+    def __len__(self):
+        return self.size
+
+    def __getitem__(self, item):
+        if 0 <= item < self.size:
+            return self.value
+        else:
+            raise IndexError(item)
+
+
+class VectorType(Type):
+    """
+    The type for vectors of primitive data items (e.g. "<f32 x 4>").
+    """
+
+    def __init__(self, element, count):
+        self.element = element
+        self.count = count
+
+    @property
+    def elements(self):
+        return _Repeat(self.element, self.count)
+
+    def __len__(self):
+        return self.count
+
+    def _to_string(self):
+        return "<%d x %s>" % (self.count, self.element)
+
+    def __eq__(self, other):
+        if isinstance(other, VectorType):
+            return self.element == other.element and self.count == other.count
+
+    def __hash__(self):
+        # TODO: why does this not take self.element/self.count into account?
+        return hash(VectorType)
+
+    def __copy__(self):
+        return self
+
+    def format_constant(self, value):
+        itemstring = ", " .join(["{0} {1}".format(x.type, x.get_reference())
+                                 for x in value])
+        return "<{0}>".format(itemstring)
+
+    def wrap_constant_value(self, values):
+        from . import Value, Constant
+        if not isinstance(values, (list, tuple)):
+            if isinstance(values, Constant):
+                if values.type != self.element:
+                    raise TypeError("expected {} for {}".format(
+                        self.element, values.type))
+                return (values, ) * self.count
+            return (Constant(self.element, values), ) * self.count
+        if len(values) != len(self):
+            raise ValueError("wrong constant size for %s: got %d elements"
+                             % (self, len(values)))
+        return [Constant(ty, val) if not isinstance(val, Value) else val
+                for ty, val in zip(self.elements, values)]
+
+
+class Aggregate(Type):
+    """
+    Base class for aggregate types.
+    See http://llvm.org/docs/LangRef.html#t-aggregate
+    """
+
+    def wrap_constant_value(self, values):
+        from . import Value, Constant
+
+        if not isinstance(values, (list, tuple)):
+            return values
+        if len(values) != len(self):
+            raise ValueError("wrong constant size for %s: got %d elements"
+                             % (self, len(values)))
+        return [Constant(ty, val) if not isinstance(val, Value) else val
+                for ty, val in zip(self.elements, values)]
+
+
+class ArrayType(Aggregate):
+    """
+    The type for fixed-size homogenous arrays (e.g. "[f32 x 3]").
+    """
+
+    def __init__(self, element, count):
+        self.element = element
+        self.count = count
+
+    @property
+    def elements(self):
+        return _Repeat(self.element, self.count)
+
+    def __len__(self):
+        return self.count
+
+    def _to_string(self):
+        return "[%d x %s]" % (self.count, self.element)
+
+    def __eq__(self, other):
+        if isinstance(other, ArrayType):
+            return self.element == other.element and self.count == other.count
+
+    def __hash__(self):
+        return hash(ArrayType)
+
+    def gep(self, i):
+        """
+        Resolve the type of the i-th element (for getelementptr lookups).
+        """
+        if not isinstance(i.type, IntType):
+            raise TypeError(i.type)
+        return self.element
+
+    def format_constant(self, value):
+        itemstring = ", " .join(["{0} {1}".format(x.type, x.get_reference())
+                                 for x in value])
+        return "[{0}]".format(itemstring)
+
+
+class BaseStructType(Aggregate):
+    """
+    The base type for heterogenous struct types.
+    """
+    _packed = False
+
+    @property
+    def packed(self):
+        """
+        A boolean attribute that indicates whether the structure uses
+        packed layout.
+        """
+        return self._packed
+
+    @packed.setter
+    def packed(self, val):
+        self._packed = bool(val)
+
+    def __len__(self):
+        assert self.elements is not None
+        return len(self.elements)
+
+    def __iter__(self):
+        assert self.elements is not None
+        return iter(self.elements)
+
+    @property
+    def is_opaque(self):
+        return self.elements is None
+
+    def structure_repr(self):
+        """
+        Return the LLVM IR for the structure representation
+        """
+        ret = '{%s}' % ', '.join([str(x) for x in self.elements])
+        return self._wrap_packed(ret)
+
+    def format_constant(self, value):
+        itemstring = ", " .join(["{0} {1}".format(x.type, x.get_reference())
+                                 for x in value])
+        ret = "{{{0}}}".format(itemstring)
+        return self._wrap_packed(ret)
+
+    def gep(self, i):
+        """
+        Resolve the type of the i-th element (for getelementptr lookups).
+
+        *i* needs to be a LLVM constant, so that the type can be determined
+        at compile-time.
+        """
+        if not isinstance(i.type, IntType):
+            raise TypeError(i.type)
+        return self.elements[i.constant]
+
+    def _wrap_packed(self, textrepr):
+        """
+        Internal helper to wrap textual repr of struct type into packed struct
+        """
+        if self.packed:
+            return '<{}>'.format(textrepr)
+        else:
+            return textrepr
+
+
+class LiteralStructType(BaseStructType):
+    """
+    The type of "literal" structs, i.e. structs with a literally-defined
+    type (by contrast with IdentifiedStructType).
+    """
+
+    null = 'zeroinitializer'
+
+    def __init__(self, elems, packed=False):
+        """
+        *elems* is a sequence of types to be used as members.
+        *packed* controls the use of packed layout.
+        """
+        self.elements = tuple(elems)
+        self.packed = packed
+
+    def _to_string(self):
+        return self.structure_repr()
+
+    def __eq__(self, other):
+        if isinstance(other, LiteralStructType):
+            return self.elements == other.elements
+
+    def __hash__(self):
+        return hash(LiteralStructType)
+
+
+class IdentifiedStructType(BaseStructType):
+    """
+    A type which is a named alias for another struct type, akin to a typedef.
+    While literal struct types can be structurally equal (see
+    LiteralStructType), identified struct types are compared by name.
+
+    Do not use this directly.
+    """
+    null = 'zeroinitializer'
+
+    def __init__(self, context, name, packed=False):
+        """
+        *context* is a llvmlite.ir.Context.
+        *name* is the identifier for the new struct type.
+        *packed* controls the use of packed layout.
+        """
+        assert name
+        self.context = context
+        self.name = name
+        self.elements = None
+        self.packed = packed
+
+    def _to_string(self):
+        return "%{name}".format(name=_wrapname(self.name))
+
+    def get_declaration(self):
+        """
+        Returns the string for the declaration of the type
+        """
+        if self.is_opaque:
+            out = "{strrep} = type opaque".format(strrep=str(self))
+        else:
+            out = "{strrep} = type {struct}".format(
+                strrep=str(self), struct=self.structure_repr())
+        return out
+
+    def __eq__(self, other):
+        if isinstance(other, IdentifiedStructType):
+            return self.name == other.name
+
+    def __hash__(self):
+        return hash(IdentifiedStructType)
+
+    def set_body(self, *elems):
+        if not self.is_opaque:
+            raise RuntimeError("{name} is already defined".format(
+                name=self.name))
+        self.elements = tuple(elems)
diff --git a/lib/python3.11/site-packages/llvmlite/ir/values.py b/lib/python3.11/site-packages/llvmlite/ir/values.py
new file mode 100644
index 0000000000000000000000000000000000000000..93431210da4a81346deedd01ce4dbefc969898e0
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/ir/values.py
@@ -0,0 +1,1217 @@
+"""
+Classes that are LLVM values: Value, Constant...
+Instructions are in the instructions module.
+"""
+
+import functools
+import string
+import re
+from types import MappingProxyType
+
+from llvmlite.ir import values, types, _utils
+from llvmlite.ir._utils import (_StrCaching, _StringReferenceCaching,
+                                _HasMetadata)
+
+_VALID_CHARS = (frozenset(map(ord, string.ascii_letters)) |
+                frozenset(map(ord, string.digits)) |
+                frozenset(map(ord, ' !#$%&\'()*+,-./:;<=>?@[]^_`{|}~')))
+
+_SIMPLE_IDENTIFIER_RE = re.compile(r"[-a-zA-Z$._][-a-zA-Z$._0-9]*$")
+
+_CMP_MAP = {
+    '>': 'gt',
+    '<': 'lt',
+    '==': 'eq',
+    '!=': 'ne',
+    '>=': 'ge',
+    '<=': 'le',
+}
+
+
+def _escape_string(text, _map={}):
+    """
+    Escape the given bytestring for safe use as a LLVM array constant.
+    Any unicode string input is first encoded with utf8 into bytes.
+    """
+    if isinstance(text, str):
+        text = text.encode()
+    assert isinstance(text, (bytes, bytearray))
+
+    if not _map:
+        for ch in range(256):
+            if ch in _VALID_CHARS:
+                _map[ch] = chr(ch)
+            else:
+                _map[ch] = '\\%02x' % ch
+
+    buf = [_map[ch] for ch in text]
+    return ''.join(buf)
+
+
+def _binop(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(lhs, rhs):
+            if lhs.type != rhs.type:
+                raise ValueError("Operands must be the same type, got (%s, %s)"
+                                 % (lhs.type, rhs.type))
+
+            fmt = "{0} ({1} {2}, {3} {4})".format(opname,
+                                                  lhs.type, lhs.get_reference(),
+                                                  rhs.type, rhs.get_reference())
+            return FormattedConstant(lhs.type, fmt)
+
+        return wrapped
+    return wrap
+
+
+def _castop(opname):
+    def wrap(fn):
+        @functools.wraps(fn)
+        def wrapped(self, typ):
+            fn(self, typ)
+            if typ == self.type:
+                return self
+
+            op = "{0} ({1} {2} to {3})".format(opname, self.type,
+                                               self.get_reference(), typ)
+            return FormattedConstant(typ, op)
+
+        return wrapped
+    return wrap
+
+
+class _ConstOpMixin(object):
+    """
+    A mixin defining constant operations, for use in constant-like classes.
+    """
+
+    #
+    # Arithmetic APIs
+    #
+
+    @_binop('shl')
+    def shl(self, other):
+        """
+        Left integer shift:
+            lhs << rhs
+        """
+
+    @_binop('lshr')
+    def lshr(self, other):
+        """
+        Logical (unsigned) right integer shift:
+            lhs >> rhs
+        """
+
+    @_binop('ashr')
+    def ashr(self, other):
+        """
+        Arithmetic (signed) right integer shift:
+            lhs >> rhs
+        """
+
+    @_binop('add')
+    def add(self, other):
+        """
+        Integer addition:
+            lhs + rhs
+        """
+
+    @_binop('fadd')
+    def fadd(self, other):
+        """
+        Floating-point addition:
+            lhs + rhs
+        """
+
+    @_binop('sub')
+    def sub(self, other):
+        """
+        Integer subtraction:
+            lhs - rhs
+        """
+
+    @_binop('fsub')
+    def fsub(self, other):
+        """
+        Floating-point subtraction:
+            lhs - rhs
+        """
+
+    @_binop('mul')
+    def mul(self, other):
+        """
+        Integer multiplication:
+            lhs * rhs
+        """
+
+    @_binop('fmul')
+    def fmul(self, other):
+        """
+        Floating-point multiplication:
+            lhs * rhs
+        """
+
+    @_binop('udiv')
+    def udiv(self, other):
+        """
+        Unsigned integer division:
+            lhs / rhs
+        """
+
+    @_binop('sdiv')
+    def sdiv(self, other):
+        """
+        Signed integer division:
+            lhs / rhs
+        """
+
+    @_binop('fdiv')
+    def fdiv(self, other):
+        """
+        Floating-point division:
+            lhs / rhs
+        """
+
+    @_binop('urem')
+    def urem(self, other):
+        """
+        Unsigned integer remainder:
+            lhs % rhs
+        """
+
+    @_binop('srem')
+    def srem(self, other):
+        """
+        Signed integer remainder:
+            lhs % rhs
+        """
+
+    @_binop('frem')
+    def frem(self, other):
+        """
+        Floating-point remainder:
+            lhs % rhs
+        """
+
+    @_binop('or')
+    def or_(self, other):
+        """
+        Bitwise integer OR:
+            lhs | rhs
+        """
+
+    @_binop('and')
+    def and_(self, other):
+        """
+        Bitwise integer AND:
+            lhs & rhs
+        """
+
+    @_binop('xor')
+    def xor(self, other):
+        """
+        Bitwise integer XOR:
+            lhs ^ rhs
+        """
+
+    def _cmp(self, prefix, sign, cmpop, other):
+        ins = prefix + 'cmp'
+        try:
+            op = _CMP_MAP[cmpop]
+        except KeyError:
+            raise ValueError("invalid comparison %r for %s" % (cmpop, ins))
+
+        if not (prefix == 'i' and cmpop in ('==', '!=')):
+            op = sign + op
+
+        if self.type != other.type:
+            raise ValueError("Operands must be the same type, got (%s, %s)"
+                             % (self.type, other.type))
+
+        fmt = "{0} {1} ({2} {3}, {4} {5})".format(
+            ins, op,
+            self.type, self.get_reference(),
+            other.type, other.get_reference())
+
+        return FormattedConstant(types.IntType(1), fmt)
+
+    def icmp_signed(self, cmpop, other):
+        """
+        Signed integer comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._cmp('i', 's', cmpop, other)
+
+    def icmp_unsigned(self, cmpop, other):
+        """
+        Unsigned integer (or pointer) comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>='
+        """
+        return self._cmp('i', 'u', cmpop, other)
+
+    def fcmp_ordered(self, cmpop, other):
+        """
+        Floating-point ordered comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        return self._cmp('f', 'o', cmpop, other)
+
+    def fcmp_unordered(self, cmpop, other):
+        """
+        Floating-point unordered comparison:
+            lhs <cmpop> rhs
+
+        where cmpop can be '==', '!=', '<', '<=', '>', '>=', 'ord', 'uno'
+        """
+        return self._cmp('f', 'u', cmpop, other)
+
+    #
+    # Unary APIs
+    #
+
+    def not_(self):
+        """
+        Bitwise integer complement:
+            ~value
+        """
+        if isinstance(self.type, types.VectorType):
+            rhs = values.Constant(self.type, (-1,) * self.type.count)
+        else:
+            rhs = values.Constant(self.type, -1)
+
+        return self.xor(rhs)
+
+    def neg(self):
+        """
+        Integer negative:
+            -value
+        """
+        zero = values.Constant(self.type, 0)
+        return zero.sub(self)
+
+    def fneg(self):
+        """
+        Floating-point negative:
+            -value
+        """
+        fmt = "fneg ({0} {1})".format(self.type, self.get_reference())
+        return FormattedConstant(self.type, fmt)
+
+    #
+    # Cast APIs
+    #
+
+    @_castop('trunc')
+    def trunc(self, typ):
+        """
+        Truncating integer downcast to a smaller type.
+        """
+
+    @_castop('zext')
+    def zext(self, typ):
+        """
+        Zero-extending integer upcast to a larger type
+        """
+
+    @_castop('sext')
+    def sext(self, typ):
+        """
+        Sign-extending integer upcast to a larger type.
+        """
+
+    @_castop('fptrunc')
+    def fptrunc(self, typ):
+        """
+        Floating-point downcast to a less precise type.
+        """
+
+    @_castop('fpext')
+    def fpext(self, typ):
+        """
+        Floating-point upcast to a more precise type.
+        """
+
+    @_castop('bitcast')
+    def bitcast(self, typ):
+        """
+        Pointer cast to a different pointer type.
+        """
+
+    @_castop('fptoui')
+    def fptoui(self, typ):
+        """
+        Convert floating-point to unsigned integer.
+        """
+
+    @_castop('uitofp')
+    def uitofp(self, typ):
+        """
+        Convert unsigned integer to floating-point.
+        """
+
+    @_castop('fptosi')
+    def fptosi(self, typ):
+        """
+        Convert floating-point to signed integer.
+        """
+
+    @_castop('sitofp')
+    def sitofp(self, typ):
+        """
+        Convert signed integer to floating-point.
+        """
+
+    @_castop('ptrtoint')
+    def ptrtoint(self, typ):
+        """
+        Cast pointer to integer.
+        """
+        if not isinstance(self.type, types.PointerType):
+            msg = "can only call ptrtoint() on pointer type, not '%s'"
+            raise TypeError(msg % (self.type,))
+        if not isinstance(typ, types.IntType):
+            raise TypeError("can only ptrtoint() to integer type, not '%s'"
+                            % (typ,))
+
+    @_castop('inttoptr')
+    def inttoptr(self, typ):
+        """
+        Cast integer to pointer.
+        """
+        if not isinstance(self.type, types.IntType):
+            msg = "can only call inttoptr() on integer constants, not '%s'"
+            raise TypeError(msg % (self.type,))
+        if not isinstance(typ, types.PointerType):
+            raise TypeError("can only inttoptr() to pointer type, not '%s'"
+                            % (typ,))
+
+    def gep(self, indices):
+        """
+        Call getelementptr on this pointer constant.
+        """
+        if not isinstance(self.type, types.PointerType):
+            raise TypeError("can only call gep() on pointer constants, not '%s'"
+                            % (self.type,))
+
+        outtype = self.type
+        for i in indices:
+            outtype = outtype.gep(i)
+
+        strindices = ["{0} {1}".format(idx.type, idx.get_reference())
+                      for idx in indices]
+
+        op = "getelementptr ({0}, {1} {2}, {3})".format(
+            self.type.pointee, self.type,
+            self.get_reference(), ', '.join(strindices))
+        return FormattedConstant(outtype.as_pointer(self.addrspace), op)
+
+
+class Value(object):
+    """
+    The base class for all values.
+    """
+
+    def __repr__(self):
+        return "<ir.%s type='%s' ...>" % (self.__class__.__name__, self.type,)
+
+
+class _Undefined(object):
+    """
+    'undef': a value for undefined values.
+    """
+    def __new__(cls):
+        try:
+            return Undefined
+        except NameError:
+            return object.__new__(_Undefined)
+
+
+Undefined = _Undefined()
+
+
+class Constant(_StrCaching, _StringReferenceCaching, _ConstOpMixin, Value):
+    """
+    A constant LLVM value.
+    """
+
+    def __init__(self, typ, constant):
+        assert isinstance(typ, types.Type)
+        assert not isinstance(typ, types.VoidType)
+        self.type = typ
+        constant = typ.wrap_constant_value(constant)
+        self.constant = constant
+
+    def _to_string(self):
+        return '{0} {1}'.format(self.type, self.get_reference())
+
+    def _get_reference(self):
+        if self.constant is None:
+            val = self.type.null
+
+        elif self.constant is Undefined:
+            val = "undef"
+
+        elif isinstance(self.constant, bytearray):
+            val = 'c"{0}"'.format(_escape_string(self.constant))
+
+        else:
+            val = self.type.format_constant(self.constant)
+
+        return val
+
+    @classmethod
+    def literal_array(cls, elems):
+        """
+        Construct a literal array constant made of the given members.
+        """
+        tys = [el.type for el in elems]
+        if len(tys) == 0:
+            raise ValueError("need at least one element")
+        ty = tys[0]
+        for other in tys:
+            if ty != other:
+                raise TypeError("all elements must have the same type")
+        return cls(types.ArrayType(ty, len(elems)), elems)
+
+    @classmethod
+    def literal_struct(cls, elems):
+        """
+        Construct a literal structure constant made of the given members.
+        """
+        tys = [el.type for el in elems]
+        return cls(types.LiteralStructType(tys), elems)
+
+    @property
+    def addrspace(self):
+        if not isinstance(self.type, types.PointerType):
+            raise TypeError("Only pointer constant have address spaces")
+        return self.type.addrspace
+
+    def __eq__(self, other):
+        if isinstance(other, Constant):
+            return str(self) == str(other)
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __repr__(self):
+        return "<ir.Constant type='%s' value=%r>" % (self.type, self.constant)
+
+
+class FormattedConstant(Constant):
+    """
+    A constant with an already formatted IR representation.
+    """
+
+    def __init__(self, typ, constant):
+        assert isinstance(constant, str)
+        Constant.__init__(self, typ, constant)
+
+    def _to_string(self):
+        return self.constant
+
+    def _get_reference(self):
+        return self.constant
+
+
+class NamedValue(_StrCaching, _StringReferenceCaching, Value):
+    """
+    The base class for named values.
+    """
+    name_prefix = '%'
+    deduplicate_name = True
+
+    def __init__(self, parent, type, name):
+        assert parent is not None
+        assert isinstance(type, types.Type)
+        self.parent = parent
+        self.type = type
+        self._set_name(name)
+
+    def _to_string(self):
+        buf = []
+        if not isinstance(self.type, types.VoidType):
+            buf.append("{0} = ".format(self.get_reference()))
+        self.descr(buf)
+        return "".join(buf).rstrip()
+
+    def descr(self, buf):
+        raise NotImplementedError
+
+    def _get_name(self):
+        return self._name
+
+    def _set_name(self, name):
+        name = self.parent.scope.register(name,
+                                          deduplicate=self.deduplicate_name)
+        self._name = name
+
+    name = property(_get_name, _set_name)
+
+    def _get_reference(self):
+        name = self.name
+        # Quote and escape value name
+        if '\\' in name or '"' in name:
+            name = name.replace('\\', '\\5c').replace('"', '\\22')
+        return '{0}"{1}"'.format(self.name_prefix, name)
+
+    def __repr__(self):
+        return "<ir.%s %r of type '%s'>" % (
+            self.__class__.__name__, self.name, self.type)
+
+    @property
+    def function_type(self):
+        ty = self.type
+        if isinstance(ty, types.PointerType):
+            ty = self.type.pointee
+        if isinstance(ty, types.FunctionType):
+            return ty
+        else:
+            raise TypeError("Not a function: {0}".format(self.type))
+
+
+class MetaDataString(NamedValue):
+    """
+    A metadata string, i.e. a constant string used as a value in a metadata
+    node.
+    """
+
+    def __init__(self, parent, string):
+        super(MetaDataString, self).__init__(parent,
+                                             types.MetaDataType(),
+                                             name="")
+        self.string = string
+
+    def descr(self, buf):
+        buf += (self.get_reference(), "\n")
+
+    def _get_reference(self):
+        return '!"{0}"'.format(_escape_string(self.string))
+
+    _to_string = _get_reference
+
+    def __eq__(self, other):
+        if isinstance(other, MetaDataString):
+            return self.string == other.string
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self.string)
+
+
+class MetaDataArgument(_StrCaching, _StringReferenceCaching, Value):
+    """
+    An argument value to a function taking metadata arguments.
+    This can wrap any other kind of LLVM value.
+
+    Do not instantiate directly, Builder.call() will create these
+    automatically.
+    """
+
+    def __init__(self, value):
+        assert isinstance(value, Value)
+        assert not isinstance(value.type, types.MetaDataType)
+        self.type = types.MetaDataType()
+        self.wrapped_value = value
+
+    def _get_reference(self):
+        # e.g. "i32* %2"
+        return "{0} {1}".format(self.wrapped_value.type,
+                                self.wrapped_value.get_reference())
+
+    _to_string = _get_reference
+
+
+class NamedMetaData(object):
+    """
+    A named metadata node.
+
+    Do not instantiate directly, use Module.add_named_metadata() instead.
+    """
+
+    def __init__(self, parent):
+        self.parent = parent
+        self.operands = []
+
+    def add(self, md):
+        self.operands.append(md)
+
+
+class MDValue(NamedValue):
+    """
+    A metadata node's value, consisting of a sequence of elements ("operands").
+
+    Do not instantiate directly, use Module.add_metadata() instead.
+    """
+    name_prefix = '!'
+
+    def __init__(self, parent, values, name):
+        super(MDValue, self).__init__(parent,
+                                      types.MetaDataType(),
+                                      name=name)
+        self.operands = tuple(values)
+        parent.metadata.append(self)
+
+    def descr(self, buf):
+        operands = []
+        for op in self.operands:
+            if isinstance(op.type, types.MetaDataType):
+                if isinstance(op, Constant) and op.constant is None:
+                    operands.append("null")
+                else:
+                    operands.append(op.get_reference())
+            else:
+                operands.append("{0} {1}".format(op.type, op.get_reference()))
+        operands = ', '.join(operands)
+        buf += ("!{{ {0} }}".format(operands), "\n")
+
+    def _get_reference(self):
+        return self.name_prefix + str(self.name)
+
+    def __eq__(self, other):
+        if isinstance(other, MDValue):
+            return self.operands == other.operands
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash(self.operands)
+
+
+class DIToken:
+    """
+    A debug information enumeration value that should appear bare in
+    the emitted metadata.
+
+    Use this to wrap known constants, e.g. the DW_* enumerations.
+    """
+
+    def __init__(self, value):
+        self.value = value
+
+
+class DIValue(NamedValue):
+    """
+    A debug information descriptor, containing key-value pairs.
+
+    Do not instantiate directly, use Module.add_debug_info() instead.
+    """
+    name_prefix = '!'
+
+    def __init__(self, parent, is_distinct, kind, operands, name):
+        super(DIValue, self).__init__(parent,
+                                      types.MetaDataType(),
+                                      name=name)
+        self.is_distinct = is_distinct
+        self.kind = kind
+        self.operands = tuple(operands)
+        parent.metadata.append(self)
+
+    def descr(self, buf):
+        if self.is_distinct:
+            buf += ("distinct ",)
+        operands = []
+        for key, value in self.operands:
+            if value is None:
+                strvalue = "null"
+            elif value is True:
+                strvalue = "true"
+            elif value is False:
+                strvalue = "false"
+            elif isinstance(value, DIToken):
+                strvalue = value.value
+            elif isinstance(value, str):
+                strvalue = '"{}"'.format(_escape_string(value))
+            elif isinstance(value, int):
+                strvalue = str(value)
+            elif isinstance(value, NamedValue):
+                strvalue = value.get_reference()
+            else:
+                raise TypeError("invalid operand type for debug info: %r"
+                                % (value,))
+            operands.append("{0}: {1}".format(key, strvalue))
+        operands = ', '.join(operands)
+        buf += ("!", self.kind, "(", operands, ")\n")
+
+    def _get_reference(self):
+        return self.name_prefix + str(self.name)
+
+    def __eq__(self, other):
+        if isinstance(other, DIValue):
+            return self.is_distinct == other.is_distinct and \
+                self.kind == other.kind and \
+                self.operands == other.operands
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash((self.is_distinct, self.kind, self.operands))
+
+
+class GlobalValue(NamedValue, _ConstOpMixin, _HasMetadata):
+    """
+    A global value.
+    """
+    name_prefix = '@'
+    deduplicate_name = False
+
+    def __init__(self, *args, **kwargs):
+        super(GlobalValue, self).__init__(*args, **kwargs)
+        self.linkage = ''
+        self.storage_class = ''
+        self.section = ''
+        self.metadata = {}
+
+
+class GlobalVariable(GlobalValue):
+    """
+    A global variable.
+    """
+
+    def __init__(self, module, typ, name, addrspace=0):
+        assert isinstance(typ, types.Type)
+        super(GlobalVariable, self).__init__(module, typ.as_pointer(addrspace),
+                                             name=name)
+        self.value_type = typ
+        self.initializer = None
+        self.unnamed_addr = False
+        self.global_constant = False
+        self.addrspace = addrspace
+        self.align = None
+        self.parent.add_global(self)
+
+    def descr(self, buf):
+        if self.global_constant:
+            kind = 'constant'
+        else:
+            kind = 'global'
+
+        if not self.linkage:
+            # Default to external linkage
+            linkage = 'external' if self.initializer is None else ''
+        else:
+            linkage = self.linkage
+
+        if linkage:
+            buf.append(linkage + " ")
+        if self.storage_class:
+            buf.append(self.storage_class + " ")
+        if self.unnamed_addr:
+            buf.append("unnamed_addr ")
+        if self.addrspace != 0:
+            buf.append('addrspace({0:d}) '.format(self.addrspace))
+
+        buf.append("{kind} {type}" .format(kind=kind, type=self.value_type))
+
+        if self.initializer is not None:
+            if self.initializer.type != self.value_type:
+                raise TypeError("got initializer of type %s "
+                                "for global value type %s"
+                                % (self.initializer.type, self.value_type))
+            buf.append(" " + self.initializer.get_reference())
+        elif linkage not in ('external', 'extern_weak'):
+            # emit 'undef' for non-external linkage GV
+            buf.append(" " + self.value_type(Undefined).get_reference())
+
+        if self.section:
+            buf.append(", section \"%s\"" % (self.section,))
+
+        if self.align is not None:
+            buf.append(", align %d" % (self.align,))
+
+        if self.metadata:
+            buf.append(self._stringify_metadata(leading_comma=True))
+
+        buf.append("\n")
+
+
+class AttributeSet(set):
+    """A set of string attribute.
+    Only accept items listed in *_known*.
+
+    Properties:
+    * Iterate in sorted order
+    """
+    _known = ()
+
+    def __init__(self, args=()):
+        super().__init__()
+        if isinstance(args, str):
+            args = [args]
+        for name in args:
+            self.add(name)
+
+    def _expand(self, name, typ):
+        return name
+
+    def add(self, name):
+        if name not in self._known:
+            raise ValueError('unknown attr {!r} for {}'.format(name, self))
+        return super(AttributeSet, self).add(name)
+
+    def _to_list(self, typ):
+        return [self._expand(i, typ) for i in sorted(self)]
+
+
+class FunctionAttributes(AttributeSet):
+    _known = frozenset([
+        'argmemonly', 'alwaysinline', 'builtin', 'cold',
+        'inaccessiblememonly', 'inaccessiblemem_or_argmemonly', 'inlinehint',
+        'jumptable', 'minsize', 'naked', 'nobuiltin', 'noduplicate',
+        'noimplicitfloat', 'noinline', 'nonlazybind', 'norecurse',
+        'noredzone', 'noreturn', 'nounwind', 'optnone', 'optsize',
+        'readnone', 'readonly', 'returns_twice', 'sanitize_address',
+        'sanitize_memory', 'sanitize_thread', 'ssp',
+        'sspreg', 'sspstrong', 'uwtable'])
+
+    def __init__(self, args=()):
+        self._alignstack = 0
+        self._personality = None
+        super(FunctionAttributes, self).__init__(args)
+
+    def add(self, name):
+        if ((name == 'alwaysinline' and 'noinline' in self) or
+                (name == 'noinline' and 'alwaysinline' in self)):
+            raise ValueError("Can't have alwaysinline and noinline")
+
+        super().add(name)
+
+    @property
+    def alignstack(self):
+        return self._alignstack
+
+    @alignstack.setter
+    def alignstack(self, val):
+        assert val >= 0
+        self._alignstack = val
+
+    @property
+    def personality(self):
+        return self._personality
+
+    @personality.setter
+    def personality(self, val):
+        assert val is None or isinstance(val, GlobalValue)
+        self._personality = val
+
+    def _to_list(self, ret_type):
+        attrs = super()._to_list(ret_type)
+        if self.alignstack:
+            attrs.append('alignstack({0:d})'.format(self.alignstack))
+        if self.personality:
+            attrs.append('personality {persty} {persfn}'.format(
+                persty=self.personality.type,
+                persfn=self.personality.get_reference()))
+        return attrs
+
+
+class Function(GlobalValue):
+    """Represent a LLVM Function but does uses a Module as parent.
+    Global Values are stored as a set of dependencies (attribute `depends`).
+    """
+
+    def __init__(self, module, ftype, name):
+        assert isinstance(ftype, types.Type)
+        super(Function, self).__init__(module, ftype.as_pointer(), name=name)
+        self.ftype = ftype
+        self.scope = _utils.NameScope()
+        self.blocks = []
+        self.attributes = FunctionAttributes()
+        self.args = tuple([Argument(self, t)
+                           for t in ftype.args])
+        self.return_value = ReturnValue(self, ftype.return_type)
+        self.parent.add_global(self)
+        self.calling_convention = ''
+
+    @property
+    def module(self):
+        return self.parent
+
+    @property
+    def entry_basic_block(self):
+        return self.blocks[0]
+
+    @property
+    def basic_blocks(self):
+        return self.blocks
+
+    def append_basic_block(self, name=''):
+        blk = Block(parent=self, name=name)
+        self.blocks.append(blk)
+        return blk
+
+    def insert_basic_block(self, before, name=''):
+        """Insert block before
+        """
+        blk = Block(parent=self, name=name)
+        self.blocks.insert(before, blk)
+        return blk
+
+    def descr_prototype(self, buf):
+        """
+        Describe the prototype ("head") of the function.
+        """
+        state = "define" if self.blocks else "declare"
+        ret = self.return_value
+        args = ", ".join(str(a) for a in self.args)
+        name = self.get_reference()
+        attrs = ' ' + ' '.join(self.attributes._to_list(
+            self.ftype.return_type)) if self.attributes else ''
+        if any(self.args):
+            vararg = ', ...' if self.ftype.var_arg else ''
+        else:
+            vararg = '...' if self.ftype.var_arg else ''
+        linkage = self.linkage
+        cconv = self.calling_convention
+        prefix = " ".join(str(x) for x in [state, linkage, cconv, ret] if x)
+        metadata = self._stringify_metadata()
+        metadata = ' {}'.format(metadata) if metadata else ''
+        section = ' section "{}"'.format(self.section) if self.section else ''
+        pt_str = "{prefix} {name}({args}{vararg}){attrs}{section}{metadata}\n"
+        prototype = pt_str.format(prefix=prefix, name=name, args=args,
+                                  vararg=vararg, attrs=attrs, section=section,
+                                  metadata=metadata)
+        buf.append(prototype)
+
+    def descr_body(self, buf):
+        """
+        Describe of the body of the function.
+        """
+        for blk in self.blocks:
+            blk.descr(buf)
+
+    def descr(self, buf):
+        self.descr_prototype(buf)
+        if self.blocks:
+            buf.append("{\n")
+            self.descr_body(buf)
+            buf.append("}\n")
+
+    def __str__(self):
+        buf = []
+        self.descr(buf)
+        return "".join(buf)
+
+    @property
+    def is_declaration(self):
+        return len(self.blocks) == 0
+
+
+class ArgumentAttributes(AttributeSet):
+    # List from
+    # https://releases.llvm.org/14.0.0/docs/LangRef.html#parameter-attributes
+    _known = MappingProxyType({
+        # True (emit type),
+        # False (emit name only)
+        'byref': True,
+        'byval': True,
+        'elementtype': True,
+        'immarg': False,
+        'inalloca': True,
+        'inreg': False,
+        'nest': False,
+        'noalias': False,
+        'nocapture': False,
+        'nofree': False,
+        'nonnull': False,
+        'noundef': False,
+        'preallocated': True,
+        'returned': False,
+        'signext': False,
+        'sret': True,
+        'swiftasync': False,
+        'swifterror': False,
+        'swiftself': False,
+        'zeroext': False,
+    })
+
+    def __init__(self, args=()):
+        self._align = 0
+        self._dereferenceable = 0
+        self._dereferenceable_or_null = 0
+        super(ArgumentAttributes, self).__init__(args)
+
+    def _expand(self, name, typ):
+        requires_type = self._known.get(name)
+        if requires_type:
+            return f"{name}({typ.pointee})"
+        else:
+            return name
+
+    @property
+    def align(self):
+        return self._align
+
+    @align.setter
+    def align(self, val):
+        assert isinstance(val, int) and val >= 0
+        self._align = val
+
+    @property
+    def dereferenceable(self):
+        return self._dereferenceable
+
+    @dereferenceable.setter
+    def dereferenceable(self, val):
+        assert isinstance(val, int) and val >= 0
+        self._dereferenceable = val
+
+    @property
+    def dereferenceable_or_null(self):
+        return self._dereferenceable_or_null
+
+    @dereferenceable_or_null.setter
+    def dereferenceable_or_null(self, val):
+        assert isinstance(val, int) and val >= 0
+        self._dereferenceable_or_null = val
+
+    def _to_list(self, typ):
+        attrs = super()._to_list(typ)
+        if self.align:
+            attrs.append('align {0:d}'.format(self.align))
+        if self.dereferenceable:
+            attrs.append('dereferenceable({0:d})'.format(self.dereferenceable))
+        if self.dereferenceable_or_null:
+            dref = 'dereferenceable_or_null({0:d})'
+            attrs.append(dref.format(self.dereferenceable_or_null))
+        return attrs
+
+
+class _BaseArgument(NamedValue):
+    def __init__(self, parent, typ, name=''):
+        assert isinstance(typ, types.Type)
+        super(_BaseArgument, self).__init__(parent, typ, name=name)
+        self.parent = parent
+        self.attributes = ArgumentAttributes()
+
+    def __repr__(self):
+        return "<ir.%s %r of type %s>" % (self.__class__.__name__, self.name,
+                                          self.type)
+
+    def add_attribute(self, attr):
+        self.attributes.add(attr)
+
+
+class Argument(_BaseArgument):
+    """
+    The specification of a function argument.
+    """
+
+    def __str__(self):
+        attrs = self.attributes._to_list(self.type)
+        if attrs:
+            return "{0} {1} {2}".format(self.type, ' '.join(attrs),
+                                        self.get_reference())
+        else:
+            return "{0} {1}".format(self.type, self.get_reference())
+
+
+class ReturnValue(_BaseArgument):
+    """
+    The specification of a function's return value.
+    """
+
+    def __str__(self):
+        attrs = self.attributes._to_list(self.type)
+        if attrs:
+            return "{0} {1}".format(' '.join(attrs), self.type)
+        else:
+            return str(self.type)
+
+
+class Block(NamedValue):
+    """
+    A LLVM IR basic block. A basic block is a sequence of
+    instructions whose execution always goes from start to end.  That
+    is, a control flow instruction (branch) can only appear as the
+    last instruction, and incoming branches can only jump to the first
+    instruction.
+    """
+
+    def __init__(self, parent, name=''):
+        super(Block, self).__init__(parent, types.LabelType(), name=name)
+        self.scope = parent.scope
+        self.instructions = []
+        self.terminator = None
+
+    @property
+    def is_terminated(self):
+        return self.terminator is not None
+
+    @property
+    def function(self):
+        return self.parent
+
+    @property
+    def module(self):
+        return self.parent.module
+
+    def descr(self, buf):
+        buf.append("{0}:\n".format(self._format_name()))
+        buf += ["  {0}\n".format(instr) for instr in self.instructions]
+
+    def replace(self, old, new):
+        """Replace an instruction"""
+        if old.type != new.type:
+            raise TypeError("new instruction has a different type")
+        pos = self.instructions.index(old)
+        self.instructions.remove(old)
+        self.instructions.insert(pos, new)
+
+        for bb in self.parent.basic_blocks:
+            for instr in bb.instructions:
+                instr.replace_usage(old, new)
+
+    def _format_name(self):
+        # Per the LLVM Language Ref on identifiers, names matching the following
+        # regex do not need to be quoted: [%@][-a-zA-Z$._][-a-zA-Z$._0-9]*
+        # Otherwise, the identifier must be quoted and escaped.
+        name = self.name
+        if not _SIMPLE_IDENTIFIER_RE.match(name):
+            name = name.replace('\\', '\\5c').replace('"', '\\22')
+            name = '"{0}"'.format(name)
+        return name
+
+
+class BlockAddress(Value):
+    """
+    The address of a basic block.
+    """
+
+    def __init__(self, function, basic_block):
+        assert isinstance(function, Function)
+        assert isinstance(basic_block, Block)
+        self.type = types.IntType(8).as_pointer()
+        self.function = function
+        self.basic_block = basic_block
+
+    def __str__(self):
+        return '{0} {1}'.format(self.type, self.get_reference())
+
+    def get_reference(self):
+        return "blockaddress({0}, {1})".format(
+            self.function.get_reference(),
+            self.basic_block.get_reference())
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__init__.py b/lib/python3.11/site-packages/llvmlite/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f2b3b082d2722e587263fb4ce5307287715a1d5
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/__init__.py
@@ -0,0 +1,57 @@
+import sys
+
+import unittest
+from unittest import TestCase
+
+import faulthandler
+
+
+try:
+    # May fail in IPython Notebook with UnsupportedOperation
+    faulthandler.enable()
+except BaseException as e:
+    msg = "Failed to enable faulthandler due to:\n{err}"
+    warnings.warn(msg.format(err=e))
+
+
+# Try to inject Numba's unittest customizations.
+from llvmlite.tests import customize
+
+
+def discover_tests(startdir):
+    """Discover test under a directory
+    """
+    # Avoid importing unittest
+    loader = unittest.TestLoader()
+    suite = loader.discover(startdir)
+    return suite
+
+
+def run_tests(suite=None, xmloutput=None, verbosity=1):
+    """
+    args
+    ----
+    - suite [TestSuite]
+        A suite of all tests to run
+    - xmloutput [str or None]
+        Path of XML output directory (optional)
+    - verbosity [int]
+        Verbosity level of tests output
+
+    Returns the TestResult object after running the test *suite*.
+    """
+    if suite is None:
+        suite = discover_tests("llvmlite.tests")
+    if xmloutput is not None:
+        import xmlrunner
+        runner = xmlrunner.XMLTestRunner(output=xmloutput)
+    else:
+        runner = None
+    prog = unittest.main(suite=suite, testRunner=runner, exit=False,
+                         verbosity=verbosity)
+    return prog.result
+
+
+def main():
+    res = run_tests()
+    sys.exit(0 if res.wasSuccessful() else 1)
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__main__.py b/lib/python3.11/site-packages/llvmlite/tests/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..97563d18687da90316eef738c8aa3ffbacec4007
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/__main__.py
@@ -0,0 +1,3 @@
+from llvmlite.tests import main
+
+main()
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8179f1b85483a6f6131c700f52cdf9dc7b402f2a
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/__main__.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/__main__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fdf251183ad135ab1ca9d25ad3c5263fb88c87c8
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/__main__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/customize.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/customize.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58e44826b2800abe4b49a0dc243830a4f2c6b280
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/customize.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/refprune_proto.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/refprune_proto.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19a45b083aaac792f9b6267568e33a4062d6952b
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/refprune_proto.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_binding.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_binding.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a70b5c3754dd9e3f4cc16b2b4e8b64d01c8b9f5
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_binding.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_ir.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_ir.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..870b9aaeea0d0589c78933febabf1f9fceefd0ed
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_ir.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_refprune.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_refprune.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc2efb1cc73ed977b6900982aa1f4a7f7009239d
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_refprune.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_valuerepr.cpython-311.pyc b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_valuerepr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7399ed690762a279c17278475aa113224f54c843
Binary files /dev/null and b/lib/python3.11/site-packages/llvmlite/tests/__pycache__/test_valuerepr.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/llvmlite/tests/customize.py b/lib/python3.11/site-packages/llvmlite/tests/customize.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d747a3ca4343a7cb94911fa1283dbfbc35e0577
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/customize.py
@@ -0,0 +1,407 @@
+# XXX Ripped off from numba.tests; we should factor it out somewhere?
+
+import collections
+import contextlib
+import cProfile
+from io import StringIO
+import gc
+import os
+import multiprocessing
+import sys
+import time
+import unittest
+import warnings
+from unittest import result, runner, signals
+
+
+# "unittest.main" is really the TestProgram class!
+# (defined in a module named itself "unittest.main"...)
+
+class NumbaTestProgram(unittest.main):
+    """
+    A TestProgram subclass adding the following options:
+    * a -R option to enable reference leak detection
+    * a --profile option to enable profiling of the test run
+
+    Currently the options are only added in 3.4+.
+    """
+
+    refleak = False
+    profile = False
+    multiprocess = False
+
+    def __init__(self, *args, **kwargs):
+        self.discovered_suite = kwargs.pop('suite', None)
+        # HACK to force unittest not to change warning display options
+        # (so that NumbaWarnings don't appear all over the place)
+        sys.warnoptions.append(':x')
+        super(NumbaTestProgram, self).__init__(*args, **kwargs)
+
+    def createTests(self):
+        if self.discovered_suite is not None:
+            self.test = self.discovered_suite
+        else:
+            super(NumbaTestProgram, self).createTests()
+
+    def _getParentArgParser(self):
+        # NOTE: this hook only exists on Python 3.4+. The options won't be
+        # added in earlier versions (which use optparse - 3.3 - or getopt()
+        # - 2.x).
+        parser = super(NumbaTestProgram, self)._getParentArgParser()
+        if self.testRunner is None:
+            parser.add_argument('-R', '--refleak', dest='refleak',
+                                action='store_true',
+                                help='Detect reference / memory leaks')
+        parser.add_argument('-m', '--multiprocess', dest='multiprocess',
+                            action='store_true',
+                            help='Parallelize tests')
+        parser.add_argument('--profile', dest='profile',
+                            action='store_true',
+                            help='Profile the test run')
+        return parser
+
+    def parseArgs(self, argv):
+        if sys.version_info < (3, 4):
+            # We want these options to work on all versions, emulate them.
+            if '-R' in argv:
+                argv.remove('-R')
+                self.refleak = True
+            if '-m' in argv:
+                argv.remove('-m')
+                self.multiprocess = True
+        super(NumbaTestProgram, self).parseArgs(argv)
+        if self.verbosity <= 0:
+            # We aren't interested in informational messages / warnings when
+            # running with '-q'.
+            self.buffer = True
+
+    def runTests(self):
+        if self.refleak:
+            self.testRunner = RefleakTestRunner
+
+            if not hasattr(sys, "gettotalrefcount"):
+                warnings.warn("detecting reference leaks requires a debug "
+                              "build of Python, only memory leaks will be "
+                              "detected")
+
+        elif self.testRunner is None:
+            self.testRunner = unittest.TextTestRunner
+
+        if self.multiprocess:
+            self.testRunner = ParallelTestRunner(self.testRunner,
+                                                 verbosity=self.verbosity,
+                                                 failfast=self.failfast,
+                                                 buffer=self.buffer)
+
+        def run_tests_real():
+            super(NumbaTestProgram, self).runTests()
+
+        if self.profile:
+            filename = os.path.splitext(
+                os.path.basename(sys.modules['__main__'].__file__)
+            )[0] + '.prof'
+            p = cProfile.Profile(timer=time.perf_counter)  # 3.3+
+            p.enable()
+            try:
+                p.runcall(run_tests_real)
+            finally:
+                p.disable()
+                print("Writing test profile data into %r" % (filename,))
+                p.dump_stats(filename)
+        else:
+            run_tests_real()
+
+
+# Monkey-patch unittest so that individual test modules get our custom
+# options for free.
+unittest.main = NumbaTestProgram
+
+
+# The reference leak detection code is liberally taken and adapted from
+# Python's own Lib/test/regrtest.py.
+
+def _refleak_cleanup():
+    # Collect cyclic trash and read memory statistics immediately after.
+    try:
+        func1 = sys.getallocatedblocks
+    except AttributeError:
+        def func1():
+            return 42
+    try:
+        func2 = sys.gettotalrefcount
+    except AttributeError:
+        def func2():
+            return 42
+
+    # Flush standard output, so that buffered data is sent to the OS and
+    # associated Python objects are reclaimed.
+    for stream in (sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__):
+        if stream is not None:
+            stream.flush()
+
+    sys._clear_type_cache()
+    # This also clears the various internal CPython freelists.
+    gc.collect()
+    return func1(), func2()
+
+
+class ReferenceLeakError(RuntimeError):
+    pass
+
+
+class IntPool(collections.defaultdict):
+
+    def __missing__(self, key):
+        return key
+
+
+class RefleakTestResult(runner.TextTestResult):
+
+    warmup = 3
+    repetitions = 6
+
+    def _huntLeaks(self, test):
+        self.stream.flush()
+
+        repcount = self.repetitions
+        nwarmup = self.warmup
+        rc_deltas = [0] * (repcount - nwarmup)
+        alloc_deltas = [0] * (repcount - nwarmup)
+        # Preallocate ints likely to be stored in rc_deltas and alloc_deltas,
+        # to make sys.getallocatedblocks() less flaky.
+        _int_pool = IntPool()
+        for i in range(-200, 200):
+            _int_pool[i]
+
+        alloc_before = rc_before = 0
+        for i in range(repcount):
+            # Use a pristine, silent result object to avoid recursion
+            res = result.TestResult()
+            test.run(res)
+            # Poorly-written tests may fail when run several times.
+            # In this case, abort the refleak run and report the failure.
+            if not res.wasSuccessful():
+                self.failures.extend(res.failures)
+                self.errors.extend(res.errors)
+                raise AssertionError
+            del res
+            alloc_after, rc_after = _refleak_cleanup()
+            if i >= nwarmup:
+                rc_deltas[i - nwarmup] = _int_pool[rc_after - rc_before]
+                alloc_deltas[i -
+                             nwarmup] = _int_pool[alloc_after -
+                                                  alloc_before]
+            alloc_before, rc_before = alloc_after, rc_after
+        return rc_deltas, alloc_deltas
+
+    def addSuccess(self, test):
+        try:
+            rc_deltas, alloc_deltas = self._huntLeaks(test)
+        except AssertionError:
+            # Test failed when repeated
+            assert not self.wasSuccessful()
+            return
+
+        # These checkers return False on success, True on failure
+        def check_rc_deltas(deltas):
+            return any(deltas)
+
+        def check_alloc_deltas(deltas):
+            # At least 1/3rd of 0s
+            if 3 * deltas.count(0) < len(deltas):
+                return True
+            # Nothing else than 1s, 0s and -1s
+            if not set(deltas) <= set((1, 0, -1)):
+                return True
+            return False
+
+        failed = False
+
+        for deltas, item_name, checker in [
+            (rc_deltas, 'references', check_rc_deltas),
+                (alloc_deltas, 'memory blocks', check_alloc_deltas)]:
+            if checker(deltas):
+                msg = '%s leaked %s %s, sum=%s' % (
+                    test, deltas, item_name, sum(deltas))
+                failed = True
+                try:
+                    raise ReferenceLeakError(msg)
+                except Exception:
+                    exc_info = sys.exc_info()
+                if self.showAll:
+                    self.stream.write("%s = %r " % (item_name, deltas))
+                self.addFailure(test, exc_info)
+
+        if not failed:
+            super(RefleakTestResult, self).addSuccess(test)
+
+
+class RefleakTestRunner(runner.TextTestRunner):
+    resultclass = RefleakTestResult
+
+
+def _flatten_suite(test):
+    """Expand suite into list of tests
+    """
+    if isinstance(test, unittest.TestSuite):
+        tests = []
+        for x in test:
+            tests.extend(_flatten_suite(x))
+        return tests
+    else:
+        return [test]
+
+
+class ParallelTestResult(runner.TextTestResult):
+    """
+    A TestResult able to inject results from other results.
+    """
+
+    def add_results(self, result):
+        """
+        Add the results from the other *result* to this result.
+        """
+        self.stream.write(result.stream.getvalue())
+        self.stream.flush()
+        self.testsRun += result.testsRun
+        self.failures.extend(result.failures)
+        self.errors.extend(result.errors)
+        self.skipped.extend(result.skipped)
+        self.expectedFailures.extend(result.expectedFailures)
+        self.unexpectedSuccesses.extend(result.unexpectedSuccesses)
+
+
+class _MinimalResult(object):
+    """
+    A minimal, picklable TestResult-alike object.
+    """
+
+    __slots__ = (
+        'failures', 'errors', 'skipped', 'expectedFailures',
+        'unexpectedSuccesses', 'stream', 'shouldStop', 'testsRun')
+
+    def fixup_case(self, case):
+        """
+        Remove any unpicklable attributes from TestCase instance *case*.
+        """
+        # Python 3.3 doesn't reset this one.
+        case._outcomeForDoCleanups = None
+
+    def __init__(self, original_result):
+        for attr in self.__slots__:
+            setattr(self, attr, getattr(original_result, attr))
+        for case, _ in self.expectedFailures:
+            self.fixup_case(case)
+        for case, _ in self.errors:
+            self.fixup_case(case)
+        for case, _ in self.failures:
+            self.fixup_case(case)
+
+
+class _FakeStringIO(object):
+    """
+    A trivial picklable StringIO-alike for Python 2.
+    """
+
+    def __init__(self, value):
+        self._value = value
+
+    def getvalue(self):
+        return self._value
+
+
+class _MinimalRunner(object):
+    """
+    A minimal picklable object able to instantiate a runner in a
+    child process and run a test case with it.
+    """
+
+    def __init__(self, runner_cls, runner_args):
+        self.runner_cls = runner_cls
+        self.runner_args = runner_args
+
+    # Python 2 doesn't know how to pickle instance methods, so we use __call__
+    # instead.
+
+    def __call__(self, test):
+        # Executed in child process
+        kwargs = self.runner_args
+        # Force recording of output in a buffer (it will be printed out
+        # by the parent).
+        kwargs['stream'] = StringIO()
+        runner = self.runner_cls(**kwargs)
+        result = runner._makeResult()
+        # Avoid child tracebacks when Ctrl-C is pressed.
+        signals.installHandler()
+        signals.registerResult(result)
+        result.failfast = runner.failfast
+        result.buffer = runner.buffer
+        with self.cleanup_object(test):
+            test(result)
+        # HACK as cStringIO.StringIO isn't picklable in 2.x
+        result.stream = _FakeStringIO(result.stream.getvalue())
+        return _MinimalResult(result)
+
+    @contextlib.contextmanager
+    def cleanup_object(self, test):
+        """
+        A context manager which cleans up unwanted attributes on a test case
+        (or any other object).
+        """
+        vanilla_attrs = set(test.__dict__)
+        try:
+            yield test
+        finally:
+            spurious_attrs = set(test.__dict__) - vanilla_attrs
+            for name in spurious_attrs:
+                del test.__dict__[name]
+
+
+class ParallelTestRunner(runner.TextTestRunner):
+    """
+    A test runner which delegates the actual running to a pool of child
+    processes.
+    """
+
+    resultclass = ParallelTestResult
+
+    def __init__(self, runner_cls, **kwargs):
+        runner.TextTestRunner.__init__(self, **kwargs)
+        self.runner_cls = runner_cls
+        self.runner_args = kwargs
+
+    def _run_inner(self, result):
+        # We hijack TextTestRunner.run()'s inner logic by passing this
+        # method as if it were a test case.
+        child_runner = _MinimalRunner(self.runner_cls, self.runner_args)
+        pool = multiprocessing.Pool()
+        imap = pool.imap_unordered
+        try:
+            for child_result in imap(child_runner, self._test_list):
+                result.add_results(child_result)
+                if child_result.shouldStop:
+                    break
+            return result
+        finally:
+            # Kill the still active workers
+            pool.terminate()
+            pool.join()
+
+    def run(self, test):
+        self._test_list = _flatten_suite(test)
+        # This will call self._run_inner() on the created result object,
+        # and print out the detailed test results at the end.
+        return super(ParallelTestRunner, self).run(self._run_inner)
+
+
+try:
+    import faulthandler
+except ImportError:
+    pass
+else:
+    try:
+        # May fail in IPython Notebook with UnsupportedOperation
+        faulthandler.enable()
+    except BaseException as e:
+        msg = "Failed to enable faulthandler due to:\n{err}"
+        warnings.warn(msg.format(err=e))
diff --git a/lib/python3.11/site-packages/llvmlite/tests/refprune_proto.py b/lib/python3.11/site-packages/llvmlite/tests/refprune_proto.py
new file mode 100644
index 0000000000000000000000000000000000000000..3edc58f4b42b18e4280873491bb65a0e0635b1d0
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/refprune_proto.py
@@ -0,0 +1,329 @@
+"""
+Contains tests and a prototype implementation for the fanout algorithm in
+the LLVM refprune pass.
+"""
+
+try:
+    from graphviz import Digraph
+except ImportError:
+    pass
+from collections import defaultdict
+
+# The entry block. It's always the same.
+ENTRY = "A"
+
+
+# The following caseNN() functions returns a 3-tuple of
+# (nodes, edges, expected).
+# `nodes` maps BB nodes to incref/decref inside the block.
+# `edges` maps BB nodes to their successor BB.
+# `expected` maps BB-node with incref to a set of BB-nodes with the decrefs, or
+#            the value can be None, indicating invalid prune.
+
+def case1():
+    edges = {
+        "A": ["B"],
+        "B": ["C", "D"],
+        "C": [],
+        "D": ["E", "F"],
+        "E": ["G"],
+        "F": [],
+        "G": ["H", "I"],
+        "I": ["G", "F"],
+        "H": ["J", "K"],
+        "J": ["L", "M"],
+        "K": [],
+        "L": ["Z"],
+        "M": ["Z", "O", "P"],
+        "O": ["Z"],
+        "P": ["Z"],
+        "Z": [],
+    }
+    nodes = defaultdict(list)
+    nodes["D"] = ["incref"]
+    nodes["H"] = ["decref"]
+    nodes["F"] = ["decref", "decref"]
+    expected = {"D": {"H", "F"}}
+    return nodes, edges, expected
+
+
+def case2():
+    edges = {
+        "A": ["B", "C"],
+        "B": ["C"],
+        "C": [],
+    }
+    nodes = defaultdict(list)
+    nodes["A"] = ["incref"]
+    nodes["B"] = ["decref"]
+    nodes["C"] = ["decref"]
+    expected = {"A": None}
+    return nodes, edges, expected
+
+
+def case3():
+    nodes, edges, _ = case1()
+    # adds an invalid edge
+    edges["H"].append("F")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case4():
+    nodes, edges, _ = case1()
+    # adds an invalid edge
+    edges["H"].append("E")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case5():
+    nodes, edges, _ = case1()
+    # adds backedge to go before incref
+    edges["B"].append("I")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case6():
+    nodes, edges, _ = case1()
+    # adds backedge to go before incref
+    edges["I"].append("B")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case7():
+    nodes, edges, _ = case1()
+    # adds forward jump outside
+    edges["I"].append("M")
+    expected = {"D": None}
+    return nodes, edges, expected
+
+
+def case8():
+    edges = {
+        "A": ["B", "C"],
+        "B": ["C"],
+        "C": [],
+    }
+    nodes = defaultdict(list)
+    nodes["A"] = ["incref"]
+    nodes["C"] = ["decref"]
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case9():
+    nodes, edges, _ = case8()
+    # adds back edge
+    edges["C"].append("B")
+    expected = {"A": None}
+    return nodes, edges, expected
+
+
+def case10():
+    nodes, edges, _ = case8()
+    # adds back edge to A
+    edges["C"].append("A")
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case11():
+    nodes, edges, _ = case8()
+    edges["C"].append("D")
+    edges["D"] = []
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case12():
+    nodes, edges, _ = case8()
+    edges["C"].append("D")
+    edges["D"] = ["A"]
+    expected = {"A": {"C"}}
+    return nodes, edges, expected
+
+
+def case13():
+    nodes, edges, _ = case8()
+    edges["C"].append("D")
+    edges["D"] = ["B"]
+    expected = {"A": None}
+    return nodes, edges, expected
+
+
+def make_predecessor_map(edges):
+    d = defaultdict(set)
+    for src, outgoings in edges.items():
+        for dst in outgoings:
+            d[dst].add(src)
+    return d
+
+
+class FanoutAlgorithm:
+    def __init__(self, nodes, edges, verbose=False):
+        self.nodes = nodes
+        self.edges = edges
+        self.rev_edges = make_predecessor_map(edges)
+        self.print = print if verbose else self._null_print
+
+    def run(self):
+        return self.find_fanout_in_function()
+
+    def _null_print(self, *args, **kwargs):
+        pass
+
+    def find_fanout_in_function(self):
+        got = {}
+        for cur_node in self.edges:
+            for incref in (x for x in self.nodes[cur_node] if x == "incref"):
+                decref_blocks = self.find_fanout(cur_node)
+                self.print(">>", cur_node, "===", decref_blocks)
+                got[cur_node] = decref_blocks
+        return got
+
+    def find_fanout(self, head_node):
+        decref_blocks = self.find_decref_candidates(head_node)
+        self.print("candidates", decref_blocks)
+        if not decref_blocks:
+            return None
+        if not self.verify_non_overlapping(
+            head_node, decref_blocks, entry=ENTRY
+        ):
+            return None
+        return set(decref_blocks)
+
+    def verify_non_overlapping(self, head_node, decref_blocks, entry):
+        self.print("verify_non_overlapping".center(80, "-"))
+        # reverse walk for each decref_blocks
+        # they should end at head_node
+        todo = list(decref_blocks)
+        while todo:
+            cur_node = todo.pop()
+            visited = set()
+
+            workstack = [cur_node]
+            del cur_node
+            while workstack:
+                cur_node = workstack.pop()
+                self.print("cur_node", cur_node, "|", workstack)
+                if cur_node in visited:
+                    continue  # skip
+                if cur_node == entry:
+                    # Entry node
+                    self.print(
+                        "!! failed because we arrived at entry", cur_node
+                    )
+                    return False
+                visited.add(cur_node)
+                # check all predecessors
+                self.print(
+                    f"   {cur_node} preds {self.get_predecessors(cur_node)}"
+                )
+                for pred in self.get_predecessors(cur_node):
+                    if pred in decref_blocks:
+                        # reject because there's a predecessor in decref_blocks
+                        self.print(
+                            "!! reject because predecessor in decref_blocks"
+                        )
+                        return False
+                    if pred != head_node:
+
+                        workstack.append(pred)
+
+        return True
+
+    def get_successors(self, node):
+        return tuple(self.edges[node])
+
+    def get_predecessors(self, node):
+        return tuple(self.rev_edges[node])
+
+    def has_decref(self, node):
+        return "decref" in self.nodes[node]
+
+    def walk_child_for_decref(
+        self, cur_node, path_stack, decref_blocks, depth=10
+    ):
+        indent = " " * len(path_stack)
+        self.print(indent, "walk", path_stack, cur_node)
+        if depth <= 0:
+            return False  # missing
+        if cur_node in path_stack:
+            if cur_node == path_stack[0]:
+                return False  # reject interior node backedge
+            return True  # skip
+        if self.has_decref(cur_node):
+            decref_blocks.add(cur_node)
+            self.print(indent, "found decref")
+            return True
+
+        depth -= 1
+        path_stack += (cur_node,)
+        found = False
+        for child in self.get_successors(cur_node):
+            if not self.walk_child_for_decref(
+                child, path_stack, decref_blocks
+            ):
+                found = False
+                break
+            else:
+                found = True
+
+        self.print(indent, f"ret {found}")
+        return found
+
+    def find_decref_candidates(self, cur_node):
+        # Forward pass
+        self.print("find_decref_candidates".center(80, "-"))
+        path_stack = (cur_node,)
+        found = False
+        decref_blocks = set()
+        for child in self.get_successors(cur_node):
+            if not self.walk_child_for_decref(
+                child, path_stack, decref_blocks
+            ):
+                found = False
+                break
+            else:
+                found = True
+        if not found:
+            return set()
+        else:
+            return decref_blocks
+
+
+def check_once():
+    nodes, edges, expected = case13()
+
+    # Render graph
+    G = Digraph()
+    for node in edges:
+        G.node(node, shape="rect", label=f"{node}\n" + r"\l".join(nodes[node]))
+    for node, children in edges.items():
+        for child in children:
+            G.edge(node, child)
+
+    G.view()
+
+    algo = FanoutAlgorithm(nodes, edges, verbose=True)
+    got = algo.run()
+    assert expected == got
+
+
+def check_all():
+    for k, fn in list(globals().items()):
+        if k.startswith("case"):
+            print(f"{fn}".center(80, "-"))
+            nodes, edges, expected = fn()
+            algo = FanoutAlgorithm(nodes, edges)
+            got = algo.run()
+            assert expected == got
+    print("ALL PASSED")
+
+
+if __name__ == "__main__":
+    # check_once()
+    check_all()
diff --git a/lib/python3.11/site-packages/llvmlite/tests/test_binding.py b/lib/python3.11/site-packages/llvmlite/tests/test_binding.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a62c4564a8bfbc691cb725a359fa7c301807af8
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/test_binding.py
@@ -0,0 +1,2431 @@
+import ctypes
+import threading
+from ctypes import CFUNCTYPE, c_int, c_int32
+from ctypes.util import find_library
+import gc
+import locale
+import os
+import platform
+import re
+import subprocess
+import sys
+import unittest
+from contextlib import contextmanager
+from tempfile import mkstemp
+
+from llvmlite import ir
+from llvmlite import binding as llvm
+from llvmlite.binding import ffi
+from llvmlite.tests import TestCase
+
+
+# arvm7l needs extra ABI symbols to link successfully
+if platform.machine() == 'armv7l':
+    llvm.load_library_permanently('libgcc_s.so.1')
+
+
+def no_de_locale():
+    cur = locale.setlocale(locale.LC_ALL)
+    try:
+        locale.setlocale(locale.LC_ALL, 'de_DE')
+    except locale.Error:
+        return True
+    else:
+        return False
+    finally:
+        locale.setlocale(locale.LC_ALL, cur)
+
+
+asm_sum = r"""
+    ; ModuleID = '<string>'
+    source_filename = "asm_sum.c"
+    target triple = "{triple}"
+    %struct.glob_type = type {{ i64, [2 x i64]}}
+
+    @glob = global i32 0
+    @glob_b = global i8 0
+    @glob_f = global float 1.5
+    @glob_struct = global %struct.glob_type {{i64 0, [2 x i64] [i64 0, i64 0]}}
+
+    define i32 @sum(i32 %.1, i32 %.2) {{
+      %.3 = add i32 %.1, %.2
+      %.4 = add i32 0, %.3
+      ret i32 %.4
+    }}
+    """
+
+asm_sum2 = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define i32 @sum(i32 %.1, i32 %.2) {{
+      %.3 = add i32 %.1, %.2
+      ret i32 %.3
+    }}
+    """
+
+asm_sum3 = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define i64 @sum(i64 %.1, i64 %.2) {{
+      %.3 = add i64 %.1, %.2
+      %.4 = add i64 5, %.3
+      %.5 = add i64 -5, %.4
+      ret i64 %.5
+    }}
+    """
+
+asm_mul = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+    @mul_glob = global i32 0
+
+    define i32 @mul(i32 %.1, i32 %.2) {{
+      %.3 = mul i32 %.1, %.2
+      ret i32 %.3
+    }}
+    """
+
+asm_square_sum = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+    @mul_glob = global i32 0
+
+    declare i32 @sum(i32, i32)
+    define i32 @square_sum(i32 %.1, i32 %.2) {{
+      %.3 = call i32 @sum(i32 %.1, i32 %.2)
+      %.4 = mul i32 %.3, %.3
+      ret i32 %.4
+    }}
+    """
+
+asm_getversion = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    declare i8* @Py_GetVersion()
+
+    define void @getversion(i32 %.1, i32 %.2) {{
+      %1 = call i8* @Py_GetVersion()
+      ret void
+    }}
+    """
+
+if platform.python_implementation() == 'PyPy':
+    asm_getversion = asm_getversion.replace('Py_GetVersion', 'PyPy_GetVersion')
+
+# `fadd` used on integer inputs
+asm_parse_error = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define i32 @sum(i32 %.1, i32 %.2) {{
+      %.3 = fadd i32 %.1, %.2
+      ret i32 %.3
+    }}
+    """
+
+# "%.bug" definition references itself
+asm_verification_fail = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @sum() {{
+      %.bug = add i32 1, %.bug
+      ret void
+    }}
+    """
+
+asm_sum_declare = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    declare i32 @sum(i32 %.1, i32 %.2)
+    """
+
+asm_double_inaccurate = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo() {{
+      %const = fadd fp128 0xLF3CB1CCF26FBC178452FB4EC7F91DEAD, 0xL00000000000000000000000000000001
+      ret void
+    }}
+    """  # noqa E501
+
+asm_double_locale = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo() {{
+      %const = fadd double 0.0, 3.14
+      ret void
+    }}
+    """
+
+
+asm_inlineasm = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo() {{
+      call void asm sideeffect "nop", ""()
+      ret void
+    }}
+    """
+
+asm_inlineasm2 = """
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @inlineme() {{
+        ret void
+    }}
+
+    define i32 @caller(i32 %.1, i32 %.2) {{
+    entry:
+      %stack = alloca i32
+      store i32 %.1, i32* %stack
+      br label %main
+    main:
+      %loaded = load i32, i32* %stack
+      %.3 = add i32 %loaded, %.2
+      %.4 = add i32 0, %.3
+      call void @inlineme()
+      ret i32 %.4
+    }}
+"""
+
+asm_inlineasm3 = """
+; ModuleID = 'test.c'
+source_filename = "test.c"
+target triple = "{triple}"
+
+; Function Attrs: noinline nounwind optnone ssp uwtable
+define void @inlineme() noinline !dbg !15 {{
+  ret void, !dbg !18
+}}
+
+; Function Attrs: noinline nounwind optnone ssp uwtable
+define i32 @foo(i32 %0, i32 %1) !dbg !19 {{
+  %3 = alloca i32, align 4
+  %4 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  call void @llvm.dbg.declare(metadata i32* %3, metadata !23, metadata !DIExpression()), !dbg !24
+  store i32 %1, i32* %4, align 4
+  call void @llvm.dbg.declare(metadata i32* %4, metadata !25, metadata !DIExpression()), !dbg !26
+  call void @inlineme(), !dbg !27
+  %5 = load i32, i32* %3, align 4, !dbg !28
+  %6 = load i32, i32* %4, align 4, !dbg !29
+  %7 = add nsw i32 %5, %6, !dbg !30
+  ret i32 %7, !dbg !31
+}}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #1 = {{ nofree nosync nounwind readnone speculatable willreturn }}
+
+!llvm.module.flags = !{{!1, !2, !3, !4, !5, !6, !7, !8, !9, !10}}
+!llvm.dbg.cu = !{{!11}}
+!llvm.ident = !{{!14}}
+
+!0 = !{{i32 2, !"SDK Version", [2 x i32] [i32 12, i32 3]}}
+!1 = !{{i32 7, !"Dwarf Version", i32 4}}
+!2 = !{{i32 2, !"Debug Info Version", i32 3}}
+!3 = !{{i32 1, !"wchar_size", i32 4}}
+!4 = !{{i32 1, !"branch-target-enforcement", i32 0}}
+!5 = !{{i32 1, !"sign-return-address", i32 0}}
+!6 = !{{i32 1, !"sign-return-address-all", i32 0}}
+!7 = !{{i32 1, !"sign-return-address-with-bkey", i32 0}}
+!8 = !{{i32 7, !"PIC Level", i32 2}}
+!9 = !{{i32 7, !"uwtable", i32 1}}
+!10 = !{{i32 7, !"frame-pointer", i32 1}}
+!11 = distinct !DICompileUnit(language: DW_LANG_C99, file: !12, producer: "Apple clang version 13.1.6 (clang-1316.0.21.2.3)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !13, splitDebugInlining: false, nameTableKind: None, sysroot: "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk", sdk: "MacOSX.sdk")
+!12 = !DIFile(filename: "test.c", directory: "/")
+!13 = !{{}}
+!14 = !{{!"Apple clang version 13.1.6 (clang-1316.0.21.2.3)"}}
+!15 = distinct !DISubprogram(name: "inlineme", scope: !12, file: !12, line: 1, type: !16, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !11, retainedNodes: !13)
+!16 = !DISubroutineType(types: !17)
+!17 = !{{null}}
+!18 = !DILocation(line: 1, column: 22, scope: !15)
+!19 = distinct !DISubprogram(name: "foo", scope: !12, file: !12, line: 3, type: !20, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !11, retainedNodes: !13)
+!20 = !DISubroutineType(types: !21)
+!21 = !{{!22, !22, !22}}
+!22 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!23 = !DILocalVariable(name: "a", arg: 1, scope: !19, file: !12, line: 3, type: !22)
+!24 = !DILocation(line: 3, column: 13, scope: !19)
+!25 = !DILocalVariable(name: "b", arg: 2, scope: !19, file: !12, line: 3, type: !22)
+!26 = !DILocation(line: 3, column: 20, scope: !19)
+!27 = !DILocation(line: 4, column: 5, scope: !19)
+!28 = !DILocation(line: 5, column: 12, scope: !19)
+!29 = !DILocation(line: 5, column: 16, scope: !19)
+!30 = !DILocation(line: 5, column: 14, scope: !19)
+!31 = !DILocation(line: 5, column: 5, scope: !19)
+"""  # noqa E501
+
+licm_asm = r"""
+; ModuleID = "<string>"
+target triple = "{triple}"
+
+define double @licm(i32 %0) {{
+  %2 = alloca i32, align 4
+  %3 = alloca double, align 8
+  %4 = alloca i32, align 4
+  %5 = alloca double, align 8
+  store i32 %0, i32* %2, align 4
+  store double 0.000000e+00, double* %3, align 8
+  store i32 0, i32* %4, align 4
+  br label %6
+
+6:                                                ; preds = %14, %1
+  %7 = load i32, i32* %4, align 4
+  %8 = load i32, i32* %2, align 4
+  %9 = icmp slt i32 %7, %8
+  br i1 %9, label %10, label %17
+
+10:                                               ; preds = %6
+  store double 7.000000e+00, double* %5, align 8
+  %11 = load double, double* %5, align 8
+  %12 = load double, double* %3, align 8
+  %13 = fadd double %12, %11
+  store double %13, double* %3, align 8
+  br label %14
+
+14:                                               ; preds = %10
+  %15 = load i32, i32* %4, align 4
+  %16 = add nsw i32 %15, 1
+  store i32 %16, i32* %4, align 4
+  br label %6
+
+17:                                               ; preds = %6
+  %18 = load double, double* %3, align 8
+  ret double %18
+}}
+"""  # noqa E501
+
+asm_global_ctors = r"""
+    ; ModuleID = "<string>"
+    target triple = "{triple}"
+
+    @A = global i32 undef
+
+    define void @ctor_A()
+    {{
+      store i32 10, i32* @A
+      ret void
+    }}
+
+    define void @dtor_A()
+    {{
+      store i32 20, i32* @A
+      ret void
+    }}
+
+    define i32 @foo()
+    {{
+      %.2 = load i32, i32* @A
+      %.3 = add i32 %.2, 2
+      ret i32 %.3
+    }}
+
+    @llvm.global_ctors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @ctor_A, i8* null}}]
+    @llvm.global_dtors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @dtor_A, i8* null}}]
+    """  # noqa E501
+
+asm_ext_ctors = r"""
+    ; ModuleID = "<string>"
+    target triple = "{triple}"
+
+    @A = external global i32
+
+    define void @ctor_A()
+    {{
+      store i32 10, i32* @A
+      ret void
+    }}
+
+    define void @dtor_A()
+    {{
+      store i32 20, i32* @A
+      ret void
+    }}
+
+    define i32 @foo()
+    {{
+      %.2 = load i32, i32* @A
+      %.3 = add i32 %.2, 2
+      ret i32 %.3
+    }}
+
+    @llvm.global_ctors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @ctor_A, i8* null}}]
+    @llvm.global_dtors = appending global [1 x {{i32, void ()*, i8*}}] [{{i32, void ()*, i8*}} {{i32 0, void ()* @dtor_A, i8* null}}]
+    """  # noqa E501
+
+
+asm_nonalphanum_blocklabel = """; ModuleID = ""
+target triple = "unknown-unknown-unknown"
+target datalayout = ""
+
+define i32 @"foo"()
+{
+"<>!*''#":
+  ret i32 12345
+}
+"""  # noqa W291 # trailing space needed for match later
+
+
+asm_null_constant = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define void @foo(i64* %.1) {{
+      ret void
+    }}
+
+    define void @bar() {{
+      call void @foo(i64* null)
+      ret void
+    }}
+"""
+
+
+riscv_asm_ilp32 = [
+    'addi\tsp, sp, -16',
+    'sw\ta1, 8(sp)',
+    'sw\ta2, 12(sp)',
+    'fld\tft0, 8(sp)',
+    'fmv.w.x\tft1, a0',
+    'fcvt.d.s\tft1, ft1',
+    'fadd.d\tft0, ft1, ft0',
+    'fsd\tft0, 8(sp)',
+    'lw\ta0, 8(sp)',
+    'lw\ta1, 12(sp)',
+    'addi\tsp, sp, 16',
+    'ret'
+]
+
+
+riscv_asm_ilp32f = [
+    'addi\tsp, sp, -16',
+    'sw\ta0, 8(sp)',
+    'sw\ta1, 12(sp)',
+    'fld\tft0, 8(sp)',
+    'fcvt.d.s\tft1, fa0',
+    'fadd.d\tft0, ft1, ft0',
+    'fsd\tft0, 8(sp)',
+    'lw\ta0, 8(sp)',
+    'lw\ta1, 12(sp)',
+    'addi\tsp, sp, 16',
+    'ret'
+]
+
+
+riscv_asm_ilp32d = [
+    'fcvt.d.s\tft0, fa0',
+    'fadd.d\tfa0, ft0, fa1',
+    'ret'
+]
+
+
+asm_attributes = r"""
+declare void @a_readonly_func(i8 *) readonly
+
+declare i8* @a_arg0_return_func(i8* returned, i32*)
+"""
+
+
+# This produces the following output from objdump:
+#
+# $ objdump -D 632.elf
+#
+# 632.elf:     file format elf64-x86-64
+#
+#
+# Disassembly of section .text:
+#
+# 0000000000000000 <__arybo>:
+#    0:	48 c1 e2 20          	shl    $0x20,%rdx
+#    4:	48 09 c2             	or     %rax,%rdx
+#    7:	48 89 d0             	mov    %rdx,%rax
+#    a:	48 c1 c0 3d          	rol    $0x3d,%rax
+#    e:	48 31 d0             	xor    %rdx,%rax
+#   11:	48 b9 01 20 00 04 80 	movabs $0x7010008004002001,%rcx
+#   18:	00 10 70
+#   1b:	48 0f af c8          	imul   %rax,%rcx
+
+issue_632_elf = \
+    "7f454c4602010100000000000000000001003e00010000000000000000000000000000" \
+    "0000000000e0000000000000000000000040000000000040000500010048c1e2204809" \
+    "c24889d048c1c03d4831d048b90120000480001070480fafc800000000000000000000" \
+    "0000000000000000000000000000002f0000000400f1ff000000000000000000000000" \
+    "00000000070000001200020000000000000000001f00000000000000002e7465787400" \
+    "5f5f617279626f002e6e6f74652e474e552d737461636b002e737472746162002e7379" \
+    "6d746162003c737472696e673e00000000000000000000000000000000000000000000" \
+    "0000000000000000000000000000000000000000000000000000000000000000000000" \
+    "00000000000000001f0000000300000000000000000000000000000000000000a80000" \
+    "0000000000380000000000000000000000000000000100000000000000000000000000" \
+    "000001000000010000000600000000000000000000000000000040000000000000001f" \
+    "000000000000000000000000000000100000000000000000000000000000000f000000" \
+    "01000000000000000000000000000000000000005f0000000000000000000000000000" \
+    "0000000000000000000100000000000000000000000000000027000000020000000000" \
+    "0000000000000000000000000000600000000000000048000000000000000100000002" \
+    "00000008000000000000001800000000000000"
+
+
+issue_632_text = \
+    "48c1e2204809c24889d048c1c03d4831d048b90120000480001070480fafc8"
+
+
+asm_tli_exp2 = r"""
+; ModuleID = '<lambda>'
+source_filename = "<string>"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+declare float @llvm.exp2.f32(float %casted)
+
+define float @foo(i16 %arg) {
+entry:
+  %casted = sitofp i16 %arg to float
+  %ret = call float @llvm.exp2.f32(float %casted)
+  ret float %ret
+}
+"""  # noqa E501
+
+
+class BaseTest(TestCase):
+
+    def setUp(self):
+        llvm.initialize()
+        llvm.initialize_native_target()
+        llvm.initialize_native_asmprinter()
+        gc.collect()
+        self.old_garbage = gc.garbage[:]
+        gc.garbage[:] = []
+
+    def tearDown(self):
+        # Test that no uncollectable objects were created
+        # (llvmlite objects have a __del__ so a reference cycle could
+        # create some).
+        gc.collect()
+        self.assertEqual(gc.garbage, [])
+        # This will probably put any existing garbage in gc.garbage again
+        del self.old_garbage
+
+    def module(self, asm=asm_sum, context=None):
+        asm = asm.format(triple=llvm.get_default_triple())
+        mod = llvm.parse_assembly(asm, context)
+        return mod
+
+    def glob(self, name='glob', mod=None):
+        if mod is None:
+            mod = self.module()
+        return mod.get_global_variable(name)
+
+    def target_machine(self, *, jit):
+        target = llvm.Target.from_default_triple()
+        return target.create_target_machine(jit=jit)
+
+
+class TestDependencies(BaseTest):
+    """
+    Test DLL dependencies are within a certain expected set.
+    """
+
+    @unittest.skipUnless(sys.platform.startswith('linux'),
+                         "Linux-specific test")
+    @unittest.skipUnless(os.environ.get('LLVMLITE_DIST_TEST'),
+                         "Distribution-specific test")
+    def test_linux(self):
+        lib_path = ffi.lib._name
+        env = os.environ.copy()
+        env['LANG'] = 'C'
+        p = subprocess.Popen(["objdump", "-p", lib_path],
+                             stdout=subprocess.PIPE, env=env)
+        out, _ = p.communicate()
+        self.assertEqual(0, p.returncode)
+        # Parse library dependencies
+        lib_pat = re.compile(r'^([-_a-zA-Z0-9]+)\.so(?:\.\d+){0,3}$')
+        deps = set()
+        for line in out.decode().splitlines():
+            parts = line.split()
+            if parts and parts[0] == 'NEEDED':
+                dep = parts[1]
+                m = lib_pat.match(dep)
+                if len(parts) != 2 or not m:
+                    self.fail("invalid NEEDED line: %r" % (line,))
+                deps.add(m.group(1))
+        # Sanity check that our dependencies were parsed ok
+        if 'libc' not in deps or 'libpthread' not in deps:
+            self.fail("failed parsing dependencies? got %r" % (deps,))
+        # Ensure all dependencies are expected
+        allowed = set(['librt', 'libdl', 'libpthread', 'libz', 'libm',
+                       'libgcc_s', 'libc', 'ld-linux', 'ld64'])
+        if platform.python_implementation() == 'PyPy':
+            allowed.add('libtinfo')
+
+        for dep in deps:
+            if not dep.startswith('ld-linux-') and dep not in allowed:
+                self.fail("unexpected dependency %r in %r" % (dep, deps))
+
+
+class TestRISCVABI(BaseTest):
+    """
+    Test calling convention of floating point arguments of RISC-V
+    using different ABI.
+    """
+    triple = "riscv32-unknown-linux"
+
+    def setUp(self):
+        super().setUp()
+        llvm.initialize_all_targets()
+        llvm.initialize_all_asmprinters()
+
+    def check_riscv_target(self):
+        try:
+            llvm.Target.from_triple(self.triple)
+        except RuntimeError as e:
+            if "No available targets are compatible with triple" in str(e):
+                self.skipTest("RISCV target unsupported by linked LLVM.")
+            else:
+                raise e
+
+    def riscv_target_machine(self, **kwarg):
+        lltarget = llvm.Target.from_triple(self.triple)
+        return lltarget.create_target_machine(**kwarg)
+
+    def fpadd_ll_module(self):
+        f64 = ir.DoubleType()
+        f32 = ir.FloatType()
+        fnty = ir.FunctionType(f64, (f32, f64))
+        module = ir.Module()
+        func = ir.Function(module, fnty, name="fpadd")
+        block = func.append_basic_block()
+        builder = ir.IRBuilder(block)
+        a, b = func.args
+        arg0 = builder.fpext(a, f64)
+        result = builder.fadd(arg0, b)
+        builder.ret(result)
+
+        llmod = llvm.parse_assembly(str(module))
+        llmod.verify()
+        return llmod
+
+    def break_up_asm(self, asm):
+        asm_list = []
+        for line in asm.splitlines():
+            s_line = line.strip()
+            if not (s_line.startswith(".") or s_line.startswith("fpadd")
+                    or s_line == ""):
+                asm_list.append(s_line)
+        return asm_list
+
+    def test_rv32d_ilp32(self):
+        self.check_riscv_target()
+        llmod = self.fpadd_ll_module()
+        target = self.riscv_target_machine(features="+f,+d")
+        self.assertEqual(self.break_up_asm(target.emit_assembly(llmod)),
+                         riscv_asm_ilp32)
+
+    def test_rv32d_ilp32f(self):
+        self.check_riscv_target()
+        llmod = self.fpadd_ll_module()
+        target = self.riscv_target_machine(features="+f,+d", abiname="ilp32f")
+        self.assertEqual(self.break_up_asm(target.emit_assembly(llmod)),
+                         riscv_asm_ilp32f)
+
+    def test_rv32d_ilp32d(self):
+        self.check_riscv_target()
+        llmod = self.fpadd_ll_module()
+        target = self.riscv_target_machine(features="+f,+d", abiname="ilp32d")
+        self.assertEqual(self.break_up_asm(target.emit_assembly(llmod)),
+                         riscv_asm_ilp32d)
+
+
+class TestMisc(BaseTest):
+    """
+    Test miscellaneous functions in llvm.binding.
+    """
+
+    def test_parse_assembly(self):
+        self.module(asm_sum)
+
+    def test_parse_assembly_error(self):
+        with self.assertRaises(RuntimeError) as cm:
+            self.module(asm_parse_error)
+        s = str(cm.exception)
+        self.assertIn("parsing error", s)
+        self.assertIn("invalid operand type", s)
+
+    def test_nonalphanum_block_name(self):
+        mod = ir.Module()
+        ft = ir.FunctionType(ir.IntType(32), [])
+        fn = ir.Function(mod, ft, "foo")
+        bd = ir.IRBuilder(fn.append_basic_block(name="<>!*''#"))
+        bd.ret(ir.Constant(ir.IntType(32), 12345))
+        asm = str(mod)
+        self.assertEqual(asm, asm_nonalphanum_blocklabel)
+
+    def test_global_context(self):
+        gcontext1 = llvm.context.get_global_context()
+        gcontext2 = llvm.context.get_global_context()
+        assert gcontext1 == gcontext2
+
+    def test_dylib_symbols(self):
+        llvm.add_symbol("__xyzzy", 1234)
+        llvm.add_symbol("__xyzzy", 5678)
+        addr = llvm.address_of_symbol("__xyzzy")
+        self.assertEqual(addr, 5678)
+        addr = llvm.address_of_symbol("__foobar")
+        self.assertIs(addr, None)
+
+    def test_get_default_triple(self):
+        triple = llvm.get_default_triple()
+        self.assertIsInstance(triple, str)
+        self.assertTrue(triple)
+
+    def test_get_process_triple(self):
+        # Sometimes we get synonyms for PPC
+        def normalize_ppc(arch):
+            if arch == 'powerpc64le':
+                return 'ppc64le'
+            else:
+                return arch
+
+        triple = llvm.get_process_triple()
+        default = llvm.get_default_triple()
+        self.assertIsInstance(triple, str)
+        self.assertTrue(triple)
+
+        default_arch = normalize_ppc(default.split('-')[0])
+        triple_arch = normalize_ppc(triple.split('-')[0])
+        # Arch must be equal
+        self.assertEqual(default_arch, triple_arch)
+
+    def test_get_host_cpu_features(self):
+        features = llvm.get_host_cpu_features()
+        # Check the content of `features`
+        self.assertIsInstance(features, dict)
+        self.assertIsInstance(features, llvm.FeatureMap)
+        for k, v in features.items():
+            self.assertIsInstance(k, str)
+            self.assertTrue(k)  # single feature string cannot be empty
+            self.assertIsInstance(v, bool)
+        self.assertIsInstance(features.flatten(), str)
+
+        re_term = r"[+\-][a-zA-Z0-9\._-]+"
+        regex = r"^({0}|{0}(,{0})*)?$".format(re_term)
+        # quick check for our regex
+        self.assertIsNotNone(re.match(regex, ""))
+        self.assertIsNotNone(re.match(regex, "+aa"))
+        self.assertIsNotNone(re.match(regex, "+a,-bb"))
+        # check CpuFeature.flatten()
+        if len(features) == 0:
+            self.assertEqual(features.flatten(), "")
+        else:
+            self.assertIsNotNone(re.match(regex, features.flatten()))
+
+    def test_get_host_cpu_name(self):
+        cpu = llvm.get_host_cpu_name()
+        self.assertIsInstance(cpu, str)
+        self.assertTrue(cpu)
+
+    def test_initfini(self):
+        code = """if 1:
+            from llvmlite import binding as llvm
+
+            llvm.initialize()
+            llvm.initialize_native_target()
+            llvm.initialize_native_asmprinter()
+            llvm.initialize_all_targets()
+            llvm.initialize_all_asmprinters()
+            llvm.shutdown()
+            """
+        subprocess.check_call([sys.executable, "-c", code])
+
+    def test_set_option(self):
+        # We cannot set an option multiple times (LLVM would exit() the
+        # process), so run the code in a subprocess.
+        code = """if 1:
+            from llvmlite import binding as llvm
+
+            llvm.set_option("progname", "-debug-pass=Disabled")
+            """
+        subprocess.check_call([sys.executable, "-c", code])
+
+    def test_version(self):
+        major, minor, patch = llvm.llvm_version_info
+        # one of these can be valid
+        valid = [(14, )]
+        self.assertIn((major,), valid)
+        self.assertIn(patch, range(10))
+
+    def test_check_jit_execution(self):
+        llvm.check_jit_execution()
+
+    @unittest.skipIf(no_de_locale(), "Locale not available")
+    def test_print_double_locale(self):
+        m = self.module(asm_double_locale)
+        expect = str(m)
+        # Change the locale so that comma is used as decimal-point
+        # to trigger the LLVM bug (llvmlite issue #80)
+        locale.setlocale(locale.LC_ALL, 'de_DE')
+        # The LLVM bug is trigged by print the module with double constant
+        got = str(m)
+        # Changing the locale should not affect the LLVM IR
+        self.assertEqual(expect, got)
+
+    def test_no_accidental_warnings(self):
+        code = "from llvmlite import binding"
+        flags = "-Werror"
+        cmdargs = [sys.executable, flags, "-c", code]
+        subprocess.check_call(cmdargs)
+
+
+class TestModuleRef(BaseTest):
+
+    def test_str(self):
+        mod = self.module()
+        s = str(mod).strip()
+        self.assertTrue(s.startswith('; ModuleID ='), s)
+
+    def test_close(self):
+        mod = self.module()
+        str(mod)
+        mod.close()
+        with self.assertRaises(ctypes.ArgumentError):
+            str(mod)
+        mod.close()
+
+    def test_with(self):
+        mod = self.module()
+        str(mod)
+        with mod:
+            str(mod)
+        with self.assertRaises(ctypes.ArgumentError):
+            str(mod)
+        with self.assertRaises(RuntimeError):
+            with mod:
+                pass
+
+    def test_name(self):
+        mod = self.module()
+        mod.name = "foo"
+        self.assertEqual(mod.name, "foo")
+        mod.name = "bar"
+        self.assertEqual(mod.name, "bar")
+
+    def test_source_file(self):
+        mod = self.module()
+        self.assertEqual(mod.source_file, "asm_sum.c")
+
+    def test_data_layout(self):
+        mod = self.module()
+        s = mod.data_layout
+        self.assertIsInstance(s, str)
+        mod.data_layout = s
+        self.assertEqual(s, mod.data_layout)
+
+    def test_triple(self):
+        mod = self.module()
+        s = mod.triple
+        self.assertEqual(s, llvm.get_default_triple())
+        mod.triple = ''
+        self.assertEqual(mod.triple, '')
+
+    def test_verify(self):
+        # Verify successful
+        mod = self.module()
+        self.assertIs(mod.verify(), None)
+        # Verify failed
+        mod = self.module(asm_verification_fail)
+        with self.assertRaises(RuntimeError) as cm:
+            mod.verify()
+        s = str(cm.exception)
+        self.assertIn("%.bug = add i32 1, %.bug", s)
+
+    def test_get_function(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        self.assertIsInstance(fn, llvm.ValueRef)
+        self.assertEqual(fn.name, "sum")
+
+        with self.assertRaises(NameError):
+            mod.get_function("foo")
+
+        # Check that fn keeps the module instance alive
+        del mod
+        str(fn.module)
+
+    def test_get_struct_type(self):
+        mod = self.module()
+        st_ty = mod.get_struct_type("struct.glob_type")
+        self.assertEqual(st_ty.name, "struct.glob_type")
+        # also match struct names of form "%struct.glob_type.{some_index}"
+        self.assertIsNotNone(re.match(
+            r'%struct\.glob_type(\.[\d]+)? = type { i64, \[2 x i64\] }',
+            str(st_ty)))
+
+        with self.assertRaises(NameError):
+            mod.get_struct_type("struct.doesnt_exist")
+
+    def test_get_global_variable(self):
+        mod = self.module()
+        gv = mod.get_global_variable("glob")
+        self.assertIsInstance(gv, llvm.ValueRef)
+        self.assertEqual(gv.name, "glob")
+
+        with self.assertRaises(NameError):
+            mod.get_global_variable("bar")
+
+        # Check that gv keeps the module instance alive
+        del mod
+        str(gv.module)
+
+    def test_global_variables(self):
+        mod = self.module()
+        it = mod.global_variables
+        del mod
+        globs = sorted(it, key=lambda value: value.name)
+        self.assertEqual(len(globs), 4)
+        self.assertEqual([g.name for g in globs],
+                         ["glob", "glob_b", "glob_f", "glob_struct"])
+
+    def test_functions(self):
+        mod = self.module()
+        it = mod.functions
+        del mod
+        funcs = list(it)
+        self.assertEqual(len(funcs), 1)
+        self.assertEqual(funcs[0].name, "sum")
+
+    def test_structs(self):
+        mod = self.module()
+        it = mod.struct_types
+        del mod
+        structs = list(it)
+        self.assertEqual(len(structs), 1)
+        self.assertIsNotNone(re.match(r'struct\.glob_type(\.[\d]+)?',
+                                      structs[0].name))
+        self.assertIsNotNone(re.match(
+            r'%struct\.glob_type(\.[\d]+)? = type { i64, \[2 x i64\] }',
+            str(structs[0])))
+
+    def test_link_in(self):
+        dest = self.module()
+        src = self.module(asm_mul)
+        dest.link_in(src)
+        self.assertEqual(
+            sorted(f.name for f in dest.functions), ["mul", "sum"])
+        dest.get_function("mul")
+        dest.close()
+        with self.assertRaises(ctypes.ArgumentError):
+            src.get_function("mul")
+
+    def test_link_in_preserve(self):
+        dest = self.module()
+        src2 = self.module(asm_mul)
+        dest.link_in(src2, preserve=True)
+        self.assertEqual(
+            sorted(f.name for f in dest.functions), ["mul", "sum"])
+        dest.close()
+        self.assertEqual(sorted(f.name for f in src2.functions), ["mul"])
+        src2.get_function("mul")
+
+    def test_link_in_error(self):
+        # Raise an error by trying to link two modules with the same global
+        # definition "sum".
+        dest = self.module()
+        src = self.module(asm_sum2)
+        with self.assertRaises(RuntimeError) as cm:
+            dest.link_in(src)
+        self.assertIn("symbol multiply defined", str(cm.exception))
+
+    def test_as_bitcode(self):
+        mod = self.module()
+        bc = mod.as_bitcode()
+        # Refer to http://llvm.org/docs/doxygen/html/ReaderWriter_8h_source.html#l00064  # noqa E501
+        # and http://llvm.org/docs/doxygen/html/ReaderWriter_8h_source.html#l00092  # noqa E501
+        bitcode_wrapper_magic = b'\xde\xc0\x17\x0b'
+        bitcode_magic = b'BC'
+        self.assertTrue(bc.startswith(bitcode_magic) or
+                        bc.startswith(bitcode_wrapper_magic))
+
+    def test_parse_bitcode_error(self):
+        with self.assertRaises(RuntimeError) as cm:
+            llvm.parse_bitcode(b"")
+        self.assertIn("LLVM bitcode parsing error", str(cm.exception))
+        # for llvm < 9
+        if llvm.llvm_version_info[0] < 9:
+            self.assertIn("Invalid bitcode signature", str(cm.exception))
+        else:
+            self.assertIn(
+                "file too small to contain bitcode header", str(cm.exception),
+            )
+
+    def test_bitcode_roundtrip(self):
+        # create a new context to avoid struct renaming
+        context1 = llvm.create_context()
+        bc = self.module(context=context1).as_bitcode()
+        context2 = llvm.create_context()
+        mod = llvm.parse_bitcode(bc, context2)
+        self.assertEqual(mod.as_bitcode(), bc)
+
+        mod.get_function("sum")
+        mod.get_global_variable("glob")
+
+    def test_cloning(self):
+        m = self.module()
+        cloned = m.clone()
+        self.assertIsNot(cloned, m)
+        self.assertEqual(cloned.as_bitcode(), m.as_bitcode())
+
+
+class JITTestMixin(object):
+    """
+    Mixin for ExecutionEngine tests.
+    """
+
+    def get_sum(self, ee, func_name="sum"):
+        ee.finalize_object()
+        cfptr = ee.get_function_address(func_name)
+        self.assertTrue(cfptr)
+        return CFUNCTYPE(c_int, c_int, c_int)(cfptr)
+
+    def test_run_code(self):
+        mod = self.module()
+        with self.jit(mod) as ee:
+            cfunc = self.get_sum(ee)
+            res = cfunc(2, -5)
+            self.assertEqual(-3, res)
+
+    def test_close(self):
+        ee = self.jit(self.module())
+        ee.close()
+        ee.close()
+        with self.assertRaises(ctypes.ArgumentError):
+            ee.finalize_object()
+
+    def test_with(self):
+        ee = self.jit(self.module())
+        with ee:
+            pass
+        with self.assertRaises(RuntimeError):
+            with ee:
+                pass
+        with self.assertRaises(ctypes.ArgumentError):
+            ee.finalize_object()
+
+    def test_module_lifetime(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        ee.close()
+        mod.close()
+
+    def test_module_lifetime2(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        mod.close()
+        ee.close()
+
+    def test_add_module(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        with self.assertRaises(KeyError):
+            ee.add_module(mod)
+        self.assertFalse(mod.closed)
+        ee.close()
+        self.assertTrue(mod.closed)
+
+    def test_add_module_lifetime(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        mod.close()
+        ee.close()
+
+    def test_add_module_lifetime2(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        ee.close()
+        mod.close()
+
+    def test_remove_module(self):
+        ee = self.jit(self.module())
+        mod = self.module(asm_mul)
+        ee.add_module(mod)
+        ee.remove_module(mod)
+        with self.assertRaises(KeyError):
+            ee.remove_module(mod)
+        self.assertFalse(mod.closed)
+        ee.close()
+        self.assertFalse(mod.closed)
+
+    def test_target_data(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        td = ee.target_data
+        # A singleton is returned
+        self.assertIs(ee.target_data, td)
+        str(td)
+        del mod, ee
+        str(td)
+
+    def test_target_data_abi_enquiries(self):
+        mod = self.module()
+        ee = self.jit(mod)
+        td = ee.target_data
+        gv_i32 = mod.get_global_variable("glob")
+        gv_i8 = mod.get_global_variable("glob_b")
+        gv_struct = mod.get_global_variable("glob_struct")
+        # A global is a pointer, it has the ABI size of a pointer
+        pointer_size = 4 if sys.maxsize < 2 ** 32 else 8
+        for g in (gv_i32, gv_i8, gv_struct):
+            self.assertEqual(td.get_abi_size(g.type), pointer_size)
+
+        self.assertEqual(td.get_pointee_abi_size(gv_i32.type), 4)
+        self.assertEqual(td.get_pointee_abi_alignment(gv_i32.type), 4)
+
+        self.assertEqual(td.get_pointee_abi_size(gv_i8.type), 1)
+        self.assertIn(td.get_pointee_abi_alignment(gv_i8.type), (1, 2, 4))
+
+        self.assertEqual(td.get_pointee_abi_size(gv_struct.type), 24)
+        self.assertIn(td.get_pointee_abi_alignment(gv_struct.type), (4, 8))
+
+    def test_object_cache_notify(self):
+        notifies = []
+
+        def notify(mod, buf):
+            notifies.append((mod, buf))
+
+        mod = self.module()
+        ee = self.jit(mod)
+        ee.set_object_cache(notify)
+
+        self.assertEqual(len(notifies), 0)
+        cfunc = self.get_sum(ee)
+        cfunc(2, -5)
+        self.assertEqual(len(notifies), 1)
+        # The right module object was found
+        self.assertIs(notifies[0][0], mod)
+        self.assertIsInstance(notifies[0][1], bytes)
+
+        notifies[:] = []
+        mod2 = self.module(asm_mul)
+        ee.add_module(mod2)
+        cfunc = self.get_sum(ee, "mul")
+        self.assertEqual(len(notifies), 1)
+        # The right module object was found
+        self.assertIs(notifies[0][0], mod2)
+        self.assertIsInstance(notifies[0][1], bytes)
+
+    def test_object_cache_getbuffer(self):
+        notifies = []
+        getbuffers = []
+
+        def notify(mod, buf):
+            notifies.append((mod, buf))
+
+        def getbuffer(mod):
+            getbuffers.append(mod)
+
+        mod = self.module()
+        ee = self.jit(mod)
+        ee.set_object_cache(notify, getbuffer)
+
+        # First return None from getbuffer(): the object is compiled normally
+        self.assertEqual(len(notifies), 0)
+        self.assertEqual(len(getbuffers), 0)
+        cfunc = self.get_sum(ee)
+        self.assertEqual(len(notifies), 1)
+        self.assertEqual(len(getbuffers), 1)
+        self.assertIs(getbuffers[0], mod)
+        sum_buffer = notifies[0][1]
+
+        # Recreate a new EE, and use getbuffer() to return the previously
+        # compiled object.
+
+        def getbuffer_successful(mod):
+            getbuffers.append(mod)
+            return sum_buffer
+
+        notifies[:] = []
+        getbuffers[:] = []
+        # Use another source module to make sure it is ignored
+        mod = self.module(asm_mul)
+        ee = self.jit(mod)
+        ee.set_object_cache(notify, getbuffer_successful)
+
+        self.assertEqual(len(notifies), 0)
+        self.assertEqual(len(getbuffers), 0)
+        cfunc = self.get_sum(ee)
+        self.assertEqual(cfunc(2, -5), -3)
+        self.assertEqual(len(notifies), 0)
+        self.assertEqual(len(getbuffers), 1)
+
+
+class JITWithTMTestMixin(JITTestMixin):
+
+    def test_emit_assembly(self):
+        """Test TargetMachineRef.emit_assembly()"""
+        target_machine = self.target_machine(jit=True)
+        mod = self.module()
+        ee = self.jit(mod, target_machine)  # noqa F841 # Keeps pointers alive
+        raw_asm = target_machine.emit_assembly(mod)
+        self.assertIn("sum", raw_asm)
+        target_machine.set_asm_verbosity(True)
+        raw_asm_verbose = target_machine.emit_assembly(mod)
+        self.assertIn("sum", raw_asm)
+        self.assertNotEqual(raw_asm, raw_asm_verbose)
+
+    def test_emit_object(self):
+        """Test TargetMachineRef.emit_object()"""
+        target_machine = self.target_machine(jit=True)
+        mod = self.module()
+        ee = self.jit(mod, target_machine)  # noqa F841 # Keeps pointers alive
+        code_object = target_machine.emit_object(mod)
+        self.assertIsInstance(code_object, bytes)
+        if sys.platform.startswith('linux'):
+            # Sanity check
+            self.assertIn(b"ELF", code_object[:10])
+
+
+class TestMCJit(BaseTest, JITWithTMTestMixin):
+    """
+    Test JIT engines created with create_mcjit_compiler().
+    """
+
+    def jit(self, mod, target_machine=None):
+        if target_machine is None:
+            target_machine = self.target_machine(jit=True)
+        return llvm.create_mcjit_compiler(mod, target_machine)
+
+
+# There are some memory corruption issues with OrcJIT on AArch64 - see Issue
+# #1000. Since OrcJIT is experimental, and we don't test regularly during
+# llvmlite development on non-x86 platforms, it seems safest to skip these
+# tests on non-x86 platforms.
+@unittest.skipUnless(platform.machine().startswith("x86"), "x86 only")
+class TestOrcLLJIT(BaseTest):
+
+    def jit(self, asm=asm_sum, func_name="sum", target_machine=None,
+            add_process=False, func_type=CFUNCTYPE(c_int, c_int, c_int),
+            suppress_errors=False):
+        lljit = llvm.create_lljit_compiler(target_machine,
+                                           use_jit_link=False,
+                                           suppress_errors=suppress_errors)
+        builder = llvm.JITLibraryBuilder()
+        if add_process:
+            builder.add_current_process()
+        rt = builder\
+            .add_ir(asm.format(triple=llvm.get_default_triple()))\
+            .export_symbol(func_name)\
+            .link(lljit, func_name)
+        cfptr = rt[func_name]
+        self.assertTrue(cfptr)
+        self.assertEqual(func_name, rt.name)
+        return lljit, rt, func_type(cfptr)
+
+    # From test_dylib_symbols
+    def test_define_symbol(self):
+        lljit = llvm.create_lljit_compiler()
+        rt = llvm.JITLibraryBuilder().import_symbol("__xyzzy", 1234)\
+            .export_symbol("__xyzzy").link(lljit, "foo")
+        self.assertEqual(rt["__xyzzy"], 1234)
+
+    def test_lookup_undefined_symbol_fails(self):
+        lljit = llvm.create_lljit_compiler()
+        with self.assertRaisesRegex(RuntimeError, 'No such library'):
+            lljit.lookup("foo", "__foobar")
+        rt = llvm.JITLibraryBuilder().import_symbol("__xyzzy", 1234)\
+            .export_symbol("__xyzzy").link(lljit, "foo")
+        self.assertNotEqual(rt["__xyzzy"], 0)
+        with self.assertRaisesRegex(RuntimeError,
+                                    'Symbols not found.*__foobar'):
+            lljit.lookup("foo", "__foobar")
+
+    def test_jit_link(self):
+        if sys.platform == "win32":
+            with self.assertRaisesRegex(RuntimeError,
+                                        'JITLink .* Windows'):
+                llvm.create_lljit_compiler(use_jit_link=True)
+        else:
+            self.assertIsNotNone(llvm.create_lljit_compiler(use_jit_link=True))
+
+    def test_run_code(self):
+        (lljit, rt, cfunc) = self.jit()
+        with lljit:
+            res = cfunc(2, -5)
+            self.assertEqual(-3, res)
+
+    def test_close(self):
+        (lljit, rt, cfunc) = self.jit()
+        lljit.close()
+        lljit.close()
+        with self.assertRaises(AssertionError):
+            lljit.lookup("foo", "fn")
+
+    def test_with(self):
+        (lljit, rt, cfunc) = self.jit()
+        with lljit:
+            pass
+        with self.assertRaises(RuntimeError):
+            with lljit:
+                pass
+        with self.assertRaises(AssertionError):
+            lljit.lookup("foo", "fn")
+
+    def test_add_ir_module(self):
+        (lljit, rt_sum, cfunc_sum) = self.jit()
+        rt_mul = llvm.JITLibraryBuilder() \
+            .add_ir(asm_mul.format(triple=llvm.get_default_triple())) \
+            .export_symbol("mul") \
+            .link(lljit, "mul")
+        res = CFUNCTYPE(c_int, c_int, c_int)(rt_mul["mul"])(2, -5)
+        self.assertEqual(-10, res)
+        self.assertNotEqual(lljit.lookup("sum", "sum")["sum"], 0)
+        self.assertNotEqual(lljit.lookup("mul", "mul")["mul"], 0)
+        with self.assertRaises(RuntimeError):
+            lljit.lookup("sum", "mul")
+        with self.assertRaises(RuntimeError):
+            lljit.lookup("mul", "sum")
+
+    def test_remove_module(self):
+        (lljit, rt_sum, _) = self.jit()
+        del rt_sum
+        gc.collect()
+        with self.assertRaises(RuntimeError):
+            lljit.lookup("sum", "sum")
+        lljit.close()
+
+    def test_lib_depends(self):
+        (lljit, rt_sum, cfunc_sum) = self.jit()
+        rt_mul = llvm.JITLibraryBuilder() \
+            .add_ir(asm_square_sum.format(triple=llvm.get_default_triple())) \
+            .export_symbol("square_sum") \
+            .add_jit_library("sum") \
+            .link(lljit, "square_sum")
+        res = CFUNCTYPE(c_int, c_int, c_int)(rt_mul["square_sum"])(2, -5)
+        self.assertEqual(9, res)
+
+    def test_target_data(self):
+        (lljit, rt, _) = self.jit()
+        td = lljit.target_data
+        # A singleton is returned
+        self.assertIs(lljit.target_data, td)
+        str(td)
+        del lljit
+        str(td)
+
+    def test_global_ctors_dtors(self):
+        # test issue #303
+        # (https://github.com/numba/llvmlite/issues/303)
+        shared_value = c_int32(0)
+        lljit = llvm.create_lljit_compiler()
+        builder = llvm.JITLibraryBuilder()
+        rt = builder \
+            .add_ir(asm_ext_ctors.format(triple=llvm.get_default_triple())) \
+            .import_symbol("A", ctypes.addressof(shared_value)) \
+            .export_symbol("foo") \
+            .link(lljit, "foo")
+        foo = rt["foo"]
+        self.assertTrue(foo)
+        self.assertEqual(CFUNCTYPE(c_int)(foo)(), 12)
+        del rt
+        self.assertNotEqual(shared_value.value, 20)
+
+    def test_lookup_current_process_symbol_fails(self):
+        # An attempt to lookup a symbol in the current process (Py_GetVersion,
+        # in this case) should fail with an appropriate error if we have not
+        # enabled searching the current process for symbols.
+        msg = 'Failed to materialize symbols:.*getversion'
+        with self.assertRaisesRegex(RuntimeError, msg):
+            self.jit(asm_getversion, "getversion", suppress_errors=True)
+
+    def test_lookup_current_process_symbol(self):
+        self.jit(asm_getversion, "getversion", None, True)
+
+    def test_thread_safe(self):
+        lljit = llvm.create_lljit_compiler()
+        llvm_ir = asm_sum.format(triple=llvm.get_default_triple())
+
+        def compile_many(i):
+            def do_work():
+                tracking = []
+                for c in range(50):
+                    tracking.append(llvm.JITLibraryBuilder()
+                                    .add_ir(llvm_ir)
+                                    .export_symbol("sum")
+                                    .link(lljit, f"sum_{i}_{c}"))
+
+            return do_work
+
+        ths = [threading.Thread(target=compile_many(i))
+               for i in range(os.cpu_count())]
+        for th in ths:
+            th.start()
+        for th in ths:
+            th.join()
+
+    def test_add_object_file(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        lljit = llvm.create_lljit_compiler(target_machine)
+        rt = llvm.JITLibraryBuilder()\
+            .add_object_img(target_machine.emit_object(mod))\
+            .export_symbol("sum")\
+            .link(lljit, "sum")
+        sum = CFUNCTYPE(c_int, c_int, c_int)(rt["sum"])
+        self.assertEqual(sum(2, 3), 5)
+
+    def test_add_object_file_from_filesystem(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        temp_desc, temp_path = mkstemp()
+
+        try:
+            with os.fdopen(temp_desc, "wb") as f:
+                f.write(obj_bin)
+            lljit = llvm.create_lljit_compiler(target_machine)
+            rt = llvm.JITLibraryBuilder() \
+                .add_object_file(temp_path) \
+                .export_symbol("sum") \
+                .link(lljit, "sum")
+            sum = CFUNCTYPE(c_int, c_int, c_int)(rt["sum"])
+            self.assertEqual(sum(2, 3), 5)
+        finally:
+            os.unlink(temp_path)
+
+
+class TestValueRef(BaseTest):
+
+    def test_str(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(str(glob), "@glob = global i32 0")
+
+    def test_name(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertEqual(glob.name, "glob")
+        glob.name = "foobar"
+        self.assertEqual(glob.name, "foobar")
+
+    def test_linkage(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        linkage = glob.linkage
+        self.assertIsInstance(glob.linkage, llvm.Linkage)
+        glob.linkage = linkage
+        self.assertEqual(glob.linkage, linkage)
+        for linkage in ("internal", "external"):
+            glob.linkage = linkage
+            self.assertIsInstance(glob.linkage, llvm.Linkage)
+            self.assertEqual(glob.linkage.name, linkage)
+
+    def test_visibility(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        visibility = glob.visibility
+        self.assertIsInstance(glob.visibility, llvm.Visibility)
+        glob.visibility = visibility
+        self.assertEqual(glob.visibility, visibility)
+        for visibility in ("hidden", "protected", "default"):
+            glob.visibility = visibility
+            self.assertIsInstance(glob.visibility, llvm.Visibility)
+            self.assertEqual(glob.visibility.name, visibility)
+
+    def test_storage_class(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        storage_class = glob.storage_class
+        self.assertIsInstance(glob.storage_class, llvm.StorageClass)
+        glob.storage_class = storage_class
+        self.assertEqual(glob.storage_class, storage_class)
+        for storage_class in ("dllimport", "dllexport", "default"):
+            glob.storage_class = storage_class
+            self.assertIsInstance(glob.storage_class, llvm.StorageClass)
+            self.assertEqual(glob.storage_class.name, storage_class)
+
+    def test_add_function_attribute(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        fn.add_function_attribute("nocapture")
+        with self.assertRaises(ValueError) as raises:
+            fn.add_function_attribute("zext")
+        self.assertEqual(str(raises.exception), "no such attribute 'zext'")
+
+    def test_module(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        self.assertIs(glob.module, mod)
+
+    def test_type(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        tp = glob.type
+        self.assertIsInstance(tp, llvm.TypeRef)
+
+    def test_type_name(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        tp = glob.type
+        self.assertEqual(tp.name, "")
+        st = mod.get_global_variable("glob_struct")
+        self.assertIsNotNone(re.match(r"struct\.glob_type(\.[\d]+)?",
+                                      st.type.element_type.name))
+
+    def test_type_printing_variable(self):
+        mod = self.module()
+        glob = mod.get_global_variable("glob")
+        tp = glob.type
+        self.assertEqual(str(tp), 'i32*')
+
+    def test_type_printing_function(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        self.assertEqual(str(fn.type), "i32 (i32, i32)*")
+
+    def test_type_printing_struct(self):
+        mod = self.module()
+        st = mod.get_global_variable("glob_struct")
+        self.assertTrue(st.type.is_pointer)
+        self.assertIsNotNone(re.match(r'%struct\.glob_type(\.[\d]+)?\*',
+                                      str(st.type)))
+        self.assertIsNotNone(re.match(
+            r"%struct\.glob_type(\.[\d]+)? = type { i64, \[2 x i64\] }",
+            str(st.type.element_type)))
+
+    def test_close(self):
+        glob = self.glob()
+        glob.close()
+        glob.close()
+
+    def test_is_declaration(self):
+        defined = self.module().get_function('sum')
+        declared = self.module(asm_sum_declare).get_function('sum')
+        self.assertFalse(defined.is_declaration)
+        self.assertTrue(declared.is_declaration)
+
+    def test_module_global_variables(self):
+        mod = self.module(asm_sum)
+        gvars = list(mod.global_variables)
+        self.assertEqual(len(gvars), 4)
+        for v in gvars:
+            self.assertTrue(v.is_global)
+
+    def test_module_functions(self):
+        mod = self.module()
+        funcs = list(mod.functions)
+        self.assertEqual(len(funcs), 1)
+        func = funcs[0]
+        self.assertTrue(func.is_function)
+        self.assertEqual(func.name, 'sum')
+
+        with self.assertRaises(ValueError):
+            func.instructions
+        with self.assertRaises(ValueError):
+            func.operands
+        with self.assertRaises(ValueError):
+            func.opcode
+
+    def test_function_arguments(self):
+        mod = self.module()
+        func = mod.get_function('sum')
+        self.assertTrue(func.is_function)
+        args = list(func.arguments)
+        self.assertEqual(len(args), 2)
+        self.assertTrue(args[0].is_argument)
+        self.assertTrue(args[1].is_argument)
+        self.assertEqual(args[0].name, '.1')
+        self.assertEqual(str(args[0].type), 'i32')
+        self.assertEqual(args[1].name, '.2')
+        self.assertEqual(str(args[1].type), 'i32')
+
+        with self.assertRaises(ValueError):
+            args[0].blocks
+        with self.assertRaises(ValueError):
+            args[0].arguments
+
+    def test_function_blocks(self):
+        func = self.module().get_function('sum')
+        blocks = list(func.blocks)
+        self.assertEqual(len(blocks), 1)
+        block = blocks[0]
+        self.assertTrue(block.is_block)
+
+    def test_block_instructions(self):
+        func = self.module().get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(len(insts), 3)
+        self.assertTrue(insts[0].is_instruction)
+        self.assertTrue(insts[1].is_instruction)
+        self.assertTrue(insts[2].is_instruction)
+        self.assertEqual(insts[0].opcode, 'add')
+        self.assertEqual(insts[1].opcode, 'add')
+        self.assertEqual(insts[2].opcode, 'ret')
+
+    def test_instruction_operands(self):
+        func = self.module().get_function('sum')
+        add = list(list(func.blocks)[0].instructions)[0]
+        self.assertEqual(add.opcode, 'add')
+        operands = list(add.operands)
+        self.assertEqual(len(operands), 2)
+        self.assertTrue(operands[0].is_operand)
+        self.assertTrue(operands[1].is_operand)
+        self.assertEqual(operands[0].name, '.1')
+        self.assertEqual(str(operands[0].type), 'i32')
+        self.assertEqual(operands[1].name, '.2')
+        self.assertEqual(str(operands[1].type), 'i32')
+
+    def test_function_attributes(self):
+        mod = self.module(asm_attributes)
+        for func in mod.functions:
+            attrs = list(func.attributes)
+            if func.name == 'a_readonly_func':
+                self.assertEqual(attrs, [b'readonly'])
+            elif func.name == 'a_arg0_return_func':
+                self.assertEqual(attrs, [])
+                args = list(func.arguments)
+                self.assertEqual(list(args[0].attributes), [b'returned'])
+                self.assertEqual(list(args[1].attributes), [])
+
+    def test_value_kind(self):
+        mod = self.module()
+        self.assertEqual(mod.get_global_variable('glob').value_kind,
+                         llvm.ValueKind.global_variable)
+        func = mod.get_function('sum')
+        self.assertEqual(func.value_kind, llvm.ValueKind.function)
+        block = list(func.blocks)[0]
+        self.assertEqual(block.value_kind, llvm.ValueKind.basic_block)
+        inst = list(block.instructions)[1]
+        self.assertEqual(inst.value_kind, llvm.ValueKind.instruction)
+        self.assertEqual(list(inst.operands)[0].value_kind,
+                         llvm.ValueKind.constant_int)
+        self.assertEqual(list(inst.operands)[1].value_kind,
+                         llvm.ValueKind.instruction)
+
+        iasm_func = self.module(asm_inlineasm).get_function('foo')
+        iasm_inst = list(list(iasm_func.blocks)[0].instructions)[0]
+        self.assertEqual(list(iasm_inst.operands)[0].value_kind,
+                         llvm.ValueKind.inline_asm)
+
+    def test_is_constant(self):
+        mod = self.module()
+        self.assertTrue(mod.get_global_variable('glob').is_constant)
+        constant_operands = 0
+        for func in mod.functions:
+            self.assertTrue(func.is_constant)
+            for block in func.blocks:
+                self.assertFalse(block.is_constant)
+                for inst in block.instructions:
+                    self.assertFalse(inst.is_constant)
+                    for op in inst.operands:
+                        if op.is_constant:
+                            constant_operands += 1
+
+        self.assertEqual(constant_operands, 1)
+
+    def test_constant_int(self):
+        mod = self.module()
+        func = mod.get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(insts[1].opcode, 'add')
+        operands = list(insts[1].operands)
+        self.assertTrue(operands[0].is_constant)
+        self.assertFalse(operands[1].is_constant)
+        self.assertEqual(operands[0].get_constant_value(), 0)
+        with self.assertRaises(ValueError):
+            operands[1].get_constant_value()
+
+        mod = self.module(asm_sum3)
+        func = mod.get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        posint64 = list(insts[1].operands)[0]
+        negint64 = list(insts[2].operands)[0]
+        self.assertEqual(posint64.get_constant_value(), 5)
+        self.assertEqual(negint64.get_constant_value(signed_int=True), -5)
+
+        # Convert from unsigned arbitrary-precision integer to signed i64
+        as_u64 = negint64.get_constant_value(signed_int=False)
+        as_i64 = int.from_bytes(as_u64.to_bytes(8, 'little'), 'little',
+                                signed=True)
+        self.assertEqual(as_i64, -5)
+
+    def test_constant_fp(self):
+        mod = self.module(asm_double_locale)
+        func = mod.get_function('foo')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(len(insts), 2)
+        self.assertEqual(insts[0].opcode, 'fadd')
+        operands = list(insts[0].operands)
+        self.assertTrue(operands[0].is_constant)
+        self.assertAlmostEqual(operands[0].get_constant_value(), 0.0)
+        self.assertTrue(operands[1].is_constant)
+        self.assertAlmostEqual(operands[1].get_constant_value(), 3.14)
+
+        mod = self.module(asm_double_inaccurate)
+        func = mod.get_function('foo')
+        inst = list(list(func.blocks)[0].instructions)[0]
+        operands = list(inst.operands)
+        with self.assertRaises(ValueError):
+            operands[0].get_constant_value()
+        self.assertAlmostEqual(operands[1].get_constant_value(round_fp=True), 0)
+
+    def test_constant_as_string(self):
+        mod = self.module(asm_null_constant)
+        func = mod.get_function('bar')
+        inst = list(list(func.blocks)[0].instructions)[0]
+        arg = list(inst.operands)[0]
+        self.assertTrue(arg.is_constant)
+        self.assertEqual(arg.get_constant_value(), 'i64* null')
+
+
+class TestTarget(BaseTest):
+
+    def test_from_triple(self):
+        f = llvm.Target.from_triple
+        with self.assertRaises(RuntimeError) as cm:
+            f("foobar")
+        self.assertIn("No available targets are compatible with",
+                      str(cm.exception))
+        triple = llvm.get_default_triple()
+        target = f(triple)
+        self.assertEqual(target.triple, triple)
+        target.close()
+
+    def test_create_target_machine(self):
+        target = llvm.Target.from_triple(llvm.get_default_triple())
+        # With the default settings
+        target.create_target_machine('', '', 1, 'default', 'default')
+        # With the host's CPU
+        cpu = llvm.get_host_cpu_name()
+        target.create_target_machine(cpu, '', 1, 'default', 'default')
+
+    def test_name(self):
+        t = llvm.Target.from_triple(llvm.get_default_triple())
+        u = llvm.Target.from_default_triple()
+        self.assertIsInstance(t.name, str)
+        self.assertEqual(t.name, u.name)
+
+    def test_description(self):
+        t = llvm.Target.from_triple(llvm.get_default_triple())
+        u = llvm.Target.from_default_triple()
+        self.assertIsInstance(t.description, str)
+        self.assertEqual(t.description, u.description)
+
+    def test_str(self):
+        target = llvm.Target.from_triple(llvm.get_default_triple())
+        s = str(target)
+        self.assertIn(target.name, s)
+        self.assertIn(target.description, s)
+
+
+class TestTargetData(BaseTest):
+
+    def target_data(self):
+        return llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
+
+    def test_get_abi_size(self):
+        td = self.target_data()
+        glob = self.glob()
+        self.assertEqual(td.get_abi_size(glob.type), 8)
+
+    def test_get_pointee_abi_size(self):
+        td = self.target_data()
+
+        glob = self.glob()
+        self.assertEqual(td.get_pointee_abi_size(glob.type), 4)
+
+        glob = self.glob("glob_struct")
+        self.assertEqual(td.get_pointee_abi_size(glob.type), 24)
+
+    def test_get_struct_element_offset(self):
+        td = self.target_data()
+        glob = self.glob("glob_struct")
+
+        with self.assertRaises(ValueError):
+            td.get_element_offset(glob.type, 0)
+
+        struct_type = glob.type.element_type
+        self.assertEqual(td.get_element_offset(struct_type, 0), 0)
+        self.assertEqual(td.get_element_offset(struct_type, 1), 8)
+
+
+class TestTargetMachine(BaseTest):
+
+    def test_add_analysis_passes(self):
+        tm = self.target_machine(jit=False)
+        pm = llvm.create_module_pass_manager()
+        tm.add_analysis_passes(pm)
+
+    def test_target_data_from_tm(self):
+        tm = self.target_machine(jit=False)
+        td = tm.target_data
+        mod = self.module()
+        gv_i32 = mod.get_global_variable("glob")
+        # A global is a pointer, it has the ABI size of a pointer
+        pointer_size = 4 if sys.maxsize < 2 ** 32 else 8
+        self.assertEqual(td.get_abi_size(gv_i32.type), pointer_size)
+
+
+class TestPassManagerBuilder(BaseTest):
+
+    def pmb(self):
+        return llvm.PassManagerBuilder()
+
+    def test_old_api(self):
+        # Test the create_pass_manager_builder() factory function
+        pmb = llvm.create_pass_manager_builder()
+        pmb.inlining_threshold = 2
+        pmb.opt_level = 3
+
+    def test_close(self):
+        pmb = self.pmb()
+        pmb.close()
+        pmb.close()
+
+    def test_opt_level(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.opt_level, int)
+        for i in range(4):
+            pmb.opt_level = i
+            self.assertEqual(pmb.opt_level, i)
+
+    def test_size_level(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.size_level, int)
+        for i in range(4):
+            pmb.size_level = i
+            self.assertEqual(pmb.size_level, i)
+
+    def test_inlining_threshold(self):
+        pmb = self.pmb()
+        with self.assertRaises(NotImplementedError):
+            pmb.inlining_threshold
+        for i in (25, 80, 350):
+            pmb.inlining_threshold = i
+
+    def test_disable_unroll_loops(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.disable_unroll_loops, bool)
+        for b in (True, False):
+            pmb.disable_unroll_loops = b
+            self.assertEqual(pmb.disable_unroll_loops, b)
+
+    def test_loop_vectorize(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.loop_vectorize, bool)
+        for b in (True, False):
+            pmb.loop_vectorize = b
+            self.assertEqual(pmb.loop_vectorize, b)
+
+    def test_slp_vectorize(self):
+        pmb = self.pmb()
+        self.assertIsInstance(pmb.slp_vectorize, bool)
+        for b in (True, False):
+            pmb.slp_vectorize = b
+            self.assertEqual(pmb.slp_vectorize, b)
+
+    def test_populate_module_pass_manager(self):
+        pmb = self.pmb()
+        pm = llvm.create_module_pass_manager()
+        pmb.populate(pm)
+        pmb.close()
+        pm.close()
+
+    def test_populate_function_pass_manager(self):
+        mod = self.module()
+        pmb = self.pmb()
+        pm = llvm.create_function_pass_manager(mod)
+        pmb.populate(pm)
+        pmb.close()
+        pm.close()
+
+
+class PassManagerTestMixin(object):
+
+    def pmb(self):
+        pmb = llvm.create_pass_manager_builder()
+        pmb.opt_level = 2
+        pmb.inlining_threshold = 300
+        return pmb
+
+    def test_close(self):
+        pm = self.pm()
+        pm.close()
+        pm.close()
+
+
+class TestModulePassManager(BaseTest, PassManagerTestMixin):
+
+    def pm(self):
+        return llvm.create_module_pass_manager()
+
+    def test_run(self):
+        pm = self.pm()
+        self.pmb().populate(pm)
+        mod = self.module()
+        orig_asm = str(mod)
+        pm.run(mod)
+        opt_asm = str(mod)
+        # Quick check that optimizations were run, should get:
+        # define i32 @sum(i32 %.1, i32 %.2) local_unnamed_addr #0 {
+        # %.X = add i32 %.2, %.1
+        # ret i32 %.X
+        # }
+        # where X in %.X is 3 or 4
+        opt_asm_split = opt_asm.splitlines()
+        for idx, l in enumerate(opt_asm_split):
+            if l.strip().startswith('ret i32'):
+                toks = {'%.3', '%.4'}
+                for t in toks:
+                    if t in l:
+                        break
+                else:
+                    raise RuntimeError("expected tokens not found")
+                othertoken = (toks ^ {t}).pop()
+
+                self.assertIn("%.3", orig_asm)
+                self.assertNotIn(othertoken, opt_asm)
+                break
+        else:
+            raise RuntimeError("expected IR not found")
+
+    def test_run_with_remarks_successful_inline(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(70)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm2)
+        (status, remarks) = pm.run_with_remarks(mod)
+        self.assertTrue(status)
+        # Inlining has happened?  The remark will tell us.
+        self.assertIn("Passed", remarks)
+        self.assertIn("inlineme", remarks)
+
+    def test_run_with_remarks_failed_inline(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(0)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm3)
+        (status, remarks) = pm.run_with_remarks(mod)
+        self.assertTrue(status)
+
+        # Inlining has not happened?  The remark will tell us.
+        self.assertIn("Missed", remarks)
+        self.assertIn("inlineme", remarks)
+        self.assertIn("noinline function attribute", remarks)
+
+    def test_run_with_remarks_inline_filter_out(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(70)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm2)
+        (status, remarks) = pm.run_with_remarks(mod, remarks_filter="nothing")
+        self.assertTrue(status)
+        self.assertEqual("", remarks)
+
+    def test_run_with_remarks_inline_filter_in(self):
+        pm = self.pm()
+        pm.add_function_inlining_pass(70)
+        self.pmb().populate(pm)
+        mod = self.module(asm_inlineasm2)
+        (status, remarks) = pm.run_with_remarks(mod, remarks_filter="inlin.*")
+        self.assertTrue(status)
+        self.assertIn("Passed", remarks)
+        self.assertIn("inlineme", remarks)
+
+
+class TestFunctionPassManager(BaseTest, PassManagerTestMixin):
+
+    def pm(self, mod=None):
+        mod = mod or self.module()
+        return llvm.create_function_pass_manager(mod)
+
+    def test_initfini(self):
+        pm = self.pm()
+        pm.initialize()
+        pm.finalize()
+
+    def test_run(self):
+        mod = self.module()
+        fn = mod.get_function("sum")
+        pm = self.pm(mod)
+        self.pmb().populate(pm)
+        mod.close()
+        orig_asm = str(fn)
+        pm.initialize()
+        pm.run(fn)
+        pm.finalize()
+        opt_asm = str(fn)
+        # Quick check that optimizations were run
+        self.assertIn("%.4", orig_asm)
+        self.assertNotIn("%.4", opt_asm)
+
+    def test_run_with_remarks(self):
+        mod = self.module(licm_asm)
+        fn = mod.get_function("licm")
+        pm = self.pm(mod)
+        pm.add_licm_pass()
+        self.pmb().populate(pm)
+        mod.close()
+
+        pm.initialize()
+        (ok, remarks) = pm.run_with_remarks(fn)
+        pm.finalize()
+        self.assertTrue(ok)
+        self.assertIn("Passed", remarks)
+        self.assertIn("licm", remarks)
+
+    def test_run_with_remarks_filter_out(self):
+        mod = self.module(licm_asm)
+        fn = mod.get_function("licm")
+        pm = self.pm(mod)
+        pm.add_licm_pass()
+        self.pmb().populate(pm)
+        mod.close()
+
+        pm.initialize()
+        (ok, remarks) = pm.run_with_remarks(fn, remarks_filter="nothing")
+        pm.finalize()
+        self.assertTrue(ok)
+        self.assertEqual("", remarks)
+
+    def test_run_with_remarks_filter_in(self):
+        mod = self.module(licm_asm)
+        fn = mod.get_function("licm")
+        pm = self.pm(mod)
+        pm.add_licm_pass()
+        self.pmb().populate(pm)
+        mod.close()
+
+        pm.initialize()
+        (ok, remarks) = pm.run_with_remarks(fn, remarks_filter="licm")
+        pm.finalize()
+        self.assertTrue(ok)
+        self.assertIn("Passed", remarks)
+        self.assertIn("licm", remarks)
+
+
+class TestPasses(BaseTest, PassManagerTestMixin):
+
+    def pm(self):
+        return llvm.create_module_pass_manager()
+
+    def test_populate(self):
+        pm = self.pm()
+        pm.add_target_library_info("") # unspecified target triple
+        pm.add_constant_merge_pass()
+        pm.add_dead_arg_elimination_pass()
+        pm.add_function_attrs_pass()
+        pm.add_function_inlining_pass(225)
+        pm.add_global_dce_pass()
+        pm.add_global_optimizer_pass()
+        pm.add_ipsccp_pass()
+        pm.add_dead_code_elimination_pass()
+        pm.add_cfg_simplification_pass()
+        pm.add_gvn_pass()
+        pm.add_instruction_combining_pass()
+        pm.add_licm_pass()
+        pm.add_sccp_pass()
+        pm.add_sroa_pass()
+        pm.add_type_based_alias_analysis_pass()
+        pm.add_basic_alias_analysis_pass()
+        pm.add_loop_rotate_pass()
+        pm.add_region_info_pass()
+        pm.add_scalar_evolution_aa_pass()
+        pm.add_aggressive_dead_code_elimination_pass()
+        pm.add_aa_eval_pass()
+        pm.add_always_inliner_pass()
+        pm.add_arg_promotion_pass(42)
+        pm.add_break_critical_edges_pass()
+        pm.add_dead_store_elimination_pass()
+        pm.add_reverse_post_order_function_attrs_pass()
+        pm.add_aggressive_instruction_combining_pass()
+        pm.add_internalize_pass()
+        pm.add_jump_threading_pass(7)
+        pm.add_lcssa_pass()
+        pm.add_loop_deletion_pass()
+        pm.add_loop_extractor_pass()
+        pm.add_single_loop_extractor_pass()
+        pm.add_loop_strength_reduce_pass()
+        pm.add_loop_simplification_pass()
+        pm.add_loop_unroll_pass()
+        pm.add_loop_unroll_and_jam_pass()
+        pm.add_loop_unswitch_pass()
+        pm.add_lower_atomic_pass()
+        pm.add_lower_invoke_pass()
+        pm.add_lower_switch_pass()
+        pm.add_memcpy_optimization_pass()
+        pm.add_merge_functions_pass()
+        pm.add_merge_returns_pass()
+        pm.add_partial_inlining_pass()
+        pm.add_prune_exception_handling_pass()
+        pm.add_reassociate_expressions_pass()
+        pm.add_demote_register_to_memory_pass()
+        pm.add_sink_pass()
+        pm.add_strip_symbols_pass()
+        pm.add_strip_dead_debug_info_pass()
+        pm.add_strip_dead_prototypes_pass()
+        pm.add_strip_debug_declare_pass()
+        pm.add_strip_nondebug_symbols_pass()
+        pm.add_tail_call_elimination_pass()
+        pm.add_basic_aa_pass()
+        pm.add_dependence_analysis_pass()
+        pm.add_dot_call_graph_pass()
+        pm.add_dot_cfg_printer_pass()
+        pm.add_dot_dom_printer_pass()
+        pm.add_dot_postdom_printer_pass()
+        pm.add_globals_mod_ref_aa_pass()
+        pm.add_iv_users_pass()
+        pm.add_lazy_value_info_pass()
+        pm.add_lint_pass()
+        pm.add_module_debug_info_pass()
+        pm.add_refprune_pass()
+
+    @unittest.skipUnless(platform.machine().startswith("x86"), "x86 only")
+    def test_target_library_info_behavior(self):
+        """Test a specific situation that demonstrate TLI is affecting
+        optimization. See https://github.com/numba/numba/issues/8898.
+        """
+        def run(use_tli):
+            mod = llvm.parse_assembly(asm_tli_exp2)
+            target = llvm.Target.from_triple(mod.triple)
+            tm = target.create_target_machine()
+            pm = llvm.ModulePassManager()
+            tm.add_analysis_passes(pm)
+            if use_tli:
+                pm.add_target_library_info(mod.triple)
+            pm.add_instruction_combining_pass()
+            pm.run(mod)
+            return mod
+
+        # Run with TLI should suppress transformation of exp2 -> ldexpf
+        mod = run(use_tli=True)
+        self.assertIn("call float @llvm.exp2.f32", str(mod))
+
+        # Run without TLI will enable the transformation
+        mod = run(use_tli=False)
+        self.assertNotIn("call float @llvm.exp2.f32", str(mod))
+        self.assertIn("call float @ldexpf", str(mod))
+
+
+class TestDylib(BaseTest):
+
+    def test_bad_library(self):
+        with self.assertRaises(RuntimeError):
+            llvm.load_library_permanently("zzzasdkf;jasd;l")
+
+    @unittest.skipUnless(platform.system() in ["Linux"],
+                         "test only works on Linux")
+    def test_libm(self):
+        libm = find_library("m")
+        llvm.load_library_permanently(libm)
+
+
+class TestAnalysis(BaseTest):
+    def build_ir_module(self):
+        m = ir.Module()
+        ft = ir.FunctionType(ir.IntType(32), [ir.IntType(32), ir.IntType(32)])
+        fn = ir.Function(m, ft, "foo")
+        bd = ir.IRBuilder(fn.append_basic_block())
+        x, y = fn.args
+        z = bd.add(x, y)
+        bd.ret(z)
+        return m
+
+    def test_get_function_cfg_on_ir(self):
+        mod = self.build_ir_module()
+        foo = mod.get_global('foo')
+        dot_showing_inst = llvm.get_function_cfg(foo)
+        dot_without_inst = llvm.get_function_cfg(foo, show_inst=False)
+        inst = "%.5 = add i32 %.1, %.2"
+        self.assertIn(inst, dot_showing_inst)
+        self.assertNotIn(inst, dot_without_inst)
+
+    def test_function_cfg_on_llvm_value(self):
+        defined = self.module().get_function('sum')
+        dot_showing_inst = llvm.get_function_cfg(defined, show_inst=True)
+        dot_without_inst = llvm.get_function_cfg(defined, show_inst=False)
+        # Check "digraph"
+        prefix = 'digraph'
+        self.assertIn(prefix, dot_showing_inst)
+        self.assertIn(prefix, dot_without_inst)
+        # Check function name
+        fname = "CFG for 'sum' function"
+        self.assertIn(fname, dot_showing_inst)
+        self.assertIn(fname, dot_without_inst)
+        # Check instruction
+        inst = "%.3 = add i32 %.1, %.2"
+        self.assertIn(inst, dot_showing_inst)
+        self.assertNotIn(inst, dot_without_inst)
+
+
+class TestTypeParsing(BaseTest):
+    @contextmanager
+    def check_parsing(self):
+        mod = ir.Module()
+        # Yield to caller and provide the module for adding
+        # new GV.
+        yield mod
+        # Caller yield back and continue with testing
+        asm = str(mod)
+        llvm.parse_assembly(asm)
+
+    def test_literal_struct(self):
+        # Natural layout
+        with self.check_parsing() as mod:
+            typ = ir.LiteralStructType([ir.IntType(32)])
+            gv = ir.GlobalVariable(mod, typ, "foo")
+            # Also test constant text repr
+            gv.initializer = ir.Constant(typ, [1])
+
+        # Packed layout
+        with self.check_parsing() as mod:
+            typ = ir.LiteralStructType([ir.IntType(32)],
+                                       packed=True)
+            gv = ir.GlobalVariable(mod, typ, "foo")
+            # Also test constant text repr
+            gv.initializer = ir.Constant(typ, [1])
+
+
+class TestGlobalConstructors(TestMCJit):
+    def test_global_ctors_dtors(self):
+        # test issue #303
+        # (https://github.com/numba/llvmlite/issues/303)
+        mod = self.module(asm_global_ctors)
+        ee = self.jit(mod)
+        ee.finalize_object()
+
+        ee.run_static_constructors()
+
+        # global variable should have been initialized
+        ptr_addr = ee.get_global_value_address("A")
+        ptr_t = ctypes.POINTER(ctypes.c_int32)
+        ptr = ctypes.cast(ptr_addr, ptr_t)
+        self.assertEqual(ptr.contents.value, 10)
+
+        foo_addr = ee.get_function_address("foo")
+        foo = ctypes.CFUNCTYPE(ctypes.c_int32)(foo_addr)
+        self.assertEqual(foo(), 12)
+
+        ee.run_static_destructors()
+
+        # destructor should have run
+        self.assertEqual(ptr.contents.value, 20)
+
+
+class TestGlobalVariables(BaseTest):
+    def check_global_variable_linkage(self, linkage, has_undef=True):
+        # This test default initializer on global variables with different
+        # linkages.  Some linkages requires an initializer be present, while
+        # it is optional for others.  This test uses ``parse_assembly()``
+        # to verify that we are adding an `undef` automatically if user didn't
+        # specific one for certain linkages.  It is a IR syntax error if the
+        # initializer is not present for certain linkages e.g. "external".
+        mod = ir.Module()
+        typ = ir.IntType(32)
+        gv = ir.GlobalVariable(mod, typ, "foo")
+        gv.linkage = linkage
+        asm = str(mod)
+        # check if 'undef' is present
+        if has_undef:
+            self.assertIn('undef', asm)
+        else:
+            self.assertNotIn('undef', asm)
+        # parse assembly to ensure correctness
+        self.module(asm)
+
+    def test_internal_linkage(self):
+        self.check_global_variable_linkage('internal')
+
+    def test_common_linkage(self):
+        self.check_global_variable_linkage('common')
+
+    def test_external_linkage(self):
+        self.check_global_variable_linkage('external', has_undef=False)
+
+    def test_available_externally_linkage(self):
+        self.check_global_variable_linkage('available_externally')
+
+    def test_private_linkage(self):
+        self.check_global_variable_linkage('private')
+
+    def test_linkonce_linkage(self):
+        self.check_global_variable_linkage('linkonce')
+
+    def test_weak_linkage(self):
+        self.check_global_variable_linkage('weak')
+
+    def test_appending_linkage(self):
+        self.check_global_variable_linkage('appending')
+
+    def test_extern_weak_linkage(self):
+        self.check_global_variable_linkage('extern_weak', has_undef=False)
+
+    def test_linkonce_odr_linkage(self):
+        self.check_global_variable_linkage('linkonce_odr')
+
+    def test_weak_odr_linkage(self):
+        self.check_global_variable_linkage('weak_odr')
+
+
+@unittest.skipUnless(platform.machine().startswith('x86'), "only on x86")
+class TestInlineAsm(BaseTest):
+    def test_inlineasm(self):
+        llvm.initialize_native_asmparser()
+        m = self.module(asm=asm_inlineasm)
+        tm = self.target_machine(jit=False)
+        asm = tm.emit_assembly(m)
+        self.assertIn('nop', asm)
+
+
+class TestObjectFile(BaseTest):
+
+    mod_asm = """
+        ;ModuleID = <string>
+        target triple = "{triple}"
+
+        declare i32 @sum(i32 %.1, i32 %.2)
+
+        define i32 @sum_twice(i32 %.1, i32 %.2) {{
+            %.3 = call i32 @sum(i32 %.1, i32 %.2)
+            %.4 = call i32 @sum(i32 %.3, i32 %.3)
+            ret i32 %.4
+        }}
+    """
+
+    def test_object_file(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        obj = llvm.ObjectFileRef.from_data(obj_bin)
+        # Check that we have a text section, and that she has a name and data
+        has_text = False
+        last_address = -1
+        for s in obj.sections():
+            if s.is_text():
+                has_text = True
+                self.assertIsNotNone(s.name())
+                self.assertTrue(s.size() > 0)
+                self.assertTrue(len(s.data()) > 0)
+                self.assertIsNotNone(s.address())
+                self.assertTrue(last_address < s.address())
+                last_address = s.address()
+                break
+        self.assertTrue(has_text)
+
+    def test_add_object_file(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        obj = llvm.ObjectFileRef.from_data(obj_bin)
+
+        jit = llvm.create_mcjit_compiler(self.module(self.mod_asm),
+                                         target_machine)
+
+        jit.add_object_file(obj)
+
+        sum_twice = CFUNCTYPE(c_int, c_int, c_int)(
+            jit.get_function_address("sum_twice"))
+
+        self.assertEqual(sum_twice(2, 3), 10)
+
+    def test_add_object_file_from_filesystem(self):
+        target_machine = self.target_machine(jit=False)
+        mod = self.module()
+        obj_bin = target_machine.emit_object(mod)
+        temp_desc, temp_path = mkstemp()
+
+        try:
+            try:
+                f = os.fdopen(temp_desc, "wb")
+                f.write(obj_bin)
+                f.flush()
+            finally:
+                f.close()
+
+            jit = llvm.create_mcjit_compiler(self.module(self.mod_asm),
+                                             target_machine)
+
+            jit.add_object_file(temp_path)
+        finally:
+            os.unlink(temp_path)
+
+        sum_twice = CFUNCTYPE(c_int, c_int, c_int)(
+            jit.get_function_address("sum_twice"))
+
+        self.assertEqual(sum_twice(2, 3), 10)
+
+    def test_get_section_content(self):
+        # See Issue #632 - section contents were getting truncated at null
+        # bytes.
+        elf = bytes.fromhex(issue_632_elf)
+        obj = llvm.ObjectFileRef.from_data(elf)
+        for s in obj.sections():
+            if s.is_text():
+                self.assertEqual(len(s.data()), 31)
+                self.assertEqual(s.data().hex(), issue_632_text)
+
+
+class TestTimePasses(BaseTest):
+    def test_reporting(self):
+        mp = llvm.create_module_pass_manager()
+
+        pmb = llvm.create_pass_manager_builder()
+        pmb.opt_level = 3
+        pmb.populate(mp)
+
+        try:
+            llvm.set_time_passes(True)
+            mp.run(self.module())
+            mp.run(self.module())
+            mp.run(self.module())
+        finally:
+            report = llvm.report_and_reset_timings()
+            llvm.set_time_passes(False)
+
+        self.assertIsInstance(report, str)
+        self.assertEqual(report.count("Pass execution timing report"), 1)
+
+    def test_empty_report(self):
+        # Returns empty str if no data is collected
+        self.assertFalse(llvm.report_and_reset_timings())
+
+
+class TestLLVMLockCallbacks(BaseTest):
+    def test_lock_callbacks(self):
+        events = []
+
+        def acq():
+            events.append('acq')
+
+        def rel():
+            events.append('rel')
+
+        # register callback
+        llvm.ffi.register_lock_callback(acq, rel)
+
+        # Check: events are initially empty
+        self.assertFalse(events)
+        # Call LLVM functions
+        llvm.create_module_pass_manager()
+        # Check: there must be at least one acq and one rel
+        self.assertIn("acq", events)
+        self.assertIn("rel", events)
+
+        # unregister callback
+        llvm.ffi.unregister_lock_callback(acq, rel)
+
+        # Check: removing non-existent callbacks will trigger a ValueError
+        with self.assertRaises(ValueError):
+            llvm.ffi.unregister_lock_callback(acq, rel)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/lib/python3.11/site-packages/llvmlite/tests/test_ir.py b/lib/python3.11/site-packages/llvmlite/tests/test_ir.py
new file mode 100644
index 0000000000000000000000000000000000000000..63a7c5f309c84057915f2b99f0c838caca21a522
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/test_ir.py
@@ -0,0 +1,2725 @@
+"""
+IR Construction Tests
+"""
+
+import copy
+import itertools
+import pickle
+import re
+import textwrap
+import unittest
+
+from . import TestCase
+from llvmlite import ir
+from llvmlite import binding as llvm
+
+
+int1 = ir.IntType(1)
+int8 = ir.IntType(8)
+int16 = ir.IntType(16)
+int32 = ir.IntType(32)
+int64 = ir.IntType(64)
+hlf = ir.HalfType()
+flt = ir.FloatType()
+dbl = ir.DoubleType()
+
+
+class TestBase(TestCase):
+    """
+    Utilities for IR tests.
+    """
+
+    def assertInText(self, pattern, text):
+        """
+        Assert *pattern* is in *text*, ignoring any whitespace differences
+        (including newlines).
+        """
+
+        def escape(c):
+            if not c.isalnum() and not c.isspace():
+                return '\\' + c
+            return c
+
+        pattern = ''.join(map(escape, pattern))
+        regex = re.sub(r'\s+', r'\\s*', pattern)
+        self.assertRegex(text, regex)
+
+    def assert_ir_line(self, line, mod):
+        lines = [line.strip() for line in str(mod).splitlines()]
+        self.assertIn(line, lines)
+
+    def assert_valid_ir(self, mod):
+        llvm.parse_assembly(str(mod))
+
+    def assert_pickle_correctly(self, irobject):
+        """Assert that the IR object pickles and unpickles correctly.
+        The IR string is equal and that their type is equal
+        """
+        newobject = pickle.loads(pickle.dumps(irobject, protocol=-1))
+        self.assertIs(irobject.__class__, newobject.__class__)
+        self.assertEqual(str(irobject), str(newobject))
+        return newobject
+
+    def module(self):
+        return ir.Module()
+
+    def function(self, module=None, name='my_func'):
+        module = module or self.module()
+        fnty = ir.FunctionType(int32, (int32, int32, dbl,
+                                       ir.PointerType(int32)))
+        return ir.Function(module, fnty, name)
+
+    def block(self, func=None, name=''):
+        func = func or self.function()
+        return func.append_basic_block(name)
+
+    def descr(self, thing):
+        buf = []
+        thing.descr(buf)
+        return "".join(buf)
+
+    def _normalize_asm(self, asm):
+        asm = textwrap.dedent(asm)
+        # Normalize indent
+        asm = asm.replace("\n    ", "\n  ")
+        return asm
+
+    def check_descr_regex(self, descr, asm):
+        expected = self._normalize_asm(asm)
+        self.assertRegex(descr, expected)
+
+    def check_descr(self, descr, asm):
+        expected = self._normalize_asm(asm)
+        self.assertEqual(descr, expected)
+
+    def check_block(self, block, asm):
+        self.check_descr(self.descr(block), asm)
+
+    def check_block_regex(self, block, asm):
+        self.check_descr_regex(self.descr(block), asm)
+
+    def check_module_body(self, module, asm):
+        expected = self._normalize_asm(asm)
+        actual = module._stringify_body()
+        self.assertEqual(actual.strip(), expected.strip())
+
+    def check_metadata(self, module, asm):
+        """
+        Check module metadata against *asm*.
+        """
+        expected = self._normalize_asm(asm)
+        actual = module._stringify_metadata()
+        self.assertEqual(actual.strip(), expected.strip())
+
+    def check_func_body(self, func, asm):
+        expected = self._normalize_asm(asm)
+        actual = self.descr(func)
+        actual = actual.partition('{')[2].rpartition('}')[0]
+        self.assertEqual(actual.strip(), expected.strip())
+
+
+class TestFunction(TestBase):
+
+    proto = """i32 @"my_func"(i32 %".1", i32 %".2", double %".3", i32* %".4")"""
+
+    def test_declare(self):
+        # A simple declaration
+        func = self.function()
+        asm = self.descr(func).strip()
+        self.assertEqual(asm.strip(), "declare %s" % self.proto)
+
+    def test_declare_attributes(self):
+        # Now with function attributes
+        func = self.function()
+        func.attributes.add("optsize")
+        func.attributes.add("alwaysinline")
+        func.attributes.alignstack = 16
+        tp_pers = ir.FunctionType(int8, (), var_arg=True)
+        pers = ir.Function(self.module(), tp_pers, '__gxx_personality_v0')
+        func.attributes.personality = pers
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         ("declare %s alwaysinline optsize alignstack(16) "
+                          "personality i8 (...)* @\"__gxx_personality_v0\"") %
+                         self.proto)
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_function_attributes(self):
+        # Now with parameter attributes
+        func = self.function()
+        func.args[0].add_attribute("zeroext")
+        func.args[1].attributes.dereferenceable = 5
+        func.args[1].attributes.dereferenceable_or_null = 10
+        func.args[3].attributes.align = 4
+        func.args[3].add_attribute("nonnull")
+        func.return_value.add_attribute("noalias")
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         """declare noalias i32 @"my_func"(i32 zeroext %".1", i32 dereferenceable(5) dereferenceable_or_null(10) %".2", double %".3", i32* nonnull align 4 %".4")"""  # noqa E501
+                         )
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_function_metadata(self):
+        # Now with function metadata
+        module = self.module()
+        func = self.function(module)
+        func.set_metadata('dbg', module.add_metadata([]))
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         f'declare {self.proto} !dbg !0'
+                         )
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_function_section(self):
+        # Test function with section
+        func = self.function()
+        func.section = "a_section"
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         f'declare {self.proto} section "a_section"'
+                         )
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_function_section_meta(self):
+        # Test function with section and metadata
+        module = self.module()
+        func = self.function(module)
+        func.section = "a_section"
+        func.set_metadata('dbg', module.add_metadata([]))
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         f'declare {self.proto} section "a_section" !dbg !0'
+                         )
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_function_attr_meta(self):
+        # Test function with attributes and metadata
+        module = self.module()
+        func = self.function(module)
+        func.attributes.add("alwaysinline")
+        func.set_metadata('dbg', module.add_metadata([]))
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         f'declare {self.proto} alwaysinline !dbg !0'
+                         )
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_function_attr_section(self):
+        # Test function with attributes and section
+        func = self.function()
+        func.attributes.add("optsize")
+        func.section = "a_section"
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         f'declare {self.proto} optsize section "a_section"')
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_function_attr_section_meta(self):
+        # Test function with attributes, section and metadata
+        module = self.module()
+        func = self.function(module)
+        func.attributes.add("alwaysinline")
+        func.section = "a_section"
+        func.set_metadata('dbg', module.add_metadata([]))
+        asm = self.descr(func).strip()
+        self.assertEqual(asm,
+                         f'declare {self.proto} alwaysinline section "a_section" !dbg !0'  # noqa E501
+                         )
+        # Check pickling
+        self.assert_pickle_correctly(func)
+
+    def test_define(self):
+        # A simple definition
+        func = self.function()
+        func.attributes.add("alwaysinline")
+        block = func.append_basic_block('my_block')
+        builder = ir.IRBuilder(block)
+        builder.ret_void()
+        asm = self.descr(func)
+        self.check_descr(asm, """\
+            define {proto} alwaysinline
+            {{
+            my_block:
+                ret void
+            }}
+            """.format(proto=self.proto))
+
+    def test_declare_intrinsics(self):
+        module = self.module()
+        pint8 = int8.as_pointer()
+
+        powi = module.declare_intrinsic('llvm.powi', [dbl])
+        memset = module.declare_intrinsic('llvm.memset', [pint8, int32])
+        memcpy = module.declare_intrinsic('llvm.memcpy', [pint8, pint8, int32])
+        assume = module.declare_intrinsic('llvm.assume')
+        self.check_descr(self.descr(powi).strip(), """\
+            declare double @"llvm.powi.f64"(double %".1", i32 %".2")""")
+        self.check_descr(self.descr(memset).strip(), """\
+            declare void @"llvm.memset.p0i8.i32"(i8* %".1", i8 %".2", i32 %".3", i1 %".4")""")  # noqa E501
+        self.check_descr(self.descr(memcpy).strip(), """\
+            declare void @"llvm.memcpy.p0i8.p0i8.i32"(i8* %".1", i8* %".2", i32 %".3", i1 %".4")""")  # noqa E501
+        self.check_descr(self.descr(assume).strip(), """\
+            declare void @"llvm.assume"(i1 %".1")""")
+
+    def test_redeclare_intrinsic(self):
+        module = self.module()
+        powi = module.declare_intrinsic('llvm.powi', [dbl])
+        powi2 = module.declare_intrinsic('llvm.powi', [dbl])
+        self.assertIs(powi, powi2)
+
+    def test_pickling(self):
+        fn = self.function()
+        self.assert_pickle_correctly(fn)
+
+    def test_alwaysinline_noinline_disallowed(self):
+        module = self.module()
+        func = self.function(module)
+        func.attributes.add('alwaysinline')
+
+        msg = "Can't have alwaysinline and noinline"
+        with self.assertRaisesRegex(ValueError, msg):
+            func.attributes.add('noinline')
+
+    def test_noinline_alwaysinline_disallowed(self):
+        module = self.module()
+        func = self.function(module)
+        func.attributes.add('noinline')
+
+        msg = "Can't have alwaysinline and noinline"
+        with self.assertRaisesRegex(ValueError, msg):
+            func.attributes.add('alwaysinline')
+
+
+class TestIR(TestBase):
+
+    def test_unnamed_metadata(self):
+        # An unnamed metadata node
+        mod = self.module()
+        mod.add_metadata([int32(123), int8(42)])
+        self.assert_ir_line("!0 = !{ i32 123, i8 42 }", mod)
+        self.assert_valid_ir(mod)
+
+    def test_unnamed_metadata_2(self):
+        # Several unnamed metadata nodes
+        mod = self.module()
+        # First node has a literal metadata string
+        m0 = mod.add_metadata([int32(123), "kernel"])
+        # Second node refers to the first one
+        m1 = mod.add_metadata([int64(456), m0])
+        # Third node is the same as the second one
+        m2 = mod.add_metadata([int64(456), m0])
+        self.assertIs(m2, m1)
+        # Fourth node refers to the first three
+        mod.add_metadata([m0, m1, m2])
+        self.assert_ir_line('!0 = !{ i32 123, !"kernel" }', mod)
+        self.assert_ir_line('!1 = !{ i64 456, !0 }', mod)
+        self.assert_ir_line('!2 = !{ !0, !1, !1 }', mod)
+
+    def test_unnamed_metadata_3(self):
+        # Passing nested metadata as a sequence
+        mod = self.module()
+        mod.add_metadata([int32(123), [int32(456)], [int32(789)], [int32(456)]])
+        self.assert_ir_line('!0 = !{ i32 456 }', mod)
+        self.assert_ir_line('!1 = !{ i32 789 }', mod)
+        self.assert_ir_line('!2 = !{ i32 123, !0, !1, !0 }', mod)
+
+    def test_metadata_string(self):
+        # Escaping contents of a metadata string
+        mod = self.module()
+        mod.add_metadata(["\"\\$"])
+        self.assert_ir_line('!0 = !{ !"\\22\\5c$" }', mod)
+
+    def test_named_metadata(self):
+        # Add a named metadata node and add metadata values to it
+        mod = self.module()
+        m0 = mod.add_metadata([int32(123)])
+        m1 = mod.add_metadata([int64(456)])
+        nmd = mod.add_named_metadata("foo")
+        nmd.add(m0)
+        nmd.add(m1)
+        nmd.add(m0)
+        self.assert_ir_line("!foo = !{ !0, !1, !0 }", mod)
+        self.assert_valid_ir(mod)
+        # Check get_named_metadata()
+        self.assertIs(nmd, mod.get_named_metadata("foo"))
+        with self.assertRaises(KeyError):
+            mod.get_named_metadata("bar")
+
+    def test_named_metadata_2(self):
+        # Add and set named metadata through a single add_named_metadata() call
+        mod = self.module()
+        m0 = mod.add_metadata([int32(123)])
+        mod.add_named_metadata("foo", m0)
+        mod.add_named_metadata("foo", [int64(456)])
+        mod.add_named_metadata("foo", ["kernel"])
+        mod.add_named_metadata("bar", [])
+        self.assert_ir_line("!foo = !{ !0, !1, !2 }", mod)
+        self.assert_ir_line("!0 = !{ i32 123 }", mod)
+        self.assert_ir_line("!1 = !{ i64 456 }", mod)
+        self.assert_ir_line('!2 = !{ !"kernel" }', mod)
+        self.assert_ir_line("!bar = !{ !3 }", mod)
+        self.assert_ir_line('!3 = !{  }', mod)
+        self.assert_valid_ir(mod)
+
+    def test_metadata_null(self):
+        # A null metadata (typed) value
+        mod = self.module()
+        mod.add_metadata([int32.as_pointer()(None)])
+        self.assert_ir_line("!0 = !{ i32* null }", mod)
+        self.assert_valid_ir(mod)
+        # A null metadata (untyped) value
+        mod = self.module()
+        mod.add_metadata([None, int32(123)])
+        self.assert_ir_line("!0 = !{ null, i32 123 }", mod)
+        self.assert_valid_ir(mod)
+
+    def test_debug_info(self):
+        # Add real world-looking debug information to a module
+        # (with various value types)
+        mod = self.module()
+        di_file = mod.add_debug_info("DIFile", {
+            "filename": "foo",
+            "directory": "bar",
+        })
+        di_func_type = mod.add_debug_info("DISubroutineType", {
+            # None as `null`
+            "types": mod.add_metadata([None]),
+        })
+        di_compileunit = mod.add_debug_info("DICompileUnit", {
+            "language": ir.DIToken("DW_LANG_Python"),
+            "file": di_file,
+            "producer": "ARTIQ",
+            "runtimeVersion": 0,
+            "isOptimized": True,
+        }, is_distinct=True)
+        mod.add_debug_info("DISubprogram", {
+            "name": "my_func",
+            "file": di_file,
+            "line": 11,
+            "type": di_func_type,
+            "isLocal": False,
+            "unit": di_compileunit,
+        }, is_distinct=True)
+
+        # Check output
+        strmod = str(mod)
+        self.assert_ir_line('!0 = !DIFile(directory: "bar", filename: "foo")',
+                            strmod)
+        self.assert_ir_line('!1 = !{ null }', strmod)
+        self.assert_ir_line('!2 = !DISubroutineType(types: !1)', strmod)
+        # self.assert_ir_line('!4 = !{ !3 }', strmod)
+        self.assert_ir_line('!3 = distinct !DICompileUnit(file: !0, '
+                            'isOptimized: true, language: DW_LANG_Python, '
+                            'producer: "ARTIQ", runtimeVersion: 0)',
+                            strmod)
+        self.assert_ir_line('!4 = distinct !DISubprogram(file: !0, isLocal: '
+                            'false, line: 11, name: "my_func", type: !2, unit: '
+                            '!3)',
+                            strmod)
+        self.assert_valid_ir(mod)
+
+    def test_debug_info_2(self):
+        # Identical debug info nodes should be merged
+        mod = self.module()
+        di1 = mod.add_debug_info("DIFile",
+                                 {"filename": "foo",
+                                  "directory": "bar",
+                                  })
+        di2 = mod.add_debug_info("DIFile",
+                                 {"filename": "foo",
+                                  "directory": "bar",
+                                  })
+        di3 = mod.add_debug_info("DIFile",
+                                 {"filename": "bar",
+                                  "directory": "foo",
+                                  })
+        di4 = mod.add_debug_info("DIFile",
+                                 {"filename": "foo",
+                                  "directory": "bar",
+                                  }, is_distinct=True)
+        self.assertIs(di1, di2)
+        self.assertEqual(len({di1, di2, di3, di4}), 3)
+        # Check output
+        strmod = str(mod)
+        self.assert_ir_line('!0 = !DIFile(directory: "bar", filename: "foo")',
+                            strmod)
+        self.assert_ir_line('!1 = !DIFile(directory: "foo", filename: "bar")',
+                            strmod)
+        self.assert_ir_line('!2 = distinct !DIFile(directory: "bar", filename: '
+                            '"foo")', strmod)
+        self.assert_valid_ir(mod)
+
+    def test_debug_info_gvar(self):
+        # This test defines a module with a global variable named 'gvar'.
+        # When the module is compiled and linked with a main function, gdb can
+        # be used to interpret and print the the value of 'gvar'.
+        mod = self.module()
+
+        gvar = ir.GlobalVariable(mod, ir.FloatType(), 'gvar')
+        gvar.initializer = ir.Constant(ir.FloatType(), 42)
+
+        di_float = mod.add_debug_info("DIBasicType", {
+            "name": "float",
+            "size": 32,
+            "encoding": ir.DIToken("DW_ATE_float")
+        })
+        di_gvar = mod.add_debug_info("DIGlobalVariableExpression", {
+            "expr": mod.add_debug_info("DIExpression", {}),
+            "var": mod.add_debug_info("DIGlobalVariable", {
+                "name": gvar.name,
+                "type": di_float,
+                "isDefinition": True
+            }, is_distinct=True)
+        })
+        gvar.set_metadata('dbg', di_gvar)
+
+        # Check output
+        strmod = str(mod)
+        self.assert_ir_line('!0 = !DIBasicType(encoding: DW_ATE_float, '
+                            'name: "float", size: 32)', strmod)
+        self.assert_ir_line('!1 = !DIExpression()', strmod)
+        self.assert_ir_line('!2 = distinct !DIGlobalVariable(isDefinition: '
+                            'true, name: "gvar", type: !0)', strmod)
+        self.assert_ir_line('!3 = !DIGlobalVariableExpression(expr: !1, '
+                            'var: !2)', strmod)
+        self.assert_ir_line('@"gvar" = global float 0x4045000000000000, '
+                            '!dbg !3', strmod)
+
+        # The remaining debug info is not part of the automated test, but
+        # can be used to produce an object file that can be loaded into a
+        # debugger to print the value of gvar. This can be done by printing the
+        # module then compiling it with clang and inspecting with gdb:
+        #
+        #     clang test_debug_info_gvar.ll -c
+        #     printf "file test_debug_info_gvar.o \n p gvar" | gdb
+        #
+        # Which should result in the output:
+        #
+        #     (gdb) $1 = 42
+
+        dver = [ir.IntType(32)(2), 'Dwarf Version', ir.IntType(32)(4)]
+        diver = [ir.IntType(32)(2), 'Debug Info Version', ir.IntType(32)(3)]
+        dver = mod.add_metadata(dver)
+        diver = mod.add_metadata(diver)
+        flags = mod.add_named_metadata('llvm.module.flags')
+        flags.add(dver)
+        flags.add(diver)
+
+        di_file = mod.add_debug_info("DIFile", {
+            "filename": "foo",
+            "directory": "bar",
+        })
+        di_cu = mod.add_debug_info("DICompileUnit", {
+            "language": ir.DIToken("DW_LANG_Python"),
+            "file": di_file,
+            'emissionKind': ir.DIToken('FullDebug'),
+            "globals": mod.add_metadata([di_gvar])
+        }, is_distinct=True)
+        mod.add_named_metadata('llvm.dbg.cu', di_cu)
+
+    def test_debug_info_unicode_string(self):
+        mod = self.module()
+        mod.add_debug_info("DILocalVariable", {"name": "a∆"})
+        # Check output
+        strmod = str(mod)
+        # The unicode character is utf8 encoded with \XX format, where XX is hex
+        name = ''.join(map(lambda x: f"\\{x:02x}", "∆".encode()))
+        self.assert_ir_line(f'!0 = !DILocalVariable(name: "a{name}")', strmod)
+
+    def test_inline_assembly(self):
+        mod = self.module()
+        foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
+        builder = ir.IRBuilder(foo.append_basic_block(''))
+        asmty = ir.FunctionType(int32, [int32])
+        asm = ir.InlineAsm(asmty, "mov $1, $2", "=r,r", side_effect=True)
+        builder.call(asm, [int32(123)])
+        builder.ret_void()
+        pat = 'call i32 asm sideeffect "mov $1, $2", "=r,r" ( i32 123 )'
+        self.assertInText(pat, str(mod))
+        self.assert_valid_ir(mod)
+
+    def test_builder_asm(self):
+        mod = self.module()
+        foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
+        builder = ir.IRBuilder(foo.append_basic_block(''))
+        asmty = ir.FunctionType(int32, [int32])
+        builder.asm(asmty, "mov $1, $2", "=r,r", [int32(123)], side_effect=True)
+        builder.ret_void()
+        pat = 'call i32 asm sideeffect "mov $1, $2", "=r,r" ( i32 123 )'
+        self.assertInText(pat, str(mod))
+        self.assert_valid_ir(mod)
+
+    def test_builder_load_reg(self):
+        mod = self.module()
+        foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
+        builder = ir.IRBuilder(foo.append_basic_block(''))
+        builder.load_reg(ir.IntType(64), "rax")
+        builder.ret_void()
+        pat = 'call i64 asm "", "={rax}"'
+        self.assertInText(pat, str(mod))
+        self.assert_valid_ir(mod)
+
+    def test_builder_store_reg(self):
+        mod = self.module()
+        foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
+        builder = ir.IRBuilder(foo.append_basic_block(''))
+        builder.store_reg(int64(123), ir.IntType(64), "rax")
+        builder.ret_void()
+        pat = 'call void asm sideeffect "", "{rax}" ( i64 123 )'
+        self.assertInText(pat, str(mod))
+        self.assert_valid_ir(mod)
+
+
+class TestGlobalValues(TestBase):
+
+    def test_globals_access(self):
+        mod = self.module()
+        foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'foo')
+        ir.Function(mod, ir.FunctionType(ir.VoidType(), []), 'bar')
+        globdouble = ir.GlobalVariable(mod, ir.DoubleType(), 'globdouble')
+        self.assertEqual(mod.get_global('foo'), foo)
+        self.assertEqual(mod.get_global('globdouble'), globdouble)
+        with self.assertRaises(KeyError):
+            mod.get_global('kkk')
+        # Globals should have a useful repr()
+        self.assertEqual(repr(globdouble),
+                         "<ir.GlobalVariable 'globdouble' of type 'double*'>")
+
+    def test_functions_global_values_access(self):
+        """
+        Accessing functions and global values through Module.functions
+        and Module.global_values.
+        """
+        mod = self.module()
+        fty = ir.FunctionType(ir.VoidType(), [])
+        foo = ir.Function(mod, fty, 'foo')
+        bar = ir.Function(mod, fty, 'bar')
+        globdouble = ir.GlobalVariable(mod, ir.DoubleType(), 'globdouble')
+        self.assertEqual(set(mod.functions), set((foo, bar)))
+        self.assertEqual(set(mod.global_values), set((foo, bar, globdouble)))
+
+    def test_global_variables_ir(self):
+        """
+        IR serialization of global variables.
+        """
+        mod = self.module()
+        # the following have side effects and write to self.module()
+        a = ir.GlobalVariable(mod, int8, 'a')  # noqa F841
+        b = ir.GlobalVariable(mod, int8, 'b', addrspace=42)  # noqa F841
+        # Initialized global variable doesn't default to "external"
+        c = ir.GlobalVariable(mod, int32, 'c')
+        c.initializer = int32(123)
+        d = ir.GlobalVariable(mod, int32, 'd')
+        d.global_constant = True
+        # Non-external linkage implies default "undef" initializer
+        e = ir.GlobalVariable(mod, int32, 'e')
+        e.linkage = "internal"
+        f = ir.GlobalVariable(mod, int32, 'f', addrspace=456)
+        f.unnamed_addr = True
+        g = ir.GlobalVariable(mod, int32, 'g')
+        g.linkage = "internal"
+        g.initializer = int32(123)
+        g.align = 16
+        h = ir.GlobalVariable(mod, int32, 'h')
+        h.linkage = "internal"
+        h.initializer = int32(123)
+        h.section = "h_section"
+        i = ir.GlobalVariable(mod, int32, 'i')
+        i.linkage = "internal"
+        i.initializer = int32(456)
+        i.align = 8
+        i.section = "i_section"
+        self.check_module_body(mod, """\
+            @"a" = external global i8
+            @"b" = external addrspace(42) global i8
+            @"c" = global i32 123
+            @"d" = external constant i32
+            @"e" = internal global i32 undef
+            @"f" = external unnamed_addr addrspace(456) global i32
+            @"g" = internal global i32 123, align 16
+            @"h" = internal global i32 123, section "h_section"
+            @"i" = internal global i32 456, section "i_section", align 8
+            """)
+
+    def test_pickle(self):
+        mod = self.module()
+        self.assert_pickle_correctly(mod)
+
+
+class TestBlock(TestBase):
+
+    def test_attributes(self):
+        func = self.function()
+        block = ir.Block(parent=func, name='start')
+        self.assertIs(block.parent, func)
+        self.assertFalse(block.is_terminated)
+
+    def test_descr(self):
+        block = self.block(name='my_block')
+        self.assertEqual(self.descr(block), "my_block:\n")
+        block.instructions.extend(['a', 'b'])
+        self.assertEqual(self.descr(block), "my_block:\n  a\n  b\n")
+
+    def test_replace(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        c = builder.add(a, b, 'c')
+        d = builder.sub(a, b, 'd')
+        builder.mul(d, b, 'e')
+        f = ir.Instruction(block, a.type, 'sdiv', (c, b), 'f')
+        self.check_block(block, """\
+            my_block:
+                %"c" = add i32 %".1", %".2"
+                %"d" = sub i32 %".1", %".2"
+                %"e" = mul i32 %"d", %".2"
+            """)
+        block.replace(d, f)
+        self.check_block(block, """\
+            my_block:
+                %"c" = add i32 %".1", %".2"
+                %"f" = sdiv i32 %"c", %".2"
+                %"e" = mul i32 %"f", %".2"
+            """)
+
+    def test_repr(self):
+        """
+        Blocks should have a useful repr()
+        """
+        func = self.function()
+        block = ir.Block(parent=func, name='start')
+        self.assertEqual(repr(block), "<ir.Block 'start' of type 'label'>")
+
+
+class TestBuildInstructions(TestBase):
+    """
+    Test IR generation of LLVM instructions through the IRBuilder class.
+    """
+
+    maxDiff = 4000
+
+    def test_simple(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        inst = builder.add(a, b, 'res')
+        self.check_block(block, """\
+            my_block:
+                %"res" = add i32 %".1", %".2"
+            """)
+        # Instructions should have a useful repr()
+        self.assertEqual(repr(inst),
+                         "<ir.Instruction 'res' of type 'i32', opname 'add', "
+                         "operands (<ir.Argument '.1' of type i32>, "
+                         "<ir.Argument '.2' of type i32>)>")
+
+    def test_binops(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b, ff = builder.function.args[:3]
+        builder.add(a, b, 'c')
+        builder.fadd(a, b, 'd')
+        builder.sub(a, b, 'e')
+        builder.fsub(a, b, 'f')
+        builder.mul(a, b, 'g')
+        builder.fmul(a, b, 'h')
+        builder.udiv(a, b, 'i')
+        builder.sdiv(a, b, 'j')
+        builder.fdiv(a, b, 'k')
+        builder.urem(a, b, 'l')
+        builder.srem(a, b, 'm')
+        builder.frem(a, b, 'n')
+        builder.or_(a, b, 'o')
+        builder.and_(a, b, 'p')
+        builder.xor(a, b, 'q')
+        builder.shl(a, b, 'r')
+        builder.ashr(a, b, 's')
+        builder.lshr(a, b, 't')
+        with self.assertRaises(ValueError) as cm:
+            builder.add(a, ff)
+        self.assertEqual(str(cm.exception),
+                         "Operands must be the same type, got (i32, double)")
+        self.assertFalse(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                %"c" = add i32 %".1", %".2"
+                %"d" = fadd i32 %".1", %".2"
+                %"e" = sub i32 %".1", %".2"
+                %"f" = fsub i32 %".1", %".2"
+                %"g" = mul i32 %".1", %".2"
+                %"h" = fmul i32 %".1", %".2"
+                %"i" = udiv i32 %".1", %".2"
+                %"j" = sdiv i32 %".1", %".2"
+                %"k" = fdiv i32 %".1", %".2"
+                %"l" = urem i32 %".1", %".2"
+                %"m" = srem i32 %".1", %".2"
+                %"n" = frem i32 %".1", %".2"
+                %"o" = or i32 %".1", %".2"
+                %"p" = and i32 %".1", %".2"
+                %"q" = xor i32 %".1", %".2"
+                %"r" = shl i32 %".1", %".2"
+                %"s" = ashr i32 %".1", %".2"
+                %"t" = lshr i32 %".1", %".2"
+            """)
+
+    def test_binop_flags(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        # As tuple
+        builder.add(a, b, 'c', flags=('nuw',))
+        # and as list
+        builder.sub(a, b, 'd', flags=['nuw', 'nsw'])
+        self.check_block(block, """\
+            my_block:
+                %"c" = add nuw i32 %".1", %".2"
+                %"d" = sub nuw nsw i32 %".1", %".2"
+            """)
+
+    def test_binop_fastmath_flags(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        # As tuple
+        builder.fadd(a, b, 'c', flags=('fast',))
+        # and as list
+        builder.fsub(a, b, 'd', flags=['ninf', 'nsz'])
+        self.check_block(block, """\
+            my_block:
+                %"c" = fadd fast i32 %".1", %".2"
+                %"d" = fsub ninf nsz i32 %".1", %".2"
+            """)
+
+    def test_binops_with_overflow(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        builder.sadd_with_overflow(a, b, 'c')
+        builder.smul_with_overflow(a, b, 'd')
+        builder.ssub_with_overflow(a, b, 'e')
+        builder.uadd_with_overflow(a, b, 'f')
+        builder.umul_with_overflow(a, b, 'g')
+        builder.usub_with_overflow(a, b, 'h')
+        self.check_block(block, """\
+my_block:
+    %"c" = call {i32, i1} @"llvm.sadd.with.overflow.i32"(i32 %".1", i32 %".2")
+    %"d" = call {i32, i1} @"llvm.smul.with.overflow.i32"(i32 %".1", i32 %".2")
+    %"e" = call {i32, i1} @"llvm.ssub.with.overflow.i32"(i32 %".1", i32 %".2")
+    %"f" = call {i32, i1} @"llvm.uadd.with.overflow.i32"(i32 %".1", i32 %".2")
+    %"g" = call {i32, i1} @"llvm.umul.with.overflow.i32"(i32 %".1", i32 %".2")
+    %"h" = call {i32, i1} @"llvm.usub.with.overflow.i32"(i32 %".1", i32 %".2")
+            """)
+
+    def test_unary_ops(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b, c = builder.function.args[:3]
+        builder.neg(a, 'd')
+        builder.not_(b, 'e')
+        builder.fneg(c, 'f')
+        self.assertFalse(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                %"d" = sub i32 0, %".1"
+                %"e" = xor i32 %".2", -1
+                %"f" = fneg double %".3"
+            """)
+
+    def test_replace_operand(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        undef1 = ir.Constant(ir.IntType(32), ir.Undefined)
+        undef2 = ir.Constant(ir.IntType(32), ir.Undefined)
+        c = builder.add(undef1, undef2, 'c')
+        self.check_block(block, """\
+            my_block:
+                %"c" = add i32 undef, undef
+            """)
+        c.replace_usage(undef1, a)
+        c.replace_usage(undef2, b)
+        self.check_block(block, """\
+            my_block:
+                %"c" = add i32 %".1", %".2"
+            """)
+
+    def test_integer_comparisons(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        builder.icmp_unsigned('==', a, b, 'c')
+        builder.icmp_unsigned('!=', a, b, 'd')
+        builder.icmp_unsigned('<', a, b, 'e')
+        builder.icmp_unsigned('<=', a, b, 'f')
+        builder.icmp_unsigned('>', a, b, 'g')
+        builder.icmp_unsigned('>=', a, b, 'h')
+        builder.icmp_signed('==', a, b, 'i')
+        builder.icmp_signed('!=', a, b, 'j')
+        builder.icmp_signed('<', a, b, 'k')
+        builder.icmp_signed('<=', a, b, 'l')
+        builder.icmp_signed('>', a, b, 'm')
+        builder.icmp_signed('>=', a, b, 'n')
+        with self.assertRaises(ValueError):
+            builder.icmp_signed('uno', a, b, 'zz')
+        with self.assertRaises(ValueError):
+            builder.icmp_signed('foo', a, b, 'zz')
+        self.assertFalse(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                %"c" = icmp eq i32 %".1", %".2"
+                %"d" = icmp ne i32 %".1", %".2"
+                %"e" = icmp ult i32 %".1", %".2"
+                %"f" = icmp ule i32 %".1", %".2"
+                %"g" = icmp ugt i32 %".1", %".2"
+                %"h" = icmp uge i32 %".1", %".2"
+                %"i" = icmp eq i32 %".1", %".2"
+                %"j" = icmp ne i32 %".1", %".2"
+                %"k" = icmp slt i32 %".1", %".2"
+                %"l" = icmp sle i32 %".1", %".2"
+                %"m" = icmp sgt i32 %".1", %".2"
+                %"n" = icmp sge i32 %".1", %".2"
+            """)
+
+    def test_float_comparisons(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        builder.fcmp_ordered('==', a, b, 'c')
+        builder.fcmp_ordered('!=', a, b, 'd')
+        builder.fcmp_ordered('<', a, b, 'e')
+        builder.fcmp_ordered('<=', a, b, 'f')
+        builder.fcmp_ordered('>', a, b, 'g')
+        builder.fcmp_ordered('>=', a, b, 'h')
+        builder.fcmp_unordered('==', a, b, 'i')
+        builder.fcmp_unordered('!=', a, b, 'j')
+        builder.fcmp_unordered('<', a, b, 'k')
+        builder.fcmp_unordered('<=', a, b, 'l')
+        builder.fcmp_unordered('>', a, b, 'm')
+        builder.fcmp_unordered('>=', a, b, 'n')
+        # fcmp_ordered and fcmp_unordered are the same for these cases
+        builder.fcmp_ordered('ord', a, b, 'u')
+        builder.fcmp_ordered('uno', a, b, 'v')
+        builder.fcmp_unordered('ord', a, b, 'w')
+        builder.fcmp_unordered('uno', a, b, 'x')
+        builder.fcmp_unordered('olt', a, b, 'y',
+                               flags=['nnan', 'ninf', 'nsz', 'arcp', 'fast'])
+        self.assertFalse(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                %"c" = fcmp oeq i32 %".1", %".2"
+                %"d" = fcmp one i32 %".1", %".2"
+                %"e" = fcmp olt i32 %".1", %".2"
+                %"f" = fcmp ole i32 %".1", %".2"
+                %"g" = fcmp ogt i32 %".1", %".2"
+                %"h" = fcmp oge i32 %".1", %".2"
+                %"i" = fcmp ueq i32 %".1", %".2"
+                %"j" = fcmp une i32 %".1", %".2"
+                %"k" = fcmp ult i32 %".1", %".2"
+                %"l" = fcmp ule i32 %".1", %".2"
+                %"m" = fcmp ugt i32 %".1", %".2"
+                %"n" = fcmp uge i32 %".1", %".2"
+                %"u" = fcmp ord i32 %".1", %".2"
+                %"v" = fcmp uno i32 %".1", %".2"
+                %"w" = fcmp ord i32 %".1", %".2"
+                %"x" = fcmp uno i32 %".1", %".2"
+                %"y" = fcmp nnan ninf nsz arcp fast olt i32 %".1", %".2"
+            """)
+
+    def test_misc_ops(self):
+        block = self.block(name='my_block')
+        t = ir.Constant(int1, True)
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        builder.select(t, a, b, 'c', flags=('arcp', 'nnan'))
+        self.assertFalse(block.is_terminated)
+        builder.unreachable()
+        self.assertTrue(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                %"c" = select arcp nnan i1 true, i32 %".1", i32 %".2"
+                unreachable
+            """)
+
+    def test_phi(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        bb2 = builder.function.append_basic_block('b2')
+        bb3 = builder.function.append_basic_block('b3')
+        phi = builder.phi(int32, 'my_phi', flags=('fast',))
+        phi.add_incoming(a, bb2)
+        phi.add_incoming(b, bb3)
+        self.assertFalse(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                %"my_phi" = phi fast i32 [%".1", %"b2"], [%".2", %"b3"]
+            """)
+
+    def test_mem_ops(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b, z = builder.function.args[:3]
+        c = builder.alloca(int32, name='c')
+        d = builder.alloca(int32, size=42, name='d')  # noqa F841
+        e = builder.alloca(dbl, size=a, name='e')
+        e.align = 8
+        self.assertEqual(e.type, ir.PointerType(dbl))
+        ee = builder.store(z, e)
+        self.assertEqual(ee.type, ir.VoidType())
+        f = builder.store(b, c)
+        self.assertEqual(f.type, ir.VoidType())
+        g = builder.load(c, 'g')
+        self.assertEqual(g.type, int32)
+        # With alignment
+        h = builder.store(b, c, align=1)
+        self.assertEqual(h.type, ir.VoidType())
+        i = builder.load(c, 'i', align=1)
+        self.assertEqual(i.type, int32)
+        # Atomics
+        j = builder.store_atomic(b, c, ordering="seq_cst", align=4)
+        self.assertEqual(j.type, ir.VoidType())
+        k = builder.load_atomic(c, ordering="seq_cst", align=4, name='k')
+        self.assertEqual(k.type, int32)
+        # Not pointer types
+        with self.assertRaises(TypeError):
+            builder.store(b, a)
+        with self.assertRaises(TypeError):
+            builder.load(b)
+        # Mismatching pointer type
+        with self.assertRaises(TypeError) as cm:
+            builder.store(b, e)
+        self.assertEqual(str(cm.exception),
+                         "cannot store i32 to double*: mismatching types")
+        self.check_block(block, """\
+            my_block:
+                %"c" = alloca i32
+                %"d" = alloca i32, i32 42
+                %"e" = alloca double, i32 %".1", align 8
+                store double %".3", double* %"e"
+                store i32 %".2", i32* %"c"
+                %"g" = load i32, i32* %"c"
+                store i32 %".2", i32* %"c", align 1
+                %"i" = load i32, i32* %"c", align 1
+                store atomic i32 %".2", i32* %"c" seq_cst, align 4
+                %"k" = load atomic i32, i32* %"c" seq_cst, align 4
+            """)
+
+    def test_gep(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        c = builder.alloca(ir.PointerType(int32), name='c')
+        d = builder.gep(c, [ir.Constant(int32, 5), a], name='d')
+        self.assertEqual(d.type, ir.PointerType(int32))
+        self.check_block(block, """\
+            my_block:
+                %"c" = alloca i32*
+                %"d" = getelementptr i32*, i32** %"c", i32 5, i32 %".1"
+            """)
+        # XXX test with more complex types
+
+    def test_gep_castinstr(self):
+        # similar to:
+        # numba::runtime::nrtdynmod.py_define_nrt_meminfo_data()
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        int8ptr = int8.as_pointer()
+        ls = ir.LiteralStructType([int64, int8ptr, int8ptr, int8ptr, int64])
+        d = builder.bitcast(a, ls.as_pointer(), name='d')
+        e = builder.gep(d, [ir.Constant(int32, x) for x in [0, 3]], name='e')
+        self.assertEqual(e.type, ir.PointerType(int8ptr))
+        self.check_block(block, """\
+            my_block:
+                %"d" = bitcast i32 %".1" to {i64, i8*, i8*, i8*, i64}*
+                %"e" = getelementptr {i64, i8*, i8*, i8*, i64}, {i64, i8*, i8*, i8*, i64}* %"d", i32 0, i32 3
+            """)  # noqa E501
+
+    def test_gep_castinstr_addrspace(self):
+        # similar to:
+        # numba::runtime::nrtdynmod.py_define_nrt_meminfo_data()
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        addrspace = 4
+        int8ptr = int8.as_pointer()
+        ls = ir.LiteralStructType([int64, int8ptr, int8ptr, int8ptr, int64])
+        d = builder.bitcast(a, ls.as_pointer(addrspace=addrspace), name='d')
+        e = builder.gep(d, [ir.Constant(int32, x) for x in [0, 3]], name='e')
+        self.assertEqual(e.type.addrspace, addrspace)
+        self.assertEqual(e.type, ir.PointerType(int8ptr, addrspace=addrspace))
+        self.check_block(block, """\
+            my_block:
+                %"d" = bitcast i32 %".1" to {i64, i8*, i8*, i8*, i64} addrspace(4)*
+                %"e" = getelementptr {i64, i8*, i8*, i8*, i64}, {i64, i8*, i8*, i8*, i64} addrspace(4)* %"d", i32 0, i32 3
+            """)  # noqa E501
+
+    def test_gep_addrspace(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        addrspace = 4
+        c = builder.alloca(ir.PointerType(int32, addrspace=addrspace), name='c')
+        self.assertEqual(str(c.type), 'i32 addrspace(4)**')
+        self.assertEqual(c.type.pointee.addrspace, addrspace)
+        d = builder.gep(c, [ir.Constant(int32, 5), a], name='d')
+        self.assertEqual(d.type.addrspace, addrspace)
+        e = builder.gep(d, [ir.Constant(int32, 10)], name='e')
+        self.assertEqual(e.type.addrspace, addrspace)
+        self.check_block(block, """\
+            my_block:
+                %"c" = alloca i32 addrspace(4)*
+                %"d" = getelementptr i32 addrspace(4)*, i32 addrspace(4)** %"c", i32 5, i32 %".1"
+                %"e" = getelementptr i32, i32 addrspace(4)* %"d", i32 10
+            """)  # noqa E501
+
+    def test_extract_insert_value(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        tp_inner = ir.LiteralStructType([int32, int1])
+        tp_outer = ir.LiteralStructType([int8, tp_inner])
+        c_inner = ir.Constant(tp_inner, (ir.Constant(int32, 4),
+                                         ir.Constant(int1, True)))
+        # Flat structure
+        c = builder.extract_value(c_inner, 0, name='c')  # noqa F841
+        d = builder.insert_value(c_inner, a, 0, name='d')  # noqa F841
+        e = builder.insert_value(d, ir.Constant(int1, False), 1, name='e')  # noqa F841 E501
+        self.assertEqual(d.type, tp_inner)
+        self.assertEqual(e.type, tp_inner)
+        # Nested structure
+        p_outer = builder.alloca(tp_outer, name='ptr')
+        j = builder.load(p_outer, name='j')
+        k = builder.extract_value(j, 0, name='k')
+        l = builder.extract_value(j, 1, name='l')
+        m = builder.extract_value(j, (1, 0), name='m')
+        n = builder.extract_value(j, (1, 1), name='n')
+        o = builder.insert_value(j, l, 1, name='o')
+        p = builder.insert_value(j, a, (1, 0), name='p')
+        self.assertEqual(k.type, int8)
+        self.assertEqual(l.type, tp_inner)
+        self.assertEqual(m.type, int32)
+        self.assertEqual(n.type, int1)
+        self.assertEqual(o.type, tp_outer)
+        self.assertEqual(p.type, tp_outer)
+
+        with self.assertRaises(TypeError):
+            # Not an aggregate
+            builder.extract_value(p_outer, 0)
+        with self.assertRaises(TypeError):
+            # Indexing too deep
+            builder.extract_value(c_inner, (0, 0))
+        with self.assertRaises(TypeError):
+            # Index out of structure bounds
+            builder.extract_value(c_inner, 5)
+        with self.assertRaises(TypeError):
+            # Not an aggregate
+            builder.insert_value(a, b, 0)
+        with self.assertRaises(TypeError):
+            # Replacement value has the wrong type
+            builder.insert_value(c_inner, a, 1)
+
+        self.check_block(block, """\
+            my_block:
+                %"c" = extractvalue {i32, i1} {i32 4, i1 true}, 0
+                %"d" = insertvalue {i32, i1} {i32 4, i1 true}, i32 %".1", 0
+                %"e" = insertvalue {i32, i1} %"d", i1 false, 1
+                %"ptr" = alloca {i8, {i32, i1}}
+                %"j" = load {i8, {i32, i1}}, {i8, {i32, i1}}* %"ptr"
+                %"k" = extractvalue {i8, {i32, i1}} %"j", 0
+                %"l" = extractvalue {i8, {i32, i1}} %"j", 1
+                %"m" = extractvalue {i8, {i32, i1}} %"j", 1, 0
+                %"n" = extractvalue {i8, {i32, i1}} %"j", 1, 1
+                %"o" = insertvalue {i8, {i32, i1}} %"j", {i32, i1} %"l", 1
+                %"p" = insertvalue {i8, {i32, i1}} %"j", i32 %".1", 1, 0
+            """)
+
+    def test_cast_ops(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b, fa, ptr = builder.function.args[:4]
+        c = builder.trunc(a, int8, name='c')
+        d = builder.zext(c, int32, name='d')  # noqa F841
+        e = builder.sext(c, int32, name='e')  # noqa F841
+        fb = builder.fptrunc(fa, flt, 'fb')
+        fc = builder.fpext(fb, dbl, 'fc')  # noqa F841
+        g = builder.fptoui(fa, int32, 'g')
+        h = builder.fptosi(fa, int8, 'h')
+        fd = builder.uitofp(g, flt, 'fd')  # noqa F841
+        fe = builder.sitofp(h, dbl, 'fe')  # noqa F841
+        i = builder.ptrtoint(ptr, int32, 'i')
+        j = builder.inttoptr(i, ir.PointerType(int8), 'j')  # noqa F841
+        k = builder.bitcast(a, flt, "k")  # noqa F841
+        self.assertFalse(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                %"c" = trunc i32 %".1" to i8
+                %"d" = zext i8 %"c" to i32
+                %"e" = sext i8 %"c" to i32
+                %"fb" = fptrunc double %".3" to float
+                %"fc" = fpext float %"fb" to double
+                %"g" = fptoui double %".3" to i32
+                %"h" = fptosi double %".3" to i8
+                %"fd" = uitofp i32 %"g" to float
+                %"fe" = sitofp i8 %"h" to double
+                %"i" = ptrtoint i32* %".4" to i32
+                %"j" = inttoptr i32 %"i" to i8*
+                %"k" = bitcast i32 %".1" to float
+            """)
+
+    def test_atomicrmw(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        c = builder.alloca(int32, name='c')
+        d = builder.atomic_rmw('add', c, a, 'monotonic', 'd')
+        self.assertEqual(d.type, int32)
+        self.check_block(block, """\
+            my_block:
+                %"c" = alloca i32
+                %"d" = atomicrmw add i32* %"c", i32 %".1" monotonic
+            """)
+
+    def test_branch(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        bb_target = builder.function.append_basic_block(name='target')
+        builder.branch(bb_target)
+        self.assertTrue(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                br label %"target"
+            """)
+
+    def test_cbranch(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        bb_true = builder.function.append_basic_block(name='b_true')
+        bb_false = builder.function.append_basic_block(name='b_false')
+        builder.cbranch(ir.Constant(int1, False), bb_true, bb_false)
+        self.assertTrue(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                br i1 false, label %"b_true", label %"b_false"
+            """)
+
+    def test_cbranch_weights(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        bb_true = builder.function.append_basic_block(name='b_true')
+        bb_false = builder.function.append_basic_block(name='b_false')
+        br = builder.cbranch(ir.Constant(int1, False), bb_true, bb_false)
+        br.set_weights([5, 42])
+        self.assertTrue(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                br i1 false, label %"b_true", label %"b_false", !prof !0
+            """)
+        self.check_metadata(builder.module, """\
+            !0 = !{ !"branch_weights", i32 5, i32 42 }
+            """)
+
+    def test_branch_indirect(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        bb_1 = builder.function.append_basic_block(name='b_1')
+        bb_2 = builder.function.append_basic_block(name='b_2')
+        indirectbr = builder.branch_indirect(
+            ir.BlockAddress(builder.function, bb_1))
+        indirectbr.add_destination(bb_1)
+        indirectbr.add_destination(bb_2)
+        self.assertTrue(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                indirectbr i8* blockaddress(@"my_func", %"b_1"), [label %"b_1", label %"b_2"]
+            """)  # noqa E501
+
+    def test_returns(self):
+        def check(block, expected_ir):
+            self.assertTrue(block.is_terminated)
+            self.check_block(block, expected_ir)
+
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        builder.ret_void()
+        check(block, """\
+            my_block:
+                ret void
+            """)
+
+        block = self.block(name='other_block')
+        builder = ir.IRBuilder(block)
+        builder.ret(int32(5))
+        check(block, """\
+            other_block:
+                ret i32 5
+            """)
+
+        # With metadata
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        inst = builder.ret_void()
+        inst.set_metadata("dbg", block.module.add_metadata(()))
+        check(block, """\
+            my_block:
+                ret void, !dbg !0
+            """)
+
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        inst = builder.ret(int32(6))
+        inst.set_metadata("dbg", block.module.add_metadata(()))
+        check(block, """\
+            my_block:
+                ret i32 6, !dbg !0
+            """)
+
+    def test_switch(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        bb_onzero = builder.function.append_basic_block(name='onzero')
+        bb_onone = builder.function.append_basic_block(name='onone')
+        bb_ontwo = builder.function.append_basic_block(name='ontwo')
+        bb_else = builder.function.append_basic_block(name='otherwise')
+        sw = builder.switch(a, bb_else)
+        sw.add_case(ir.Constant(int32, 0), bb_onzero)
+        sw.add_case(ir.Constant(int32, 1), bb_onone)
+        # A plain Python value gets converted into the right IR constant
+        sw.add_case(2, bb_ontwo)
+        self.assertTrue(block.is_terminated)
+        self.check_block(block, """\
+            my_block:
+                switch i32 %".1", label %"otherwise" [i32 0, label %"onzero" i32 1, label %"onone" i32 2, label %"ontwo"]
+            """)  # noqa E501
+
+    def test_call(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        tp_f = ir.FunctionType(flt, (int32, int32))
+        tp_g = ir.FunctionType(dbl, (int32,), var_arg=True)
+        tp_h = ir.FunctionType(hlf, (int32, int32))
+        f = ir.Function(builder.function.module, tp_f, 'f')
+        g = ir.Function(builder.function.module, tp_g, 'g')
+        h = ir.Function(builder.function.module, tp_h, 'h')
+        builder.call(f, (a, b), 'res_f')
+        builder.call(g, (b, a), 'res_g')
+        builder.call(h, (a, b), 'res_h')
+        builder.call(f, (a, b), 'res_f_fast', cconv='fastcc')
+        res_f_readonly = builder.call(f, (a, b), 'res_f_readonly')
+        res_f_readonly.attributes.add('readonly')
+        builder.call(f, (a, b), 'res_fast', fastmath='fast')
+        builder.call(f, (a, b), 'res_nnan_ninf', fastmath=('nnan', 'ninf'))
+        builder.call(f, (a, b), 'res_noinline', attrs='noinline')
+        builder.call(f, (a, b), 'res_alwaysinline', attrs='alwaysinline')
+        builder.call(f, (a, b), 'res_noinline_ro', attrs=('noinline',
+                                                          'readonly'))
+        self.check_block(block, """\
+        my_block:
+            %"res_f" = call float @"f"(i32 %".1", i32 %".2")
+            %"res_g" = call double (i32, ...) @"g"(i32 %".2", i32 %".1")
+            %"res_h" = call half @"h"(i32 %".1", i32 %".2")
+            %"res_f_fast" = call fastcc float @"f"(i32 %".1", i32 %".2")
+            %"res_f_readonly" = call float @"f"(i32 %".1", i32 %".2") readonly
+            %"res_fast" = call fast float @"f"(i32 %".1", i32 %".2")
+            %"res_nnan_ninf" = call ninf nnan float @"f"(i32 %".1", i32 %".2")
+            %"res_noinline" = call float @"f"(i32 %".1", i32 %".2") noinline
+            %"res_alwaysinline" = call float @"f"(i32 %".1", i32 %".2") alwaysinline
+            %"res_noinline_ro" = call float @"f"(i32 %".1", i32 %".2") noinline readonly
+        """) # noqa E501
+
+    def test_call_metadata(self):
+        """
+        Function calls with metadata arguments.
+        """
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        dbg_declare_ty = ir.FunctionType(ir.VoidType(), [ir.MetaDataType()] * 3)
+        dbg_declare = ir.Function(
+            builder.module,
+            dbg_declare_ty,
+            'llvm.dbg.declare')
+        a = builder.alloca(int32, name="a")
+        b = builder.module.add_metadata(())
+        builder.call(dbg_declare, (a, b, b))
+        self.check_block(block, """\
+            my_block:
+                %"a" = alloca i32
+                call void @"llvm.dbg.declare"(metadata i32* %"a", metadata !0, metadata !0)
+            """)  # noqa E501
+
+    def test_call_attributes(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        fun_ty = ir.FunctionType(
+            ir.VoidType(), (int32.as_pointer(), int32, int32.as_pointer()))
+        fun = ir.Function(builder.function.module, fun_ty, 'fun')
+        fun.args[0].add_attribute('sret')
+        retval = builder.alloca(int32, name='retval')
+        other = builder.alloca(int32, name='other')
+        builder.call(
+            fun,
+            (retval, ir.Constant(int32, 42), other),
+            arg_attrs={
+                0: ('sret', 'noalias'),
+                2: 'noalias'
+            }
+        )
+        self.check_block_regex(block, """\
+        my_block:
+            %"retval" = alloca i32
+            %"other" = alloca i32
+            call void @"fun"\\(i32\\* noalias sret(\\(i32\\))? %"retval", i32 42, i32\\* noalias %"other"\\)
+        """)  # noqa E501
+
+    def test_call_tail(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        fun_ty = ir.FunctionType(ir.VoidType(), ())
+        fun = ir.Function(builder.function.module, fun_ty, 'my_fun')
+
+        builder.call(fun, ())
+        builder.call(fun, (), tail=False)
+        builder.call(fun, (), tail=True)
+        builder.call(fun, (), tail='tail')
+        builder.call(fun, (), tail='notail')
+        builder.call(fun, (), tail='musttail')
+        builder.call(fun, (), tail=[])  # This is a falsy value
+        builder.call(fun, (), tail='not a marker')  # This is a truthy value
+
+        self.check_block(block, """\
+        my_block:
+            call void @"my_fun"()
+            call void @"my_fun"()
+            tail call void @"my_fun"()
+            tail call void @"my_fun"()
+            notail call void @"my_fun"()
+            musttail call void @"my_fun"()
+            call void @"my_fun"()
+            tail call void @"my_fun"()
+        """)  # noqa E501
+
+    def test_invalid_call_attributes(self):
+        block = self.block()
+        builder = ir.IRBuilder(block)
+        fun_ty = ir.FunctionType(ir.VoidType(), ())
+        fun = ir.Function(builder.function.module, fun_ty, 'fun')
+        with self.assertRaises(ValueError):
+            # The function has no arguments, so this should fail.
+            builder.call(fun, (), arg_attrs={0: 'sret'})
+
+    def test_invoke(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        tp_f = ir.FunctionType(flt, (int32, int32))
+        f = ir.Function(builder.function.module, tp_f, 'f')
+        bb_normal = builder.function.append_basic_block(name='normal')
+        bb_unwind = builder.function.append_basic_block(name='unwind')
+        builder.invoke(f, (a, b), bb_normal, bb_unwind, 'res_f')
+        self.check_block(block, """\
+            my_block:
+                %"res_f" = invoke float @"f"(i32 %".1", i32 %".2")
+                    to label %"normal" unwind label %"unwind"
+            """)
+
+    def test_invoke_attributes(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        fun_ty = ir.FunctionType(
+            ir.VoidType(), (int32.as_pointer(), int32, int32.as_pointer()))
+        fun = ir.Function(builder.function.module, fun_ty, 'fun')
+        fun.calling_convention = "fastcc"
+        fun.args[0].add_attribute('sret')
+        retval = builder.alloca(int32, name='retval')
+        other = builder.alloca(int32, name='other')
+        bb_normal = builder.function.append_basic_block(name='normal')
+        bb_unwind = builder.function.append_basic_block(name='unwind')
+        builder.invoke(
+            fun,
+            (retval, ir.Constant(int32, 42), other),
+            bb_normal,
+            bb_unwind,
+            cconv='fastcc',
+            fastmath='fast',
+            attrs='noinline',
+            arg_attrs={
+                0: ('sret', 'noalias'),
+                2: 'noalias'
+            }
+        )
+        self.check_block_regex(block, """\
+        my_block:
+            %"retval" = alloca i32
+            %"other" = alloca i32
+            invoke fast fastcc void @"fun"\\(i32\\* noalias sret(\\(i32\\))? %"retval", i32 42, i32\\* noalias %"other"\\) noinline
+                to label %"normal" unwind label %"unwind"
+        """)  # noqa E501
+
+    def test_landingpad(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        lp = builder.landingpad(ir.LiteralStructType([int32,
+                                                      int8.as_pointer()]), 'lp')
+        int_typeinfo = ir.GlobalVariable(builder.function.module,
+                                         int8.as_pointer(), "_ZTIi")
+        int_typeinfo.global_constant = True
+        lp.add_clause(ir.CatchClause(int_typeinfo))
+        lp.add_clause(ir.FilterClause(ir.Constant(ir.ArrayType(
+            int_typeinfo.type, 1), [int_typeinfo])))
+        builder.resume(lp)
+        self.check_block(block, """\
+            my_block:
+                %"lp" = landingpad {i32, i8*}
+                    catch i8** @"_ZTIi"
+                    filter [1 x i8**] [i8** @"_ZTIi"]
+                resume {i32, i8*} %"lp"
+            """)
+
+    def test_assume(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        c = builder.icmp_signed('>', a, b, name='c')
+        builder.assume(c)
+        self.check_block(block, """\
+            my_block:
+                %"c" = icmp sgt i32 %".1", %".2"
+                call void @"llvm.assume"(i1 %"c")
+            """)
+
+    def test_vector_ops(self):
+        block = self.block(name='insert_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        a.name = 'a'
+        b.name = 'b'
+
+        vecty = ir.VectorType(a.type, 2)
+        vec = ir.Constant(vecty, ir.Undefined)
+        idxty = ir.IntType(32)
+        vec = builder.insert_element(vec, a, idxty(0), name='vec1')
+        vec = builder.insert_element(vec, b, idxty(1), name='vec2')
+
+        self.check_block(block, """\
+insert_block:
+    %"vec1" = insertelement <2 x i32> <i32 undef, i32 undef>, i32 %"a", i32 0
+    %"vec2" = insertelement <2 x i32> %"vec1", i32 %"b", i32 1
+            """)
+
+        block = builder.append_basic_block("shuffle_block")
+        builder.branch(block)
+        builder.position_at_end(block)
+
+        mask = ir.Constant(vecty, [1, 0])
+        builder.shuffle_vector(vec, vec, mask, name='shuf')
+
+        self.check_block(block, """\
+            shuffle_block:
+                %"shuf" = shufflevector <2 x i32> %"vec2", <2 x i32> %"vec2", <2 x i32> <i32 1, i32 0>
+            """)  # noqa E501
+
+        block = builder.append_basic_block("add_block")
+        builder.branch(block)
+        builder.position_at_end(block)
+
+        builder.add(vec, vec, name='sum')
+
+        self.check_block(block, """\
+            add_block:
+                %"sum" = add <2 x i32> %"vec2", %"vec2"
+            """)
+
+        block = builder.append_basic_block("extract_block")
+        builder.branch(block)
+        builder.position_at_end(block)
+
+        c = builder.extract_element(vec, idxty(0), name='ex1')
+        d = builder.extract_element(vec, idxty(1), name='ex2')
+
+        self.check_block(block, """\
+            extract_block:
+              %"ex1" = extractelement <2 x i32> %"vec2", i32 0
+              %"ex2" = extractelement <2 x i32> %"vec2", i32 1
+            """)
+
+        builder.ret(builder.add(c, d))
+        self.assert_valid_ir(builder.module)
+
+    def test_bitreverse(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int64, 5)
+        c = builder.bitreverse(a, name='c')
+        builder.ret(c)
+        self.check_block(block, """\
+            my_block:
+                %"c" = call i64 @"llvm.bitreverse.i64"(i64 5)
+                ret i64 %"c"
+            """)
+
+    def test_bitreverse_wrongtype(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.bitreverse(a, name='c')
+        self.assertIn(
+            "expected an integer type, got float",
+            str(raises.exception))
+
+    def test_fence(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        with self.assertRaises(ValueError) as raises:
+            builder.fence("monotonic", None)
+        self.assertIn(
+            "Invalid fence ordering \"monotonic\"!",
+            str(raises.exception))
+        with self.assertRaises(ValueError) as raises:
+            builder.fence(None, "monotonic")
+        self.assertIn(
+            "Invalid fence ordering \"None\"!",
+            str(raises.exception))
+        builder.fence("acquire", None)
+        builder.fence("release", "singlethread")
+        builder.fence("acq_rel", "singlethread")
+        builder.fence("seq_cst")
+        builder.ret_void()
+        self.check_block(block, """\
+            my_block:
+                fence acquire
+                fence syncscope("singlethread") release
+                fence syncscope("singlethread") acq_rel
+                fence seq_cst
+                ret void
+            """)
+
+    def test_comment(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        with self.assertRaises(AssertionError):
+            builder.comment("so\nmany lines")
+        builder.comment("my comment")
+        builder.ret_void()
+        self.check_block(block, """\
+            my_block:
+                ; my comment
+                ret void
+            """)
+
+    def test_bswap(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int32, 5)
+        c = builder.bswap(a, name='c')
+        builder.ret(c)
+        self.check_block(block, """\
+            my_block:
+                %"c" = call i32 @"llvm.bswap.i32"(i32 5)
+                ret i32 %"c"
+            """)
+
+    def test_ctpop(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int16, 5)
+        c = builder.ctpop(a, name='c')
+        builder.ret(c)
+        self.check_block(block, """\
+            my_block:
+                %"c" = call i16 @"llvm.ctpop.i16"(i16 5)
+                ret i16 %"c"
+            """)
+
+    def test_ctlz(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int16, 5)
+        b = ir.Constant(int1, 1)
+        c = builder.ctlz(a, b, name='c')
+        builder.ret(c)
+        self.check_block(block, """\
+            my_block:
+                %"c" = call i16 @"llvm.ctlz.i16"(i16 5, i1 1)
+                ret i16 %"c"
+            """)
+
+    def test_convert_to_fp16_f32(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5.0)
+        b = builder.convert_to_fp16(a, name='b')
+        builder.ret(b)
+        self.check_block(block, """\
+            my_block:
+                %"b" = call i16 @"llvm.convert.to.fp16.f32"(float 0x4014000000000000)
+                ret i16 %"b"
+            """)  # noqa E501
+
+    def test_convert_to_fp16_f32_wrongtype(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int16, 5)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.convert_to_fp16(a, name='b')
+        self.assertIn(
+            "expected a float type, got i16",
+            str(raises.exception))
+
+    def test_convert_from_fp16_f32(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int16, 5)
+        b = builder.convert_from_fp16(a, name='b', to=flt)
+        builder.ret(b)
+        self.check_block(block, """\
+            my_block:
+                %"b" = call float @"llvm.convert.from.fp16.f32"(i16 5)
+                ret float %"b"
+            """)
+
+    def test_convert_from_fp16_f32_notype(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5.5)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.convert_from_fp16(a, name='b')
+        self.assertIn(
+            "expected a float return type",
+            str(raises.exception))
+
+    def test_convert_from_fp16_f32_wrongtype(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5.5)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.convert_from_fp16(a, name='b', to=flt)
+        self.assertIn(
+            "expected an i16 type, got float",
+            str(raises.exception))
+
+    def test_convert_from_fp16_f32_wrongtype2(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5.5)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.convert_from_fp16(a, name='b', to=int16)
+        self.assertIn(
+            "expected a float type, got i16",
+            str(raises.exception))
+
+    def test_cttz(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int64, 5)
+        b = ir.Constant(int1, 1)
+        c = builder.cttz(a, b, name='c')
+        builder.ret(c)
+        self.check_block(block, """\
+            my_block:
+                %"c" = call i64 @"llvm.cttz.i64"(i64 5, i1 1)
+                ret i64 %"c"
+            """)
+
+    def test_cttz_wrongflag(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int64, 5)
+        b = ir.Constant(int32, 3)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.cttz(a, b, name='c')
+        self.assertIn(
+            "expected an i1 type, got i32",
+            str(raises.exception))
+
+    def test_cttz_wrongtype(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5)
+        b = ir.Constant(int1, 1)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.cttz(a, b, name='c')
+        self.assertIn(
+            "expected an integer type, got float",
+            str(raises.exception))
+
+    def test_fma(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5)
+        b = ir.Constant(flt, 1)
+        c = ir.Constant(flt, 2)
+        fma = builder.fma(a, b, c, name='fma')
+        builder.ret(fma)
+        self.check_block(block, """\
+            my_block:
+                %"fma" = call float @"llvm.fma.f32"(float 0x4014000000000000, float 0x3ff0000000000000, float 0x4000000000000000)
+                ret float %"fma"
+            """)  # noqa E501
+
+    def test_fma_wrongtype(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(int32, 5)
+        b = ir.Constant(int32, 1)
+        c = ir.Constant(int32, 2)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.fma(a, b, c, name='fma')
+        self.assertIn(
+            "expected an floating point type, got i32",
+            str(raises.exception))
+
+    def test_fma_mixedtypes(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a = ir.Constant(flt, 5)
+        b = ir.Constant(dbl, 1)
+        c = ir.Constant(flt, 2)
+
+        with self.assertRaises(TypeError) as raises:
+            builder.fma(a, b, c, name='fma')
+        self.assertIn(
+            "expected types to be the same, got float, double, float",
+            str(raises.exception))
+
+    def test_arg_attributes(self):
+        def gen_code(attr_name):
+            fnty = ir.FunctionType(ir.IntType(32), [ir.IntType(32).as_pointer(),
+                                                    ir.IntType(32)])
+            module = ir.Module()
+
+            func = ir.Function(module, fnty, name="sum")
+
+            bb_entry = func.append_basic_block()
+            bb_loop = func.append_basic_block()
+            bb_exit = func.append_basic_block()
+
+            builder = ir.IRBuilder()
+            builder.position_at_end(bb_entry)
+
+            builder.branch(bb_loop)
+            builder.position_at_end(bb_loop)
+
+            index = builder.phi(ir.IntType(32))
+            index.add_incoming(ir.Constant(index.type, 0), bb_entry)
+            accum = builder.phi(ir.IntType(32))
+            accum.add_incoming(ir.Constant(accum.type, 0), bb_entry)
+
+            func.args[0].add_attribute(attr_name)
+            ptr = builder.gep(func.args[0], [index])
+            value = builder.load(ptr)
+
+            added = builder.add(accum, value)
+            accum.add_incoming(added, bb_loop)
+
+            indexp1 = builder.add(index, ir.Constant(index.type, 1))
+            index.add_incoming(indexp1, bb_loop)
+
+            cond = builder.icmp_unsigned('<', indexp1, func.args[1])
+            builder.cbranch(cond, bb_loop, bb_exit)
+
+            builder.position_at_end(bb_exit)
+            builder.ret(added)
+
+            return str(module)
+
+        for attr_name in (
+            'byref',
+            'byval',
+            'elementtype',
+            'immarg',
+            'inalloca',
+            'inreg',
+            'nest',
+            'noalias',
+            'nocapture',
+            'nofree',
+            'nonnull',
+            'noundef',
+            'preallocated',
+            'returned',
+            'signext',
+            'swiftasync',
+            'swifterror',
+            'swiftself',
+            'zeroext',
+        ):
+            # If this parses, we emitted the right byval attribute format
+            llvm.parse_assembly(gen_code(attr_name))
+        # sret doesn't fit this pattern and is tested in test_call_attributes
+
+
+class TestBuilderMisc(TestBase):
+    """
+    Test various other features of the IRBuilder class.
+    """
+
+    def test_attributes(self):
+        block = self.block(name='start')
+        builder = ir.IRBuilder(block)
+        self.assertIs(builder.function, block.parent)
+        self.assertIsInstance(builder.function, ir.Function)
+        self.assertIs(builder.module, block.parent.module)
+        self.assertIsInstance(builder.module, ir.Module)
+
+    def test_goto_block(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        a, b = builder.function.args[:2]
+        builder.add(a, b, 'c')
+        bb_new = builder.append_basic_block(name='foo')
+        with builder.goto_block(bb_new):
+            builder.fadd(a, b, 'd')
+            with builder.goto_entry_block():
+                builder.sub(a, b, 'e')
+            builder.fsub(a, b, 'f')
+            builder.branch(bb_new)
+        builder.mul(a, b, 'g')
+        with builder.goto_block(bb_new):
+            builder.fmul(a, b, 'h')
+        self.check_block(block, """\
+            my_block:
+                %"c" = add i32 %".1", %".2"
+                %"e" = sub i32 %".1", %".2"
+                %"g" = mul i32 %".1", %".2"
+            """)
+        self.check_block(bb_new, """\
+            foo:
+                %"d" = fadd i32 %".1", %".2"
+                %"f" = fsub i32 %".1", %".2"
+                %"h" = fmul i32 %".1", %".2"
+                br label %"foo"
+            """)
+
+    def test_if_then(self):
+        block = self.block(name='one')
+        builder = ir.IRBuilder(block)
+        z = ir.Constant(int1, 0)
+        a = builder.add(z, z, 'a')
+        with builder.if_then(a) as bbend:
+            builder.add(z, z, 'b')
+            # Block will be terminated implicitly
+        self.assertIs(builder.block, bbend)
+        c = builder.add(z, z, 'c')
+        with builder.if_then(c):
+            builder.add(z, z, 'd')
+            builder.branch(block)
+            # No implicit termination
+        self.check_func_body(builder.function, """\
+            one:
+                %"a" = add i1 0, 0
+                br i1 %"a", label %"one.if", label %"one.endif"
+            one.if:
+                %"b" = add i1 0, 0
+                br label %"one.endif"
+            one.endif:
+                %"c" = add i1 0, 0
+                br i1 %"c", label %"one.endif.if", label %"one.endif.endif"
+            one.endif.if:
+                %"d" = add i1 0, 0
+                br label %"one"
+            one.endif.endif:
+            """)
+
+    def test_if_then_nested(self):
+        # Implicit termination in a nested if/then
+        block = self.block(name='one')
+        builder = ir.IRBuilder(block)
+        z = ir.Constant(int1, 0)
+        a = builder.add(z, z, 'a')
+        with builder.if_then(a):
+            b = builder.add(z, z, 'b')
+            with builder.if_then(b):
+                builder.add(z, z, 'c')
+        builder.ret_void()
+        self.check_func_body(builder.function, """\
+            one:
+                %"a" = add i1 0, 0
+                br i1 %"a", label %"one.if", label %"one.endif"
+            one.if:
+                %"b" = add i1 0, 0
+                br i1 %"b", label %"one.if.if", label %"one.if.endif"
+            one.endif:
+                ret void
+            one.if.if:
+                %"c" = add i1 0, 0
+                br label %"one.if.endif"
+            one.if.endif:
+                br label %"one.endif"
+            """)
+
+    def test_if_then_long_label(self):
+        full_label = 'Long' * 20
+        block = self.block(name=full_label)
+        builder = ir.IRBuilder(block)
+        z = ir.Constant(int1, 0)
+        a = builder.add(z, z, 'a')
+        with builder.if_then(a):
+            b = builder.add(z, z, 'b')
+            with builder.if_then(b):
+                builder.add(z, z, 'c')
+        builder.ret_void()
+        self.check_func_body(builder.function, """\
+            {full_label}:
+                %"a" = add i1 0, 0
+                br i1 %"a", label %"{label}.if", label %"{label}.endif"
+            {label}.if:
+                %"b" = add i1 0, 0
+                br i1 %"b", label %"{label}.if.if", label %"{label}.if.endif"
+            {label}.endif:
+                ret void
+            {label}.if.if:
+                %"c" = add i1 0, 0
+                br label %"{label}.if.endif"
+            {label}.if.endif:
+                br label %"{label}.endif"
+            """.format(full_label=full_label, label=full_label[:25] + '..'))
+
+    def test_if_then_likely(self):
+        def check(likely):
+            block = self.block(name='one')
+            builder = ir.IRBuilder(block)
+            z = ir.Constant(int1, 0)
+            with builder.if_then(z, likely=likely):
+                pass
+            self.check_block(block, """\
+                one:
+                    br i1 0, label %"one.if", label %"one.endif", !prof !0
+                """)
+            return builder
+        builder = check(True)
+        self.check_metadata(builder.module, """\
+            !0 = !{ !"branch_weights", i32 99, i32 1 }
+            """)
+        builder = check(False)
+        self.check_metadata(builder.module, """\
+            !0 = !{ !"branch_weights", i32 1, i32 99 }
+            """)
+
+    def test_if_else(self):
+        block = self.block(name='one')
+        builder = ir.IRBuilder(block)
+        z = ir.Constant(int1, 0)
+        a = builder.add(z, z, 'a')
+        with builder.if_else(a) as (then, otherwise):
+            with then:
+                builder.add(z, z, 'b')
+            with otherwise:
+                builder.add(z, z, 'c')
+            # Each block will be terminated implicitly
+        with builder.if_else(a) as (then, otherwise):
+            with then:
+                builder.branch(block)
+            with otherwise:
+                builder.ret_void()
+            # No implicit termination
+        self.check_func_body(builder.function, """\
+            one:
+                %"a" = add i1 0, 0
+                br i1 %"a", label %"one.if", label %"one.else"
+            one.if:
+                %"b" = add i1 0, 0
+                br label %"one.endif"
+            one.else:
+                %"c" = add i1 0, 0
+                br label %"one.endif"
+            one.endif:
+                br i1 %"a", label %"one.endif.if", label %"one.endif.else"
+            one.endif.if:
+                br label %"one"
+            one.endif.else:
+                ret void
+            one.endif.endif:
+            """)
+
+    def test_if_else_likely(self):
+        def check(likely):
+            block = self.block(name='one')
+            builder = ir.IRBuilder(block)
+            z = ir.Constant(int1, 0)
+            with builder.if_else(z, likely=likely) as (then, otherwise):
+                with then:
+                    builder.branch(block)
+                with otherwise:
+                    builder.ret_void()
+            self.check_func_body(builder.function, """\
+                one:
+                    br i1 0, label %"one.if", label %"one.else", !prof !0
+                one.if:
+                    br label %"one"
+                one.else:
+                    ret void
+                one.endif:
+                """)
+            return builder
+        builder = check(True)
+        self.check_metadata(builder.module, """\
+            !0 = !{ !"branch_weights", i32 99, i32 1 }
+            """)
+        builder = check(False)
+        self.check_metadata(builder.module, """\
+            !0 = !{ !"branch_weights", i32 1, i32 99 }
+            """)
+
+    def test_positioning(self):
+        """
+        Test IRBuilder.position_{before,after,at_start,at_end}.
+        """
+        func = self.function()
+        builder = ir.IRBuilder()
+        z = ir.Constant(int32, 0)
+        bb_one = func.append_basic_block(name='one')
+        bb_two = func.append_basic_block(name='two')
+        bb_three = func.append_basic_block(name='three')
+        # .at_start(empty block)
+        builder.position_at_start(bb_one)
+        builder.add(z, z, 'a')
+        # .at_end(empty block)
+        builder.position_at_end(bb_two)
+        builder.add(z, z, 'm')
+        builder.add(z, z, 'n')
+        # .at_start(block)
+        builder.position_at_start(bb_two)
+        o = builder.add(z, z, 'o')
+        builder.add(z, z, 'p')
+        # .at_end(block)
+        builder.position_at_end(bb_one)
+        b = builder.add(z, z, 'b')
+        # .after(instr)
+        builder.position_after(o)
+        builder.add(z, z, 'q')
+        # .before(instr)
+        builder.position_before(b)
+        builder.add(z, z, 'c')
+        self.check_block(bb_one, """\
+            one:
+                %"a" = add i32 0, 0
+                %"c" = add i32 0, 0
+                %"b" = add i32 0, 0
+            """)
+        self.check_block(bb_two, """\
+            two:
+                %"o" = add i32 0, 0
+                %"q" = add i32 0, 0
+                %"p" = add i32 0, 0
+                %"m" = add i32 0, 0
+                %"n" = add i32 0, 0
+            """)
+        self.check_block(bb_three, """\
+            three:
+            """)
+
+    def test_instruction_removal(self):
+        func = self.function()
+        builder = ir.IRBuilder()
+        blk = func.append_basic_block(name='entry')
+        builder.position_at_end(blk)
+        k = ir.Constant(int32, 1234)
+        a = builder.add(k, k, 'a')
+        retvoid = builder.ret_void()
+        self.assertTrue(blk.is_terminated)
+        builder.remove(retvoid)
+        self.assertFalse(blk.is_terminated)
+        b = builder.mul(a, a, 'b')
+        c = builder.add(b, b, 'c')
+        builder.remove(c)
+        builder.ret_void()
+        self.assertTrue(blk.is_terminated)
+        self.check_block(blk, """\
+            entry:
+                %"a" = add i32 1234, 1234
+                %"b" = mul i32 %"a", %"a"
+                ret void
+        """)
+
+    def test_metadata(self):
+        block = self.block(name='my_block')
+        builder = ir.IRBuilder(block)
+        builder.debug_metadata = builder.module.add_metadata([])
+        builder.alloca(ir.PointerType(int32), name='c')
+        self.check_block(block, """\
+            my_block:
+                %"c" = alloca i32*, !dbg !0
+            """)
+
+
+class TestTypes(TestBase):
+
+    def has_logical_equality(self, ty):
+        while isinstance(ty, ir.PointerType):
+            ty = ty.pointee
+        return not isinstance(ty, ir.LabelType)
+
+    def assorted_types(self):
+        """
+        A bunch of mutually unequal types
+        """
+        # Avoid polluting the namespace
+        context = ir.Context()
+        types = [
+            ir.LabelType(), ir.VoidType(),
+            ir.FunctionType(int1, (int8, int8)), ir.FunctionType(int1, (int8,)),
+            ir.FunctionType(int1, (int8,), var_arg=True),
+            ir.FunctionType(int8, (int8,)),
+            int1, int8, int32, flt, dbl,
+            ir.ArrayType(flt, 5), ir.ArrayType(dbl, 5), ir.ArrayType(dbl, 4),
+            ir.LiteralStructType((int1, int8)), ir.LiteralStructType((int8,
+                                                                      int1)),
+            context.get_identified_type("MyType1"),
+            context.get_identified_type("MyType2"),
+        ]
+        types += [ir.PointerType(tp) for tp in types
+                  if not isinstance(tp, (ir.VoidType, ir.LabelType))]
+
+        return types
+
+    def test_pickling(self):
+        types = self.assorted_types()
+        for ty in types:
+            newty = self.assert_pickle_correctly(ty)
+            if self.has_logical_equality(ty):
+                self.assertEqual(newty, ty)
+
+    def test_comparisons(self):
+        types = self.assorted_types()
+        for a, b in itertools.product(types, types):
+            if a is not b:
+                self.assertFalse(a == b, (a, b))
+                self.assertTrue(a != b, (a, b))
+        # We assume copy.copy() works fine here...
+        for tp in types:
+            other = copy.copy(tp)
+            if self.has_logical_equality(tp):
+                self.assertTrue(tp == other, (tp, other))
+                self.assertFalse(tp != other, (tp, other))
+            else:
+                self.assertFalse(tp == other, (tp, other))
+                self.assertTrue(tp != other, (tp, other))
+
+    def test_str(self):
+        """
+        Test the string representation of types.
+        """
+        self.assertEqual(str(int1), 'i1')
+        self.assertEqual(str(ir.IntType(29)), 'i29')
+        self.assertEqual(str(flt), 'float')
+        self.assertEqual(str(dbl), 'double')
+        self.assertEqual(str(ir.VoidType()), 'void')
+        self.assertEqual(str(ir.FunctionType(int1, ())), 'i1 ()')
+        self.assertEqual(str(ir.FunctionType(int1, (flt,))), 'i1 (float)')
+        self.assertEqual(str(ir.FunctionType(int1, (flt, dbl))),
+                         'i1 (float, double)')
+        self.assertEqual(str(ir.FunctionType(int1, (), var_arg=True)),
+                         'i1 (...)')
+        self.assertEqual(str(ir.FunctionType(int1, (flt,), var_arg=True)),
+                         'i1 (float, ...)')
+        self.assertEqual(str(ir.FunctionType(int1, (flt, dbl), var_arg=True)),
+                         'i1 (float, double, ...)')
+        self.assertEqual(str(ir.PointerType(int32)), 'i32*')
+        self.assertEqual(str(ir.PointerType(ir.PointerType(int32))), 'i32**')
+        self.assertEqual(str(ir.ArrayType(int1, 5)), '[5 x i1]')
+        self.assertEqual(str(ir.ArrayType(ir.PointerType(int1), 5)),
+                         '[5 x i1*]')
+        self.assertEqual(str(ir.PointerType(ir.ArrayType(int1, 5))),
+                         '[5 x i1]*')
+        self.assertEqual(str(ir.LiteralStructType((int1,))), '{i1}')
+        self.assertEqual(str(ir.LiteralStructType((int1, flt))), '{i1, float}')
+        self.assertEqual(str(ir.LiteralStructType((
+            ir.PointerType(int1), ir.LiteralStructType((int32, int8))))),
+            '{i1*, {i32, i8}}')
+        self.assertEqual(str(ir.LiteralStructType((int1,), packed=True)),
+                         '<{i1}>')
+        self.assertEqual(str(ir.LiteralStructType((int1, flt), packed=True)),
+                         '<{i1, float}>')
+
+        # Avoid polluting the namespace
+        context = ir.Context()
+        mytype = context.get_identified_type("MyType")
+        self.assertEqual(str(mytype), "%\"MyType\"")
+        mytype1 = context.get_identified_type("MyType\\")
+        self.assertEqual(str(mytype1), "%\"MyType\\5c\"")
+        mytype2 = context.get_identified_type("MyType\"")
+        self.assertEqual(str(mytype2), "%\"MyType\\22\"")
+
+    def test_hash(self):
+        for typ in filter(self.has_logical_equality, self.assorted_types()):
+            self.assertEqual(hash(typ), hash(copy.copy(typ)))
+
+    def test_gep(self):
+        def check_constant(tp, i, expected):
+            actual = tp.gep(ir.Constant(int32, i))
+            self.assertEqual(actual, expected)
+
+        def check_index_type(tp):
+            index = ir.Constant(dbl, 1.0)
+            with self.assertRaises(TypeError):
+                tp.gep(index)
+
+        tp = ir.PointerType(dbl)
+        for i in range(5):
+            check_constant(tp, i, dbl)
+        check_index_type(tp)
+
+        tp = ir.ArrayType(int1, 3)
+        for i in range(3):
+            check_constant(tp, i, int1)
+        check_index_type(tp)
+
+        tp = ir.LiteralStructType((dbl, ir.LiteralStructType((int1, int8))))
+        check_constant(tp, 0, dbl)
+        check_constant(tp, 1, ir.LiteralStructType((int1, int8)))
+        with self.assertRaises(IndexError):
+            tp.gep(ir.Constant(int32, 2))
+        check_index_type(tp)
+
+        context = ir.Context()
+        tp = ir.IdentifiedStructType(context, "MyType")
+        tp.set_body(dbl, ir.LiteralStructType((int1, int8)))
+        check_constant(tp, 0, dbl)
+        check_constant(tp, 1, ir.LiteralStructType((int1, int8)))
+        with self.assertRaises(IndexError):
+            tp.gep(ir.Constant(int32, 2))
+        check_index_type(tp)
+
+    def test_abi_size(self):
+        td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
+
+        def check(tp, expected):
+            self.assertEqual(tp.get_abi_size(td), expected)
+        check(int8, 1)
+        check(int32, 4)
+        check(int64, 8)
+        check(ir.ArrayType(int8, 5), 5)
+        check(ir.ArrayType(int32, 5), 20)
+        check(ir.LiteralStructType((dbl, flt, flt)), 16)
+
+    def test_abi_alignment(self):
+        td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
+
+        def check(tp, expected):
+            self.assertIn(tp.get_abi_alignment(td), expected)
+        check(int8, (1, 2, 4))
+        check(int32, (4,))
+        check(int64, (8,))
+        check(ir.ArrayType(int8, 5), (1, 2, 4))
+        check(ir.ArrayType(int32, 5), (4,))
+        check(ir.LiteralStructType((dbl, flt, flt)), (8,))
+
+    def test_identified_struct(self):
+        context = ir.Context()
+        mytype = context.get_identified_type("MyType")
+        module = ir.Module(context=context)
+        self.assertTrue(mytype.is_opaque)
+        self.assert_valid_ir(module)
+        oldstr = str(module)
+        mytype.set_body(ir.IntType(32), ir.IntType(64), ir.FloatType())
+        self.assertFalse(mytype.is_opaque)
+        self.assert_valid_ir(module)
+        self.assertNotEqual(oldstr, str(module))
+
+    def test_target_data_non_default_context(self):
+        context = ir.Context()
+        mytype = context.get_identified_type("MyType")
+        mytype.elements = [ir.IntType(32)]
+        td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
+        self.assertEqual(mytype.get_abi_size(td, context=context), 4)
+
+    def test_vector(self):
+        vecty = ir.VectorType(ir.IntType(32), 8)
+        self.assertEqual(str(vecty), "<8 x i32>")
+
+
+def c32(i):
+    return ir.Constant(int32, i)
+
+
+class TestConstant(TestBase):
+
+    def test_integers(self):
+        c = ir.Constant(int32, 42)
+        self.assertEqual(str(c), 'i32 42')
+        c = ir.Constant(int1, 1)
+        self.assertEqual(str(c), 'i1 1')
+        c = ir.Constant(int1, 0)
+        self.assertEqual(str(c), 'i1 0')
+        c = ir.Constant(int1, True)
+        self.assertEqual(str(c), 'i1 true')
+        c = ir.Constant(int1, False)
+        self.assertEqual(str(c), 'i1 false')
+        c = ir.Constant(int1, ir.Undefined)
+        self.assertEqual(str(c), 'i1 undef')
+        c = ir.Constant(int1, None)
+        self.assertEqual(str(c), 'i1 0')
+
+    def test_reals(self):
+        # XXX Test NaNs and infs
+        c = ir.Constant(flt, 1.5)
+        self.assertEqual(str(c), 'float 0x3ff8000000000000')
+        c = ir.Constant(flt, -1.5)
+        self.assertEqual(str(c), 'float 0xbff8000000000000')
+        c = ir.Constant(dbl, 1.5)
+        self.assertEqual(str(c), 'double 0x3ff8000000000000')
+        c = ir.Constant(dbl, -1.5)
+        self.assertEqual(str(c), 'double 0xbff8000000000000')
+        c = ir.Constant(dbl, ir.Undefined)
+        self.assertEqual(str(c), 'double undef')
+        c = ir.Constant(dbl, None)
+        self.assertEqual(str(c), 'double 0.0')
+
+    def test_arrays(self):
+        c = ir.Constant(ir.ArrayType(int32, 3), (c32(5), c32(6), c32(4)))
+        self.assertEqual(str(c), '[3 x i32] [i32 5, i32 6, i32 4]')
+        c = ir.Constant(ir.ArrayType(int32, 2), (c32(5), c32(ir.Undefined)))
+        self.assertEqual(str(c), '[2 x i32] [i32 5, i32 undef]')
+
+        c = ir.Constant.literal_array((c32(5), c32(6), c32(ir.Undefined)))
+        self.assertEqual(str(c), '[3 x i32] [i32 5, i32 6, i32 undef]')
+        with self.assertRaises(TypeError) as raises:
+            ir.Constant.literal_array((c32(5), ir.Constant(flt, 1.5)))
+        self.assertEqual(str(raises.exception),
+                         "all elements must have the same type")
+
+        c = ir.Constant(ir.ArrayType(int32, 2), ir.Undefined)
+        self.assertEqual(str(c), '[2 x i32] undef')
+        c = ir.Constant(ir.ArrayType(int32, 2), None)
+        self.assertEqual(str(c), '[2 x i32] zeroinitializer')
+        # Raw array syntax
+        c = ir.Constant(ir.ArrayType(int8, 11), bytearray(b"foobar_123\x80"))
+        self.assertEqual(str(c), r'[11 x i8] c"foobar_123\80"')
+        c = ir.Constant(ir.ArrayType(int8, 4), bytearray(b"\x00\x01\x04\xff"))
+        self.assertEqual(str(c), r'[4 x i8] c"\00\01\04\ff"')
+        # Recursive instantiation of inner constants
+        c = ir.Constant(ir.ArrayType(int32, 3), (5, ir.Undefined, 6))
+        self.assertEqual(str(c), '[3 x i32] [i32 5, i32 undef, i32 6]')
+        # Invalid number of args
+        with self.assertRaises(ValueError):
+            ir.Constant(ir.ArrayType(int32, 3), (5, 6))
+
+    def test_vector(self):
+        vecty = ir.VectorType(ir.IntType(32), 8)
+        vals = [1, 2, 4, 3, 8, 6, 9, 7]
+        vec = ir.Constant(vecty, vals)
+        vec_repr = "<8 x i32> <{}>".format(
+            ', '.join(map('i32 {}'.format, vals)))
+        self.assertEqual(str(vec), vec_repr)
+
+    def test_non_nullable_int(self):
+        constant = ir.Constant(ir.IntType(32), None).constant
+        self.assertEqual(constant, 0)
+
+    def test_structs(self):
+        st1 = ir.LiteralStructType((flt, int1))
+        st2 = ir.LiteralStructType((int32, st1))
+        c = ir.Constant(st1, (ir.Constant(ir.FloatType(), 1.5),
+                              ir.Constant(int1, True)))
+        self.assertEqual(str(c),
+                         '{float, i1} {float 0x3ff8000000000000, i1 true}')
+        c = ir.Constant.literal_struct((ir.Constant(ir.FloatType(), 1.5),
+                                        ir.Constant(int1, True)))
+        self.assertEqual(c.type, st1)
+        self.assertEqual(str(c),
+                         '{float, i1} {float 0x3ff8000000000000, i1 true}')
+        c = ir.Constant.literal_struct((ir.Constant(ir.FloatType(), 1.5),
+                                        ir.Constant(int1, ir.Undefined)))
+        self.assertEqual(c.type, st1)
+        self.assertEqual(str(c),
+                         '{float, i1} {float 0x3ff8000000000000, i1 undef}')
+        c = ir.Constant(st1, ir.Undefined)
+        self.assertEqual(str(c), '{float, i1} undef')
+        c = ir.Constant(st1, None)
+        self.assertEqual(str(c), '{float, i1} zeroinitializer')
+        # Recursive instantiation of inner constants
+        c1 = ir.Constant(st1, (1.5, True))
+        self.assertEqual(str(c1),
+                         '{float, i1} {float 0x3ff8000000000000, i1 true}')
+        c2 = ir.Constant(st2, (42, c1))
+        self.assertEqual(str(c2), ('{i32, {float, i1}} {i32 42, {float, i1} '
+                                   '{float 0x3ff8000000000000, i1 true}}'))
+        c3 = ir.Constant(st2, (42, (1.5, True)))
+        self.assertEqual(str(c3), str(c2))
+        # Invalid number of args
+        with self.assertRaises(ValueError):
+            ir.Constant(st2, (4, 5, 6))
+
+    def test_undefined_literal_struct_pickling(self):
+        i8 = ir.IntType(8)
+        st = ir.Constant(ir.LiteralStructType([i8, i8]), ir.Undefined)
+        self.assert_pickle_correctly(st)
+
+    def test_type_instantiaton(self):
+        """
+        Instantiating a type should create a constant.
+        """
+        c = int8(42)
+        self.assertIsInstance(c, ir.Constant)
+        self.assertEqual(str(c), 'i8 42')
+        c = int1(True)
+        self.assertIsInstance(c, ir.Constant)
+        self.assertEqual(str(c), 'i1 true')
+        # Arrays
+        at = ir.ArrayType(int32, 3)
+        c = at([c32(4), c32(5), c32(6)])
+        self.assertEqual(str(c), '[3 x i32] [i32 4, i32 5, i32 6]')
+        c = at([4, 5, 6])
+        self.assertEqual(str(c), '[3 x i32] [i32 4, i32 5, i32 6]')
+        c = at(None)
+        self.assertEqual(str(c), '[3 x i32] zeroinitializer')
+        with self.assertRaises(ValueError):
+            at([4, 5, 6, 7])
+        # Structs
+        st1 = ir.LiteralStructType((flt, int1))
+        st2 = ir.LiteralStructType((int32, st1))
+        c = st1((1.5, True))
+        self.assertEqual(str(c), ('{float, i1} {float 0x3ff8000000000000, i1 '
+                                  'true}'))
+        c = st2((42, (1.5, True)))
+        self.assertEqual(str(c), ('{i32, {float, i1}} {i32 42, {float, i1} '
+                                  '{float 0x3ff8000000000000, i1 true}}'))
+
+    def test_repr(self):
+        """
+        Constants should have a useful repr().
+        """
+        c = int32(42)
+        self.assertEqual(repr(c), "<ir.Constant type='i32' value=42>")
+
+    def test_encoding_problem(self):
+        c = ir.Constant(ir.ArrayType(ir.IntType(8), 256),
+                        bytearray(range(256)))
+        m = self.module()
+        gv = ir.GlobalVariable(m, c.type, "myconstant")
+        gv.global_constant = True
+        gv.initializer = c
+        # With utf-8, the following will cause:
+        # UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe0 in position
+        # 136: invalid continuation byte
+        parsed = llvm.parse_assembly(str(m))
+        # Make sure the encoding does not modify the IR
+        reparsed = llvm.parse_assembly(str(parsed))
+        self.assertEqual(str(parsed), str(reparsed))
+
+    def test_gep(self):
+        m = self.module()
+        tp = ir.LiteralStructType((flt, int1))
+        gv = ir.GlobalVariable(m, tp, "myconstant")
+        c = gv.gep([ir.Constant(int32, x) for x in (0, 1)])
+        self.assertEqual(str(c),
+                         'getelementptr ({float, i1}, {float, i1}* @"myconstant", i32 0, i32 1)')  # noqa E501
+        self.assertEqual(c.type, ir.PointerType(int1))
+
+        const = ir.Constant(tp, None)
+        with self.assertRaises(TypeError):
+            const.gep([ir.Constant(int32, 0)])
+
+        const_ptr = ir.Constant(tp.as_pointer(), None)
+        c2 = const_ptr.gep([ir.Constant(int32, 0)])
+        self.assertEqual(str(c2),
+                         'getelementptr ({float, i1}, {float, i1}* null, i32 0)')  # noqa E501
+        self.assertEqual(c.type, ir.PointerType(int1))
+
+    def test_gep_addrspace_globalvar(self):
+        m = self.module()
+        tp = ir.LiteralStructType((flt, int1))
+        addrspace = 4
+
+        gv = ir.GlobalVariable(m, tp, "myconstant", addrspace=addrspace)
+        self.assertEqual(gv.addrspace, addrspace)
+        c = gv.gep([ir.Constant(int32, x) for x in (0, 1)])
+        self.assertEqual(c.type.addrspace, addrspace)
+        self.assertEqual(str(c),
+                         ('getelementptr ({float, i1}, {float, i1} '
+                          'addrspace(4)* @"myconstant", i32 0, i32 1)'))
+        self.assertEqual(c.type, ir.PointerType(int1, addrspace=addrspace))
+
+    def test_trunc(self):
+        c = ir.Constant(int64, 1).trunc(int32)
+        self.assertEqual(str(c), 'trunc (i64 1 to i32)')
+
+    def test_zext(self):
+        c = ir.Constant(int32, 1).zext(int64)
+        self.assertEqual(str(c), 'zext (i32 1 to i64)')
+
+    def test_sext(self):
+        c = ir.Constant(int32, -1).sext(int64)
+        self.assertEqual(str(c), 'sext (i32 -1 to i64)')
+
+    def test_fptrunc(self):
+        c = ir.Constant(flt, 1).fptrunc(hlf)
+        self.assertEqual(str(c), 'fptrunc (float 0x3ff0000000000000 to half)')
+
+    def test_fpext(self):
+        c = ir.Constant(flt, 1).fpext(dbl)
+        self.assertEqual(str(c), 'fpext (float 0x3ff0000000000000 to double)')
+
+    def test_bitcast(self):
+        m = self.module()
+        gv = ir.GlobalVariable(m, int32, "myconstant")
+        c = gv.bitcast(int64.as_pointer())
+        self.assertEqual(str(c), 'bitcast (i32* @"myconstant" to i64*)')
+
+    def test_fptoui(self):
+        c = ir.Constant(flt, 1).fptoui(int32)
+        self.assertEqual(str(c), 'fptoui (float 0x3ff0000000000000 to i32)')
+
+    def test_uitofp(self):
+        c = ir.Constant(int32, 1).uitofp(flt)
+        self.assertEqual(str(c), 'uitofp (i32 1 to float)')
+
+    def test_fptosi(self):
+        c = ir.Constant(flt, 1).fptosi(int32)
+        self.assertEqual(str(c), 'fptosi (float 0x3ff0000000000000 to i32)')
+
+    def test_sitofp(self):
+        c = ir.Constant(int32, 1).sitofp(flt)
+        self.assertEqual(str(c), 'sitofp (i32 1 to float)')
+
+    def test_ptrtoint_1(self):
+        ptr = ir.Constant(int64.as_pointer(), None)
+        one = ir.Constant(int32, 1)
+        c = ptr.ptrtoint(int32)
+
+        self.assertRaises(TypeError, one.ptrtoint, int64)
+        self.assertRaises(TypeError, ptr.ptrtoint, flt)
+        self.assertEqual(str(c), 'ptrtoint (i64* null to i32)')
+
+    def test_ptrtoint_2(self):
+        m = self.module()
+        gv = ir.GlobalVariable(m, int32, "myconstant")
+        c = gv.ptrtoint(int64)
+        self.assertEqual(str(c), 'ptrtoint (i32* @"myconstant" to i64)')
+
+        self.assertRaisesRegex(
+            TypeError,
+            r"can only ptrtoint\(\) to integer type, not 'i64\*'",
+            gv.ptrtoint,
+            int64.as_pointer())
+
+        c2 = ir.Constant(int32, 0)
+        self.assertRaisesRegex(
+            TypeError,
+            r"can only call ptrtoint\(\) on pointer type, not 'i32'",
+            c2.ptrtoint,
+            int64)
+
+    def test_inttoptr(self):
+        one = ir.Constant(int32, 1)
+        pi = ir.Constant(flt, 3.14)
+        c = one.inttoptr(int64.as_pointer())
+
+        self.assertRaises(TypeError, one.inttoptr, int64)
+        self.assertRaises(TypeError, pi.inttoptr, int64.as_pointer())
+        self.assertEqual(str(c), 'inttoptr (i32 1 to i64*)')
+
+    def test_neg(self):
+        one = ir.Constant(int32, 1)
+        self.assertEqual(str(one.neg()), 'sub (i32 0, i32 1)')
+
+    def test_not(self):
+        one = ir.Constant(int32, 1)
+        self.assertEqual(str(one.not_()), 'xor (i32 1, i32 -1)')
+
+    def test_fneg(self):
+        one = ir.Constant(flt, 1)
+        self.assertEqual(str(one.fneg()), 'fneg (float 0x3ff0000000000000)')
+
+    def test_int_binops(self):
+        one = ir.Constant(int32, 1)
+        two = ir.Constant(int32, 2)
+
+        oracle = {one.shl:  'shl',  one.lshr: 'lshr', one.ashr: 'ashr',
+                  one.add:  'add',  one.sub:  'sub',  one.mul:  'mul',
+                  one.udiv: 'udiv', one.sdiv: 'sdiv', one.urem: 'urem',
+                  one.srem: 'srem', one.or_:  'or',   one.and_: 'and',
+                  one.xor:  'xor'}
+        for fn, irop in oracle.items():
+            self.assertEqual(str(fn(two)), irop + ' (i32 1, i32 2)')
+
+        # unsigned integer compare
+        oracle = {'==': 'eq', '!=': 'ne', '>':
+                  'ugt', '>=': 'uge', '<': 'ult', '<=': 'ule'}
+        for cop, cond in oracle.items():
+            actual = str(one.icmp_unsigned(cop, two))
+            expected = 'icmp ' + cond + ' (i32 1, i32 2)'
+            self.assertEqual(actual, expected)
+
+        # signed integer compare
+        oracle = {'==': 'eq', '!=': 'ne',
+                  '>': 'sgt', '>=': 'sge', '<': 'slt', '<=': 'sle'}
+        for cop, cond in oracle.items():
+            actual = str(one.icmp_signed(cop, two))
+            expected = 'icmp ' + cond + ' (i32 1, i32 2)'
+            self.assertEqual(actual, expected)
+
+    def test_flt_binops(self):
+        one = ir.Constant(flt, 1)
+        two = ir.Constant(flt, 2)
+
+        oracle = {one.fadd: 'fadd', one.fsub: 'fsub', one.fmul:  'fmul',
+                  one.fdiv: 'fdiv', one.frem: 'frem'}
+        for fn, irop in oracle.items():
+            actual = str(fn(two))
+            expected = irop + (' (float 0x3ff0000000000000,'
+                               ' float 0x4000000000000000)')
+            self.assertEqual(actual, expected)
+
+        # ordered float compare
+        oracle = {'==': 'oeq', '!=': 'one', '>': 'ogt', '>=': 'oge',
+                  '<': 'olt', '<=': 'ole'}
+        for cop, cond in oracle.items():
+            actual = str(one.fcmp_ordered(cop, two))
+            expected = 'fcmp ' + cond + (' (float 0x3ff0000000000000,'
+                                         ' float 0x4000000000000000)')
+            self.assertEqual(actual, expected)
+
+        # unordered float compare
+        oracle = {'==': 'ueq', '!=': 'une', '>': 'ugt', '>=': 'uge',
+                  '<': 'ult', '<=': 'ule'}
+        for cop, cond in oracle.items():
+            actual = str(one.fcmp_unordered(cop, two))
+            expected = 'fcmp ' + cond + (' (float 0x3ff0000000000000,'
+                                         ' float 0x4000000000000000)')
+            self.assertEqual(actual, expected)
+
+
+class TestTransforms(TestBase):
+    def test_call_transform(self):
+        mod = ir.Module()
+        foo = ir.Function(mod, ir.FunctionType(ir.VoidType(), ()), "foo")
+        bar = ir.Function(mod, ir.FunctionType(ir.VoidType(), ()), "bar")
+        builder = ir.IRBuilder()
+        builder.position_at_end(foo.append_basic_block())
+        call = builder.call(foo, ())
+        self.assertEqual(call.callee, foo)
+        modified = ir.replace_all_calls(mod, foo, bar)
+        self.assertIn(call, modified)
+        self.assertNotEqual(call.callee, foo)
+        self.assertEqual(call.callee, bar)
+
+
+class TestSingleton(TestBase):
+    def test_undefined(self):
+        self.assertIs(ir.Undefined, ir.values._Undefined())
+        self.assertIs(ir.Undefined, copy.copy(ir.Undefined))
+        self.assertIs(ir.Undefined, copy.deepcopy(ir.Undefined))
+        self.assert_pickle_correctly(ir.Undefined)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/lib/python3.11/site-packages/llvmlite/tests/test_refprune.py b/lib/python3.11/site-packages/llvmlite/tests/test_refprune.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2948d03fbcbc64a100b0544457b7c1063758f84
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/test_refprune.py
@@ -0,0 +1,526 @@
+import unittest
+from llvmlite import ir
+from llvmlite import binding as llvm
+from llvmlite.tests import TestCase
+
+from . import refprune_proto as proto
+
+
+def _iterate_cases(generate_test):
+    def wrap(fn):
+        def wrapped(self):
+            return generate_test(self, fn)
+        wrapped.__doc__ = f"generated test for {fn.__module__}.{fn.__name__}"
+        return wrapped
+
+    for k, case_fn in proto.__dict__.items():
+        if k.startswith('case'):
+            yield f'test_{k}', wrap(case_fn)
+
+
+class TestRefPrunePrototype(TestCase):
+    """
+    Test that the prototype is working.
+    """
+    def generate_test(self, case_gen):
+        nodes, edges, expected = case_gen()
+        got = proto.FanoutAlgorithm(nodes, edges).run()
+        self.assertEqual(expected, got)
+
+    # Generate tests
+    for name, case in _iterate_cases(generate_test):
+        locals()[name] = case
+
+
+ptr_ty = ir.IntType(8).as_pointer()
+
+
+class TestRefPrunePass(TestCase):
+    """
+    Test that the C++ implementation matches the expected behavior as for
+    the prototype.
+
+    This generates a LLVM module for each test case, runs the pruner and checks
+    that the expected results are achieved.
+    """
+
+    def make_incref(self, m):
+        fnty = ir.FunctionType(ir.VoidType(), [ptr_ty])
+        return ir.Function(m, fnty, name='NRT_incref')
+
+    def make_decref(self, m):
+        fnty = ir.FunctionType(ir.VoidType(), [ptr_ty])
+        return ir.Function(m, fnty, name='NRT_decref')
+
+    def make_switcher(self, m):
+        fnty = ir.FunctionType(ir.IntType(32), ())
+        return ir.Function(m, fnty, name='switcher')
+
+    def make_brancher(self, m):
+        fnty = ir.FunctionType(ir.IntType(1), ())
+        return ir.Function(m, fnty, name='brancher')
+
+    def generate_ir(self, nodes, edges):
+        # Build LLVM module for the CFG
+        m = ir.Module()
+
+        incref_fn = self.make_incref(m)
+        decref_fn = self.make_decref(m)
+        switcher_fn = self.make_switcher(m)
+        brancher_fn = self.make_brancher(m)
+
+        fnty = ir.FunctionType(ir.VoidType(), [ptr_ty])
+        fn = ir.Function(m, fnty, name='main')
+        [ptr] = fn.args
+        ptr.name = 'mem'
+        # populate the BB nodes
+        bbmap = {}
+        for bb in edges:
+            bbmap[bb] = fn.append_basic_block(bb)
+        # populate the BB
+        builder = ir.IRBuilder()
+        for bb, jump_targets in edges.items():
+            builder.position_at_end(bbmap[bb])
+            # Insert increfs and decrefs
+            for action in nodes[bb]:
+                if action == 'incref':
+                    builder.call(incref_fn, [ptr])
+                elif action == 'decref':
+                    builder.call(decref_fn, [ptr])
+                else:
+                    raise AssertionError('unreachable')
+
+            # Insert the terminator.
+            # Switch base on the number of jump targets.
+            n_targets = len(jump_targets)
+            if n_targets == 0:
+                builder.ret_void()
+            elif n_targets == 1:
+                [dst] = jump_targets
+                builder.branch(bbmap[dst])
+            elif n_targets == 2:
+                [left, right] = jump_targets
+                sel = builder.call(brancher_fn, ())
+                builder.cbranch(sel, bbmap[left], bbmap[right])
+            elif n_targets > 2:
+                sel = builder.call(switcher_fn, ())
+                [head, *tail] = jump_targets
+
+                sw = builder.switch(sel, default=bbmap[head])
+                for i, dst in enumerate(tail):
+                    sw.add_case(sel.type(i), bbmap[dst])
+            else:
+                raise AssertionError('unreachable')
+
+        return m
+
+    def apply_refprune(self, irmod):
+        mod = llvm.parse_assembly(str(irmod))
+        pm = llvm.ModulePassManager()
+        pm.add_refprune_pass()
+        pm.run(mod)
+        return mod
+
+    def check(self, mod, expected, nodes):
+        # preprocess incref/decref locations
+        d = {}
+        for k, vs in nodes.items():
+            n_incref = vs.count('incref')
+            n_decref = vs.count('decref')
+            d[k] = {'incref': n_incref, 'decref': n_decref}
+        for k, stats in d.items():
+            if expected.get(k):
+                stats['incref'] -= 1
+                for dec_bb in expected[k]:
+                    d[dec_bb]['decref'] -= 1
+
+        # find the main function
+        for f in mod.functions:
+            if f.name == 'main':
+                break
+        # check each BB
+        for bb in f.blocks:
+            stats = d[bb.name]
+            text = str(bb)
+            n_incref = text.count('NRT_incref')
+            n_decref = text.count('NRT_decref')
+            self.assertEqual(stats['incref'], n_incref, msg=f'BB {bb}')
+            self.assertEqual(stats['decref'], n_decref, msg=f'BB {bb}')
+
+    def generate_test(self, case_gen):
+        nodes, edges, expected = case_gen()
+        irmod = self.generate_ir(nodes, edges)
+        outmod = self.apply_refprune(irmod)
+        self.check(outmod, expected, nodes)
+
+    # Generate tests
+    for name, case in _iterate_cases(generate_test):
+        locals()[name] = case
+
+
+class BaseTestByIR(TestCase):
+    refprune_bitmask = 0
+
+    prologue = r"""
+declare void @NRT_incref(i8* %ptr)
+declare void @NRT_decref(i8* %ptr)
+"""
+
+    def check(self, irmod, subgraph_limit=None):
+        mod = llvm.parse_assembly(f"{self.prologue}\n{irmod}")
+        pm = llvm.ModulePassManager()
+        if subgraph_limit is None:
+            pm.add_refprune_pass(self.refprune_bitmask)
+        else:
+            pm.add_refprune_pass(self.refprune_bitmask,
+                                 subgraph_limit=subgraph_limit)
+        before = llvm.dump_refprune_stats()
+        pm.run(mod)
+        after = llvm.dump_refprune_stats()
+        return mod, after - before
+
+
+class TestPerBB(BaseTestByIR):
+    refprune_bitmask = llvm.RefPruneSubpasses.PER_BB
+
+    per_bb_ir_1 = r"""
+define void @main(i8* %ptr) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_bb_1(self):
+        mod, stats = self.check(self.per_bb_ir_1)
+        self.assertEqual(stats.basicblock, 2)
+
+    per_bb_ir_2 = r"""
+define void @main(i8* %ptr) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_bb_2(self):
+        mod, stats = self.check(self.per_bb_ir_2)
+        self.assertEqual(stats.basicblock, 4)
+        # not pruned
+        self.assertIn("call void @NRT_incref(i8* %ptr)", str(mod))
+
+    per_bb_ir_3 = r"""
+define void @main(i8* %ptr, i8* %other) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %other)
+    ret void
+}
+"""
+
+    def test_per_bb_3(self):
+        mod, stats = self.check(self.per_bb_ir_3)
+        self.assertEqual(stats.basicblock, 2)
+        # not pruned
+        self.assertIn("call void @NRT_decref(i8* %other)", str(mod))
+
+    per_bb_ir_4 = r"""
+; reordered
+define void @main(i8* %ptr, i8* %other) {
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %other)
+    call void @NRT_incref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_bb_4(self):
+        mod, stats = self.check(self.per_bb_ir_4)
+        self.assertEqual(stats.basicblock, 4)
+        # not pruned
+        self.assertIn("call void @NRT_decref(i8* %other)", str(mod))
+
+
+class TestDiamond(BaseTestByIR):
+    refprune_bitmask = llvm.RefPruneSubpasses.DIAMOND
+
+    per_diamond_1 = r"""
+define void @main(i8* %ptr) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br label %bb_B
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_1(self):
+        mod, stats = self.check(self.per_diamond_1)
+        self.assertEqual(stats.diamond, 2)
+
+    per_diamond_2 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    br label %bb_D
+bb_C:
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_2(self):
+        mod, stats = self.check(self.per_diamond_2)
+        self.assertEqual(stats.diamond, 2)
+
+    per_diamond_3 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    br label %bb_D
+bb_C:
+    call void @NRT_decref(i8* %ptr)  ; reject because of decref in diamond
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_3(self):
+        mod, stats = self.check(self.per_diamond_3)
+        self.assertEqual(stats.diamond, 0)
+
+    per_diamond_4 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_incref(i8* %ptr)     ; extra incref will not affect prune
+    br label %bb_D
+bb_C:
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_4(self):
+        mod, stats = self.check(self.per_diamond_4)
+        self.assertEqual(stats.diamond, 2)
+
+    per_diamond_5 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    br label %bb_D
+bb_C:
+    br label %bb_D
+bb_D:
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_per_diamond_5(self):
+        mod, stats = self.check(self.per_diamond_5)
+        self.assertEqual(stats.diamond, 4)
+
+
+class TestFanout(BaseTestByIR):
+    """More complex cases are tested in TestRefPrunePass
+    """
+
+    refprune_bitmask = llvm.RefPruneSubpasses.FANOUT
+
+    fanout_1 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+bb_C:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_fanout_1(self):
+        mod, stats = self.check(self.fanout_1)
+        self.assertEqual(stats.fanout, 3)
+
+    fanout_2 = r"""
+define void @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret void
+bb_C:
+    call void @NRT_decref(i8* %ptr)
+    br label %bb_B                      ; illegal jump to other decref
+}
+"""
+
+    def test_fanout_2(self):
+        mod, stats = self.check(self.fanout_2)
+        self.assertEqual(stats.fanout, 0)
+
+    fanout_3 = r"""
+define void @main(i8* %ptr, i1 %cond) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+bb_C:
+    call void @NRT_decref(i8* %ptr)
+    call void @NRT_decref(i8* %ptr)
+    ret void
+}
+"""
+
+    def test_fanout_3(self):
+        mod, stats = self.check(self.fanout_3)
+        self.assertEqual(stats.fanout, 6)
+
+    def test_fanout_3_limited(self):
+        # With subgraph limit at 1, it is essentially turning off the fanout
+        # pruner.
+        mod, stats = self.check(self.fanout_3, subgraph_limit=1)
+        self.assertEqual(stats.fanout, 0)
+
+
+class TestFanoutRaise(BaseTestByIR):
+    refprune_bitmask = llvm.RefPruneSubpasses.FANOUT_RAISE
+
+    fanout_raise_1 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_output !0
+    ret i32 1
+}
+!0 = !{i1 true}
+"""
+
+    def test_fanout_raise_1(self):
+        mod, stats = self.check(self.fanout_raise_1)
+        self.assertEqual(stats.fanout_raise, 2)
+
+    fanout_raise_2 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_typo !0      ; bad metadata
+    ret i32 1
+}
+
+!0 = !{i1 true}
+"""
+
+    def test_fanout_raise_2(self):
+        # This is ensuring that fanout_raise is not pruning when the metadata
+        # is incorrectly named.
+        mod, stats = self.check(self.fanout_raise_2)
+        self.assertEqual(stats.fanout_raise, 0)
+
+    fanout_raise_3 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    ret i32 0
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_output !0
+    ret i32 1
+}
+
+!0 = !{i32 1}       ; ok; use i32
+"""
+
+    def test_fanout_raise_3(self):
+        mod, stats = self.check(self.fanout_raise_3)
+        self.assertEqual(stats.fanout_raise, 2)
+
+    fanout_raise_4 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    ret i32 1    ; BAD; all tails are raising without decref
+bb_C:
+    ret i32 1    ; BAD; all tails are raising without decref
+}
+
+!0 = !{i1 1}
+"""
+
+    def test_fanout_raise_4(self):
+        mod, stats = self.check(self.fanout_raise_4)
+        self.assertEqual(stats.fanout_raise, 0)
+
+    fanout_raise_5 = r"""
+define i32 @main(i8* %ptr, i1 %cond, i8** %excinfo) {
+bb_A:
+    call void @NRT_incref(i8* %ptr)
+    br i1 %cond, label %bb_B, label %bb_C
+bb_B:
+    call void @NRT_decref(i8* %ptr)
+    br label %common.ret
+bb_C:
+    store i8* null, i8** %excinfo, !numba_exception_output !0
+    br label %common.ret
+common.ret:
+    %common.ret.op = phi i32 [ 0, %bb_B ], [ 1, %bb_C ]
+    ret i32 %common.ret.op
+}
+!0 = !{i1 1}
+"""
+
+    def test_fanout_raise_5(self):
+        mod, stats = self.check(self.fanout_raise_5)
+        self.assertEqual(stats.fanout_raise, 2)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/lib/python3.11/site-packages/llvmlite/tests/test_valuerepr.py b/lib/python3.11/site-packages/llvmlite/tests/test_valuerepr.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8d7e4b2c073ecdfd5ae8c985ebd9108245bd78f
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/tests/test_valuerepr.py
@@ -0,0 +1,60 @@
+import math
+import sys
+import unittest
+
+from llvmlite.ir import (
+    Constant, FloatType, DoubleType, LiteralStructType, IntType,
+    ArrayType, HalfType)
+from llvmlite.tests import TestCase
+
+
+int8 = IntType(8)
+int16 = IntType(16)
+
+
+PY36_OR_LATER = sys.version_info[:2] >= (3, 6)
+
+
+class TestValueRepr(TestCase):
+
+    def test_double_repr(self):
+        def check_repr(val, expected):
+            c = Constant(DoubleType(), val)
+            self.assertEqual(str(c), expected)
+        check_repr(math.pi, "double 0x400921fb54442d18")
+        check_repr(float('inf'), "double 0x7ff0000000000000")
+        check_repr(float('-inf'), "double 0xfff0000000000000")
+
+    def test_float_repr(self):
+        def check_repr(val, expected):
+            c = Constant(FloatType(), val)
+            self.assertEqual(str(c), expected)
+        check_repr(math.pi, "float 0x400921fb60000000")
+        check_repr(float('inf'), "float 0x7ff0000000000000")
+        check_repr(float('-inf'), "float 0xfff0000000000000")
+
+    @unittest.skipUnless(PY36_OR_LATER, 'py36+ only')
+    def test_half_repr(self):
+        def check_repr(val, expected):
+            c = Constant(HalfType(), val)
+            self.assertEqual(str(c), expected)
+        check_repr(math.pi, "half 0x4009200000000000")
+        check_repr(float('inf'), "half 0x7ff0000000000000")
+        check_repr(float('-inf'), "half 0xfff0000000000000")
+
+    def test_struct_repr(self):
+        tp = LiteralStructType([int8, int16])
+        c = Constant(tp, (Constant(int8, 100), Constant(int16, 1000)))
+        self.assertEqual(str(c), "{i8, i16} {i8 100, i16 1000}")
+
+    def test_array_repr(self):
+        tp = ArrayType(int8, 3)
+        values = [Constant(int8, x) for x in (5, 10, -15)]
+        c = Constant(tp, values)
+        self.assertEqual(str(c), "[3 x i8] [i8 5, i8 10, i8 -15]")
+        c = Constant(tp, bytearray(b"\x01\x02\x03"))
+        self.assertEqual(str(c), '[3 x i8] c"\\01\\02\\03"')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/lib/python3.11/site-packages/llvmlite/utils.py b/lib/python3.11/site-packages/llvmlite/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e07ecd370f45b3af0fe67f9a0ac6ea1cee16db3f
--- /dev/null
+++ b/lib/python3.11/site-packages/llvmlite/utils.py
@@ -0,0 +1,29 @@
+import os
+import sys
+
+
+# This module must be importable without loading the binding, to avoid
+# bootstrapping issues in setup.py.
+
+def get_library_name():
+    """
+    Return the name of the llvmlite shared library file.
+    """
+    if os.name == 'posix':
+        if sys.platform == 'darwin':
+            return 'libllvmlite.dylib'
+        else:
+            return 'libllvmlite.so'
+    else:
+        assert os.name == 'nt'
+        return 'llvmlite.dll'
+
+
+def get_library_files():
+    """
+    Return the names of shared library files needed for this platform.
+    """
+    files = [get_library_name()]
+    if os.name == 'nt':
+        files.extend(['msvcr120.dll', 'msvcp120.dll'])
+    return files
diff --git a/lib/python3.11/site-packages/markupsafe/__init__.py b/lib/python3.11/site-packages/markupsafe/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..21d31960385611ad029826a36417fe50a17ca557
--- /dev/null
+++ b/lib/python3.11/site-packages/markupsafe/__init__.py
@@ -0,0 +1,304 @@
+import functools
+import re
+import string
+import sys
+import typing as t
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    class HasHTML(te.Protocol):
+        def __html__(self) -> str:
+            pass
+
+    _P = te.ParamSpec("_P")
+
+
+__version__ = "2.1.3"
+
+_strip_comments_re = re.compile(r"<!--.*?-->", re.DOTALL)
+_strip_tags_re = re.compile(r"<.*?>", re.DOTALL)
+
+
+def _simple_escaping_wrapper(func: "t.Callable[_P, str]") -> "t.Callable[_P, Markup]":
+    @functools.wraps(func)
+    def wrapped(self: "Markup", *args: "_P.args", **kwargs: "_P.kwargs") -> "Markup":
+        arg_list = _escape_argspec(list(args), enumerate(args), self.escape)
+        _escape_argspec(kwargs, kwargs.items(), self.escape)
+        return self.__class__(func(self, *arg_list, **kwargs))  # type: ignore[arg-type]
+
+    return wrapped  # type: ignore[return-value]
+
+
+class Markup(str):
+    """A string that is ready to be safely inserted into an HTML or XML
+    document, either because it was escaped or because it was marked
+    safe.
+
+    Passing an object to the constructor converts it to text and wraps
+    it to mark it safe without escaping. To escape the text, use the
+    :meth:`escape` class method instead.
+
+    >>> Markup("Hello, <em>World</em>!")
+    Markup('Hello, <em>World</em>!')
+    >>> Markup(42)
+    Markup('42')
+    >>> Markup.escape("Hello, <em>World</em>!")
+    Markup('Hello &lt;em&gt;World&lt;/em&gt;!')
+
+    This implements the ``__html__()`` interface that some frameworks
+    use. Passing an object that implements ``__html__()`` will wrap the
+    output of that method, marking it safe.
+
+    >>> class Foo:
+    ...     def __html__(self):
+    ...         return '<a href="/foo">foo</a>'
+    ...
+    >>> Markup(Foo())
+    Markup('<a href="/foo">foo</a>')
+
+    This is a subclass of :class:`str`. It has the same methods, but
+    escapes their arguments and returns a ``Markup`` instance.
+
+    >>> Markup("<em>%s</em>") % ("foo & bar",)
+    Markup('<em>foo &amp; bar</em>')
+    >>> Markup("<em>Hello</em> ") + "<foo>"
+    Markup('<em>Hello</em> &lt;foo&gt;')
+    """
+
+    __slots__ = ()
+
+    def __new__(
+        cls, base: t.Any = "", encoding: t.Optional[str] = None, errors: str = "strict"
+    ) -> "te.Self":
+        if hasattr(base, "__html__"):
+            base = base.__html__()
+
+        if encoding is None:
+            return super().__new__(cls, base)
+
+        return super().__new__(cls, base, encoding, errors)
+
+    def __html__(self) -> "te.Self":
+        return self
+
+    def __add__(self, other: t.Union[str, "HasHTML"]) -> "te.Self":
+        if isinstance(other, str) or hasattr(other, "__html__"):
+            return self.__class__(super().__add__(self.escape(other)))
+
+        return NotImplemented
+
+    def __radd__(self, other: t.Union[str, "HasHTML"]) -> "te.Self":
+        if isinstance(other, str) or hasattr(other, "__html__"):
+            return self.escape(other).__add__(self)
+
+        return NotImplemented
+
+    def __mul__(self, num: "te.SupportsIndex") -> "te.Self":
+        if isinstance(num, int):
+            return self.__class__(super().__mul__(num))
+
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __mod__(self, arg: t.Any) -> "te.Self":
+        if isinstance(arg, tuple):
+            # a tuple of arguments, each wrapped
+            arg = tuple(_MarkupEscapeHelper(x, self.escape) for x in arg)
+        elif hasattr(type(arg), "__getitem__") and not isinstance(arg, str):
+            # a mapping of arguments, wrapped
+            arg = _MarkupEscapeHelper(arg, self.escape)
+        else:
+            # a single argument, wrapped with the helper and a tuple
+            arg = (_MarkupEscapeHelper(arg, self.escape),)
+
+        return self.__class__(super().__mod__(arg))
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+    def join(self, seq: t.Iterable[t.Union[str, "HasHTML"]]) -> "te.Self":
+        return self.__class__(super().join(map(self.escape, seq)))
+
+    join.__doc__ = str.join.__doc__
+
+    def split(  # type: ignore[override]
+        self, sep: t.Optional[str] = None, maxsplit: int = -1
+    ) -> t.List["te.Self"]:
+        return [self.__class__(v) for v in super().split(sep, maxsplit)]
+
+    split.__doc__ = str.split.__doc__
+
+    def rsplit(  # type: ignore[override]
+        self, sep: t.Optional[str] = None, maxsplit: int = -1
+    ) -> t.List["te.Self"]:
+        return [self.__class__(v) for v in super().rsplit(sep, maxsplit)]
+
+    rsplit.__doc__ = str.rsplit.__doc__
+
+    def splitlines(  # type: ignore[override]
+        self, keepends: bool = False
+    ) -> t.List["te.Self"]:
+        return [self.__class__(v) for v in super().splitlines(keepends)]
+
+    splitlines.__doc__ = str.splitlines.__doc__
+
+    def unescape(self) -> str:
+        """Convert escaped markup back into a text string. This replaces
+        HTML entities with the characters they represent.
+
+        >>> Markup("Main &raquo; <em>About</em>").unescape()
+        'Main » <em>About</em>'
+        """
+        from html import unescape
+
+        return unescape(str(self))
+
+    def striptags(self) -> str:
+        """:meth:`unescape` the markup, remove tags, and normalize
+        whitespace to single spaces.
+
+        >>> Markup("Main &raquo;\t<em>About</em>").striptags()
+        'Main » About'
+        """
+        # Use two regexes to avoid ambiguous matches.
+        value = _strip_comments_re.sub("", self)
+        value = _strip_tags_re.sub("", value)
+        value = " ".join(value.split())
+        return self.__class__(value).unescape()
+
+    @classmethod
+    def escape(cls, s: t.Any) -> "te.Self":
+        """Escape a string. Calls :func:`escape` and ensures that for
+        subclasses the correct type is returned.
+        """
+        rv = escape(s)
+
+        if rv.__class__ is not cls:
+            return cls(rv)
+
+        return rv  # type: ignore[return-value]
+
+    __getitem__ = _simple_escaping_wrapper(str.__getitem__)
+    capitalize = _simple_escaping_wrapper(str.capitalize)
+    title = _simple_escaping_wrapper(str.title)
+    lower = _simple_escaping_wrapper(str.lower)
+    upper = _simple_escaping_wrapper(str.upper)
+    replace = _simple_escaping_wrapper(str.replace)
+    ljust = _simple_escaping_wrapper(str.ljust)
+    rjust = _simple_escaping_wrapper(str.rjust)
+    lstrip = _simple_escaping_wrapper(str.lstrip)
+    rstrip = _simple_escaping_wrapper(str.rstrip)
+    center = _simple_escaping_wrapper(str.center)
+    strip = _simple_escaping_wrapper(str.strip)
+    translate = _simple_escaping_wrapper(str.translate)
+    expandtabs = _simple_escaping_wrapper(str.expandtabs)
+    swapcase = _simple_escaping_wrapper(str.swapcase)
+    zfill = _simple_escaping_wrapper(str.zfill)
+    casefold = _simple_escaping_wrapper(str.casefold)
+
+    if sys.version_info >= (3, 9):
+        removeprefix = _simple_escaping_wrapper(str.removeprefix)
+        removesuffix = _simple_escaping_wrapper(str.removesuffix)
+
+    def partition(self, sep: str) -> t.Tuple["te.Self", "te.Self", "te.Self"]:
+        l, s, r = super().partition(self.escape(sep))
+        cls = self.__class__
+        return cls(l), cls(s), cls(r)
+
+    def rpartition(self, sep: str) -> t.Tuple["te.Self", "te.Self", "te.Self"]:
+        l, s, r = super().rpartition(self.escape(sep))
+        cls = self.__class__
+        return cls(l), cls(s), cls(r)
+
+    def format(self, *args: t.Any, **kwargs: t.Any) -> "te.Self":
+        formatter = EscapeFormatter(self.escape)
+        return self.__class__(formatter.vformat(self, args, kwargs))
+
+    def format_map(  # type: ignore[override]
+        self, map: t.Mapping[str, t.Any]
+    ) -> "te.Self":
+        formatter = EscapeFormatter(self.escape)
+        return self.__class__(formatter.vformat(self, (), map))
+
+    def __html_format__(self, format_spec: str) -> "te.Self":
+        if format_spec:
+            raise ValueError("Unsupported format specification for Markup.")
+
+        return self
+
+
+class EscapeFormatter(string.Formatter):
+    __slots__ = ("escape",)
+
+    def __init__(self, escape: t.Callable[[t.Any], Markup]) -> None:
+        self.escape = escape
+        super().__init__()
+
+    def format_field(self, value: t.Any, format_spec: str) -> str:
+        if hasattr(value, "__html_format__"):
+            rv = value.__html_format__(format_spec)
+        elif hasattr(value, "__html__"):
+            if format_spec:
+                raise ValueError(
+                    f"Format specifier {format_spec} given, but {type(value)} does not"
+                    " define __html_format__. A class that defines __html__ must define"
+                    " __html_format__ to work with format specifiers."
+                )
+            rv = value.__html__()
+        else:
+            # We need to make sure the format spec is str here as
+            # otherwise the wrong callback methods are invoked.
+            rv = string.Formatter.format_field(self, value, str(format_spec))
+        return str(self.escape(rv))
+
+
+_ListOrDict = t.TypeVar("_ListOrDict", list, dict)
+
+
+def _escape_argspec(
+    obj: _ListOrDict, iterable: t.Iterable[t.Any], escape: t.Callable[[t.Any], Markup]
+) -> _ListOrDict:
+    """Helper for various string-wrapped functions."""
+    for key, value in iterable:
+        if isinstance(value, str) or hasattr(value, "__html__"):
+            obj[key] = escape(value)
+
+    return obj
+
+
+class _MarkupEscapeHelper:
+    """Helper for :meth:`Markup.__mod__`."""
+
+    __slots__ = ("obj", "escape")
+
+    def __init__(self, obj: t.Any, escape: t.Callable[[t.Any], Markup]) -> None:
+        self.obj = obj
+        self.escape = escape
+
+    def __getitem__(self, item: t.Any) -> "te.Self":
+        return self.__class__(self.obj[item], self.escape)
+
+    def __str__(self) -> str:
+        return str(self.escape(self.obj))
+
+    def __repr__(self) -> str:
+        return str(self.escape(repr(self.obj)))
+
+    def __int__(self) -> int:
+        return int(self.obj)
+
+    def __float__(self) -> float:
+        return float(self.obj)
+
+
+# circular import
+try:
+    from ._speedups import escape as escape
+    from ._speedups import escape_silent as escape_silent
+    from ._speedups import soft_str as soft_str
+except ImportError:
+    from ._native import escape as escape
+    from ._native import escape_silent as escape_silent  # noqa: F401
+    from ._native import soft_str as soft_str  # noqa: F401
diff --git a/lib/python3.11/site-packages/markupsafe/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/markupsafe/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76755930c704c9e8bb0692e0641855f36d5ab671
Binary files /dev/null and b/lib/python3.11/site-packages/markupsafe/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/markupsafe/__pycache__/_native.cpython-311.pyc b/lib/python3.11/site-packages/markupsafe/__pycache__/_native.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ab54ccfda85c3a8944d1a8394af4867bae039d5
Binary files /dev/null and b/lib/python3.11/site-packages/markupsafe/__pycache__/_native.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/markupsafe/_native.py b/lib/python3.11/site-packages/markupsafe/_native.py
new file mode 100644
index 0000000000000000000000000000000000000000..8117b2716d110074d9a81365c59343e81396b7f5
--- /dev/null
+++ b/lib/python3.11/site-packages/markupsafe/_native.py
@@ -0,0 +1,63 @@
+import typing as t
+
+from . import Markup
+
+
+def escape(s: t.Any) -> Markup:
+    """Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in
+    the string with HTML-safe sequences. Use this if you need to display
+    text that might contain such characters in HTML.
+
+    If the object has an ``__html__`` method, it is called and the
+    return value is assumed to already be safe for HTML.
+
+    :param s: An object to be converted to a string and escaped.
+    :return: A :class:`Markup` string with the escaped text.
+    """
+    if hasattr(s, "__html__"):
+        return Markup(s.__html__())
+
+    return Markup(
+        str(s)
+        .replace("&", "&amp;")
+        .replace(">", "&gt;")
+        .replace("<", "&lt;")
+        .replace("'", "&#39;")
+        .replace('"', "&#34;")
+    )
+
+
+def escape_silent(s: t.Optional[t.Any]) -> Markup:
+    """Like :func:`escape` but treats ``None`` as the empty string.
+    Useful with optional values, as otherwise you get the string
+    ``'None'`` when the value is ``None``.
+
+    >>> escape(None)
+    Markup('None')
+    >>> escape_silent(None)
+    Markup('')
+    """
+    if s is None:
+        return Markup()
+
+    return escape(s)
+
+
+def soft_str(s: t.Any) -> str:
+    """Convert an object to a string if it isn't already. This preserves
+    a :class:`Markup` string rather than converting it back to a basic
+    string, so it will still be marked as safe and won't be escaped
+    again.
+
+    >>> value = escape("<User 1>")
+    >>> value
+    Markup('&lt;User 1&gt;')
+    >>> escape(str(value))
+    Markup('&amp;lt;User 1&amp;gt;')
+    >>> escape(soft_str(value))
+    Markup('&lt;User 1&gt;')
+    """
+    if not isinstance(s, str):
+        return str(s)
+
+    return s
diff --git a/lib/python3.11/site-packages/markupsafe/_speedups.c b/lib/python3.11/site-packages/markupsafe/_speedups.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c463fb82d53e9a9616acfbbece0eb3be6d0d5e7
--- /dev/null
+++ b/lib/python3.11/site-packages/markupsafe/_speedups.c
@@ -0,0 +1,320 @@
+#include <Python.h>
+
+static PyObject* markup;
+
+static int
+init_constants(void)
+{
+	PyObject *module;
+
+	/* import markup type so that we can mark the return value */
+	module = PyImport_ImportModule("markupsafe");
+	if (!module)
+		return 0;
+	markup = PyObject_GetAttrString(module, "Markup");
+	Py_DECREF(module);
+
+	return 1;
+}
+
+#define GET_DELTA(inp, inp_end, delta) \
+	while (inp < inp_end) { \
+		switch (*inp++) { \
+		case '"': \
+		case '\'': \
+		case '&': \
+			delta += 4; \
+			break; \
+		case '<': \
+		case '>': \
+			delta += 3; \
+			break; \
+		} \
+	}
+
+#define DO_ESCAPE(inp, inp_end, outp) \
+	{ \
+		Py_ssize_t ncopy = 0; \
+		while (inp < inp_end) { \
+			switch (*inp) { \
+			case '"': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = '#'; \
+				*outp++ = '3'; \
+				*outp++ = '4'; \
+				*outp++ = ';'; \
+				break; \
+			case '\'': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = '#'; \
+				*outp++ = '3'; \
+				*outp++ = '9'; \
+				*outp++ = ';'; \
+				break; \
+			case '&': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'a'; \
+				*outp++ = 'm'; \
+				*outp++ = 'p'; \
+				*outp++ = ';'; \
+				break; \
+			case '<': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'l'; \
+				*outp++ = 't'; \
+				*outp++ = ';'; \
+				break; \
+			case '>': \
+				memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+				outp += ncopy; ncopy = 0; \
+				*outp++ = '&'; \
+				*outp++ = 'g'; \
+				*outp++ = 't'; \
+				*outp++ = ';'; \
+				break; \
+			default: \
+				ncopy++; \
+			} \
+			inp++; \
+		} \
+		memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \
+	}
+
+static PyObject*
+escape_unicode_kind1(PyUnicodeObject *in)
+{
+	Py_UCS1 *inp = PyUnicode_1BYTE_DATA(in);
+	Py_UCS1 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS1 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta,
+						PyUnicode_IS_ASCII(in) ? 127 : 255);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_1BYTE_DATA(in);
+	outp = PyUnicode_1BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+static PyObject*
+escape_unicode_kind2(PyUnicodeObject *in)
+{
+	Py_UCS2 *inp = PyUnicode_2BYTE_DATA(in);
+	Py_UCS2 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS2 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 65535);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_2BYTE_DATA(in);
+	outp = PyUnicode_2BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+
+static PyObject*
+escape_unicode_kind4(PyUnicodeObject *in)
+{
+	Py_UCS4 *inp = PyUnicode_4BYTE_DATA(in);
+	Py_UCS4 *inp_end = inp + PyUnicode_GET_LENGTH(in);
+	Py_UCS4 *outp;
+	PyObject *out;
+	Py_ssize_t delta = 0;
+
+	GET_DELTA(inp, inp_end, delta);
+	if (!delta) {
+		Py_INCREF(in);
+		return (PyObject*)in;
+	}
+
+	out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 1114111);
+	if (!out)
+		return NULL;
+
+	inp = PyUnicode_4BYTE_DATA(in);
+	outp = PyUnicode_4BYTE_DATA(out);
+	DO_ESCAPE(inp, inp_end, outp);
+	return out;
+}
+
+static PyObject*
+escape_unicode(PyUnicodeObject *in)
+{
+	if (PyUnicode_READY(in))
+		return NULL;
+
+	switch (PyUnicode_KIND(in)) {
+	case PyUnicode_1BYTE_KIND:
+		return escape_unicode_kind1(in);
+	case PyUnicode_2BYTE_KIND:
+		return escape_unicode_kind2(in);
+	case PyUnicode_4BYTE_KIND:
+		return escape_unicode_kind4(in);
+	}
+	assert(0);  /* shouldn't happen */
+	return NULL;
+}
+
+static PyObject*
+escape(PyObject *self, PyObject *text)
+{
+	static PyObject *id_html;
+	PyObject *s = NULL, *rv = NULL, *html;
+
+	if (id_html == NULL) {
+		id_html = PyUnicode_InternFromString("__html__");
+		if (id_html == NULL) {
+			return NULL;
+		}
+	}
+
+	/* we don't have to escape integers, bools or floats */
+	if (PyLong_CheckExact(text) ||
+		PyFloat_CheckExact(text) || PyBool_Check(text) ||
+		text == Py_None)
+		return PyObject_CallFunctionObjArgs(markup, text, NULL);
+
+	/* if the object has an __html__ method that performs the escaping */
+	html = PyObject_GetAttr(text ,id_html);
+	if (html) {
+		s = PyObject_CallObject(html, NULL);
+		Py_DECREF(html);
+		if (s == NULL) {
+			return NULL;
+		}
+		/* Convert to Markup object */
+		rv = PyObject_CallFunctionObjArgs(markup, (PyObject*)s, NULL);
+		Py_DECREF(s);
+		return rv;
+	}
+
+	/* otherwise make the object unicode if it isn't, then escape */
+	PyErr_Clear();
+	if (!PyUnicode_Check(text)) {
+		PyObject *unicode = PyObject_Str(text);
+		if (!unicode)
+			return NULL;
+		s = escape_unicode((PyUnicodeObject*)unicode);
+		Py_DECREF(unicode);
+	}
+	else
+		s = escape_unicode((PyUnicodeObject*)text);
+
+	/* convert the unicode string into a markup object. */
+	rv = PyObject_CallFunctionObjArgs(markup, (PyObject*)s, NULL);
+	Py_DECREF(s);
+	return rv;
+}
+
+
+static PyObject*
+escape_silent(PyObject *self, PyObject *text)
+{
+	if (text != Py_None)
+		return escape(self, text);
+	return PyObject_CallFunctionObjArgs(markup, NULL);
+}
+
+
+static PyObject*
+soft_str(PyObject *self, PyObject *s)
+{
+	if (!PyUnicode_Check(s))
+		return PyObject_Str(s);
+	Py_INCREF(s);
+	return s;
+}
+
+
+static PyMethodDef module_methods[] = {
+	{
+		"escape",
+		(PyCFunction)escape,
+		METH_O,
+		"Replace the characters ``&``, ``<``, ``>``, ``'``, and ``\"`` in"
+		" the string with HTML-safe sequences. Use this if you need to display"
+		" text that might contain such characters in HTML.\n\n"
+		"If the object has an ``__html__`` method, it is called and the"
+		" return value is assumed to already be safe for HTML.\n\n"
+		":param s: An object to be converted to a string and escaped.\n"
+		":return: A :class:`Markup` string with the escaped text.\n"
+	},
+	{
+		"escape_silent",
+		(PyCFunction)escape_silent,
+		METH_O,
+		"Like :func:`escape` but treats ``None`` as the empty string."
+		" Useful with optional values, as otherwise you get the string"
+		" ``'None'`` when the value is ``None``.\n\n"
+		">>> escape(None)\n"
+		"Markup('None')\n"
+		">>> escape_silent(None)\n"
+		"Markup('')\n"
+	},
+	{
+		"soft_str",
+		(PyCFunction)soft_str,
+		METH_O,
+		"Convert an object to a string if it isn't already. This preserves"
+		" a :class:`Markup` string rather than converting it back to a basic"
+		" string, so it will still be marked as safe and won't be escaped"
+		" again.\n\n"
+		">>> value = escape(\"<User 1>\")\n"
+		">>> value\n"
+		"Markup('&lt;User 1&gt;')\n"
+		">>> escape(str(value))\n"
+		"Markup('&amp;lt;User 1&amp;gt;')\n"
+		">>> escape(soft_str(value))\n"
+		"Markup('&lt;User 1&gt;')\n"
+	},
+	{NULL, NULL, 0, NULL}  /* Sentinel */
+};
+
+static struct PyModuleDef module_definition = {
+	PyModuleDef_HEAD_INIT,
+	"markupsafe._speedups",
+	NULL,
+	-1,
+	module_methods,
+	NULL,
+	NULL,
+	NULL,
+	NULL
+};
+
+PyMODINIT_FUNC
+PyInit__speedups(void)
+{
+	if (!init_constants())
+		return NULL;
+
+	return PyModule_Create(&module_definition);
+}
diff --git a/lib/python3.11/site-packages/markupsafe/_speedups.cpython-311-darwin.so b/lib/python3.11/site-packages/markupsafe/_speedups.cpython-311-darwin.so
new file mode 100644
index 0000000000000000000000000000000000000000..1b63f2eb76589bdebe01a385e13fe248dc1f9db1
Binary files /dev/null and b/lib/python3.11/site-packages/markupsafe/_speedups.cpython-311-darwin.so differ
diff --git a/lib/python3.11/site-packages/markupsafe/_speedups.pyi b/lib/python3.11/site-packages/markupsafe/_speedups.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..f673240f6d299917d829a5fdbf85d25d84dd0a72
--- /dev/null
+++ b/lib/python3.11/site-packages/markupsafe/_speedups.pyi
@@ -0,0 +1,9 @@
+from typing import Any
+from typing import Optional
+
+from . import Markup
+
+def escape(s: Any) -> Markup: ...
+def escape_silent(s: Optional[Any]) -> Markup: ...
+def soft_str(s: Any) -> str: ...
+def soft_unicode(s: Any) -> str: ...
diff --git a/lib/python3.11/site-packages/markupsafe/py.typed b/lib/python3.11/site-packages/markupsafe/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/mlx-0.0.7.dist-info/INSTALLER b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/mlx-0.0.7.dist-info/LICENSE b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..98ff47b9ef9d4ac9f1a4bde3db13dd27456c5ea1
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2023 Apple Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/lib/python3.11/site-packages/mlx-0.0.7.dist-info/METADATA b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..bbc14e38d8d7f851dc62bebe9ec01a7d4fb998f3
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/METADATA
@@ -0,0 +1,122 @@
+Metadata-Version: 2.1
+Name: mlx
+Version: 0.0.7
+Summary: A framework for machine learning on Apple silicon.
+Author: MLX Contributors
+Author-email: mlx@group.apple.com
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: pybind11-stubgen ; extra == 'dev'
+Provides-Extra: testing
+Requires-Dist: numpy ; extra == 'testing'
+Requires-Dist: torch ; extra == 'testing'
+
+# MLX
+
+[**Quickstart**](#quickstart) | [**Installation**](#installation) |
+[**Documentation**](https://ml-explore.github.io/mlx/build/html/index.html) |
+[**Examples**](#examples) 
+
+[![CircleCI](https://circleci.com/gh/ml-explore/mlx.svg?style=svg)](https://circleci.com/gh/ml-explore/mlx)
+
+MLX is an array framework for machine learning on Apple silicon, brought to you
+by Apple machine learning research.
+
+Some key features of MLX include:
+
+ - **Familiar APIs**: MLX has a Python API that closely follows NumPy.
+   MLX also has a fully featured C++ API, which closely mirrors the Python API. 
+   MLX has higher-level packages like `mlx.nn` and `mlx.optimizers` with APIs
+   that closely follow PyTorch to simplify building more complex models.
+
+ - **Composable function transformations**: MLX supports composable function
+   transformations for automatic differentiation, automatic vectorization,
+   and computation graph optimization.
+
+ - **Lazy computation**: Computations in MLX are lazy. Arrays are only
+   materialized when needed.
+
+ - **Dynamic graph construction**: Computation graphs in MLX are constructed
+   dynamically. Changing the shapes of function arguments does not trigger
+   slow compilations, and debugging is simple and intuitive.
+
+ - **Multi-device**: Operations can run on any of the supported devices
+   (currently the CPU and the GPU).
+
+ - **Unified memory**: A notable difference from MLX and other frameworks
+   is the *unified memory model*. Arrays in MLX live in shared memory.
+   Operations on MLX arrays can be performed on any of the supported
+   device types without transferring data.
+
+MLX is designed by machine learning researchers for machine learning
+researchers. The framework is intended to be user-friendly, but still efficient
+to train and deploy models. The design of the framework itself is also
+conceptually simple. We intend to make it easy for researchers to extend and
+improve MLX with the goal of quickly exploring new ideas. 
+
+The design of MLX is inspired by frameworks like
+[NumPy](https://numpy.org/doc/stable/index.html),
+[PyTorch](https://pytorch.org/), [Jax](https://github.com/google/jax), and
+[ArrayFire](https://arrayfire.org/).
+
+## Examples
+
+The [MLX examples repo](https://github.com/ml-explore/mlx-examples) has a
+variety of examples, including:
+
+- [Transformer language model](https://github.com/ml-explore/mlx-examples/tree/main/transformer_lm) training.
+- Large-scale text generation with
+  [LLaMA](https://github.com/ml-explore/mlx-examples/tree/main/llms/llama) and
+  finetuning with [LoRA](https://github.com/ml-explore/mlx-examples/tree/main/lora).
+- Generating images with [Stable Diffusion](https://github.com/ml-explore/mlx-examples/tree/main/stable_diffusion).
+- Speech recognition with [OpenAI's Whisper](https://github.com/ml-explore/mlx-examples/tree/main/whisper).
+
+## Quickstart
+
+See the [quick start
+guide](https://ml-explore.github.io/mlx/build/html/quick_start.html)
+in the documentation.
+
+## Installation
+
+MLX is available on [PyPI](https://pypi.org/project/mlx/). To install the Python API, run:
+
+```
+pip install mlx
+```
+
+Checkout the
+[documentation](https://ml-explore.github.io/mlx/build/html/install.html#)
+for more information on building the C++ and Python APIs from source.
+
+## Contributing 
+
+Check out the [contribution guidelines](CONTRIBUTING.md) for more information
+on contributing to MLX. See the
+[docs](https://ml-explore.github.io/mlx/build/html/install.html) for more
+information on building from source, and running tests.
+
+We are grateful for all of [our
+contributors](ACKNOWLEDGMENTS.md#Individual-Contributors). If you contribute
+to MLX and wish to be acknowledged, please add your name to the list in your
+pull request.
+
+## Citing MLX
+
+The MLX software suite was initially developed with equal contribution by Awni
+Hannun, Jagrit Digani, Angelos Katharopoulos, and Ronan Collobert. If you find
+MLX useful in your research and wish to cite it, please use the following
+BibTex entry:
+
+```
+@software{mlx2023,
+  author = {Awni Hannun and Jagrit Digani and Angelos Katharopoulos and Ronan Collobert},
+  title = {{MLX}: Efficient and flexible machine learning on Apple silicon},
+  url = {https://github.com/ml-explore},
+  version = {0.0},
+  year = {2023},
+}
+```
diff --git a/lib/python3.11/site-packages/mlx-0.0.7.dist-info/RECORD b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..8007be1ed6eeb6050cd4a6d3ff74c0e8c24a7118
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/RECORD
@@ -0,0 +1,199 @@
+mlx-0.0.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+mlx-0.0.7.dist-info/LICENSE,sha256=zPq3zLLqMG9xUxyMp3u1VQdgbNkHaLHjK4tSq1tIzwE,1066
+mlx-0.0.7.dist-info/METADATA,sha256=CK9nqz-nrSgrFZpRYpc86IYysL_W7zObqiiczNHD5OA,4731
+mlx-0.0.7.dist-info/RECORD,,
+mlx-0.0.7.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mlx-0.0.7.dist-info/WHEEL,sha256=9CmlYCCxe9UEGaJDl4r_tPKbyfF_OdzBb5_jMO3h1CA,110
+mlx-0.0.7.dist-info/top_level.txt,sha256=NCVZzyms-obPlDq2Sa--m3oyfnnmLma38KCnE6gmcFE,4
+mlx/__pycache__/_reprlib_fix.cpython-311.pyc,,
+mlx/__pycache__/extension.cpython-311.pyc,,
+mlx/__pycache__/optimizers.cpython-311.pyc,,
+mlx/__pycache__/utils.cpython-311.pyc,,
+mlx/_reprlib_fix.py,sha256=YoRQib4PSzl1FIMvs4BwkvipAwOrfufqtV89vNF4Yhc,518
+mlx/core.cpython-311-darwin.so,sha256=4GMiWnLS2sZGsrIwB9mAryue5Lztf-SttAn_AzadmCc,1098840
+mlx/extension.py,sha256=tqKrGeP1ElK9UfBMHUeOq56qWnMMxZrt7DVVM8QZ7yU,3769
+mlx/include/metal_cpp/Foundation/Foundation.hpp,sha256=pYbEkzTrb2O0jJPzI0m9cBNvVSDTh_t39Dv7h0ZDma0,1808
+mlx/include/metal_cpp/Foundation/NSArray.hpp,sha256=8nhS0gF060n7taK9aIynkuMPxlbKgqgijsj61yvhrPQ,4818
+mlx/include/metal_cpp/Foundation/NSAutoreleasePool.hpp,sha256=K8_qNgYgyeP49WUSsz90Lo41qTb-x5Xjs23T9UNSkkU,3302
+mlx/include/metal_cpp/Foundation/NSBundle.hpp,sha256=y0Le2v43bCAdIdrSClvLpRtCL8c4qdB3WK59Gz_AYYs,16845
+mlx/include/metal_cpp/Foundation/NSData.hpp,sha256=rAPEZQn1W05O_sZ6LYexLhvv1CmllqyFWddGIrxGJ8s,2198
+mlx/include/metal_cpp/Foundation/NSDate.hpp,sha256=353UgslEWyV-D1_T7_Sr1fCP4nVjixwJK2QGnRZQKgg,2085
+mlx/include/metal_cpp/Foundation/NSDefines.hpp,sha256=c8BfIDwW9yCKiofyatyeLJ9YvnHO87PsBqSQtciN3tY,2203
+mlx/include/metal_cpp/Foundation/NSDictionary.hpp,sha256=Lt7EBR6ppPFhhnoZq9UqMETHf_L1k9A0gs637ZTEQSU,5738
+mlx/include/metal_cpp/Foundation/NSEnumerator.hpp,sha256=P4mkVmpWN0kdXnqqTMkyIovckr4_IZAoFzyg2IZDRs4,3141
+mlx/include/metal_cpp/Foundation/NSError.hpp,sha256=rFqCSIXVsWOsH7Ikegv2irMF3aoMn7fM6teB9VipMgc,7802
+mlx/include/metal_cpp/Foundation/NSLock.hpp,sha256=OjnoMx18m4E89eDPliPMw3cG8LtAqNsoBSxSO0l9DoY,4350
+mlx/include/metal_cpp/Foundation/NSNotification.hpp,sha256=rpAgI4upmIG2inWZ9ACYy-Q8za7muZ2WmUtA5l8WGHw,4696
+mlx/include/metal_cpp/Foundation/NSNumber.hpp,sha256=4a2fEU1Fm_wrWOs4zULhYQne0WymnRGsDeSGq1bDbuQ,22098
+mlx/include/metal_cpp/Foundation/NSObjCRuntime.hpp,sha256=SHYqTLWQ2F8T4dfXJ98OlATOexXQ3NnXzmFyVpb4wFM,1665
+mlx/include/metal_cpp/Foundation/NSObject.hpp,sha256=T_64vByLI4n3HIE05MVJZteUIAdN-y0oogsczYT-JTE,11105
+mlx/include/metal_cpp/Foundation/NSPrivate.hpp,sha256=JYewPlM0BKHLnmQiItPlYuc1HNAO-akJjhXnEKUZO00,20217
+mlx/include/metal_cpp/Foundation/NSProcessInfo.hpp,sha256=1NLI7-3mR8cseE_jE6c-D2_pRJKXA9fRl4V2uRZtiDI,16642
+mlx/include/metal_cpp/Foundation/NSRange.hpp,sha256=7VFC565QzvzfF1CI91osTozl-d1mM9UToCcGyXmf5cc,3147
+mlx/include/metal_cpp/Foundation/NSSet.hpp,sha256=0rORF6rpK2-R1AQCgT4CMNnGr18xZ8P5x82LEQLQ2sc,3368
+mlx/include/metal_cpp/Foundation/NSSharedPtr.hpp,sha256=208e_0hJddLllsT16pJa4rQAyFqA1uYuez5gWyRS6EU,8496
+mlx/include/metal_cpp/Foundation/NSString.hpp,sha256=AqRvSkbHPncbC36TJuR-4beEVT7ZPwnrVjmyoassaL8,11001
+mlx/include/metal_cpp/Foundation/NSTypes.hpp,sha256=9IaLleaqYbdjlMvT_mqFlYDlzg4vF_8MQQTO2Sdp6vo,1893
+mlx/include/metal_cpp/Foundation/NSURL.hpp,sha256=b1oGmKqL5F1WrWSaCK3Iqs0vxL8utVbOgtYW4RZUe_I,3668
+mlx/include/metal_cpp/LICENSE.txt,sha256=mgnj5ca95epXBMNZliB1O16xkRb5_WScN7W8RJeiXOo,11344
+mlx/include/metal_cpp/Metal/MTLAccelerationStructure.hpp,sha256=jqK65WOzpPUNE6H-XYb1PC3myk6vBIQr4fRrClCDZYs,85372
+mlx/include/metal_cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp,sha256=EC1flOCenKN-CNLIbHcpli7kP1PQGxkGUU8ZdMYQ4Qs,16289
+mlx/include/metal_cpp/Metal/MTLAccelerationStructureTypes.hpp,sha256=I29afo7zt4fiCY2ip3vPN72lhb6Whgjpx0lcHabfib4,5800
+mlx/include/metal_cpp/Metal/MTLArgument.hpp,sha256=_gQiklV3kRM2ukcYg0JCz3rUsK-zUOiZMYrp_thHjXU,23515
+mlx/include/metal_cpp/Metal/MTLArgumentEncoder.hpp,sha256=PaV9gzYeC1JLqDdcAJK9H6DaPVV2rclNWvNPK70KUWs,10739
+mlx/include/metal_cpp/Metal/MTLBinaryArchive.hpp,sha256=I8a_7I2WI-ftil5s4bT8N5rnUeRUt2HtsM2O9LW_t2M,5132
+mlx/include/metal_cpp/Metal/MTLBlitCommandEncoder.hpp,sha256=6QF2GR7c4XQXfA5COwCb2Q6xRXVMkYnO1gmUlrNw05o,16482
+mlx/include/metal_cpp/Metal/MTLBlitPass.hpp,sha256=zPt4836TDUuDPyRCyF7tJBEtEMpoWziJLlSRgWleURs,6982
+mlx/include/metal_cpp/Metal/MTLBuffer.hpp,sha256=IDVEI2qXwq6rU_tQsPkOpma-IV7othYmJIT2QCOBsic,3542
+mlx/include/metal_cpp/Metal/MTLCaptureManager.hpp,sha256=ANj6r5G9Gc1l9WikJQmZZlOWvfViJclzyPwKF59UvUg,7524
+mlx/include/metal_cpp/Metal/MTLCaptureScope.hpp,sha256=DU5_HrnsaHBttsqHfXCk-oPr8ifhMdP-DiYpS1G-qC0,3733
+mlx/include/metal_cpp/Metal/MTLCommandBuffer.hpp,sha256=29LVLOZlzB8G0bVfnHm867TXc0FPqbM7eXbNrZ2zRzE,17642
+mlx/include/metal_cpp/Metal/MTLCommandEncoder.hpp,sha256=IQGAhZMikxwU1IINtvw3MSTLwlbQKRWuTNZnZAw_0m8,2946
+mlx/include/metal_cpp/Metal/MTLCommandQueue.hpp,sha256=Uz74PTJAhqMi8XgLrj1RZOio-FYxLnTO9Msdy1dE7RA,2960
+mlx/include/metal_cpp/Metal/MTLComputeCommandEncoder.hpp,sha256=Z2E_Ny8OJj4gvC_YZtku5sni2t4o9Mbm7xvJk2tpgHc,17157
+mlx/include/metal_cpp/Metal/MTLComputePass.hpp,sha256=VOyFJlwaB89gmrtLdmnAz7gl97a5HbTYo-M6icWbN5M,7792
+mlx/include/metal_cpp/Metal/MTLComputePipeline.hpp,sha256=WTBUdVq1sxvHocezHO5wpVmaa94Xnthq27kSUCedcMY,15017
+mlx/include/metal_cpp/Metal/MTLCounters.hpp,sha256=RmlZCNFZIVPC4ue6FoIgYVq1Weq2Nu1GQD-G0yIwimg,9056
+mlx/include/metal_cpp/Metal/MTLDefines.hpp,sha256=1MG6A6zwLk99Yknu7PAvBvIMefVhumr1kFoKxQ-6xKk,1900
+mlx/include/metal_cpp/Metal/MTLDepthStencil.hpp,sha256=nP5OtW6QGUK7tzrXtJWJlch9bXkDYPYgp5BjMAptH6E,9631
+mlx/include/metal_cpp/Metal/MTLDevice.hpp,sha256=HyHg83T53RuLU1y_ZthBvEIzpOi1Lu0nXptaJfdrhwc,63880
+mlx/include/metal_cpp/Metal/MTLDrawable.hpp,sha256=07X3GSg7uJEWoOMWxI77cIWdr2NaBfJEXOtPJZr4M44,3193
+mlx/include/metal_cpp/Metal/MTLDynamicLibrary.hpp,sha256=yBUYfobLLHd00UOGALdsEF0FBiF1hUDr7G3FdKy6uMY,2606
+mlx/include/metal_cpp/Metal/MTLEvent.hpp,sha256=W8QBQWIUn-DcuBYzg0NB0L1W_Zs6G6QuQCeKUKM7tIo,4976
+mlx/include/metal_cpp/Metal/MTLFence.hpp,sha256=DuxPaIkQN9fWi1E6RHg8YrKNeB2nxGOZMuHXd8TiE9c,1723
+mlx/include/metal_cpp/Metal/MTLFunctionConstantValues.hpp,sha256=dz9s7_TYqjTJbthwEJTDoqdXsZ34JE2k4BERCYzWqWQ,3088
+mlx/include/metal_cpp/Metal/MTLFunctionDescriptor.hpp,sha256=JkzBrxhlg4_ezt2NLomw-MsGuBqdV9embOekJow-mks,5410
+mlx/include/metal_cpp/Metal/MTLFunctionHandle.hpp,sha256=HykCHezEwao-pmH6eL57qOyNt_G5RYsrsofxFDyHjiQ,1842
+mlx/include/metal_cpp/Metal/MTLFunctionLog.hpp,sha256=ZiIPh0Ef5oeiYIWsFZJGnOXZj2bejYFDe_3NVoRT2nY,3262
+mlx/include/metal_cpp/Metal/MTLFunctionStitching.hpp,sha256=fEipcQvZ2d8GeyPyn0AiyMup4doS9Yf-uzZRFpjkfyI,11407
+mlx/include/metal_cpp/Metal/MTLHeaderBridge.hpp,sha256=qYNlYMWNAx4z4iNnMyrqdQr_NJ5md2n1HMSxmP5ykRM,105217
+mlx/include/metal_cpp/Metal/MTLHeap.hpp,sha256=O9zMAFEKDGKAt710IDSwdsW3mYSyM7Mt2IVvJNJnAq0,11624
+mlx/include/metal_cpp/Metal/MTLIOCommandBuffer.hpp,sha256=OweZPLAmFoJFypxGIWisfb6Bzlvgv5qIYB2MVu6jBLw,7417
+mlx/include/metal_cpp/Metal/MTLIOCommandQueue.hpp,sha256=Al9BpGDKaSu5zQblMphnr9EXvrVee2ZaZWMba6L7QSs,7465
+mlx/include/metal_cpp/Metal/MTLIOCompressor.hpp,sha256=s7UjSrJLyfQt69RzWBY692G1audMRzjIVR-7GjkZFOQ,3043
+mlx/include/metal_cpp/Metal/MTLIndirectCommandBuffer.hpp,sha256=J3H4HH0p8qq_DYU8pQC_w4qDmYtNqj6FzoOo_AVGfxA,9715
+mlx/include/metal_cpp/Metal/MTLIndirectCommandEncoder.hpp,sha256=AW1Qzyggw9k9EqS71CvlFUHu4lag6nvvzK-LnV4oG0k,11239
+mlx/include/metal_cpp/Metal/MTLIntersectionFunctionTable.hpp,sha256=NUP7rHPWulH7M2M1wvzlyjjF7S0BJvG-_XFn4nWehcg,8181
+mlx/include/metal_cpp/Metal/MTLLibrary.hpp,sha256=le2P__N8XA4RCN62L2ZB-F9uo2p8BjQ-A6j0kEOqzws,23904
+mlx/include/metal_cpp/Metal/MTLLinkedFunctions.hpp,sha256=FmUoNjOGSegryBa0PDa1qcxEF0RUESixbd7OPyU-qDM,3867
+mlx/include/metal_cpp/Metal/MTLParallelRenderCommandEncoder.hpp,sha256=uHyC4bf8BjFUz6xEkFg79Lqzz9CV-0NNnNoQ-U3xfsA,3899
+mlx/include/metal_cpp/Metal/MTLPipeline.hpp,sha256=1EaeWaT8YNfvPaX0gqktNMOLtojBF6cVMlZiFT7vjyg,3775
+mlx/include/metal_cpp/Metal/MTLPixelFormat.hpp,sha256=DYqej_xuztbD0lhsioWTYWO2Sg7jRShyJ7izoVlex5Y,5910
+mlx/include/metal_cpp/Metal/MTLPrivate.hpp,sha256=vPTld95A83b1nIVT4qwsdcrttngMK5L5Ow-0HTr-zm4,6415
+mlx/include/metal_cpp/Metal/MTLRasterizationRate.hpp,sha256=LtcYTnjLSTaxTw98WdUg_9R9BaAozvXOTHcsnmSqbTo,15447
+mlx/include/metal_cpp/Metal/MTLRenderCommandEncoder.hpp,sha256=JNisXL9uSMMm_5B2vkVfuI8dgrMMMIrC8-E7P0pjdeo,60813
+mlx/include/metal_cpp/Metal/MTLRenderPass.hpp,sha256=YQCYdLOnOWsUgIbQimBDFo4l_FmbZfeHIJFADL3NnRQ,32752
+mlx/include/metal_cpp/Metal/MTLRenderPipeline.hpp,sha256=TuBYsiWg4hpumgaKccAn8TVAeLw26l_FdVGa6JsaMLA,72929
+mlx/include/metal_cpp/Metal/MTLResource.hpp,sha256=Be28y-6-9GvFuugCUhnykiTUqbMqYgVovDjUdpIrFDA,5244
+mlx/include/metal_cpp/Metal/MTLResourceStateCommandEncoder.hpp,sha256=eOjzuG-vDtQLJ8QOzhiqxXxiMEShXyn9cn-Uhmtigr8,5330
+mlx/include/metal_cpp/Metal/MTLResourceStatePass.hpp,sha256=N5sMbFCjfEdf10_3VZJfQvDl3nLuydqrKnUgiJzynRU,7585
+mlx/include/metal_cpp/Metal/MTLSampler.hpp,sha256=0rifEvFw4V8_kMmusAU4NXiZeZbCSX_L4x0K6QyEkog,10838
+mlx/include/metal_cpp/Metal/MTLStageInputOutputDescriptor.hpp,sha256=LfDoa6Dj5WQFS2Qg_FQRCkVgBpbbfjBdFtn1SIzsCyI,13120
+mlx/include/metal_cpp/Metal/MTLTexture.hpp,sha256=jM-mSxqfGBNXE6xwzx1M7CC8GOiyungRuop-6uTuf-M,24807
+mlx/include/metal_cpp/Metal/MTLTypes.hpp,sha256=9_le5gsR93J2awZRAk_Rep_yAWKShAQOgI6faZKD_tg,4389
+mlx/include/metal_cpp/Metal/MTLVersion.hpp,sha256=iaG4OsKd3JlcsoLEvyAx_5TdCRup1ykH0FUYqbu6Lxo,1509
+mlx/include/metal_cpp/Metal/MTLVertexDescriptor.hpp,sha256=4oRbxIiJV2eafs-SqTXTVgPttIC22KtTZ0t4AXnLlgc,12017
+mlx/include/metal_cpp/Metal/MTLVisibleFunctionTable.hpp,sha256=P5Cv_bIIfJ4ktplCeZ3fAhHtLEXngF5cAlQgAr55c-0,3833
+mlx/include/metal_cpp/Metal/Metal.hpp,sha256=Bm5ldz-FxywsGmAdjZ8U2X5hlYjwfzHUjKCoW38T-w8,3190
+mlx/include/metal_cpp/MetalFX/MTLFXDefines.hpp,sha256=Ms80cxZbVVAFYDogYahvmzyVZqkDezrwXKXB_79m3KE,2104
+mlx/include/metal_cpp/MetalFX/MTLFXPrivate.hpp,sha256=LcubGmMx98T8OduyEawEx8swCEo_n5Z3ZfwuxwvAtz0,15147
+mlx/include/metal_cpp/MetalFX/MTLFXSpatialScaler.hpp,sha256=8QCySJ9V5JfuTNAHujkvgKQJ_hdM-yV8cqdw5v8l1Ns,18385
+mlx/include/metal_cpp/MetalFX/MTLFXTemporalScaler.hpp,sha256=57Qfhq3YqYOd0qwLfOBvz_viu55-Pmor0_IF99UWMAg,32887
+mlx/include/metal_cpp/MetalFX/MetalFX.hpp,sha256=Vm0W_ycCRb0UOOvLIPYm5gIEHW1nikG5vTvoKfTgAtE,1350
+mlx/include/metal_cpp/QuartzCore/CADefines.hpp,sha256=q6k-jUxe5uulNnsoqkM61OuyEVSJO4W8gIAVM6mSbwE,1895
+mlx/include/metal_cpp/QuartzCore/CAMetalDrawable.hpp,sha256=RE4_Cp9FacJMh7AlqZw-IhelLMXvUv_YpXVLQ2aNVrU,2363
+mlx/include/metal_cpp/QuartzCore/CAMetalLayer.hpp,sha256=i4WjUgWUsQVRPj8dxk4aBC06TKaXsKxRdgNNIgNe0pk,5502
+mlx/include/metal_cpp/QuartzCore/CAPrivate.hpp,sha256=aFEVW34Ih_Gs1aGv5Rml0pNaFxDwWLP6qBQWw3N6EzA,5010
+mlx/include/metal_cpp/QuartzCore/QuartzCore.hpp,sha256=-fQqOpndpszueKWJ4U_jovMID_s0QxCOJHpQoUj8JBE,1346
+mlx/include/metal_cpp/README.md,sha256=ZVbXv3dwSy-n_EmPpYlB2cJXkUCZXdE0-jJsY9pHsd0,14584
+mlx/include/metal_cpp/SingleHeader/MakeSingleHeader.py,sha256=JqlbeaangDoU2dRPyOfKgU5jkbmUghucuumqPEbZOWc,8984
+mlx/include/metal_cpp/SingleHeader/__pycache__/MakeSingleHeader.cpython-311.pyc,,
+mlx/include/mlx/3rdparty/pocketfft.h,sha256=Dq6iEwS_MkY5_xECLuY_r0io-rZK_lw8LR7---HX36Y,110508
+mlx/include/mlx/allocator.h,sha256=r0AgIuBbvq67OeO8eUD8cb4a72HDF6-PISAnOMfC-kM,1519
+mlx/include/mlx/array.h,sha256=D_dkEyq5zbBSc8kK5KNgQbAikvihW9Xn_1HlwI9uaps,11348
+mlx/include/mlx/backend/accelerate/utils.h,sha256=ryQ9t4EI6UkMBCE48MVcGUSstbRDlwM9YI__vs4dTzY,752
+mlx/include/mlx/backend/common/arange.h,sha256=J44RZZx_DB7DSELCtDFHBThHfLopu_JWj_5ew_q0ROw,1823
+mlx/include/mlx/backend/common/binary.h,sha256=uvS_NdciYF-6VHhKrDNFL1Sd2Ag8hn_kClpYmcu6E9E,15169
+mlx/include/mlx/backend/common/copy.h,sha256=5-b2CRTRoyCJ4WL5RkPAQXaLKaEn8pz-XojHGs4u1Rc,690
+mlx/include/mlx/backend/common/erf.h,sha256=Wm6jXR40EgAmyh0zbGOvRbZh58LVhe3_P1-hwN9GPuo,274
+mlx/include/mlx/backend/common/reduce.h,sha256=iR0xKDMZSEDrf2W0TLLXuqxVesf-nOioGu0MDGalT-0,11138
+mlx/include/mlx/backend/common/threefry.h,sha256=sXTdUFRAgEXf789u7IhWIj7n-Gtzwo4HiQXDA6BwFyU,572
+mlx/include/mlx/backend/common/unary.h,sha256=5vAiPfmNjXxMohP6RqZiOngCXcXa76RtrLDEyTeQobs,3356
+mlx/include/mlx/backend/common/utils.h,sha256=4pS1LCC-Tux3x4Y0A3LeTyTLGDSxbjapNkNFWUNjrc8,610
+mlx/include/mlx/backend/metal/allocator.h,sha256=lluCLBSXYbp6WGtl9zKsikpMHrptRjeZJ0Cf70zFkoc,1491
+mlx/include/mlx/backend/metal/copy.h,sha256=jXW0_jDwX97NmnwigeZwovS_MZ1PeZix2iuZf7f9Xts,400
+mlx/include/mlx/backend/metal/device.h,sha256=1Q0xSLn21dTzD5rWanoBBg1eMqOPf2958Z0rJL9GJag,2196
+mlx/include/mlx/backend/metal/kernels/atomic.h,sha256=0Iph_jNZoTyTrR-iEXXDzIwFoRWOkhqndX6IHJxFhKg,9217
+mlx/include/mlx/backend/metal/kernels/bf16.h,sha256=YdmOaznu1O1UNTyGlnpnEkvi1r44EouYNBAZ4SAX2yA,11904
+mlx/include/mlx/backend/metal/kernels/bf16_math.h,sha256=VRM_iZpBcY3Sg3yxkNPzjU30x32zcmd0diIagA1D5l4,26337
+mlx/include/mlx/backend/metal/kernels/complex.h,sha256=XDYKDiBdeM5KGpfpmwXmelZ00LmFCdxiGOIGoUMEeyI,3526
+mlx/include/mlx/backend/metal/kernels/conv_params.h,sha256=pzJn2uZ8TqY1WXRyGRx-MzBYBOfMSyhiDPgu8LMSElk,592
+mlx/include/mlx/backend/metal/kernels/defines.h,sha256=Bkplnhk_KYkqUzpB9TSlYUuXyucJQZYNyW9AR55g8fM,477
+mlx/include/mlx/backend/metal/kernels/erf.h,sha256=k1CfVsb-rEQaXGYJcAbgVR90VwEY5w_88BhJCSsj97k,2736
+mlx/include/mlx/backend/metal/kernels/gemm/conv.h,sha256=ilmFKKdzy8qwn1Zt0cu43f_mKsMLhIJy6DgIdx5ZU5I,14236
+mlx/include/mlx/backend/metal/kernels/gemm/gemm.h,sha256=x80JGVUliIDkFyzoGGd5iC0veHZVPx_BFkeVdGzgVOk,16184
+mlx/include/mlx/backend/metal/kernels/reduce.h,sha256=RgBsV24CtUU_dXCNzDP8sojJdjRz2bdF3PqB8UNJrlA,3554
+mlx/include/mlx/backend/metal/kernels/utils.h,sha256=mRGC9B2cjzCZT2kxY__EM0QmRQQBL8GSHC0rg7_4cJo,7202
+mlx/include/mlx/backend/metal/matmul.h,sha256=n32FxTg1zL-_oIaPRrs9QcI5TywhMemcm2KJ4zF-n0Q,592
+mlx/include/mlx/backend/metal/metal.h,sha256=9kgNkbx0Pqy-W3o7stP0cjvSAcoU0I20dZEsKmsSAS4,552
+mlx/include/mlx/backend/metal/mps/gemm.h,sha256=501lddlggxogceZI3wkWK98yIZurE0qgVxx0ICHyBxs,11307
+mlx/include/mlx/backend/metal/utils.h,sha256=ape52Rl1et96MA4H_a0cbVveLvhASJlszqX6mxl-nis,4205
+mlx/include/mlx/device.h,sha256=KtG7G03J5T0Ad2zn931OyRGfCa1XKn3ZyEUoIBY0No4,563
+mlx/include/mlx/dtype.h,sha256=jrOMl7xEhOZ7Dn0udDfi-Mq8QbT3atbd7CL0SZ4Yxjk,2575
+mlx/include/mlx/fft.h,sha256=MpW4UMjetc81i8pt3NJnTCvtXuaP92CX3w2iatYZHTw,4179
+mlx/include/mlx/graph_utils.h,sha256=23pv6xyLYTl-l2o9Z3DqlcvGVGZEA-uIV29jamcK-1Q,593
+mlx/include/mlx/io/load.h,sha256=vl7Z0pSJTjgG7KkSLXbe5oLjPhnVkWR9XdvC-ZCf_fk,2508
+mlx/include/mlx/io/safetensor.h,sha256=ro-grE_iXiGbCgygGFSeqsvxD_DDiwKckCsyb424e-g,624
+mlx/include/mlx/linalg.h,sha256=-CJ8NhHmycVsT29ObUmVZbxd2gwCpj8qj2RvOv-Glto,1771
+mlx/include/mlx/mlx.h,sha256=raZfU4bjGTSRAZa8P1XkoxHHeiooTZVI9C63ydGwm8c,296
+mlx/include/mlx/ops.h,sha256=322gdgz9l7pz-M0Pgpo0T6LbAe_w0RMV-A1-jRN_Le0,32224
+mlx/include/mlx/primitives.h,sha256=uJhmcwsXyseQlfeJBDjLCNrhPM91vursiw8_R79yUGg,44227
+mlx/include/mlx/random.h,sha256=aNoyWf-zAg9WKgqfe1yBpOvxedygIUZMQBgsd3kNnzQ,4887
+mlx/include/mlx/scheduler.h,sha256=sZX0BU1J15e_IOzBsv95KwAQmU4wrayd3b6ClvxGA4M,3864
+mlx/include/mlx/stream.h,sha256=7BvNtylObXbyIHZ0gCrbMb1bN3DUq7PfzEa-bIvqEXE,686
+mlx/include/mlx/transforms.h,sha256=Qt8pjvxAPYMoa8Dz2WUcJBdeKEFKNdczV0O3UTE_XmY,6527
+mlx/include/mlx/transforms_impl.h,sha256=RttUce4KHg3PLUFc9aRVjxenCIztlBSTlQq5LnVxKVg,542
+mlx/include/mlx/types/bf16.h,sha256=fLnTB0fbL2vIs_CCvWhrr7SfDnFUEpDPmg7RNmrRnzE,6753
+mlx/include/mlx/types/complex.h,sha256=oaTl_rCth3TO33sT2Db6SX--n9lIfE_dw7rjE06Qqmc,2878
+mlx/include/mlx/types/fp16.h,sha256=j0E7-PKkVkCT-bOMRdBEYdvxUdo9rf6w80dNSNCYNaQ,8322
+mlx/include/mlx/types/half_types.h,sha256=-D-ilDAh5shp1xp4lx0J87y9iFfBs43gLNi-XqzmLWA,1367
+mlx/include/mlx/utils.h,sha256=cchUDEk5qbWNIPHf_cRwbsxnczz2_moUr_Dipz-cfhM,1524
+mlx/lib/libmlx.dylib,sha256=ir7-RqHznJKyhGSBTwWnMPqYmbF3V3A0A8bvNi8GrJM,12420704
+mlx/lib/mlx.metallib,sha256=Lu30EADtJwKD2hHYibsQGqTIjG-PDsaP5rBApb5CRQE,59495531
+mlx/nn/__init__.py,sha256=b-1hqkAnzpthKJNKgRGVHsltNEqOU7URFMoY2Z46Buw,126
+mlx/nn/__pycache__/__init__.cpython-311.pyc,,
+mlx/nn/__pycache__/losses.cpython-311.pyc,,
+mlx/nn/__pycache__/utils.cpython-311.pyc,,
+mlx/nn/layers/__init__.py,sha256=2Ge23mO7W5VOMkogmcY2dqTKRRD3lY0g_WhVDP-9Hi0,1249
+mlx/nn/layers/__pycache__/__init__.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/activations.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/base.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/containers.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/convolution.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/dropout.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/embedding.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/linear.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/normalization.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/positional_encoding.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/quantized.cpython-311.pyc,,
+mlx/nn/layers/__pycache__/transformer.cpython-311.pyc,,
+mlx/nn/layers/activations.py,sha256=ukopw8ZFpSIQijXscov80Gv_0j0jKh0Y4Z3qrUFzpkk,11826
+mlx/nn/layers/base.py,sha256=iFp3PVGUhT9pAaWNnWtNY-yZ-uCQxvH-O1CYbKoGCug,19485
+mlx/nn/layers/containers.py,sha256=Ke8gPBPZvrtrjK1qrbRNGtSV4rvBkYTKVBW2pQXrNvY,618
+mlx/nn/layers/convolution.py,sha256=ZP43OBZTKF3ui_2Xrtx7VvAlLic_jcn2oL-MPLU7Rys,4060
+mlx/nn/layers/dropout.py,sha256=1GR5uWU82eFd296WuPB7CqNcNj3acEIlS3_4ZAxnx-g,4529
+mlx/nn/layers/embedding.py,sha256=5G7TvVyEaHTlQCASNVfBGea_1ywDVNqDkxHP2U-JEcs,878
+mlx/nn/layers/linear.py,sha256=ekgkElIUlfdWZNRDZkoyQFTotzyjNpD_0v7Ac8pnako,4137
+mlx/nn/layers/normalization.py,sha256=m92TwFfNQ4NbQlxtlTfJsWZlBJtO0_tR0M8H2d9wZEs,12021
+mlx/nn/layers/positional_encoding.py,sha256=_4zbYLMGYI0EVq4b6eitmB2hgBXblcrJJYsq0KCSafs,6611
+mlx/nn/layers/quantized.py,sha256=FA_NzLBheO2i5AClMWCkaFrNXJGScxlwvumqaJTIxAA,4136
+mlx/nn/layers/transformer.py,sha256=IUTNGvVoaKLS7Gwes_yK3SqgX6voPgMqk7nmdE4nyI0,12235
+mlx/nn/losses.py,sha256=1yWCxt-QSv4lGV9U6KJyeTzybQWW4LPZhipkLFx7hWk,12158
+mlx/nn/utils.py,sha256=tQJ62bu2eAAhzYqV7QriQtNGrYSz85XGxHolEPkGiGs,999
+mlx/optimizers.py,sha256=krPDwdaMy1JTlaVBgRHlg7PNqyxiVRkfNEbEf_wV-5g,17090
+mlx/share/cmake/MLX/MLXConfig.cmake,sha256=02CzwjTAHLTyLzFMtE7LLzyX_CSHreASjFyiYEpfIp4,1884
+mlx/share/cmake/MLX/MLXConfigVersion.cmake,sha256=p6TWi4EVJlFiJx_BxHZqpPBhkKaze00W3S-JRcRHD78,2762
+mlx/share/cmake/MLX/MLXTargets-release.cmake,sha256=bUjlsca3AGGUHl1X9lfm3CiQiSFeYTkm2c7GLzITeJs,788
+mlx/share/cmake/MLX/MLXTargets.cmake,sha256=vS5sI59URF-Pz8SPKMDVbyTPq1ENZ3zoR_VPzWToXkw,4705
+mlx/share/cmake/MLX/extension.cmake,sha256=q09-X3ckTrFCZOc5UNyoqjUC94OQQSXXWW7Bmg7sxok,1637
+mlx/utils.py,sha256=F-bmWn6a4VFRUvnSeZPvIFwT8Z6IHEtgEAfcLiGBrz8,4667
diff --git a/lib/python3.11/site-packages/mlx-0.0.7.dist-info/REQUESTED b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/mlx-0.0.7.dist-info/WHEEL b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..f522bdef6bc559b2ee834406fc466314216b771d
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_14_0_arm64
+
diff --git a/lib/python3.11/site-packages/mlx-0.0.7.dist-info/top_level.txt b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2bef5b38b10153d7f09657bf3adb775fc84ea055
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx-0.0.7.dist-info/top_level.txt
@@ -0,0 +1 @@
+mlx
diff --git a/lib/python3.11/site-packages/mlx/__pycache__/_reprlib_fix.cpython-311.pyc b/lib/python3.11/site-packages/mlx/__pycache__/_reprlib_fix.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28703806a788a6a2081bf67ea3e54e4cde20f11a
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/__pycache__/_reprlib_fix.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/__pycache__/extension.cpython-311.pyc b/lib/python3.11/site-packages/mlx/__pycache__/extension.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ddfe23c64850eefd1bd949a2a9dd8951e45ecdc
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/__pycache__/extension.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/__pycache__/optimizers.cpython-311.pyc b/lib/python3.11/site-packages/mlx/__pycache__/optimizers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..066f6b7cc5d88d09ee92c9a699f28dfd58e7914b
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/__pycache__/optimizers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/__pycache__/utils.cpython-311.pyc b/lib/python3.11/site-packages/mlx/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..21f23cc05a938fcee95e53a369b12438c2de8479
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/__pycache__/utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/_reprlib_fix.py b/lib/python3.11/site-packages/mlx/_reprlib_fix.py
new file mode 100644
index 0000000000000000000000000000000000000000..02bf661dcee69b68b39023ca677f946fcc7d4105
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/_reprlib_fix.py
@@ -0,0 +1,20 @@
+# Copyright © 2023 Apple Inc.
+
+import array
+import reprlib
+
+
+class FixedRepr(reprlib.Repr):
+    """Only route python array instances to repr_array."""
+
+    def repr_array(self, x, maxlevel):
+        if isinstance(x, array.array):
+            return super().repr_array(x, maxlevel)
+        else:
+            return self.repr_instance(x, maxlevel)
+
+
+# We need to monkey-patch reprlib so that we can use the debugger without
+# renaming the array to something else
+fixed_repr = FixedRepr()
+reprlib.repr = fixed_repr.repr
diff --git a/lib/python3.11/site-packages/mlx/core.cpython-311-darwin.so b/lib/python3.11/site-packages/mlx/core.cpython-311-darwin.so
new file mode 100644
index 0000000000000000000000000000000000000000..4fb6193d7925563f2e9782f36e52a68362ee426b
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/core.cpython-311-darwin.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e063225a72d2dac646b2b23007d980af2b9ee4bced7fe4adb409ff03369d9827
+size 1098840
diff --git a/lib/python3.11/site-packages/mlx/extension.py b/lib/python3.11/site-packages/mlx/extension.py
new file mode 100644
index 0000000000000000000000000000000000000000..842cf667fc44b474f22e31da95e2d4fd13bcf9c7
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/extension.py
@@ -0,0 +1,96 @@
+# Copyright © 2023 Apple Inc.
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import Extension, find_namespace_packages, setup
+from setuptools.command.build_ext import build_ext
+
+import mlx
+
+_MLX_PATH = str(mlx.__path__[0])
+
+
+# A CMakeExtension needs a sourcedir instead of a file list.
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.fspath(Path(sourcedir).resolve())
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
+        ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name)  # type: ignore[no-untyped-call]
+        extdir = ext_fullpath.parent.resolve()
+
+        debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        cfg = "Debug" if debug else "Release"
+
+        # CMake lets you override the generator - we need to check this.
+        # Can be set with Conda-Build, for example.
+        cmake_generator = os.environ.get("CMAKE_GENERATOR", "")
+
+        # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
+        # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code
+        # from Python.
+        cmake_args = [
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",
+            "-DBUILD_SHARED_LIBS=ON",
+        ]
+        build_args = []
+        # Adding CMake arguments set as environment variable
+        # (needed e.g. to build for ARM OSx on conda-forge)
+        if "CMAKE_ARGS" in os.environ:
+            cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
+
+        if sys.platform.startswith("darwin"):
+            # Cross-compile support for macOS - respect ARCHFLAGS if set
+            archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+            if archs:
+                cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+
+        # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
+        # across all generators.
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            # self.parallel is a Python 3 only way to set parallel jobs by hand
+            # using -j in the build_ext call, not supported by pip or PyPA-build.
+            if hasattr(self, "parallel") and self.parallel:
+                # CMake 3.12+ only.
+                build_args += [f"-j{self.parallel}"]
+
+        build_temp = Path(self.build_temp) / ext.name
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True)
+
+        # Make sure cmake can find MLX
+        os.environ["MLX_DIR"] = _MLX_PATH
+
+        subprocess.run(
+            ["cmake", ext.sourcedir, *cmake_args], cwd=build_temp, check=True
+        )
+        subprocess.run(
+            ["cmake", "--build", ".", *build_args], cwd=build_temp, check=True
+        )
+
+    def run(self):
+        super().run()
+
+        # Based on https://github.com/pypa/setuptools/blob/main/setuptools/command/build_ext.py#L102
+        if self.inplace:
+            for ext in self.extensions:
+                if isinstance(ext, CMakeExtension):
+                    # Resolve inplace package dir
+                    build_py = self.get_finalized_command("build_py")
+                    inplace_file, regular_file = self._get_inplace_equivalent(
+                        build_py, ext
+                    )
+
+                    inplace_dir = str(Path(inplace_file).parent.resolve())
+                    regular_dir = str(Path(regular_file).parent.resolve())
+
+                    self.copy_tree(regular_dir, inplace_dir)
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/Foundation.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/Foundation.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8b64277ff5c3d773ace5dd2ad8d648955dd6e3cb
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/Foundation.hpp
@@ -0,0 +1,47 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/Foundation.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSArray.hpp"
+#include "NSAutoreleasePool.hpp"
+#include "NSBundle.hpp"
+#include "NSData.hpp"
+#include "NSDate.hpp"
+#include "NSDefines.hpp"
+#include "NSDictionary.hpp"
+#include "NSEnumerator.hpp"
+#include "NSError.hpp"
+#include "NSLock.hpp"
+#include "NSNotification.hpp"
+#include "NSNumber.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSProcessInfo.hpp"
+#include "NSRange.hpp"
+#include "NSSet.hpp"
+#include "NSSharedPtr.hpp"
+#include "NSString.hpp"
+#include "NSTypes.hpp"
+#include "NSURL.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSArray.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSArray.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ccdb80448b306b58d9ca6651d19ddfd6917799c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSArray.hpp
@@ -0,0 +1,115 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSArray.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSObject.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+class Array : public Copying<Array>
+{
+public:
+    static Array* array();
+    static Array* array(const Object* pObject);
+    static Array* array(const Object* const* pObjects, UInteger count);
+
+    static Array* alloc();
+
+    Array*        init();
+    Array*        init(const Object* const* pObjects, UInteger count);
+    Array*        init(const class Coder* pCoder);
+
+    template <class _Object = Object>
+    _Object* object(UInteger index) const;
+    UInteger count() const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Array::array()
+{
+    return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(array));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Array::array(const Object* pObject)
+{
+    return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(arrayWithObject_), pObject);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Array::array(const Object* const* pObjects, UInteger count)
+{
+    return Object::sendMessage<Array*>(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(arrayWithObjects_count_), pObjects, count);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Array::alloc()
+{
+    return NS::Object::alloc<Array>(_NS_PRIVATE_CLS(NSArray));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Array::init()
+{
+    return NS::Object::init<Array>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Array::init(const Object* const* pObjects, UInteger count)
+{
+    return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(initWithObjects_count_), pObjects, count);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Array::init(const class Coder* pCoder)
+{
+    return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::Array::count() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(count));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Object>
+_NS_INLINE _Object* NS::Array::object(UInteger index) const
+{
+    return Object::sendMessage<_Object*>(this, _NS_PRIVATE_SEL(objectAtIndex_), index);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSAutoreleasePool.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSAutoreleasePool.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3008590d480e60a2a450dadb52504d23254c8b23
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSAutoreleasePool.hpp
@@ -0,0 +1,83 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSAutoreleasePool.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+class AutoreleasePool : public Object
+{
+public:
+    static AutoreleasePool* alloc();
+    AutoreleasePool*        init();
+
+    void                    drain();
+
+    void                    addObject(Object* pObject);
+
+    static void             showPools();
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::AutoreleasePool* NS::AutoreleasePool::alloc()
+{
+    return NS::Object::alloc<AutoreleasePool>(_NS_PRIVATE_CLS(NSAutoreleasePool));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::AutoreleasePool* NS::AutoreleasePool::init()
+{
+    return NS::Object::init<AutoreleasePool>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::AutoreleasePool::drain()
+{
+    Object::sendMessage<void>(this, _NS_PRIVATE_SEL(drain));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::AutoreleasePool::addObject(Object* pObject)
+{
+    Object::sendMessage<void>(this, _NS_PRIVATE_SEL(addObject_), pObject);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::AutoreleasePool::showPools()
+{
+    Object::sendMessage<void>(_NS_PRIVATE_CLS(NSAutoreleasePool), _NS_PRIVATE_SEL(showPools));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSBundle.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSBundle.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..323d93f332ca1d82f5a247e3bf86b18c047bdb23
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSBundle.hpp
@@ -0,0 +1,374 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSBundle.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSNotification.hpp"
+#include "NSObject.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+_NS_CONST(NotificationName, BundleDidLoadNotification);
+_NS_CONST(NotificationName, BundleResourceRequestLowDiskSpaceNotification);
+
+class String* LocalizedString(const String* pKey, const String*);
+class String* LocalizedStringFromTable(const String* pKey, const String* pTbl, const String*);
+class String* LocalizedStringFromTableInBundle(const String* pKey, const String* pTbl, const class Bundle* pBdle, const String*);
+class String* LocalizedStringWithDefaultValue(const String* pKey, const String* pTbl, const class Bundle* pBdle, const String* pVal, const String*);
+
+class Bundle : public Referencing<Bundle>
+{
+public:
+    static Bundle*    mainBundle();
+
+    static Bundle*    bundle(const class String* pPath);
+    static Bundle*    bundle(const class URL* pURL);
+
+    static Bundle*    alloc();
+
+    Bundle*           init(const class String* pPath);
+    Bundle*           init(const class URL* pURL);
+
+    class Array*      allBundles() const;
+    class Array*      allFrameworks() const;
+
+    bool              load();
+    bool              unload();
+
+    bool              isLoaded() const;
+
+    bool              preflightAndReturnError(class Error** pError) const;
+    bool              loadAndReturnError(class Error** pError);
+
+    class URL*        bundleURL() const;
+    class URL*        resourceURL() const;
+    class URL*        executableURL() const;
+    class URL*        URLForAuxiliaryExecutable(const class String* pExecutableName) const;
+
+    class URL*        privateFrameworksURL() const;
+    class URL*        sharedFrameworksURL() const;
+    class URL*        sharedSupportURL() const;
+    class URL*        builtInPlugInsURL() const;
+    class URL*        appStoreReceiptURL() const;
+
+    class String*     bundlePath() const;
+    class String*     resourcePath() const;
+    class String*     executablePath() const;
+    class String*     pathForAuxiliaryExecutable(const class String* pExecutableName) const;
+
+    class String*     privateFrameworksPath() const;
+    class String*     sharedFrameworksPath() const;
+    class String*     sharedSupportPath() const;
+    class String*     builtInPlugInsPath() const;
+
+    class String*     bundleIdentifier() const;
+    class Dictionary* infoDictionary() const;
+    class Dictionary* localizedInfoDictionary() const;
+    class Object*     objectForInfoDictionaryKey(const class String* pKey);
+
+    class String*     localizedString(const class String* pKey, const class String* pValue = nullptr, const class String* pTableName = nullptr) const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_PRIVATE_DEF_CONST(NS::NotificationName, BundleDidLoadNotification);
+_NS_PRIVATE_DEF_CONST(NS::NotificationName, BundleResourceRequestLowDiskSpaceNotification);
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::LocalizedString(const String* pKey, const String*)
+{
+    return Bundle::mainBundle()->localizedString(pKey, nullptr, nullptr);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::LocalizedStringFromTable(const String* pKey, const String* pTbl, const String*)
+{
+    return Bundle::mainBundle()->localizedString(pKey, nullptr, pTbl);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::LocalizedStringFromTableInBundle(const String* pKey, const String* pTbl, const Bundle* pBdl, const String*)
+{
+    return pBdl->localizedString(pKey, nullptr, pTbl);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::LocalizedStringWithDefaultValue(const String* pKey, const String* pTbl, const Bundle* pBdl, const String* pVal, const String*)
+{
+    return pBdl->localizedString(pKey, pVal, pTbl);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Bundle* NS::Bundle::mainBundle()
+{
+    return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(mainBundle));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Bundle* NS::Bundle::bundle(const class String* pPath)
+{
+    return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(bundleWithPath_), pPath);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Bundle* NS::Bundle::bundle(const class URL* pURL)
+{
+    return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(bundleWithURL_), pURL);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Bundle* NS::Bundle::alloc()
+{
+    return Object::sendMessage<Bundle*>(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(alloc));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Bundle* NS::Bundle::init(const String* pPath)
+{
+    return Object::sendMessage<Bundle*>(this, _NS_PRIVATE_SEL(initWithPath_), pPath);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Bundle* NS::Bundle::init(const URL* pURL)
+{
+    return Object::sendMessage<Bundle*>(this, _NS_PRIVATE_SEL(initWithURL_), pURL);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Bundle::allBundles() const
+{
+    return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(allBundles));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Bundle::allFrameworks() const
+{
+    return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(allFrameworks));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Bundle::load()
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(load));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Bundle::unload()
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(unload));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Bundle::isLoaded() const
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isLoaded));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Bundle::preflightAndReturnError(Error** pError) const
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(preflightAndReturnError_), pError);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Bundle::loadAndReturnError(Error** pError)
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(loadAndReturnError_), pError);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::bundleURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(bundleURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::resourceURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(resourceURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::executableURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(executableURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::URLForAuxiliaryExecutable(const String* pExecutableName) const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(URLForAuxiliaryExecutable_), pExecutableName);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::privateFrameworksURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(privateFrameworksURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::sharedFrameworksURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(sharedFrameworksURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::sharedSupportURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(sharedSupportURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::builtInPlugInsURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(builtInPlugInsURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::Bundle::appStoreReceiptURL() const
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(appStoreReceiptURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::bundlePath() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(bundlePath));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::resourcePath() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(resourcePath));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::executablePath() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(executablePath));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::pathForAuxiliaryExecutable(const String* pExecutableName) const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(pathForAuxiliaryExecutable_), pExecutableName);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::privateFrameworksPath() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(privateFrameworksPath));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::sharedFrameworksPath() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(sharedFrameworksPath));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::sharedSupportPath() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(sharedSupportPath));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::builtInPlugInsPath() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(builtInPlugInsPath));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::bundleIdentifier() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(bundleIdentifier));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Bundle::infoDictionary() const
+{
+    return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(infoDictionary));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Bundle::localizedInfoDictionary() const
+{
+    return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(localizedInfoDictionary));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Object* NS::Bundle::objectForInfoDictionaryKey(const String* pKey)
+{
+    return Object::sendMessage<Object*>(this, _NS_PRIVATE_SEL(objectForInfoDictionaryKey_), pKey);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Bundle::localizedString(const String* pKey, const String* pValue /* = nullptr */, const String* pTableName /* = nullptr */) const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedStringForKey_value_table_), pKey, pValue, pTableName);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSData.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSData.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ddfa6dd08f7a9e5fa6ffb736c74ec5f54439e7ec
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSData.hpp
@@ -0,0 +1,54 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSData.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSObject.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+class Data : public Copying<Data>
+{
+public:
+    void*    mutableBytes() const;
+    UInteger length() const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void* NS::Data::mutableBytes() const
+{
+    return Object::sendMessage<void*>(this, _NS_PRIVATE_SEL(mutableBytes));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::Data::length() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(length));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDate.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDate.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..61f10a95b738821710982fb3cab424b59078ef2b
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDate.hpp
@@ -0,0 +1,53 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSDate.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+
+using TimeInterval = double;
+
+class Date : public Copying<Date>
+{
+public:
+    static Date* dateWithTimeIntervalSinceNow(TimeInterval secs);
+};
+
+} // NS
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Date* NS::Date::dateWithTimeIntervalSinceNow(NS::TimeInterval secs)
+{
+    return NS::Object::sendMessage<NS::Date*>(_NS_PRIVATE_CLS(NSDate), _NS_PRIVATE_SEL(dateWithTimeIntervalSinceNow_), secs);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDefines.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDefines.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a042be631cdea60852e399c723e3c3f8209d9420
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDefines.hpp
@@ -0,0 +1,45 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSDefines.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _NS_WEAK_IMPORT __attribute__((weak_import))
+#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN
+#define _NS_EXPORT __attribute__((visibility("hidden")))
+#else
+#define _NS_EXPORT __attribute__((visibility("default")))
+#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN
+#define _NS_EXTERN extern "C" _NS_EXPORT
+#define _NS_INLINE inline __attribute__((always_inline))
+#define _NS_PACKED __attribute__((packed))
+
+#define _NS_CONST(type, name) _NS_EXTERN type const name
+#define _NS_ENUM(type, name) enum name : type
+#define _NS_OPTIONS(type, name) \
+    using name = type;          \
+    enum : name
+
+#define _NS_CAST_TO_UINT(value) static_cast<NS::UInteger>(value)
+#define _NS_VALIDATE_SIZE(ns, name) static_assert(sizeof(ns::name) == sizeof(ns##name), "size mismatch " #ns "::" #name)
+#define _NS_VALIDATE_ENUM(ns, name) static_assert(_NS_CAST_TO_UINT(ns::name) == _NS_CAST_TO_UINT(ns##name), "value mismatch " #ns "::" #name)
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDictionary.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDictionary.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..078cd5c8f4211702e250da54df7c722b43cb36cc
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSDictionary.hpp
@@ -0,0 +1,128 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSDictionary.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSEnumerator.hpp"
+#include "NSObject.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+class Dictionary : public NS::Copying<Dictionary>
+{
+public:
+    static Dictionary* dictionary();
+    static Dictionary* dictionary(const Object* pObject, const Object* pKey);
+    static Dictionary* dictionary(const Object* const* pObjects, const Object* const* pKeys, UInteger count);
+
+    static Dictionary* alloc();
+
+    Dictionary*        init();
+    Dictionary*        init(const Object* const* pObjects, const Object* const* pKeys, UInteger count);
+    Dictionary*        init(const class Coder* pCoder);
+
+    template <class _KeyType = Object>
+    Enumerator<_KeyType>* keyEnumerator() const;
+
+    template <class _Object = Object>
+    _Object* object(const Object* pKey) const;
+    UInteger count() const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary()
+{
+    return Object::sendMessage<Dictionary*>(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionary));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary(const Object* pObject, const Object* pKey)
+{
+    return Object::sendMessage<Dictionary*>(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionaryWithObject_forKey_), pObject, pKey);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary(const Object* const* pObjects, const Object* const* pKeys, UInteger count)
+{
+    return Object::sendMessage<Dictionary*>(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionaryWithObjects_forKeys_count_),
+        pObjects, pKeys, count);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Dictionary::alloc()
+{
+    return NS::Object::alloc<Dictionary>(_NS_PRIVATE_CLS(NSDictionary));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Dictionary::init()
+{
+    return NS::Object::init<Dictionary>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Dictionary::init(const Object* const* pObjects, const Object* const* pKeys, UInteger count)
+{
+    return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(initWithObjects_forKeys_count_), pObjects, pKeys, count);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Dictionary::init(const class Coder* pCoder)
+{
+    return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _KeyType>
+_NS_INLINE NS::Enumerator<_KeyType>* NS::Dictionary::keyEnumerator() const
+{
+    return Object::sendMessage<Enumerator<_KeyType>*>(this, _NS_PRIVATE_SEL(keyEnumerator));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Object>
+_NS_INLINE _Object* NS::Dictionary::object(const Object* pKey) const
+{
+    return Object::sendMessage<_Object*>(this, _NS_PRIVATE_SEL(objectForKey_), pKey);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::Dictionary::count() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(count));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSEnumerator.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSEnumerator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..eed19dbac28b8ceb3e624bd4e49ce332486a346f
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSEnumerator.hpp
@@ -0,0 +1,78 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSEnumerator.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSObject.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+struct FastEnumerationState
+{
+    unsigned long  state;
+    Object**       itemsPtr;
+    unsigned long* mutationsPtr;
+    unsigned long  extra[5];
+} _NS_PACKED;
+
+class FastEnumeration : public Referencing<FastEnumeration>
+{
+public:
+    NS::UInteger countByEnumerating(FastEnumerationState* pState, Object** pBuffer, NS::UInteger len);
+};
+
+template <class _ObjectType>
+class Enumerator : public Referencing<Enumerator<_ObjectType>, FastEnumeration>
+{
+public:
+    _ObjectType* nextObject();
+    class Array* allObjects();
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::FastEnumeration::countByEnumerating(FastEnumerationState* pState, Object** pBuffer, NS::UInteger len)
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(countByEnumeratingWithState_objects_count_), pState, pBuffer, len);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _ObjectType>
+_NS_INLINE _ObjectType* NS::Enumerator<_ObjectType>::nextObject()
+{
+    return Object::sendMessage<_ObjectType*>(this, _NS_PRIVATE_SEL(nextObject));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _ObjectType>
+_NS_INLINE NS::Array* NS::Enumerator<_ObjectType>::allObjects()
+{
+    return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(allObjects));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSError.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSError.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f19ff861f7ca38e19526e1d54a2879fbbd8c8fa8
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSError.hpp
@@ -0,0 +1,173 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSError.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+using ErrorDomain = class String*;
+
+_NS_CONST(ErrorDomain, CocoaErrorDomain);
+_NS_CONST(ErrorDomain, POSIXErrorDomain);
+_NS_CONST(ErrorDomain, OSStatusErrorDomain);
+_NS_CONST(ErrorDomain, MachErrorDomain);
+
+using ErrorUserInfoKey = class String*;
+
+_NS_CONST(ErrorUserInfoKey, UnderlyingErrorKey);
+_NS_CONST(ErrorUserInfoKey, LocalizedDescriptionKey);
+_NS_CONST(ErrorUserInfoKey, LocalizedFailureReasonErrorKey);
+_NS_CONST(ErrorUserInfoKey, LocalizedRecoverySuggestionErrorKey);
+_NS_CONST(ErrorUserInfoKey, LocalizedRecoveryOptionsErrorKey);
+_NS_CONST(ErrorUserInfoKey, RecoveryAttempterErrorKey);
+_NS_CONST(ErrorUserInfoKey, HelpAnchorErrorKey);
+_NS_CONST(ErrorUserInfoKey, DebugDescriptionErrorKey);
+_NS_CONST(ErrorUserInfoKey, LocalizedFailureErrorKey);
+_NS_CONST(ErrorUserInfoKey, StringEncodingErrorKey);
+_NS_CONST(ErrorUserInfoKey, URLErrorKey);
+_NS_CONST(ErrorUserInfoKey, FilePathErrorKey);
+
+class Error : public Copying<Error>
+{
+public:
+    static Error*     error(ErrorDomain domain, Integer code, class Dictionary* pDictionary);
+
+    static Error*     alloc();
+    Error*            init();
+    Error*            init(ErrorDomain domain, Integer code, class Dictionary* pDictionary);
+
+    Integer           code() const;
+    ErrorDomain       domain() const;
+    class Dictionary* userInfo() const;
+
+    class String*     localizedDescription() const;
+    class Array*      localizedRecoveryOptions() const;
+    class String*     localizedRecoverySuggestion() const;
+    class String*     localizedFailureReason() const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, CocoaErrorDomain);
+_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, POSIXErrorDomain);
+_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, OSStatusErrorDomain);
+_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, MachErrorDomain);
+
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, UnderlyingErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedDescriptionKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedFailureReasonErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedRecoverySuggestionErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedRecoveryOptionsErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, RecoveryAttempterErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, HelpAnchorErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, DebugDescriptionErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedFailureErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, StringEncodingErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, URLErrorKey);
+_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, FilePathErrorKey);
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Error* NS::Error::error(ErrorDomain domain, Integer code, class Dictionary* pDictionary)
+{
+    return Object::sendMessage<Error*>(_NS_PRIVATE_CLS(NSError), _NS_PRIVATE_SEL(errorWithDomain_code_userInfo_), domain, code, pDictionary);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Error* NS::Error::alloc()
+{
+    return Object::alloc<Error>(_NS_PRIVATE_CLS(NSError));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Error* NS::Error::init()
+{
+    return Object::init<Error>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Error* NS::Error::init(ErrorDomain domain, Integer code, class Dictionary* pDictionary)
+{
+    return Object::sendMessage<Error*>(this, _NS_PRIVATE_SEL(initWithDomain_code_userInfo_), domain, code, pDictionary);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Integer NS::Error::code() const
+{
+    return Object::sendMessage<Integer>(this, _NS_PRIVATE_SEL(code));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::ErrorDomain NS::Error::domain() const
+{
+    return Object::sendMessage<ErrorDomain>(this, _NS_PRIVATE_SEL(domain));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Error::userInfo() const
+{
+    return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(userInfo));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Error::localizedDescription() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedDescription));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::Error::localizedRecoveryOptions() const
+{
+    return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(localizedRecoveryOptions));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Error::localizedRecoverySuggestion() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedRecoverySuggestion));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Error::localizedFailureReason() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(localizedFailureReason));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSLock.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSLock.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ca371fbae8030d33f36aafd9c1f03b53da622ba9
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSLock.hpp
@@ -0,0 +1,118 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSLock.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSTypes.hpp"
+#include "NSDate.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+
+template <class _Class, class _Base = class Object>
+class Locking : public _Base
+{
+public:
+    void lock();
+    void unlock();
+};
+
+class Condition : public Locking<Condition>
+{
+public:
+    static Condition* alloc();
+
+    Condition*        init();
+
+    void              wait();
+    bool              waitUntilDate(Date* pLimit);
+    void              signal();
+    void              broadcast();
+};
+
+} // NS
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template<class _Class, class _Base /* = NS::Object */>
+_NS_INLINE void NS::Locking<_Class, _Base>::lock()
+{
+    NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(lock));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template<class _Class, class _Base /* = NS::Object */>
+_NS_INLINE void NS::Locking<_Class, _Base>::unlock()
+{
+    NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(unlock));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Condition* NS::Condition::alloc()
+{
+    return NS::Object::alloc<NS::Condition>(_NS_PRIVATE_CLS(NSCondition));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Condition* NS::Condition::init()
+{
+    return NS::Object::init<NS::Condition>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::Condition::wait()
+{
+    NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(wait));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Condition::waitUntilDate(NS::Date* pLimit)
+{
+    return NS::Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(waitUntilDate_), pLimit);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::Condition::signal()
+{
+    NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(signal));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::Condition::broadcast()
+{
+    NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(broadcast));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSNotification.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSNotification.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..49cf2d4a498f362f02685a953b249315e82ad23c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSNotification.hpp
@@ -0,0 +1,110 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSNotification.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSDictionary.hpp"
+#include "NSObject.hpp"
+#include "NSString.hpp"
+#include "NSTypes.hpp"
+#include <functional>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+using NotificationName = class String*;
+
+class Notification : public NS::Referencing<Notification>
+{
+public:
+    NS::String*     name() const;
+    NS::Object*     object() const;
+    NS::Dictionary* userInfo() const;
+};
+
+using ObserverBlock = void(^)(Notification*);
+using ObserverFunction = std::function<void(Notification*)>;
+
+class NotificationCenter : public NS::Referencing<NotificationCenter>
+{
+    public:
+        static class NotificationCenter* defaultCenter();
+        Object* addObserver(NotificationName name, Object* pObj, void* pQueue, ObserverBlock block);
+        Object* addObserver(NotificationName name, Object* pObj, void* pQueue, ObserverFunction &handler);
+        void removeObserver(Object* pObserver);
+
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Notification::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _NS_PRIVATE_SEL(name));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Object* NS::Notification::object() const
+{
+    return Object::sendMessage<NS::Object*>(this, _NS_PRIVATE_SEL(object));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::Notification::userInfo() const
+{
+    return Object::sendMessage<NS::Dictionary*>(this, _NS_PRIVATE_SEL(userInfo));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::NotificationCenter* NS::NotificationCenter::defaultCenter()
+{
+    return NS::Object::sendMessage<NS::NotificationCenter*>(_NS_PRIVATE_CLS(NSNotificationCenter), _NS_PRIVATE_SEL(defaultCenter));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Object* NS::NotificationCenter::addObserver(NS::NotificationName name, Object* pObj, void* pQueue, NS::ObserverBlock block)
+{
+    return NS::Object::sendMessage<Object*>(this, _NS_PRIVATE_SEL(addObserverName_object_queue_block_), name, pObj, pQueue, block);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Object* NS::NotificationCenter::addObserver(NS::NotificationName name, Object* pObj, void* pQueue, NS::ObserverFunction &handler)
+{
+    __block ObserverFunction blockFunction = handler;
+
+    return addObserver(name, pObj, pQueue, ^(NS::Notification* pNotif) {blockFunction(pNotif);});
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::NotificationCenter::removeObserver(Object* pObserver)
+{
+    return NS::Object::sendMessage<void>(this, _NS_PRIVATE_SEL(removeObserver_), pObserver);
+}
+
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSNumber.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSNumber.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..13c7802487a8d5ab94660f1e24871d5ff25b1e9c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSNumber.hpp
@@ -0,0 +1,501 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSNumber.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSObjCRuntime.hpp"
+#include "NSObject.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+class Value : public Copying<Value>
+{
+public:
+    static Value* value(const void* pValue, const char* pType);
+    static Value* value(const void* pPointer);
+
+    static Value* alloc();
+
+    Value*        init(const void* pValue, const char* pType);
+    Value*        init(const class Coder* pCoder);
+
+    void          getValue(void* pValue, UInteger size) const;
+    const char*   objCType() const;
+
+    bool          isEqualToValue(Value* pValue) const;
+    void*         pointerValue() const;
+};
+
+class Number : public Copying<Number, Value>
+{
+public:
+    static Number*     number(char value);
+    static Number*     number(unsigned char value);
+    static Number*     number(short value);
+    static Number*     number(unsigned short value);
+    static Number*     number(int value);
+    static Number*     number(unsigned int value);
+    static Number*     number(long value);
+    static Number*     number(unsigned long value);
+    static Number*     number(long long value);
+    static Number*     number(unsigned long long value);
+    static Number*     number(float value);
+    static Number*     number(double value);
+    static Number*     number(bool value);
+
+    static Number*     alloc();
+
+    Number*            init(const class Coder* pCoder);
+    Number*            init(char value);
+    Number*            init(unsigned char value);
+    Number*            init(short value);
+    Number*            init(unsigned short value);
+    Number*            init(int value);
+    Number*            init(unsigned int value);
+    Number*            init(long value);
+    Number*            init(unsigned long value);
+    Number*            init(long long value);
+    Number*            init(unsigned long long value);
+    Number*            init(float value);
+    Number*            init(double value);
+    Number*            init(bool value);
+
+    char               charValue() const;
+    unsigned char      unsignedCharValue() const;
+    short              shortValue() const;
+    unsigned short     unsignedShortValue() const;
+    int                intValue() const;
+    unsigned int       unsignedIntValue() const;
+    long               longValue() const;
+    unsigned long      unsignedLongValue() const;
+    long long          longLongValue() const;
+    unsigned long long unsignedLongLongValue() const;
+    float              floatValue() const;
+    double             doubleValue() const;
+    bool               boolValue() const;
+    Integer            integerValue() const;
+    UInteger           unsignedIntegerValue() const;
+    class String*      stringValue() const;
+
+    ComparisonResult   compare(const Number* pOtherNumber) const;
+    bool               isEqualToNumber(const Number* pNumber) const;
+
+    class String*      descriptionWithLocale(const Object* pLocale) const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Value* NS::Value::value(const void* pValue, const char* pType)
+{
+    return Object::sendMessage<Value*>(_NS_PRIVATE_CLS(NSValue), _NS_PRIVATE_SEL(valueWithBytes_objCType_), pValue, pType);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Value* NS::Value::value(const void* pPointer)
+{
+    return Object::sendMessage<Value*>(_NS_PRIVATE_CLS(NSValue), _NS_PRIVATE_SEL(valueWithPointer_), pPointer);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Value* NS::Value::alloc()
+{
+    return NS::Object::alloc<Value>(_NS_PRIVATE_CLS(NSValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Value* NS::Value::init(const void* pValue, const char* pType)
+{
+    return Object::sendMessage<Value*>(this, _NS_PRIVATE_SEL(initWithBytes_objCType_), pValue, pType);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Value* NS::Value::init(const class Coder* pCoder)
+{
+    return Object::sendMessage<Value*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::Value::getValue(void* pValue, UInteger size) const
+{
+    Object::sendMessage<void>(this, _NS_PRIVATE_SEL(getValue_size_), pValue, size);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE const char* NS::Value::objCType() const
+{
+    return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(objCType));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Value::isEqualToValue(Value* pValue) const
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqualToValue_), pValue);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void* NS::Value::pointerValue() const
+{
+    return Object::sendMessage<void*>(this, _NS_PRIVATE_SEL(pointerValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(char value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithChar_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(unsigned char value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedChar_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(short value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithShort_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(unsigned short value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedShort_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(int value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithInt_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(unsigned int value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedInt_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(long value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(unsigned long value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(long long value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithLongLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(unsigned long long value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedLongLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(float value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithFloat_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(double value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithDouble_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::number(bool value)
+{
+    return Object::sendMessage<Number*>(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithBool_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::alloc()
+{
+    return NS::Object::alloc<Number>(_NS_PRIVATE_CLS(NSNumber));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(const Coder* pCoder)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(char value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithChar_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(unsigned char value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedChar_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(short value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithShort_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(unsigned short value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedShort_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(int value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithInt_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(unsigned int value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedInt_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(long value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(unsigned long value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(long long value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithLongLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(unsigned long long value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithUnsignedLongLong_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(float value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithFloat_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(double value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithDouble_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Number* NS::Number::init(bool value)
+{
+    return Object::sendMessage<Number*>(this, _NS_PRIVATE_SEL(initWithBool_), value);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE char NS::Number::charValue() const
+{
+    return Object::sendMessage<char>(this, _NS_PRIVATE_SEL(charValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE unsigned char NS::Number::unsignedCharValue() const
+{
+    return Object::sendMessage<unsigned char>(this, _NS_PRIVATE_SEL(unsignedCharValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE short NS::Number::shortValue() const
+{
+    return Object::sendMessage<short>(this, _NS_PRIVATE_SEL(shortValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE unsigned short NS::Number::unsignedShortValue() const
+{
+    return Object::sendMessage<unsigned short>(this, _NS_PRIVATE_SEL(unsignedShortValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE int NS::Number::intValue() const
+{
+    return Object::sendMessage<int>(this, _NS_PRIVATE_SEL(intValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE unsigned int NS::Number::unsignedIntValue() const
+{
+    return Object::sendMessage<unsigned int>(this, _NS_PRIVATE_SEL(unsignedIntValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE long NS::Number::longValue() const
+{
+    return Object::sendMessage<long>(this, _NS_PRIVATE_SEL(longValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE unsigned long NS::Number::unsignedLongValue() const
+{
+    return Object::sendMessage<unsigned long>(this, _NS_PRIVATE_SEL(unsignedLongValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE long long NS::Number::longLongValue() const
+{
+    return Object::sendMessage<long long>(this, _NS_PRIVATE_SEL(longLongValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE unsigned long long NS::Number::unsignedLongLongValue() const
+{
+    return Object::sendMessage<unsigned long long>(this, _NS_PRIVATE_SEL(unsignedLongLongValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE float NS::Number::floatValue() const
+{
+    return Object::sendMessage<float>(this, _NS_PRIVATE_SEL(floatValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE double NS::Number::doubleValue() const
+{
+    return Object::sendMessage<double>(this, _NS_PRIVATE_SEL(doubleValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Number::boolValue() const
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(boolValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Integer NS::Number::integerValue() const
+{
+    return Object::sendMessage<Integer>(this, _NS_PRIVATE_SEL(integerValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::Number::unsignedIntegerValue() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(unsignedIntegerValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Number::stringValue() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(stringValue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::ComparisonResult NS::Number::compare(const Number* pOtherNumber) const
+{
+    return Object::sendMessage<ComparisonResult>(this, _NS_PRIVATE_SEL(compare_), pOtherNumber);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Number::isEqualToNumber(const Number* pNumber) const
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqualToNumber_), pNumber);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Number::descriptionWithLocale(const Object* pLocale) const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(descriptionWithLocale_), pLocale);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSObjCRuntime.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSObjCRuntime.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a3860e94a466a26fe6de09e751076dcfbae149e4
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSObjCRuntime.hpp
@@ -0,0 +1,43 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSObjCRuntime.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+
+_NS_ENUM(Integer, ComparisonResult) {
+    OrderedAscending = -1L,
+    OrderedSame,
+    OrderedDescending
+};
+
+const Integer NotFound = IntegerMax;
+
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSObject.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSObject.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..957071bcaf5ed7b50c4911612c48e72e65304435
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSObject.hpp
@@ -0,0 +1,302 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSObject.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSPrivate.hpp"
+#include "NSTypes.hpp"
+
+#include <objc/message.h>
+#include <objc/runtime.h>
+
+#include <type_traits>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+template <class _Class, class _Base = class Object>
+class _NS_EXPORT Referencing : public _Base
+{
+public:
+    _Class*  retain();
+    void     release();
+
+    _Class*  autorelease();
+
+    UInteger retainCount() const;
+};
+
+template <class _Class, class _Base = class Object>
+class Copying : public Referencing<_Class, _Base>
+{
+public:
+    _Class* copy() const;
+};
+
+template <class _Class, class _Base = class Object>
+class SecureCoding : public Referencing<_Class, _Base>
+{
+};
+
+class Object : public Referencing<Object, objc_object>
+{
+public:
+    UInteger      hash() const;
+    bool          isEqual(const Object* pObject) const;
+
+    class String* description() const;
+    class String* debugDescription() const;
+
+protected:
+    friend class Referencing<Object, objc_object>;
+
+    template <class _Class>
+    static _Class* alloc(const char* pClassName);
+    template <class _Class>
+    static _Class* alloc(const void* pClass);
+    template <class _Class>
+    _Class* init();
+
+    template <class _Dst>
+    static _Dst                   bridgingCast(const void* pObj);
+    static class MethodSignature* methodSignatureForSelector(const void* pObj, SEL selector);
+    static bool                   respondsToSelector(const void* pObj, SEL selector);
+    template <typename _Type>
+    static constexpr bool doesRequireMsgSendStret();
+    template <typename _Ret, typename... _Args>
+    static _Ret sendMessage(const void* pObj, SEL selector, _Args... args);
+    template <typename _Ret, typename... _Args>
+    static _Ret sendMessageSafe(const void* pObj, SEL selector, _Args... args);
+
+private:
+    Object() = delete;
+    Object(const Object&) = delete;
+    ~Object() = delete;
+
+    Object& operator=(const Object&) = delete;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class, class _Base /* = Object */>
+_NS_INLINE _Class* NS::Referencing<_Class, _Base>::retain()
+{
+    return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(retain));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class, class _Base /* = Object */>
+_NS_INLINE void NS::Referencing<_Class, _Base>::release()
+{
+    Object::sendMessage<void>(this, _NS_PRIVATE_SEL(release));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class, class _Base /* = Object */>
+_NS_INLINE _Class* NS::Referencing<_Class, _Base>::autorelease()
+{
+    return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(autorelease));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class, class _Base /* = Object */>
+_NS_INLINE NS::UInteger NS::Referencing<_Class, _Base>::retainCount() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(retainCount));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class, class _Base /* = Object */>
+_NS_INLINE _Class* NS::Copying<_Class, _Base>::copy() const
+{
+    return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(copy));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Dst>
+_NS_INLINE _Dst NS::Object::bridgingCast(const void* pObj)
+{
+#ifdef __OBJC__
+    return (__bridge _Dst)pObj;
+#else
+    return (_Dst)pObj;
+#endif // __OBJC__
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <typename _Type>
+_NS_INLINE constexpr bool NS::Object::doesRequireMsgSendStret()
+{
+#if (defined(__i386__) || defined(__x86_64__))
+    constexpr size_t kStructLimit = (sizeof(std::uintptr_t) << 1);
+
+    return sizeof(_Type) > kStructLimit;
+#elif defined(__arm64__)
+    return false;
+#elif defined(__arm__)
+    constexpr size_t kStructLimit = sizeof(std::uintptr_t);
+
+    return std::is_class(_Type) && (sizeof(_Type) > kStructLimit);
+#else
+#error "Unsupported architecture!"
+#endif
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <>
+_NS_INLINE constexpr bool NS::Object::doesRequireMsgSendStret<void>()
+{
+    return false;
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <typename _Ret, typename... _Args>
+_NS_INLINE _Ret NS::Object::sendMessage(const void* pObj, SEL selector, _Args... args)
+{
+#if (defined(__i386__) || defined(__x86_64__))
+    if constexpr (std::is_floating_point<_Ret>())
+    {
+        using SendMessageProcFpret = _Ret (*)(const void*, SEL, _Args...);
+
+        const SendMessageProcFpret pProc = reinterpret_cast<SendMessageProcFpret>(&objc_msgSend_fpret);
+
+        return (*pProc)(pObj, selector, args...);
+    }
+    else
+#endif // ( defined( __i386__ )  || defined( __x86_64__ )  )
+#if !defined(__arm64__)
+        if constexpr (doesRequireMsgSendStret<_Ret>())
+    {
+        using SendMessageProcStret = void (*)(_Ret*, const void*, SEL, _Args...);
+
+        const SendMessageProcStret pProc = reinterpret_cast<SendMessageProcStret>(&objc_msgSend_stret);
+        _Ret                       ret;
+
+        (*pProc)(&ret, pObj, selector, args...);
+
+        return ret;
+    }
+    else
+#endif // !defined( __arm64__ )
+    {
+        using SendMessageProc = _Ret (*)(const void*, SEL, _Args...);
+
+        const SendMessageProc pProc = reinterpret_cast<SendMessageProc>(&objc_msgSend);
+
+        return (*pProc)(pObj, selector, args...);
+    }
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::MethodSignature* NS::Object::methodSignatureForSelector(const void* pObj, SEL selector)
+{
+    return sendMessage<MethodSignature*>(pObj, _NS_PRIVATE_SEL(methodSignatureForSelector_), selector);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Object::respondsToSelector(const void* pObj, SEL selector)
+{
+    return sendMessage<bool>(pObj, _NS_PRIVATE_SEL(respondsToSelector_), selector);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <typename _Ret, typename... _Args>
+_NS_INLINE _Ret NS::Object::sendMessageSafe(const void* pObj, SEL selector, _Args... args)
+{
+    if ((respondsToSelector(pObj, selector)) || (nullptr != methodSignatureForSelector(pObj, selector)))
+    {
+        return sendMessage<_Ret>(pObj, selector, args...);
+    }
+
+    if constexpr (!std::is_void<_Ret>::value)
+    {
+        return 0;
+    }
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class>
+_NS_INLINE _Class* NS::Object::alloc(const char* pClassName)
+{
+    return sendMessage<_Class*>(objc_lookUpClass(pClassName), _NS_PRIVATE_SEL(alloc));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class>
+_NS_INLINE _Class* NS::Object::alloc(const void* pClass)
+{
+    return sendMessage<_Class*>(pClass, _NS_PRIVATE_SEL(alloc));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+template <class _Class>
+_NS_INLINE _Class* NS::Object::init()
+{
+    return sendMessage<_Class*>(this, _NS_PRIVATE_SEL(init));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::Object::hash() const
+{
+    return sendMessage<UInteger>(this, _NS_PRIVATE_SEL(hash));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Object::isEqual(const Object* pObject) const
+{
+    return sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqual_), pObject);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Object::description() const
+{
+    return sendMessage<String*>(this, _NS_PRIVATE_SEL(description));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::Object::debugDescription() const
+{
+    return sendMessageSafe<String*>(this, _NS_PRIVATE_SEL(debugDescription));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSPrivate.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSPrivate.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..af5ffb148fa6e6c932d86dfe70a894006ffb4eb0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSPrivate.hpp
@@ -0,0 +1,507 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSPrivate.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include <objc/runtime.h>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _NS_PRIVATE_CLS(symbol) (Private::Class::s_k##symbol)
+#define _NS_PRIVATE_SEL(accessor) (Private::Selector::s_k##accessor)
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#if defined(NS_PRIVATE_IMPLEMENTATION)
+
+#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN
+#define _NS_PRIVATE_VISIBILITY __attribute__((visibility("hidden")))
+#else
+#define _NS_PRIVATE_VISIBILITY __attribute__((visibility("default")))
+#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN
+
+#define _NS_PRIVATE_IMPORT __attribute__((weak_import))
+
+#ifdef __OBJC__
+#define _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol) ((__bridge void*)objc_lookUpClass(#symbol))
+#define _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol) ((__bridge void*)objc_getProtocol(#symbol))
+#else
+#define _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol) objc_lookUpClass(#symbol)
+#define _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol) objc_getProtocol(#symbol)
+#endif // __OBJC__
+
+#define _NS_PRIVATE_DEF_CLS(symbol) void* s_k##symbol _NS_PRIVATE_VISIBILITY = _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol)
+#define _NS_PRIVATE_DEF_PRO(symbol) void* s_k##symbol _NS_PRIVATE_VISIBILITY = _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol)
+#define _NS_PRIVATE_DEF_SEL(accessor, symbol) SEL s_k##accessor _NS_PRIVATE_VISIBILITY = sel_registerName(symbol)
+#define _NS_PRIVATE_DEF_CONST(type, symbol)              \
+    _NS_EXTERN type const NS##symbol _NS_PRIVATE_IMPORT; \
+    type const                       NS::symbol = (nullptr != &NS##symbol) ? NS##symbol : nullptr
+
+#else
+
+#define _NS_PRIVATE_DEF_CLS(symbol) extern void* s_k##symbol
+#define _NS_PRIVATE_DEF_PRO(symbol) extern void* s_k##symbol
+#define _NS_PRIVATE_DEF_SEL(accessor, symbol) extern SEL s_k##accessor
+#define _NS_PRIVATE_DEF_CONST(type, symbol) extern type const NS::symbol
+
+#endif // NS_PRIVATE_IMPLEMENTATION
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+namespace Private
+{
+    namespace Class
+    {
+
+        _NS_PRIVATE_DEF_CLS(NSArray);
+        _NS_PRIVATE_DEF_CLS(NSAutoreleasePool);
+        _NS_PRIVATE_DEF_CLS(NSBundle);
+        _NS_PRIVATE_DEF_CLS(NSCondition);
+        _NS_PRIVATE_DEF_CLS(NSDate);
+        _NS_PRIVATE_DEF_CLS(NSDictionary);
+        _NS_PRIVATE_DEF_CLS(NSError);
+        _NS_PRIVATE_DEF_CLS(NSNotificationCenter);
+        _NS_PRIVATE_DEF_CLS(NSNumber);
+        _NS_PRIVATE_DEF_CLS(NSObject);
+        _NS_PRIVATE_DEF_CLS(NSProcessInfo);
+        _NS_PRIVATE_DEF_CLS(NSSet);
+        _NS_PRIVATE_DEF_CLS(NSString);
+        _NS_PRIVATE_DEF_CLS(NSURL);
+        _NS_PRIVATE_DEF_CLS(NSValue);
+
+    } // Class
+} // Private
+} // MTL
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+namespace Private
+{
+    namespace Protocol
+    {
+
+    } // Protocol
+} // Private
+} // NS
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+namespace Private
+{
+    namespace Selector
+    {
+
+        _NS_PRIVATE_DEF_SEL(addObject_,
+            "addObject:");
+        _NS_PRIVATE_DEF_SEL(addObserverName_object_queue_block_,
+            "addObserverForName:object:queue:usingBlock:");
+        _NS_PRIVATE_DEF_SEL(activeProcessorCount,
+            "activeProcessorCount");
+        _NS_PRIVATE_DEF_SEL(allBundles,
+            "allBundles");
+        _NS_PRIVATE_DEF_SEL(allFrameworks,
+            "allFrameworks");
+        _NS_PRIVATE_DEF_SEL(allObjects,
+            "allObjects");
+        _NS_PRIVATE_DEF_SEL(alloc,
+            "alloc");
+        _NS_PRIVATE_DEF_SEL(appStoreReceiptURL,
+            "appStoreReceiptURL");
+        _NS_PRIVATE_DEF_SEL(arguments,
+            "arguments");
+        _NS_PRIVATE_DEF_SEL(array,
+            "array");
+        _NS_PRIVATE_DEF_SEL(arrayWithObject_,
+            "arrayWithObject:");
+        _NS_PRIVATE_DEF_SEL(arrayWithObjects_count_,
+            "arrayWithObjects:count:");
+        _NS_PRIVATE_DEF_SEL(automaticTerminationSupportEnabled,
+            "automaticTerminationSupportEnabled");
+        _NS_PRIVATE_DEF_SEL(autorelease,
+            "autorelease");
+        _NS_PRIVATE_DEF_SEL(beginActivityWithOptions_reason_,
+            "beginActivityWithOptions:reason:");
+        _NS_PRIVATE_DEF_SEL(boolValue,
+            "boolValue");
+        _NS_PRIVATE_DEF_SEL(broadcast,
+            "broadcast");
+        _NS_PRIVATE_DEF_SEL(builtInPlugInsPath,
+            "builtInPlugInsPath");
+        _NS_PRIVATE_DEF_SEL(builtInPlugInsURL,
+            "builtInPlugInsURL");
+        _NS_PRIVATE_DEF_SEL(bundleIdentifier,
+            "bundleIdentifier");
+        _NS_PRIVATE_DEF_SEL(bundlePath,
+            "bundlePath");
+        _NS_PRIVATE_DEF_SEL(bundleURL,
+            "bundleURL");
+        _NS_PRIVATE_DEF_SEL(bundleWithPath_,
+            "bundleWithPath:");
+        _NS_PRIVATE_DEF_SEL(bundleWithURL_,
+            "bundleWithURL:");
+        _NS_PRIVATE_DEF_SEL(caseInsensitiveCompare_,
+            "caseInsensitiveCompare:");
+        _NS_PRIVATE_DEF_SEL(characterAtIndex_,
+            "characterAtIndex:");
+        _NS_PRIVATE_DEF_SEL(charValue,
+            "charValue");
+        _NS_PRIVATE_DEF_SEL(countByEnumeratingWithState_objects_count_,
+            "countByEnumeratingWithState:objects:count:");
+        _NS_PRIVATE_DEF_SEL(cStringUsingEncoding_,
+            "cStringUsingEncoding:");
+        _NS_PRIVATE_DEF_SEL(code,
+            "code");
+        _NS_PRIVATE_DEF_SEL(compare_,
+            "compare:");
+        _NS_PRIVATE_DEF_SEL(copy,
+            "copy");
+        _NS_PRIVATE_DEF_SEL(count,
+            "count");
+        _NS_PRIVATE_DEF_SEL(dateWithTimeIntervalSinceNow_,
+            "dateWithTimeIntervalSinceNow:");
+        _NS_PRIVATE_DEF_SEL(defaultCenter,
+            "defaultCenter");
+        _NS_PRIVATE_DEF_SEL(descriptionWithLocale_,
+            "descriptionWithLocale:");
+        _NS_PRIVATE_DEF_SEL(disableAutomaticTermination_,
+            "disableAutomaticTermination:");
+        _NS_PRIVATE_DEF_SEL(disableSuddenTermination,
+            "disableSuddenTermination");
+        _NS_PRIVATE_DEF_SEL(debugDescription,
+            "debugDescription");
+        _NS_PRIVATE_DEF_SEL(description,
+            "description");
+        _NS_PRIVATE_DEF_SEL(dictionary,
+            "dictionary");
+        _NS_PRIVATE_DEF_SEL(dictionaryWithObject_forKey_,
+            "dictionaryWithObject:forKey:");
+        _NS_PRIVATE_DEF_SEL(dictionaryWithObjects_forKeys_count_,
+            "dictionaryWithObjects:forKeys:count:");
+        _NS_PRIVATE_DEF_SEL(domain,
+            "domain");
+        _NS_PRIVATE_DEF_SEL(doubleValue,
+            "doubleValue");
+        _NS_PRIVATE_DEF_SEL(drain,
+            "drain");
+        _NS_PRIVATE_DEF_SEL(enableAutomaticTermination_,
+            "enableAutomaticTermination:");
+        _NS_PRIVATE_DEF_SEL(enableSuddenTermination,
+            "enableSuddenTermination");
+        _NS_PRIVATE_DEF_SEL(endActivity_,
+            "endActivity:");
+        _NS_PRIVATE_DEF_SEL(environment,
+            "environment");
+        _NS_PRIVATE_DEF_SEL(errorWithDomain_code_userInfo_,
+            "errorWithDomain:code:userInfo:");
+        _NS_PRIVATE_DEF_SEL(executablePath,
+            "executablePath");
+        _NS_PRIVATE_DEF_SEL(executableURL,
+            "executableURL");
+        _NS_PRIVATE_DEF_SEL(fileSystemRepresentation,
+            "fileSystemRepresentation");
+        _NS_PRIVATE_DEF_SEL(fileURLWithPath_,
+            "fileURLWithPath:");
+        _NS_PRIVATE_DEF_SEL(floatValue,
+            "floatValue");
+        _NS_PRIVATE_DEF_SEL(fullUserName,
+            "fullUserName");
+        _NS_PRIVATE_DEF_SEL(getValue_size_,
+            "getValue:size:");
+        _NS_PRIVATE_DEF_SEL(globallyUniqueString,
+            "globallyUniqueString");
+        _NS_PRIVATE_DEF_SEL(hash,
+            "hash");
+        _NS_PRIVATE_DEF_SEL(hostName,
+            "hostName");
+        _NS_PRIVATE_DEF_SEL(infoDictionary,
+            "infoDictionary");
+        _NS_PRIVATE_DEF_SEL(init,
+            "init");
+        _NS_PRIVATE_DEF_SEL(initFileURLWithPath_,
+            "initFileURLWithPath:");
+        _NS_PRIVATE_DEF_SEL(initWithBool_,
+            "initWithBool:");
+        _NS_PRIVATE_DEF_SEL(initWithBytes_objCType_,
+            "initWithBytes:objCType:");
+        _NS_PRIVATE_DEF_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_,
+            "initWithBytesNoCopy:length:encoding:freeWhenDone:");
+        _NS_PRIVATE_DEF_SEL(initWithChar_,
+            "initWithChar:");
+        _NS_PRIVATE_DEF_SEL(initWithCoder_,
+            "initWithCoder:");
+        _NS_PRIVATE_DEF_SEL(initWithCString_encoding_,
+            "initWithCString:encoding:");
+        _NS_PRIVATE_DEF_SEL(initWithDomain_code_userInfo_,
+            "initWithDomain:code:userInfo:");
+        _NS_PRIVATE_DEF_SEL(initWithDouble_,
+            "initWithDouble:");
+        _NS_PRIVATE_DEF_SEL(initWithFloat_,
+            "initWithFloat:");
+        _NS_PRIVATE_DEF_SEL(initWithInt_,
+            "initWithInt:");
+        _NS_PRIVATE_DEF_SEL(initWithLong_,
+            "initWithLong:");
+        _NS_PRIVATE_DEF_SEL(initWithLongLong_,
+            "initWithLongLong:");
+        _NS_PRIVATE_DEF_SEL(initWithObjects_count_,
+            "initWithObjects:count:");
+        _NS_PRIVATE_DEF_SEL(initWithObjects_forKeys_count_,
+            "initWithObjects:forKeys:count:");
+        _NS_PRIVATE_DEF_SEL(initWithPath_,
+            "initWithPath:");
+        _NS_PRIVATE_DEF_SEL(initWithShort_,
+            "initWithShort:");
+        _NS_PRIVATE_DEF_SEL(initWithString_,
+            "initWithString:");
+        _NS_PRIVATE_DEF_SEL(initWithUnsignedChar_,
+            "initWithUnsignedChar:");
+        _NS_PRIVATE_DEF_SEL(initWithUnsignedInt_,
+            "initWithUnsignedInt:");
+        _NS_PRIVATE_DEF_SEL(initWithUnsignedLong_,
+            "initWithUnsignedLong:");
+        _NS_PRIVATE_DEF_SEL(initWithUnsignedLongLong_,
+            "initWithUnsignedLongLong:");
+        _NS_PRIVATE_DEF_SEL(initWithUnsignedShort_,
+            "initWithUnsignedShort:");
+        _NS_PRIVATE_DEF_SEL(initWithURL_,
+            "initWithURL:");
+        _NS_PRIVATE_DEF_SEL(integerValue,
+            "integerValue");
+        _NS_PRIVATE_DEF_SEL(intValue,
+            "intValue");
+        _NS_PRIVATE_DEF_SEL(isEqual_,
+            "isEqual:");
+        _NS_PRIVATE_DEF_SEL(isEqualToNumber_,
+            "isEqualToNumber:");
+        _NS_PRIVATE_DEF_SEL(isEqualToString_,
+            "isEqualToString:");
+        _NS_PRIVATE_DEF_SEL(isEqualToValue_,
+            "isEqualToValue:");
+        _NS_PRIVATE_DEF_SEL(isiOSAppOnMac,
+            "isiOSAppOnMac");
+        _NS_PRIVATE_DEF_SEL(isLoaded,
+            "isLoaded");
+        _NS_PRIVATE_DEF_SEL(isLowPowerModeEnabled,
+            "isLowPowerModeEnabled");
+        _NS_PRIVATE_DEF_SEL(isMacCatalystApp,
+            "isMacCatalystApp");
+        _NS_PRIVATE_DEF_SEL(isOperatingSystemAtLeastVersion_,
+            "isOperatingSystemAtLeastVersion:");
+        _NS_PRIVATE_DEF_SEL(keyEnumerator,
+            "keyEnumerator");
+        _NS_PRIVATE_DEF_SEL(length,
+            "length");
+        _NS_PRIVATE_DEF_SEL(lengthOfBytesUsingEncoding_,
+            "lengthOfBytesUsingEncoding:");
+        _NS_PRIVATE_DEF_SEL(load,
+            "load");
+        _NS_PRIVATE_DEF_SEL(loadAndReturnError_,
+            "loadAndReturnError:");
+        _NS_PRIVATE_DEF_SEL(localizedDescription,
+            "localizedDescription");
+        _NS_PRIVATE_DEF_SEL(localizedFailureReason,
+            "localizedFailureReason");
+        _NS_PRIVATE_DEF_SEL(localizedInfoDictionary,
+            "localizedInfoDictionary");
+        _NS_PRIVATE_DEF_SEL(localizedRecoveryOptions,
+            "localizedRecoveryOptions");
+        _NS_PRIVATE_DEF_SEL(localizedRecoverySuggestion,
+            "localizedRecoverySuggestion");
+        _NS_PRIVATE_DEF_SEL(localizedStringForKey_value_table_,
+            "localizedStringForKey:value:table:");
+        _NS_PRIVATE_DEF_SEL(lock,
+            "lock");
+        _NS_PRIVATE_DEF_SEL(longValue,
+            "longValue");
+        _NS_PRIVATE_DEF_SEL(longLongValue,
+            "longLongValue");
+        _NS_PRIVATE_DEF_SEL(mainBundle,
+            "mainBundle");
+        _NS_PRIVATE_DEF_SEL(maximumLengthOfBytesUsingEncoding_,
+            "maximumLengthOfBytesUsingEncoding:");
+        _NS_PRIVATE_DEF_SEL(methodSignatureForSelector_,
+            "methodSignatureForSelector:");
+        _NS_PRIVATE_DEF_SEL(mutableBytes,
+            "mutableBytes");
+        _NS_PRIVATE_DEF_SEL(name,
+            "name");
+        _NS_PRIVATE_DEF_SEL(nextObject,
+            "nextObject");
+        _NS_PRIVATE_DEF_SEL(numberWithBool_,
+            "numberWithBool:");
+        _NS_PRIVATE_DEF_SEL(numberWithChar_,
+            "numberWithChar:");
+        _NS_PRIVATE_DEF_SEL(numberWithDouble_,
+            "numberWithDouble:");
+        _NS_PRIVATE_DEF_SEL(numberWithFloat_,
+            "numberWithFloat:");
+        _NS_PRIVATE_DEF_SEL(numberWithInt_,
+            "numberWithInt:");
+        _NS_PRIVATE_DEF_SEL(numberWithLong_,
+            "numberWithLong:");
+        _NS_PRIVATE_DEF_SEL(numberWithLongLong_,
+            "numberWithLongLong:");
+        _NS_PRIVATE_DEF_SEL(numberWithShort_,
+            "numberWithShort:");
+        _NS_PRIVATE_DEF_SEL(numberWithUnsignedChar_,
+            "numberWithUnsignedChar:");
+        _NS_PRIVATE_DEF_SEL(numberWithUnsignedInt_,
+            "numberWithUnsignedInt:");
+        _NS_PRIVATE_DEF_SEL(numberWithUnsignedLong_,
+            "numberWithUnsignedLong:");
+        _NS_PRIVATE_DEF_SEL(numberWithUnsignedLongLong_,
+            "numberWithUnsignedLongLong:");
+        _NS_PRIVATE_DEF_SEL(numberWithUnsignedShort_,
+            "numberWithUnsignedShort:");
+        _NS_PRIVATE_DEF_SEL(objCType,
+            "objCType");
+        _NS_PRIVATE_DEF_SEL(object,
+            "object");
+        _NS_PRIVATE_DEF_SEL(objectAtIndex_,
+            "objectAtIndex:");
+        _NS_PRIVATE_DEF_SEL(objectEnumerator,
+            "objectEnumerator");
+        _NS_PRIVATE_DEF_SEL(objectForInfoDictionaryKey_,
+            "objectForInfoDictionaryKey:");
+        _NS_PRIVATE_DEF_SEL(objectForKey_,
+            "objectForKey:");
+        _NS_PRIVATE_DEF_SEL(operatingSystem,
+            "operatingSystem");
+        _NS_PRIVATE_DEF_SEL(operatingSystemVersion,
+            "operatingSystemVersion");
+        _NS_PRIVATE_DEF_SEL(operatingSystemVersionString,
+            "operatingSystemVersionString");
+        _NS_PRIVATE_DEF_SEL(pathForAuxiliaryExecutable_,
+            "pathForAuxiliaryExecutable:");
+        _NS_PRIVATE_DEF_SEL(performActivityWithOptions_reason_usingBlock_,
+            "performActivityWithOptions:reason:usingBlock:");
+        _NS_PRIVATE_DEF_SEL(performExpiringActivityWithReason_usingBlock_,
+            "performExpiringActivityWithReason:usingBlock:");
+        _NS_PRIVATE_DEF_SEL(physicalMemory,
+            "physicalMemory");
+        _NS_PRIVATE_DEF_SEL(pointerValue,
+            "pointerValue");
+        _NS_PRIVATE_DEF_SEL(preflightAndReturnError_,
+            "preflightAndReturnError:");
+        _NS_PRIVATE_DEF_SEL(privateFrameworksPath,
+            "privateFrameworksPath");
+        _NS_PRIVATE_DEF_SEL(privateFrameworksURL,
+            "privateFrameworksURL");
+        _NS_PRIVATE_DEF_SEL(processIdentifier,
+            "processIdentifier");
+        _NS_PRIVATE_DEF_SEL(processInfo,
+            "processInfo");
+        _NS_PRIVATE_DEF_SEL(processName,
+            "processName");
+        _NS_PRIVATE_DEF_SEL(processorCount,
+            "processorCount");
+        _NS_PRIVATE_DEF_SEL(rangeOfString_options_,
+            "rangeOfString:options:");
+        _NS_PRIVATE_DEF_SEL(release,
+            "release");
+        _NS_PRIVATE_DEF_SEL(removeObserver_,
+            "removeObserver:");
+        _NS_PRIVATE_DEF_SEL(resourcePath,
+            "resourcePath");
+        _NS_PRIVATE_DEF_SEL(resourceURL,
+            "resourceURL");
+        _NS_PRIVATE_DEF_SEL(respondsToSelector_,
+            "respondsToSelector:");
+        _NS_PRIVATE_DEF_SEL(retain,
+            "retain");
+        _NS_PRIVATE_DEF_SEL(retainCount,
+            "retainCount");
+        _NS_PRIVATE_DEF_SEL(setAutomaticTerminationSupportEnabled_,
+            "setAutomaticTerminationSupportEnabled:");
+        _NS_PRIVATE_DEF_SEL(setProcessName_,
+            "setProcessName:");
+        _NS_PRIVATE_DEF_SEL(sharedFrameworksPath,
+            "sharedFrameworksPath");
+        _NS_PRIVATE_DEF_SEL(sharedFrameworksURL,
+            "sharedFrameworksURL");
+        _NS_PRIVATE_DEF_SEL(sharedSupportPath,
+            "sharedSupportPath");
+        _NS_PRIVATE_DEF_SEL(sharedSupportURL,
+            "sharedSupportURL");
+        _NS_PRIVATE_DEF_SEL(shortValue,
+            "shortValue");
+        _NS_PRIVATE_DEF_SEL(showPools,
+            "showPools");
+        _NS_PRIVATE_DEF_SEL(signal,
+            "signal");
+        _NS_PRIVATE_DEF_SEL(string,
+            "string");
+        _NS_PRIVATE_DEF_SEL(stringValue,
+            "stringValue");
+        _NS_PRIVATE_DEF_SEL(stringWithString_,
+            "stringWithString:");
+        _NS_PRIVATE_DEF_SEL(stringWithCString_encoding_,
+            "stringWithCString:encoding:");
+        _NS_PRIVATE_DEF_SEL(stringByAppendingString_,
+            "stringByAppendingString:");
+        _NS_PRIVATE_DEF_SEL(systemUptime,
+            "systemUptime");
+        _NS_PRIVATE_DEF_SEL(thermalState,
+            "thermalState");
+        _NS_PRIVATE_DEF_SEL(unload,
+            "unload");
+        _NS_PRIVATE_DEF_SEL(unlock,
+            "unlock");
+        _NS_PRIVATE_DEF_SEL(unsignedCharValue,
+            "unsignedCharValue");
+        _NS_PRIVATE_DEF_SEL(unsignedIntegerValue,
+            "unsignedIntegerValue");
+        _NS_PRIVATE_DEF_SEL(unsignedIntValue,
+            "unsignedIntValue");
+        _NS_PRIVATE_DEF_SEL(unsignedLongValue,
+            "unsignedLongValue");
+        _NS_PRIVATE_DEF_SEL(unsignedLongLongValue,
+            "unsignedLongLongValue");
+        _NS_PRIVATE_DEF_SEL(unsignedShortValue,
+            "unsignedShortValue");
+        _NS_PRIVATE_DEF_SEL(URLForAuxiliaryExecutable_,
+            "URLForAuxiliaryExecutable:");
+        _NS_PRIVATE_DEF_SEL(userInfo,
+            "userInfo");
+        _NS_PRIVATE_DEF_SEL(userName,
+            "userName");
+        _NS_PRIVATE_DEF_SEL(UTF8String,
+            "UTF8String");
+        _NS_PRIVATE_DEF_SEL(valueWithBytes_objCType_,
+            "valueWithBytes:objCType:");
+        _NS_PRIVATE_DEF_SEL(valueWithPointer_,
+            "valueWithPointer:");
+        _NS_PRIVATE_DEF_SEL(wait,
+            "wait");
+        _NS_PRIVATE_DEF_SEL(waitUntilDate_,
+            "waitUntilDate:");
+    } // Class
+} // Private
+} // MTL
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSProcessInfo.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSProcessInfo.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..565b599379b88a4229c3a081bf851361081ed398
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSProcessInfo.hpp
@@ -0,0 +1,354 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSProcessInfo.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSNotification.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSTypes.hpp"
+
+#include <functional>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+_NS_CONST(NotificationName, ProcessInfoThermalStateDidChangeNotification);
+_NS_CONST(NotificationName, ProcessInfoPowerStateDidChangeNotification);
+
+_NS_ENUM(NS::Integer, ProcessInfoThermalState) {
+    ProcessInfoThermalStateNominal = 0,
+    ProcessInfoThermalStateFair = 1,
+    ProcessInfoThermalStateSerious = 2,
+    ProcessInfoThermalStateCritical = 3
+};
+
+_NS_OPTIONS(std::uint64_t, ActivityOptions) {
+    ActivityIdleDisplaySleepDisabled = (1ULL << 40),
+    ActivityIdleSystemSleepDisabled = (1ULL << 20),
+    ActivitySuddenTerminationDisabled = (1ULL << 14),
+    ActivityAutomaticTerminationDisabled = (1ULL << 15),
+    ActivityUserInitiated = (0x00FFFFFFULL | ActivityIdleSystemSleepDisabled),
+    ActivityUserInitiatedAllowingIdleSystemSleep = (ActivityUserInitiated & ~ActivityIdleSystemSleepDisabled),
+    ActivityBackground = 0x000000FFULL,
+    ActivityLatencyCritical = 0xFF00000000ULL,
+};
+
+class ProcessInfo : public Referencing<ProcessInfo>
+{
+public:
+    static ProcessInfo*     processInfo();
+
+    class Array*            arguments() const;
+    class Dictionary*       environment() const;
+    class String*           hostName() const;
+    class String*           processName() const;
+    void                    setProcessName(const String* pString);
+    int                     processIdentifier() const;
+    class String*           globallyUniqueString() const;
+
+    class String*           userName() const;
+    class String*           fullUserName() const;
+
+    UInteger                operatingSystem() const;
+    OperatingSystemVersion  operatingSystemVersion() const;
+    class String*           operatingSystemVersionString() const;
+    bool                    isOperatingSystemAtLeastVersion(OperatingSystemVersion version) const;
+
+    UInteger                processorCount() const;
+    UInteger                activeProcessorCount() const;
+    unsigned long long      physicalMemory() const;
+    TimeInterval            systemUptime() const;
+
+    void                    disableSuddenTermination();
+    void                    enableSuddenTermination();
+
+    void                    disableAutomaticTermination(const class String* pReason);
+    void                    enableAutomaticTermination(const class String* pReason);
+    bool                    automaticTerminationSupportEnabled() const;
+    void                    setAutomaticTerminationSupportEnabled(bool enabled);
+
+    class Object*           beginActivity(ActivityOptions options, const class String* pReason);
+    void                    endActivity(class Object* pActivity);
+    void                    performActivity(ActivityOptions options, const class String* pReason, void (^block)(void));
+    void                    performActivity(ActivityOptions options, const class String* pReason, const std::function<void()>& func);
+    void                    performExpiringActivity(const class String* pReason, void (^block)(bool expired));
+    void                    performExpiringActivity(const class String* pReason, const std::function<void(bool expired)>& func);
+
+    ProcessInfoThermalState thermalState() const;
+    bool                    isLowPowerModeEnabled() const;
+
+    bool                    isiOSAppOnMac() const;
+    bool                    isMacCatalystApp() const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoThermalStateDidChangeNotification);
+_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoPowerStateDidChangeNotification);
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::ProcessInfo* NS::ProcessInfo::processInfo()
+{
+    return Object::sendMessage<ProcessInfo*>(_NS_PRIVATE_CLS(NSProcessInfo), _NS_PRIVATE_SEL(processInfo));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Array* NS::ProcessInfo::arguments() const
+{
+    return Object::sendMessage<Array*>(this, _NS_PRIVATE_SEL(arguments));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Dictionary* NS::ProcessInfo::environment() const
+{
+    return Object::sendMessage<Dictionary*>(this, _NS_PRIVATE_SEL(environment));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::ProcessInfo::hostName() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(hostName));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::ProcessInfo::processName() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(processName));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::setProcessName(const String* pString)
+{
+    Object::sendMessage<void>(this, _NS_PRIVATE_SEL(setProcessName_), pString);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE int NS::ProcessInfo::processIdentifier() const
+{
+    return Object::sendMessage<int>(this, _NS_PRIVATE_SEL(processIdentifier));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::ProcessInfo::globallyUniqueString() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(globallyUniqueString));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::ProcessInfo::userName() const
+{
+    return Object::sendMessageSafe<String*>(this, _NS_PRIVATE_SEL(userName));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::ProcessInfo::fullUserName() const
+{
+    return Object::sendMessageSafe<String*>(this, _NS_PRIVATE_SEL(fullUserName));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::ProcessInfo::operatingSystem() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(operatingSystem));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::OperatingSystemVersion NS::ProcessInfo::operatingSystemVersion() const
+{
+    return Object::sendMessage<OperatingSystemVersion>(this, _NS_PRIVATE_SEL(operatingSystemVersion));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::ProcessInfo::operatingSystemVersionString() const
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(operatingSystemVersionString));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::ProcessInfo::isOperatingSystemAtLeastVersion(OperatingSystemVersion version) const
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isOperatingSystemAtLeastVersion_), version);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::ProcessInfo::processorCount() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(processorCount));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::ProcessInfo::activeProcessorCount() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(activeProcessorCount));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE unsigned long long NS::ProcessInfo::physicalMemory() const
+{
+    return Object::sendMessage<unsigned long long>(this, _NS_PRIVATE_SEL(physicalMemory));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::TimeInterval NS::ProcessInfo::systemUptime() const
+{
+    return Object::sendMessage<TimeInterval>(this, _NS_PRIVATE_SEL(systemUptime));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::disableSuddenTermination()
+{
+    Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(disableSuddenTermination));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::enableSuddenTermination()
+{
+    Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(enableSuddenTermination));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::disableAutomaticTermination(const String* pReason)
+{
+    Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(disableAutomaticTermination_), pReason);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::enableAutomaticTermination(const String* pReason)
+{
+    Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(enableAutomaticTermination_), pReason);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::ProcessInfo::automaticTerminationSupportEnabled() const
+{
+    return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(automaticTerminationSupportEnabled));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::setAutomaticTerminationSupportEnabled(bool enabled)
+{
+    Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(setAutomaticTerminationSupportEnabled_), enabled);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Object* NS::ProcessInfo::beginActivity(ActivityOptions options, const String* pReason)
+{
+    return Object::sendMessage<Object*>(this, _NS_PRIVATE_SEL(beginActivityWithOptions_reason_), options, pReason);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::endActivity(Object* pActivity)
+{
+    Object::sendMessage<void>(this, _NS_PRIVATE_SEL(endActivity_), pActivity);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::performActivity(ActivityOptions options, const String* pReason, void (^block)(void))
+{
+    Object::sendMessage<void>(this, _NS_PRIVATE_SEL(performActivityWithOptions_reason_usingBlock_), options, pReason, block);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::performActivity(ActivityOptions options, const String* pReason, const std::function<void()>& function)
+{
+    __block std::function<void()> blockFunction = function;
+
+    performActivity(options, pReason, ^() { blockFunction(); });
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::performExpiringActivity(const String* pReason, void (^block)(bool expired))
+{
+    Object::sendMessageSafe<void>(this, _NS_PRIVATE_SEL(performExpiringActivityWithReason_usingBlock_), pReason, block);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE void NS::ProcessInfo::performExpiringActivity(const String* pReason, const std::function<void(bool expired)>& function)
+{
+    __block std::function<void(bool expired)> blockFunction = function;
+
+    performExpiringActivity(pReason, ^(bool expired) { blockFunction(expired); });
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::ProcessInfoThermalState NS::ProcessInfo::thermalState() const
+{
+    return Object::sendMessage<ProcessInfoThermalState>(this, _NS_PRIVATE_SEL(thermalState));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::ProcessInfo::isLowPowerModeEnabled() const
+{
+    return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(isLowPowerModeEnabled));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::ProcessInfo::isiOSAppOnMac() const
+{
+    return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(isiOSAppOnMac));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::ProcessInfo::isMacCatalystApp() const
+{
+    return Object::sendMessageSafe<bool>(this, _NS_PRIVATE_SEL(isMacCatalystApp));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSRange.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSRange.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2c5beb5b9a10ed623518a8ce038989f9d502585d
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSRange.hpp
@@ -0,0 +1,83 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSRange.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+struct Range
+{
+    static Range Make(UInteger loc, UInteger len);
+
+    Range(UInteger loc, UInteger len);
+
+    bool     Equal(const Range& range) const;
+    bool     LocationInRange(UInteger loc) const;
+    UInteger Max() const;
+
+    UInteger location;
+    UInteger length;
+} _NS_PACKED;
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Range::Range(UInteger loc, UInteger len)
+    : location(loc)
+    , length(len)
+{
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Range NS::Range::Make(UInteger loc, UInteger len)
+{
+    return Range(loc, len);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Range::Equal(const Range& range) const
+{
+    return (location == range.location) && (length == range.length);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::Range::LocationInRange(UInteger loc) const
+{
+    return (!(loc < location)) && ((loc - location) < length);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::Range::Max() const
+{
+    return location + length;
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSSet.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSSet.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a4eb0d64e62ec3f8933ad80f8ade5f290247df41
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSSet.hpp
@@ -0,0 +1,87 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSSet.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSObject.hpp"
+#include "NSEnumerator.hpp"
+
+/*****Immutable Set*******/
+
+namespace NS
+{
+    class Set : public NS::Copying <Set>
+    {
+        public:
+            UInteger count() const;
+            Enumerator<Object>* objectEnumerator() const;
+
+            static Set* alloc();
+
+            Set* init();
+            Set* init(const Object* const* pObjects, UInteger count);
+            Set* init(const class Coder* pCoder);
+
+    };
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::Set::count() const
+{
+    return NS::Object::sendMessage<NS::UInteger>(this, _NS_PRIVATE_SEL(count));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Enumerator<NS::Object>* NS::Set::objectEnumerator() const
+{
+    return NS::Object::sendMessage<Enumerator<NS::Object>*>(this, _NS_PRIVATE_SEL(objectEnumerator));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Set* NS::Set::alloc()
+{
+    return NS::Object::alloc<Set>(_NS_PRIVATE_CLS(NSSet));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Set* NS::Set::init()
+{
+    return NS::Object::init<Set>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Set* NS::Set::init(const Object* const* pObjects, NS::UInteger count)
+{
+    return NS::Object::sendMessage<Set*>(this, _NS_PRIVATE_SEL(initWithObjects_count_), pObjects, count);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Set* NS::Set::init(const class Coder* pCoder)
+{
+    return Object::sendMessage<Set*>(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSSharedPtr.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSSharedPtr.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..09e8855ef3e0ac3b7db2322fc875ab917e196080
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSSharedPtr.hpp
@@ -0,0 +1,311 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSSharedPtr.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "NSDefines.hpp"
+
+namespace NS
+{
+template <class _Class>
+class SharedPtr
+{
+public:
+    /**
+     * Create a new null pointer.
+     */
+    SharedPtr();
+
+    /**
+     * Destroy this SharedPtr, decreasing the reference count.
+     */
+    ~SharedPtr();
+
+    /**
+     * SharedPtr copy constructor.
+     */
+    SharedPtr(const SharedPtr<_Class>& other) noexcept;
+
+    /**
+     * Construction from another pointee type.
+     */
+    template <class _OtherClass>
+    SharedPtr(const SharedPtr<_OtherClass>& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> * = nullptr) noexcept;
+
+    /**
+     * SharedPtr move constructor.
+     */
+    SharedPtr(SharedPtr<_Class>&& other) noexcept;
+
+    /**
+     * Move from another pointee type.
+     */
+    template <class _OtherClass>
+    SharedPtr(SharedPtr<_OtherClass>&& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> * = nullptr) noexcept;
+
+    /**
+     * Copy assignment operator.
+     * Copying increases reference count. Only releases previous pointee if objects are different.
+     */
+    SharedPtr& operator=(const SharedPtr<_Class>& other);
+
+    /**
+     * Copy-assignment from different pointee.
+     * Copying increases reference count. Only releases previous pointee if objects are different.
+     */
+    template <class _OtherClass>
+    typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, SharedPtr &>
+    operator=(const SharedPtr<_OtherClass>& other);
+
+    /**
+     * Move assignment operator.
+     * Move without affecting reference counts, unless pointees are equal. Moved-from object is reset to nullptr.
+     */
+    SharedPtr& operator=(SharedPtr<_Class>&& other);
+
+    /**
+     * Move-asignment from different pointee.
+     * Move without affecting reference counts, unless pointees are equal. Moved-from object is reset to nullptr.
+     */
+    template <class _OtherClass>
+    typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, SharedPtr &>
+    operator=(SharedPtr<_OtherClass>&& other);
+
+    /**
+     * Access raw pointee.
+     * @warning Avoid wrapping the returned value again, as it may lead double frees unless this object becomes detached.
+     */
+    _Class* get() const;
+
+    /**
+     * Call operations directly on the pointee.
+     */
+    _Class* operator->() const;
+
+    /**
+     * Implicit cast to bool.
+     */
+    explicit operator bool() const;
+
+    /**
+     * Reset this SharedPtr to null, decreasing the reference count.
+     */
+    void reset();
+
+    /**
+     * Detach the SharedPtr from the pointee, without decreasing the reference count.
+     */
+    void detach();
+
+    template <class _OtherClass>
+    friend SharedPtr<_OtherClass> RetainPtr(_OtherClass* ptr);
+
+    template <class _OtherClass>
+    friend SharedPtr<_OtherClass> TransferPtr(_OtherClass* ptr);
+
+private:
+    _Class* m_pObject;
+};
+
+/**
+ * Create a SharedPtr by retaining an existing raw pointer.
+ * Increases the reference count of the passed-in object.
+ * If the passed-in object was in an AutoreleasePool, it will be removed from it.
+ */
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class> RetainPtr(_Class* pObject)
+{
+    NS::SharedPtr<_Class> ret;
+    ret.m_pObject = pObject->retain();
+    return ret;
+}
+
+/*
+ * Create a SharedPtr by transfering the ownership of an existing raw pointer to SharedPtr.
+ * Does not increase the reference count of the passed-in pointer, it is assumed to be >= 1.
+ * This method does not remove objects from an AutoreleasePool.
+*/
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class> TransferPtr(_Class* pObject)
+{
+    NS::SharedPtr<_Class> ret;
+    ret.m_pObject = pObject;
+    return ret;
+}
+
+}
+
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class>::SharedPtr()
+    : m_pObject(nullptr)
+{
+}
+
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class>::~SharedPtr()
+{
+    if (m_pObject)
+    {
+        m_pObject->release();
+    }
+}
+
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(const NS::SharedPtr<_Class>& other) noexcept
+    : m_pObject(other.m_pObject->retain())
+{
+}
+
+template <class _Class>
+template <class _OtherClass>
+_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(const NS::SharedPtr<_OtherClass>& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> *) noexcept
+    : m_pObject(reinterpret_cast<_Class*>(other.get()->retain()))
+{
+}
+
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(NS::SharedPtr<_Class>&& other) noexcept
+    : m_pObject(other.m_pObject)
+{
+    other.m_pObject = nullptr;
+}
+
+template <class _Class>
+template <class _OtherClass>
+_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(NS::SharedPtr<_OtherClass>&& other, typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>> *) noexcept
+    : m_pObject(reinterpret_cast<_Class*>(other.get()))
+{
+    other.detach();
+}
+
+template <class _Class>
+_NS_INLINE _Class* NS::SharedPtr<_Class>::get() const
+{
+    return m_pObject;
+}
+
+template <class _Class>
+_NS_INLINE _Class* NS::SharedPtr<_Class>::operator->() const
+{
+    return m_pObject;
+}
+
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class>::operator bool() const
+{
+    return nullptr != m_pObject;
+}
+
+template <class _Class>
+_NS_INLINE void NS::SharedPtr<_Class>::reset()
+{
+    m_pObject->release();
+    m_pObject = nullptr;
+}
+
+template <class _Class>
+_NS_INLINE void NS::SharedPtr<_Class>::detach()
+{
+    m_pObject = nullptr;
+}
+
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class>& NS::SharedPtr<_Class>::operator=(const SharedPtr<_Class>& other)
+{
+    if (m_pObject != other.m_pObject)
+    {
+        if (m_pObject)
+        {
+            m_pObject->release();
+        }
+        m_pObject = other.m_pObject->retain();
+    }
+    return *this;
+}
+
+template <class _Class>
+template <class _OtherClass>
+typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, NS::SharedPtr<_Class> &>
+_NS_INLINE NS::SharedPtr<_Class>::operator=(const SharedPtr<_OtherClass>& other)
+{
+    if (m_pObject != other.get())
+    {
+        if (m_pObject)
+        {
+            m_pObject->release();
+        }
+        m_pObject = reinterpret_cast<_Class*>(other.get()->retain());
+    }
+    return *this;
+}
+
+template <class _Class>
+_NS_INLINE NS::SharedPtr<_Class>& NS::SharedPtr<_Class>::operator=(SharedPtr<_Class>&& other)
+{
+    if (m_pObject != other.m_pObject)
+    {
+        if (m_pObject)
+        {
+            m_pObject->release();
+        }
+        m_pObject = other.m_pObject;
+    }
+    else
+    {
+        m_pObject = other.m_pObject;
+        other.m_pObject->release();
+    }
+    other.m_pObject = nullptr;
+    return *this;
+}
+
+template <class _Class>
+template <class _OtherClass>
+typename std::enable_if_t<std::is_convertible_v<_OtherClass *, _Class *>, NS::SharedPtr<_Class> &>
+_NS_INLINE NS::SharedPtr<_Class>::operator=(SharedPtr<_OtherClass>&& other)
+{
+    if (m_pObject != other.get())
+    {
+        if (m_pObject)
+        {
+            m_pObject->release();
+        }
+        m_pObject = reinterpret_cast<_Class*>(other.get());
+        other.detach();
+    }
+    else
+    {
+        m_pObject = other.get();
+        other.reset();
+    }
+    return *this;
+}
+
+template <class _ClassLhs, class _ClassRhs>
+_NS_INLINE bool operator==(const NS::SharedPtr<_ClassLhs>& lhs, const NS::SharedPtr<_ClassRhs>& rhs)
+{
+    return lhs.get() == rhs.get();
+}
+
+template <class _ClassLhs, class _ClassRhs>
+_NS_INLINE bool operator!=(const NS::SharedPtr<_ClassLhs>& lhs, const NS::SharedPtr<_ClassRhs>& rhs)
+{
+    return lhs.get() != rhs.get();
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSString.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSString.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c601fc0129ed6c3da9773366f6284d99b26d6791
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSString.hpp
@@ -0,0 +1,255 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSString.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSObjCRuntime.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSRange.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+_NS_ENUM(NS::UInteger, StringEncoding) {
+    ASCIIStringEncoding = 1,
+    NEXTSTEPStringEncoding = 2,
+    JapaneseEUCStringEncoding = 3,
+    UTF8StringEncoding = 4,
+    ISOLatin1StringEncoding = 5,
+    SymbolStringEncoding = 6,
+    NonLossyASCIIStringEncoding = 7,
+    ShiftJISStringEncoding = 8,
+    ISOLatin2StringEncoding = 9,
+    UnicodeStringEncoding = 10,
+    WindowsCP1251StringEncoding = 11,
+    WindowsCP1252StringEncoding = 12,
+    WindowsCP1253StringEncoding = 13,
+    WindowsCP1254StringEncoding = 14,
+    WindowsCP1250StringEncoding = 15,
+    ISO2022JPStringEncoding = 21,
+    MacOSRomanStringEncoding = 30,
+
+    UTF16StringEncoding = UnicodeStringEncoding,
+
+    UTF16BigEndianStringEncoding = 0x90000100,
+    UTF16LittleEndianStringEncoding = 0x94000100,
+
+    UTF32StringEncoding = 0x8c000100,
+    UTF32BigEndianStringEncoding = 0x98000100,
+    UTF32LittleEndianStringEncoding = 0x9c000100
+};
+
+_NS_OPTIONS(NS::UInteger, StringCompareOptions) {
+    CaseInsensitiveSearch = 1,
+    LiteralSearch = 2,
+    BackwardsSearch = 4,
+    AnchoredSearch = 8,
+    NumericSearch = 64,
+    DiacriticInsensitiveSearch = 128,
+    WidthInsensitiveSearch = 256,
+    ForcedOrderingSearch = 512,
+    RegularExpressionSearch = 1024
+};
+
+using unichar = unsigned short;
+
+class String : public Copying<String>
+{
+public:
+    static String*   string();
+    static String*   string(const String* pString);
+    static String*   string(const char* pString, StringEncoding encoding);
+
+    static String*   alloc();
+    String*          init();
+    String*          init(const String* pString);
+    String*          init(const char* pString, StringEncoding encoding);
+    String*          init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer);
+
+    unichar          character(UInteger index) const;
+    UInteger         length() const;
+
+    const char*      cString(StringEncoding encoding) const;
+    const char*      utf8String() const;
+    UInteger         maximumLengthOfBytes(StringEncoding encoding) const;
+    UInteger         lengthOfBytes(StringEncoding encoding) const;
+
+    bool             isEqualToString(const String* pString) const;
+    Range            rangeOfString(const String* pString, StringCompareOptions options) const;
+
+    const char*      fileSystemRepresentation() const;
+
+    String*          stringByAppendingString(const String* pString) const;
+    ComparisonResult caseInsensitiveCompare(const String* pString) const;
+};
+
+/// Create an NS::String* from a string literal.
+#define MTLSTR(literal) (NS::String*)__builtin___CFStringMakeConstantString("" literal "")
+
+template <std::size_t _StringLen>
+[[deprecated("please use MTLSTR(str)")]] constexpr const String* MakeConstantString(const char (&str)[_StringLen])
+{
+    return reinterpret_cast<const String*>(__CFStringMakeConstantString(str));
+}
+
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::string()
+{
+    return Object::sendMessage<String*>(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(string));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::string(const String* pString)
+{
+    return Object::sendMessage<String*>(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(stringWithString_), pString);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::string(const char* pString, StringEncoding encoding)
+{
+    return Object::sendMessage<String*>(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(stringWithCString_encoding_), pString, encoding);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::alloc()
+{
+    return Object::alloc<String>(_NS_PRIVATE_CLS(NSString));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::init()
+{
+    return Object::init<String>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::init(const String* pString)
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(initWithString_), pString);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::init(const char* pString, StringEncoding encoding)
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(initWithCString_encoding_), pString, encoding);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer)
+{
+    return Object::sendMessage<String*>(this, _NS_PRIVATE_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_), pBytes, len, encoding, freeBuffer);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::unichar NS::String::character(UInteger index) const
+{
+    return Object::sendMessage<unichar>(this, _NS_PRIVATE_SEL(characterAtIndex_), index);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::String::length() const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(length));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE const char* NS::String::cString(StringEncoding encoding) const
+{
+    return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(cStringUsingEncoding_), encoding);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE const char* NS::String::utf8String() const
+{
+    return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(UTF8String));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::String::maximumLengthOfBytes(StringEncoding encoding) const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(maximumLengthOfBytesUsingEncoding_), encoding);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::UInteger NS::String::lengthOfBytes(StringEncoding encoding) const
+{
+    return Object::sendMessage<UInteger>(this, _NS_PRIVATE_SEL(lengthOfBytesUsingEncoding_), encoding);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE bool NS::String::isEqualToString(const NS::String* pString) const
+{
+    return Object::sendMessage<bool>(this, _NS_PRIVATE_SEL(isEqualToString_), pString);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::Range NS::String::rangeOfString(const NS::String* pString, NS::StringCompareOptions options) const
+{
+    return Object::sendMessage<Range>(this, _NS_PRIVATE_SEL(rangeOfString_options_), pString, options);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE const char* NS::String::fileSystemRepresentation() const
+{
+    return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(fileSystemRepresentation));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::String* NS::String::stringByAppendingString(const String* pString) const
+{
+    return Object::sendMessage<NS::String*>(this, _NS_PRIVATE_SEL(stringByAppendingString_), pString);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::ComparisonResult NS::String::caseInsensitiveCompare(const String* pString) const
+{
+    return Object::sendMessage<NS::ComparisonResult>(this, _NS_PRIVATE_SEL(caseInsensitiveCompare_), pString);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSTypes.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSTypes.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5f098f6709c73d4eff0f5b8595f89094174da85f
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSTypes.hpp
@@ -0,0 +1,51 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSTypes.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <cstdint>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+using TimeInterval = double;
+
+using Integer = std::intptr_t;
+using UInteger = std::uintptr_t;
+
+const Integer  IntegerMax = INTPTR_MAX;
+const Integer  IntegerMin = INTPTR_MIN;
+const UInteger UIntegerMax = UINTPTR_MAX;
+
+struct OperatingSystemVersion
+{
+    Integer majorVersion;
+    Integer minorVersion;
+    Integer patchVersion;
+} _NS_PACKED;
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSURL.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSURL.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a7bc3e6e355401dde3bf3a42015ebfbf9fadf581
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Foundation/NSURL.hpp
@@ -0,0 +1,90 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Foundation/NSURL.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "NSDefines.hpp"
+#include "NSObject.hpp"
+#include "NSPrivate.hpp"
+#include "NSTypes.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace NS
+{
+class URL : public Copying<URL>
+{
+public:
+    static URL* fileURLWithPath(const class String* pPath);
+
+    static URL* alloc();
+    URL*        init();
+    URL*        init(const class String* pString);
+    URL*        initFileURLWithPath(const class String* pPath);
+
+    const char* fileSystemRepresentation() const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::URL::fileURLWithPath(const String* pPath)
+{
+    return Object::sendMessage<URL*>(_NS_PRIVATE_CLS(NSURL), _NS_PRIVATE_SEL(fileURLWithPath_), pPath);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::URL::alloc()
+{
+    return Object::alloc<URL>(_NS_PRIVATE_CLS(NSURL));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::URL::init()
+{
+    return Object::init<URL>();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::URL::init(const String* pString)
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(initWithString_), pString);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE NS::URL* NS::URL::initFileURLWithPath(const String* pPath)
+{
+    return Object::sendMessage<URL*>(this, _NS_PRIVATE_SEL(initFileURLWithPath_), pPath);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_NS_INLINE const char* NS::URL::fileSystemRepresentation() const
+{
+    return Object::sendMessage<const char*>(this, _NS_PRIVATE_SEL(fileSystemRepresentation));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/LICENSE.txt b/lib/python3.11/site-packages/mlx/include/metal_cpp/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6c877ff988be532d23ff7a380d8dd251b51b694e
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright © 2023 Apple Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructure.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructure.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..cb30db71e49af503447771a90cb5bf3c8e6cd97c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructure.hpp
@@ -0,0 +1,1826 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLAccelerationStructure.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLAccelerationStructure.hpp"
+#include "MTLAccelerationStructureTypes.hpp"
+#include "MTLResource.hpp"
+#include "MTLStageInputOutputDescriptor.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_OPTIONS(NS::UInteger, AccelerationStructureUsage) {
+    AccelerationStructureUsageNone = 0,
+    AccelerationStructureUsageRefit = 1,
+    AccelerationStructureUsagePreferFastBuild = 2,
+    AccelerationStructureUsageExtendedLimits = 4,
+};
+
+_MTL_OPTIONS(uint32_t, AccelerationStructureInstanceOptions) {
+    AccelerationStructureInstanceOptionNone = 0,
+    AccelerationStructureInstanceOptionDisableTriangleCulling = 1,
+    AccelerationStructureInstanceOptionTriangleFrontFacingWindingCounterClockwise = 2,
+    AccelerationStructureInstanceOptionOpaque = 4,
+    AccelerationStructureInstanceOptionNonOpaque = 8,
+};
+
+class AccelerationStructureDescriptor : public NS::Copying<AccelerationStructureDescriptor>
+{
+public:
+    static class AccelerationStructureDescriptor* alloc();
+
+    class AccelerationStructureDescriptor*        init();
+
+    MTL::AccelerationStructureUsage               usage() const;
+    void                                          setUsage(MTL::AccelerationStructureUsage usage);
+};
+
+class AccelerationStructureGeometryDescriptor : public NS::Copying<AccelerationStructureGeometryDescriptor>
+{
+public:
+    static class AccelerationStructureGeometryDescriptor* alloc();
+
+    class AccelerationStructureGeometryDescriptor*        init();
+
+    NS::UInteger                                          intersectionFunctionTableOffset() const;
+    void                                                  setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset);
+
+    bool                                                  opaque() const;
+    void                                                  setOpaque(bool opaque);
+
+    bool                                                  allowDuplicateIntersectionFunctionInvocation() const;
+    void                                                  setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation);
+
+    NS::String*                                           label() const;
+    void                                                  setLabel(const NS::String* label);
+
+    class Buffer*                                         primitiveDataBuffer() const;
+    void                                                  setPrimitiveDataBuffer(const class Buffer* primitiveDataBuffer);
+
+    NS::UInteger                                          primitiveDataBufferOffset() const;
+    void                                                  setPrimitiveDataBufferOffset(NS::UInteger primitiveDataBufferOffset);
+
+    NS::UInteger                                          primitiveDataStride() const;
+    void                                                  setPrimitiveDataStride(NS::UInteger primitiveDataStride);
+
+    NS::UInteger                                          primitiveDataElementSize() const;
+    void                                                  setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize);
+};
+
+_MTL_ENUM(uint32_t, MotionBorderMode) {
+    MotionBorderModeClamp = 0,
+    MotionBorderModeVanish = 1,
+};
+
+class PrimitiveAccelerationStructureDescriptor : public NS::Copying<PrimitiveAccelerationStructureDescriptor, MTL::AccelerationStructureDescriptor>
+{
+public:
+    static class PrimitiveAccelerationStructureDescriptor* alloc();
+
+    class PrimitiveAccelerationStructureDescriptor*        init();
+
+    NS::Array*                                             geometryDescriptors() const;
+    void                                                   setGeometryDescriptors(const NS::Array* geometryDescriptors);
+
+    MTL::MotionBorderMode                                  motionStartBorderMode() const;
+    void                                                   setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode);
+
+    MTL::MotionBorderMode                                  motionEndBorderMode() const;
+    void                                                   setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode);
+
+    float                                                  motionStartTime() const;
+    void                                                   setMotionStartTime(float motionStartTime);
+
+    float                                                  motionEndTime() const;
+    void                                                   setMotionEndTime(float motionEndTime);
+
+    NS::UInteger                                           motionKeyframeCount() const;
+    void                                                   setMotionKeyframeCount(NS::UInteger motionKeyframeCount);
+
+    static MTL::PrimitiveAccelerationStructureDescriptor*  descriptor();
+};
+
+class AccelerationStructureTriangleGeometryDescriptor : public NS::Copying<AccelerationStructureTriangleGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
+{
+public:
+    static class AccelerationStructureTriangleGeometryDescriptor* alloc();
+
+    class AccelerationStructureTriangleGeometryDescriptor*        init();
+
+    class Buffer*                                                 vertexBuffer() const;
+    void                                                          setVertexBuffer(const class Buffer* vertexBuffer);
+
+    NS::UInteger                                                  vertexBufferOffset() const;
+    void                                                          setVertexBufferOffset(NS::UInteger vertexBufferOffset);
+
+    MTL::AttributeFormat                                          vertexFormat() const;
+    void                                                          setVertexFormat(MTL::AttributeFormat vertexFormat);
+
+    NS::UInteger                                                  vertexStride() const;
+    void                                                          setVertexStride(NS::UInteger vertexStride);
+
+    class Buffer*                                                 indexBuffer() const;
+    void                                                          setIndexBuffer(const class Buffer* indexBuffer);
+
+    NS::UInteger                                                  indexBufferOffset() const;
+    void                                                          setIndexBufferOffset(NS::UInteger indexBufferOffset);
+
+    MTL::IndexType                                                indexType() const;
+    void                                                          setIndexType(MTL::IndexType indexType);
+
+    NS::UInteger                                                  triangleCount() const;
+    void                                                          setTriangleCount(NS::UInteger triangleCount);
+
+    class Buffer*                                                 transformationMatrixBuffer() const;
+    void                                                          setTransformationMatrixBuffer(const class Buffer* transformationMatrixBuffer);
+
+    NS::UInteger                                                  transformationMatrixBufferOffset() const;
+    void                                                          setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset);
+
+    static MTL::AccelerationStructureTriangleGeometryDescriptor*  descriptor();
+};
+
+class AccelerationStructureBoundingBoxGeometryDescriptor : public NS::Copying<AccelerationStructureBoundingBoxGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
+{
+public:
+    static class AccelerationStructureBoundingBoxGeometryDescriptor* alloc();
+
+    class AccelerationStructureBoundingBoxGeometryDescriptor*        init();
+
+    class Buffer*                                                    boundingBoxBuffer() const;
+    void                                                             setBoundingBoxBuffer(const class Buffer* boundingBoxBuffer);
+
+    NS::UInteger                                                     boundingBoxBufferOffset() const;
+    void                                                             setBoundingBoxBufferOffset(NS::UInteger boundingBoxBufferOffset);
+
+    NS::UInteger                                                     boundingBoxStride() const;
+    void                                                             setBoundingBoxStride(NS::UInteger boundingBoxStride);
+
+    NS::UInteger                                                     boundingBoxCount() const;
+    void                                                             setBoundingBoxCount(NS::UInteger boundingBoxCount);
+
+    static MTL::AccelerationStructureBoundingBoxGeometryDescriptor*  descriptor();
+};
+
+class MotionKeyframeData : public NS::Referencing<MotionKeyframeData>
+{
+public:
+    static class MotionKeyframeData* alloc();
+
+    class MotionKeyframeData*        init();
+
+    class Buffer*                    buffer() const;
+    void                             setBuffer(const class Buffer* buffer);
+
+    NS::UInteger                     offset() const;
+    void                             setOffset(NS::UInteger offset);
+
+    static MTL::MotionKeyframeData*  data();
+};
+
+class AccelerationStructureMotionTriangleGeometryDescriptor : public NS::Copying<AccelerationStructureMotionTriangleGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
+{
+public:
+    static class AccelerationStructureMotionTriangleGeometryDescriptor* alloc();
+
+    class AccelerationStructureMotionTriangleGeometryDescriptor*        init();
+
+    NS::Array*                                                          vertexBuffers() const;
+    void                                                                setVertexBuffers(const NS::Array* vertexBuffers);
+
+    MTL::AttributeFormat                                                vertexFormat() const;
+    void                                                                setVertexFormat(MTL::AttributeFormat vertexFormat);
+
+    NS::UInteger                                                        vertexStride() const;
+    void                                                                setVertexStride(NS::UInteger vertexStride);
+
+    class Buffer*                                                       indexBuffer() const;
+    void                                                                setIndexBuffer(const class Buffer* indexBuffer);
+
+    NS::UInteger                                                        indexBufferOffset() const;
+    void                                                                setIndexBufferOffset(NS::UInteger indexBufferOffset);
+
+    MTL::IndexType                                                      indexType() const;
+    void                                                                setIndexType(MTL::IndexType indexType);
+
+    NS::UInteger                                                        triangleCount() const;
+    void                                                                setTriangleCount(NS::UInteger triangleCount);
+
+    class Buffer*                                                       transformationMatrixBuffer() const;
+    void                                                                setTransformationMatrixBuffer(const class Buffer* transformationMatrixBuffer);
+
+    NS::UInteger                                                        transformationMatrixBufferOffset() const;
+    void                                                                setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset);
+
+    static MTL::AccelerationStructureMotionTriangleGeometryDescriptor*  descriptor();
+};
+
+class AccelerationStructureMotionBoundingBoxGeometryDescriptor : public NS::Copying<AccelerationStructureMotionBoundingBoxGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
+{
+public:
+    static class AccelerationStructureMotionBoundingBoxGeometryDescriptor* alloc();
+
+    class AccelerationStructureMotionBoundingBoxGeometryDescriptor*        init();
+
+    NS::Array*                                                             boundingBoxBuffers() const;
+    void                                                                   setBoundingBoxBuffers(const NS::Array* boundingBoxBuffers);
+
+    NS::UInteger                                                           boundingBoxStride() const;
+    void                                                                   setBoundingBoxStride(NS::UInteger boundingBoxStride);
+
+    NS::UInteger                                                           boundingBoxCount() const;
+    void                                                                   setBoundingBoxCount(NS::UInteger boundingBoxCount);
+
+    static MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor*  descriptor();
+};
+
+_MTL_ENUM(NS::Integer, CurveType) {
+    CurveTypeRound = 0,
+    CurveTypeFlat = 1,
+};
+
+_MTL_ENUM(NS::Integer, CurveBasis) {
+    CurveBasisBSpline = 0,
+    CurveBasisCatmullRom = 1,
+    CurveBasisLinear = 2,
+    CurveBasisBezier = 3,
+};
+
+_MTL_ENUM(NS::Integer, CurveEndCaps) {
+    CurveEndCapsNone = 0,
+    CurveEndCapsDisk = 1,
+    CurveEndCapsSphere = 2,
+};
+
+class AccelerationStructureCurveGeometryDescriptor : public NS::Copying<AccelerationStructureCurveGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
+{
+public:
+    static class AccelerationStructureCurveGeometryDescriptor* alloc();
+
+    class AccelerationStructureCurveGeometryDescriptor*        init();
+
+    class Buffer*                                              controlPointBuffer() const;
+    void                                                       setControlPointBuffer(const class Buffer* controlPointBuffer);
+
+    NS::UInteger                                               controlPointBufferOffset() const;
+    void                                                       setControlPointBufferOffset(NS::UInteger controlPointBufferOffset);
+
+    NS::UInteger                                               controlPointCount() const;
+    void                                                       setControlPointCount(NS::UInteger controlPointCount);
+
+    NS::UInteger                                               controlPointStride() const;
+    void                                                       setControlPointStride(NS::UInteger controlPointStride);
+
+    MTL::AttributeFormat                                       controlPointFormat() const;
+    void                                                       setControlPointFormat(MTL::AttributeFormat controlPointFormat);
+
+    class Buffer*                                              radiusBuffer() const;
+    void                                                       setRadiusBuffer(const class Buffer* radiusBuffer);
+
+    NS::UInteger                                               radiusBufferOffset() const;
+    void                                                       setRadiusBufferOffset(NS::UInteger radiusBufferOffset);
+
+    MTL::AttributeFormat                                       radiusFormat() const;
+    void                                                       setRadiusFormat(MTL::AttributeFormat radiusFormat);
+
+    NS::UInteger                                               radiusStride() const;
+    void                                                       setRadiusStride(NS::UInteger radiusStride);
+
+    class Buffer*                                              indexBuffer() const;
+    void                                                       setIndexBuffer(const class Buffer* indexBuffer);
+
+    NS::UInteger                                               indexBufferOffset() const;
+    void                                                       setIndexBufferOffset(NS::UInteger indexBufferOffset);
+
+    MTL::IndexType                                             indexType() const;
+    void                                                       setIndexType(MTL::IndexType indexType);
+
+    NS::UInteger                                               segmentCount() const;
+    void                                                       setSegmentCount(NS::UInteger segmentCount);
+
+    NS::UInteger                                               segmentControlPointCount() const;
+    void                                                       setSegmentControlPointCount(NS::UInteger segmentControlPointCount);
+
+    MTL::CurveType                                             curveType() const;
+    void                                                       setCurveType(MTL::CurveType curveType);
+
+    MTL::CurveBasis                                            curveBasis() const;
+    void                                                       setCurveBasis(MTL::CurveBasis curveBasis);
+
+    MTL::CurveEndCaps                                          curveEndCaps() const;
+    void                                                       setCurveEndCaps(MTL::CurveEndCaps curveEndCaps);
+
+    static MTL::AccelerationStructureCurveGeometryDescriptor*  descriptor();
+};
+
+class AccelerationStructureMotionCurveGeometryDescriptor : public NS::Copying<AccelerationStructureMotionCurveGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
+{
+public:
+    static class AccelerationStructureMotionCurveGeometryDescriptor* alloc();
+
+    class AccelerationStructureMotionCurveGeometryDescriptor*        init();
+
+    NS::Array*                                                       controlPointBuffers() const;
+    void                                                             setControlPointBuffers(const NS::Array* controlPointBuffers);
+
+    NS::UInteger                                                     controlPointCount() const;
+    void                                                             setControlPointCount(NS::UInteger controlPointCount);
+
+    NS::UInteger                                                     controlPointStride() const;
+    void                                                             setControlPointStride(NS::UInteger controlPointStride);
+
+    MTL::AttributeFormat                                             controlPointFormat() const;
+    void                                                             setControlPointFormat(MTL::AttributeFormat controlPointFormat);
+
+    NS::Array*                                                       radiusBuffers() const;
+    void                                                             setRadiusBuffers(const NS::Array* radiusBuffers);
+
+    MTL::AttributeFormat                                             radiusFormat() const;
+    void                                                             setRadiusFormat(MTL::AttributeFormat radiusFormat);
+
+    NS::UInteger                                                     radiusStride() const;
+    void                                                             setRadiusStride(NS::UInteger radiusStride);
+
+    class Buffer*                                                    indexBuffer() const;
+    void                                                             setIndexBuffer(const class Buffer* indexBuffer);
+
+    NS::UInteger                                                     indexBufferOffset() const;
+    void                                                             setIndexBufferOffset(NS::UInteger indexBufferOffset);
+
+    MTL::IndexType                                                   indexType() const;
+    void                                                             setIndexType(MTL::IndexType indexType);
+
+    NS::UInteger                                                     segmentCount() const;
+    void                                                             setSegmentCount(NS::UInteger segmentCount);
+
+    NS::UInteger                                                     segmentControlPointCount() const;
+    void                                                             setSegmentControlPointCount(NS::UInteger segmentControlPointCount);
+
+    MTL::CurveType                                                   curveType() const;
+    void                                                             setCurveType(MTL::CurveType curveType);
+
+    MTL::CurveBasis                                                  curveBasis() const;
+    void                                                             setCurveBasis(MTL::CurveBasis curveBasis);
+
+    MTL::CurveEndCaps                                                curveEndCaps() const;
+    void                                                             setCurveEndCaps(MTL::CurveEndCaps curveEndCaps);
+
+    static MTL::AccelerationStructureMotionCurveGeometryDescriptor*  descriptor();
+};
+
+struct AccelerationStructureInstanceDescriptor
+{
+    MTL::PackedFloat4x3                       transformationMatrix;
+    MTL::AccelerationStructureInstanceOptions options;
+    uint32_t                                  mask;
+    uint32_t                                  intersectionFunctionTableOffset;
+    uint32_t                                  accelerationStructureIndex;
+} _MTL_PACKED;
+
+struct AccelerationStructureUserIDInstanceDescriptor
+{
+    MTL::PackedFloat4x3                       transformationMatrix;
+    MTL::AccelerationStructureInstanceOptions options;
+    uint32_t                                  mask;
+    uint32_t                                  intersectionFunctionTableOffset;
+    uint32_t                                  accelerationStructureIndex;
+    uint32_t                                  userID;
+} _MTL_PACKED;
+
+_MTL_ENUM(NS::UInteger, AccelerationStructureInstanceDescriptorType) {
+    AccelerationStructureInstanceDescriptorTypeDefault = 0,
+    AccelerationStructureInstanceDescriptorTypeUserID = 1,
+    AccelerationStructureInstanceDescriptorTypeMotion = 2,
+    AccelerationStructureInstanceDescriptorTypeIndirect = 3,
+    AccelerationStructureInstanceDescriptorTypeIndirectMotion = 4,
+};
+
+struct AccelerationStructureMotionInstanceDescriptor
+{
+    MTL::AccelerationStructureInstanceOptions options;
+    uint32_t                                  mask;
+    uint32_t                                  intersectionFunctionTableOffset;
+    uint32_t                                  accelerationStructureIndex;
+    uint32_t                                  userID;
+    uint32_t                                  motionTransformsStartIndex;
+    uint32_t                                  motionTransformsCount;
+    MTL::MotionBorderMode                     motionStartBorderMode;
+    MTL::MotionBorderMode                     motionEndBorderMode;
+    float                                     motionStartTime;
+    float                                     motionEndTime;
+} _MTL_PACKED;
+
+struct IndirectAccelerationStructureInstanceDescriptor
+{
+    MTL::PackedFloat4x3                       transformationMatrix;
+    MTL::AccelerationStructureInstanceOptions options;
+    uint32_t                                  mask;
+    uint32_t                                  intersectionFunctionTableOffset;
+    uint32_t                                  userID;
+    MTL::ResourceID                           accelerationStructureID;
+} _MTL_PACKED;
+
+struct IndirectAccelerationStructureMotionInstanceDescriptor
+{
+    MTL::AccelerationStructureInstanceOptions options;
+    uint32_t                                  mask;
+    uint32_t                                  intersectionFunctionTableOffset;
+    uint32_t                                  userID;
+    MTL::ResourceID                           accelerationStructureID;
+    uint32_t                                  motionTransformsStartIndex;
+    uint32_t                                  motionTransformsCount;
+    MTL::MotionBorderMode                     motionStartBorderMode;
+    MTL::MotionBorderMode                     motionEndBorderMode;
+    float                                     motionStartTime;
+    float                                     motionEndTime;
+} _MTL_PACKED;
+
+class InstanceAccelerationStructureDescriptor : public NS::Copying<InstanceAccelerationStructureDescriptor, MTL::AccelerationStructureDescriptor>
+{
+public:
+    static class InstanceAccelerationStructureDescriptor* alloc();
+
+    class InstanceAccelerationStructureDescriptor*        init();
+
+    class Buffer*                                         instanceDescriptorBuffer() const;
+    void                                                  setInstanceDescriptorBuffer(const class Buffer* instanceDescriptorBuffer);
+
+    NS::UInteger                                          instanceDescriptorBufferOffset() const;
+    void                                                  setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset);
+
+    NS::UInteger                                          instanceDescriptorStride() const;
+    void                                                  setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride);
+
+    NS::UInteger                                          instanceCount() const;
+    void                                                  setInstanceCount(NS::UInteger instanceCount);
+
+    NS::Array*                                            instancedAccelerationStructures() const;
+    void                                                  setInstancedAccelerationStructures(const NS::Array* instancedAccelerationStructures);
+
+    MTL::AccelerationStructureInstanceDescriptorType      instanceDescriptorType() const;
+    void                                                  setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType);
+
+    class Buffer*                                         motionTransformBuffer() const;
+    void                                                  setMotionTransformBuffer(const class Buffer* motionTransformBuffer);
+
+    NS::UInteger                                          motionTransformBufferOffset() const;
+    void                                                  setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset);
+
+    NS::UInteger                                          motionTransformCount() const;
+    void                                                  setMotionTransformCount(NS::UInteger motionTransformCount);
+
+    static MTL::InstanceAccelerationStructureDescriptor*  descriptor();
+};
+
+class IndirectInstanceAccelerationStructureDescriptor : public NS::Copying<IndirectInstanceAccelerationStructureDescriptor, MTL::AccelerationStructureDescriptor>
+{
+public:
+    static class IndirectInstanceAccelerationStructureDescriptor* alloc();
+
+    class IndirectInstanceAccelerationStructureDescriptor*        init();
+
+    class Buffer*                                                 instanceDescriptorBuffer() const;
+    void                                                          setInstanceDescriptorBuffer(const class Buffer* instanceDescriptorBuffer);
+
+    NS::UInteger                                                  instanceDescriptorBufferOffset() const;
+    void                                                          setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset);
+
+    NS::UInteger                                                  instanceDescriptorStride() const;
+    void                                                          setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride);
+
+    NS::UInteger                                                  maxInstanceCount() const;
+    void                                                          setMaxInstanceCount(NS::UInteger maxInstanceCount);
+
+    class Buffer*                                                 instanceCountBuffer() const;
+    void                                                          setInstanceCountBuffer(const class Buffer* instanceCountBuffer);
+
+    NS::UInteger                                                  instanceCountBufferOffset() const;
+    void                                                          setInstanceCountBufferOffset(NS::UInteger instanceCountBufferOffset);
+
+    MTL::AccelerationStructureInstanceDescriptorType              instanceDescriptorType() const;
+    void                                                          setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType);
+
+    class Buffer*                                                 motionTransformBuffer() const;
+    void                                                          setMotionTransformBuffer(const class Buffer* motionTransformBuffer);
+
+    NS::UInteger                                                  motionTransformBufferOffset() const;
+    void                                                          setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset);
+
+    NS::UInteger                                                  maxMotionTransformCount() const;
+    void                                                          setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount);
+
+    class Buffer*                                                 motionTransformCountBuffer() const;
+    void                                                          setMotionTransformCountBuffer(const class Buffer* motionTransformCountBuffer);
+
+    NS::UInteger                                                  motionTransformCountBufferOffset() const;
+    void                                                          setMotionTransformCountBufferOffset(NS::UInteger motionTransformCountBufferOffset);
+
+    static MTL::IndirectInstanceAccelerationStructureDescriptor*  descriptor();
+};
+
+class AccelerationStructure : public NS::Referencing<AccelerationStructure, Resource>
+{
+public:
+    NS::UInteger    size() const;
+
+    MTL::ResourceID gpuResourceID() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureDescriptor* MTL::AccelerationStructureDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureDescriptor* MTL::AccelerationStructureDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureDescriptor>();
+}
+
+// property: usage
+_MTL_INLINE MTL::AccelerationStructureUsage MTL::AccelerationStructureDescriptor::usage() const
+{
+    return Object::sendMessage<MTL::AccelerationStructureUsage>(this, _MTL_PRIVATE_SEL(usage));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureDescriptor::setUsage(MTL::AccelerationStructureUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setUsage_), usage);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureGeometryDescriptor* MTL::AccelerationStructureGeometryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureGeometryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureGeometryDescriptor* MTL::AccelerationStructureGeometryDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureGeometryDescriptor>();
+}
+
+// property: intersectionFunctionTableOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::intersectionFunctionTableOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(intersectionFunctionTableOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTableOffset_), intersectionFunctionTableOffset);
+}
+
+// property: opaque
+_MTL_INLINE bool MTL::AccelerationStructureGeometryDescriptor::opaque() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(opaque));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setOpaque(bool opaque)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaque_), opaque);
+}
+
+// property: allowDuplicateIntersectionFunctionInvocation
+_MTL_INLINE bool MTL::AccelerationStructureGeometryDescriptor::allowDuplicateIntersectionFunctionInvocation() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(allowDuplicateIntersectionFunctionInvocation));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAllowDuplicateIntersectionFunctionInvocation_), allowDuplicateIntersectionFunctionInvocation);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::AccelerationStructureGeometryDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: primitiveDataBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureGeometryDescriptor::primitiveDataBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(primitiveDataBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataBuffer(const MTL::Buffer* primitiveDataBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataBuffer_), primitiveDataBuffer);
+}
+
+// property: primitiveDataBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataBufferOffset(NS::UInteger primitiveDataBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataBufferOffset_), primitiveDataBufferOffset);
+}
+
+// property: primitiveDataStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataStride(NS::UInteger primitiveDataStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataStride_), primitiveDataStride);
+}
+
+// property: primitiveDataElementSize
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataElementSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataElementSize));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataElementSize_), primitiveDataElementSize);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::PrimitiveAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLPrimitiveAccelerationStructureDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::init()
+{
+    return NS::Object::init<MTL::PrimitiveAccelerationStructureDescriptor>();
+}
+
+// property: geometryDescriptors
+_MTL_INLINE NS::Array* MTL::PrimitiveAccelerationStructureDescriptor::geometryDescriptors() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(geometryDescriptors));
+}
+
+_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setGeometryDescriptors(const NS::Array* geometryDescriptors)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setGeometryDescriptors_), geometryDescriptors);
+}
+
+// property: motionStartBorderMode
+_MTL_INLINE MTL::MotionBorderMode MTL::PrimitiveAccelerationStructureDescriptor::motionStartBorderMode() const
+{
+    return Object::sendMessage<MTL::MotionBorderMode>(this, _MTL_PRIVATE_SEL(motionStartBorderMode));
+}
+
+_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionStartBorderMode_), motionStartBorderMode);
+}
+
+// property: motionEndBorderMode
+_MTL_INLINE MTL::MotionBorderMode MTL::PrimitiveAccelerationStructureDescriptor::motionEndBorderMode() const
+{
+    return Object::sendMessage<MTL::MotionBorderMode>(this, _MTL_PRIVATE_SEL(motionEndBorderMode));
+}
+
+_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionEndBorderMode_), motionEndBorderMode);
+}
+
+// property: motionStartTime
+_MTL_INLINE float MTL::PrimitiveAccelerationStructureDescriptor::motionStartTime() const
+{
+    return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(motionStartTime));
+}
+
+_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionStartTime(float motionStartTime)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionStartTime_), motionStartTime);
+}
+
+// property: motionEndTime
+_MTL_INLINE float MTL::PrimitiveAccelerationStructureDescriptor::motionEndTime() const
+{
+    return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(motionEndTime));
+}
+
+_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionEndTime(float motionEndTime)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionEndTime_), motionEndTime);
+}
+
+// property: motionKeyframeCount
+_MTL_INLINE NS::UInteger MTL::PrimitiveAccelerationStructureDescriptor::motionKeyframeCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionKeyframeCount));
+}
+
+_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionKeyframeCount(NS::UInteger motionKeyframeCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionKeyframeCount_), motionKeyframeCount);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::PrimitiveAccelerationStructureDescriptor*>(_MTL_PRIVATE_CLS(MTLPrimitiveAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureTriangleGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureTriangleGeometryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureTriangleGeometryDescriptor>();
+}
+
+// property: vertexBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::vertexBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(vertexBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexBuffer(const MTL::Buffer* vertexBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_), vertexBuffer);
+}
+
+// property: vertexBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::vertexBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexBufferOffset(NS::UInteger vertexBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_), vertexBufferOffset);
+}
+
+// property: vertexFormat
+_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureTriangleGeometryDescriptor::vertexFormat() const
+{
+    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(vertexFormat));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat);
+}
+
+// property: vertexStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::vertexStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride);
+}
+
+// property: indexBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::indexBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
+}
+
+// property: indexBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::indexBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
+}
+
+// property: indexType
+_MTL_INLINE MTL::IndexType MTL::AccelerationStructureTriangleGeometryDescriptor::indexType() const
+{
+    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
+}
+
+// property: triangleCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::triangleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(triangleCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount);
+}
+
+// property: transformationMatrixBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer);
+}
+
+// property: transformationMatrixBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(transformationMatrixBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBufferOffset_), transformationMatrixBufferOffset);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::AccelerationStructureTriangleGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureTriangleGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureBoundingBoxGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureBoundingBoxGeometryDescriptor>();
+}
+
+// property: boundingBoxBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(boundingBoxBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBuffer(const MTL::Buffer* boundingBoxBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffer_), boundingBoxBuffer);
+}
+
+// property: boundingBoxBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBufferOffset(NS::UInteger boundingBoxBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBufferOffset_), boundingBoxBufferOffset);
+}
+
+// property: boundingBoxStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride);
+}
+
+// property: boundingBoxCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::AccelerationStructureBoundingBoxGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::alloc()
+{
+    return NS::Object::alloc<MTL::MotionKeyframeData>(_MTL_PRIVATE_CLS(MTLMotionKeyframeData));
+}
+
+// method: init
+_MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::init()
+{
+    return NS::Object::init<MTL::MotionKeyframeData>();
+}
+
+// property: buffer
+_MTL_INLINE MTL::Buffer* MTL::MotionKeyframeData::buffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(buffer));
+}
+
+_MTL_INLINE void MTL::MotionKeyframeData::setBuffer(const MTL::Buffer* buffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_), buffer);
+}
+
+// property: offset
+_MTL_INLINE NS::UInteger MTL::MotionKeyframeData::offset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(offset));
+}
+
+_MTL_INLINE void MTL::MotionKeyframeData::setOffset(NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOffset_), offset);
+}
+
+// static method: data
+_MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::data()
+{
+    return Object::sendMessage<MTL::MotionKeyframeData*>(_MTL_PRIVATE_CLS(MTLMotionKeyframeData), _MTL_PRIVATE_SEL(data));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureMotionTriangleGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureMotionTriangleGeometryDescriptor>();
+}
+
+// property: vertexBuffers
+_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexBuffers() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexBuffers));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexBuffers(const NS::Array* vertexBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffers_), vertexBuffers);
+}
+
+// property: vertexFormat
+_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexFormat() const
+{
+    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(vertexFormat));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat);
+}
+
+// property: vertexStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride);
+}
+
+// property: indexBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
+}
+
+// property: indexBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
+}
+
+// property: indexType
+_MTL_INLINE MTL::IndexType MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexType() const
+{
+    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
+}
+
+// property: triangleCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::triangleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(triangleCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount);
+}
+
+// property: transformationMatrixBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer);
+}
+
+// property: transformationMatrixBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(transformationMatrixBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBufferOffset_), transformationMatrixBufferOffset);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::AccelerationStructureMotionTriangleGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor>();
+}
+
+// property: boundingBoxBuffers
+_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxBuffers() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(boundingBoxBuffers));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxBuffers(const NS::Array* boundingBoxBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffers_), boundingBoxBuffers);
+}
+
+// property: boundingBoxStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride);
+}
+
+// property: boundingBoxCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureCurveGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureCurveGeometryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureCurveGeometryDescriptor>();
+}
+
+// property: controlPointBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::controlPointBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(controlPointBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointBuffer(const MTL::Buffer* controlPointBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBuffer_), controlPointBuffer);
+}
+
+// property: controlPointBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointBufferOffset(NS::UInteger controlPointBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBufferOffset_), controlPointBufferOffset);
+}
+
+// property: controlPointCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount);
+}
+
+// property: controlPointStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride);
+}
+
+// property: controlPointFormat
+_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureCurveGeometryDescriptor::controlPointFormat() const
+{
+    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(controlPointFormat));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat);
+}
+
+// property: radiusBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::radiusBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(radiusBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusBuffer(const MTL::Buffer* radiusBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBuffer_), radiusBuffer);
+}
+
+// property: radiusBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::radiusBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusBufferOffset(NS::UInteger radiusBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBufferOffset_), radiusBufferOffset);
+}
+
+// property: radiusFormat
+_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureCurveGeometryDescriptor::radiusFormat() const
+{
+    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(radiusFormat));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat);
+}
+
+// property: radiusStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::radiusStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride);
+}
+
+// property: indexBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::indexBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
+}
+
+// property: indexBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::indexBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
+}
+
+// property: indexType
+_MTL_INLINE MTL::IndexType MTL::AccelerationStructureCurveGeometryDescriptor::indexType() const
+{
+    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
+}
+
+// property: segmentCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::segmentCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount);
+}
+
+// property: segmentControlPointCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::segmentControlPointCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentControlPointCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount);
+}
+
+// property: curveType
+_MTL_INLINE MTL::CurveType MTL::AccelerationStructureCurveGeometryDescriptor::curveType() const
+{
+    return Object::sendMessage<MTL::CurveType>(this, _MTL_PRIVATE_SEL(curveType));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveType_), curveType);
+}
+
+// property: curveBasis
+_MTL_INLINE MTL::CurveBasis MTL::AccelerationStructureCurveGeometryDescriptor::curveBasis() const
+{
+    return Object::sendMessage<MTL::CurveBasis>(this, _MTL_PRIVATE_SEL(curveBasis));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis);
+}
+
+// property: curveEndCaps
+_MTL_INLINE MTL::CurveEndCaps MTL::AccelerationStructureCurveGeometryDescriptor::curveEndCaps() const
+{
+    return Object::sendMessage<MTL::CurveEndCaps>(this, _MTL_PRIVATE_SEL(curveEndCaps));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::AccelerationStructureCurveGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureCurveGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructureMotionCurveGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructureMotionCurveGeometryDescriptor>();
+}
+
+// property: controlPointBuffers
+_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointBuffers() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(controlPointBuffers));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointBuffers(const NS::Array* controlPointBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBuffers_), controlPointBuffers);
+}
+
+// property: controlPointCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount);
+}
+
+// property: controlPointStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride);
+}
+
+// property: controlPointFormat
+_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointFormat() const
+{
+    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(controlPointFormat));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat);
+}
+
+// property: radiusBuffers
+_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusBuffers() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(radiusBuffers));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusBuffers(const NS::Array* radiusBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBuffers_), radiusBuffers);
+}
+
+// property: radiusFormat
+_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusFormat() const
+{
+    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(radiusFormat));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat);
+}
+
+// property: radiusStride
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusStride));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride);
+}
+
+// property: indexBuffer
+_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
+}
+
+// property: indexBufferOffset
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
+}
+
+// property: indexType
+_MTL_INLINE MTL::IndexType MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexType() const
+{
+    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
+}
+
+// property: segmentCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::segmentCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount);
+}
+
+// property: segmentControlPointCount
+_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::segmentControlPointCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentControlPointCount));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount);
+}
+
+// property: curveType
+_MTL_INLINE MTL::CurveType MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveType() const
+{
+    return Object::sendMessage<MTL::CurveType>(this, _MTL_PRIVATE_SEL(curveType));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveType_), curveType);
+}
+
+// property: curveBasis
+_MTL_INLINE MTL::CurveBasis MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveBasis() const
+{
+    return Object::sendMessage<MTL::CurveBasis>(this, _MTL_PRIVATE_SEL(curveBasis));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis);
+}
+
+// property: curveEndCaps
+_MTL_INLINE MTL::CurveEndCaps MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveEndCaps() const
+{
+    return Object::sendMessage<MTL::CurveEndCaps>(this, _MTL_PRIVATE_SEL(curveEndCaps));
+}
+
+_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::AccelerationStructureMotionCurveGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::InstanceAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLInstanceAccelerationStructureDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::init()
+{
+    return NS::Object::init<MTL::InstanceAccelerationStructureDescriptor>();
+}
+
+// property: instanceDescriptorBuffer
+_MTL_INLINE MTL::Buffer* MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer);
+}
+
+// property: instanceDescriptorBufferOffset
+_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorBufferOffset));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBufferOffset_), instanceDescriptorBufferOffset);
+}
+
+// property: instanceDescriptorStride
+_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorStride));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride);
+}
+
+// property: instanceCount
+_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceCount));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceCount(NS::UInteger instanceCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCount_), instanceCount);
+}
+
+// property: instancedAccelerationStructures
+_MTL_INLINE NS::Array* MTL::InstanceAccelerationStructureDescriptor::instancedAccelerationStructures() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(instancedAccelerationStructures));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstancedAccelerationStructures(const NS::Array* instancedAccelerationStructures)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstancedAccelerationStructures_), instancedAccelerationStructures);
+}
+
+// property: instanceDescriptorType
+_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorType() const
+{
+    return Object::sendMessage<MTL::AccelerationStructureInstanceDescriptorType>(this, _MTL_PRIVATE_SEL(instanceDescriptorType));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType);
+}
+
+// property: motionTransformBuffer
+_MTL_INLINE MTL::Buffer* MTL::InstanceAccelerationStructureDescriptor::motionTransformBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(motionTransformBuffer));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer);
+}
+
+// property: motionTransformBufferOffset
+_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformBufferOffset));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBufferOffset_), motionTransformBufferOffset);
+}
+
+// property: motionTransformCount
+_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformCount));
+}
+
+_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformCount(NS::UInteger motionTransformCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCount_), motionTransformCount);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::InstanceAccelerationStructureDescriptor*>(_MTL_PRIVATE_CLS(MTLInstanceAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::IndirectInstanceAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLIndirectInstanceAccelerationStructureDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::init()
+{
+    return NS::Object::init<MTL::IndirectInstanceAccelerationStructureDescriptor>();
+}
+
+// property: instanceDescriptorBuffer
+_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer);
+}
+
+// property: instanceDescriptorBufferOffset
+_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorBufferOffset));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBufferOffset_), instanceDescriptorBufferOffset);
+}
+
+// property: instanceDescriptorStride
+_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorStride));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride);
+}
+
+// property: maxInstanceCount
+_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::maxInstanceCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxInstanceCount));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMaxInstanceCount(NS::UInteger maxInstanceCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxInstanceCount_), maxInstanceCount);
+}
+
+// property: instanceCountBuffer
+_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::instanceCountBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(instanceCountBuffer));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBuffer(const MTL::Buffer* instanceCountBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCountBuffer_), instanceCountBuffer);
+}
+
+// property: instanceCountBufferOffset
+_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceCountBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceCountBufferOffset));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBufferOffset(NS::UInteger instanceCountBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCountBufferOffset_), instanceCountBufferOffset);
+}
+
+// property: instanceDescriptorType
+_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorType() const
+{
+    return Object::sendMessage<MTL::AccelerationStructureInstanceDescriptorType>(this, _MTL_PRIVATE_SEL(instanceDescriptorType));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType);
+}
+
+// property: motionTransformBuffer
+_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(motionTransformBuffer));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer);
+}
+
+// property: motionTransformBufferOffset
+_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformBufferOffset));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBufferOffset_), motionTransformBufferOffset);
+}
+
+// property: maxMotionTransformCount
+_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::maxMotionTransformCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxMotionTransformCount));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxMotionTransformCount_), maxMotionTransformCount);
+}
+
+// property: motionTransformCountBuffer
+_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(motionTransformCountBuffer));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBuffer(const MTL::Buffer* motionTransformCountBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCountBuffer_), motionTransformCountBuffer);
+}
+
+// property: motionTransformCountBufferOffset
+_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformCountBufferOffset));
+}
+
+_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBufferOffset(NS::UInteger motionTransformCountBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCountBufferOffset_), motionTransformCountBufferOffset);
+}
+
+// static method: descriptor
+_MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::descriptor()
+{
+    return Object::sendMessage<MTL::IndirectInstanceAccelerationStructureDescriptor*>(_MTL_PRIVATE_CLS(MTLIndirectInstanceAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor));
+}
+
+// property: size
+_MTL_INLINE NS::UInteger MTL::AccelerationStructure::size() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::AccelerationStructure::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e0b4ccd97b406df169bff50b56b7d1af4b7d57a1
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp
@@ -0,0 +1,290 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLAccelerationStructureCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLAccelerationStructureCommandEncoder.hpp"
+#include "MTLArgument.hpp"
+#include "MTLCommandEncoder.hpp"
+
+namespace MTL
+{
+_MTL_OPTIONS(NS::UInteger, AccelerationStructureRefitOptions) {
+    AccelerationStructureRefitOptionVertexData = 1,
+    AccelerationStructureRefitOptionPerPrimitiveData = 2,
+};
+
+class AccelerationStructureCommandEncoder : public NS::Referencing<AccelerationStructureCommandEncoder, CommandEncoder>
+{
+public:
+    void buildAccelerationStructure(const class AccelerationStructure* accelerationStructure, const class AccelerationStructureDescriptor* descriptor, const class Buffer* scratchBuffer, NS::UInteger scratchBufferOffset);
+
+    void refitAccelerationStructure(const class AccelerationStructure* sourceAccelerationStructure, const class AccelerationStructureDescriptor* descriptor, const class AccelerationStructure* destinationAccelerationStructure, const class Buffer* scratchBuffer, NS::UInteger scratchBufferOffset);
+
+    void refitAccelerationStructure(const class AccelerationStructure* sourceAccelerationStructure, const class AccelerationStructureDescriptor* descriptor, const class AccelerationStructure* destinationAccelerationStructure, const class Buffer* scratchBuffer, NS::UInteger scratchBufferOffset, MTL::AccelerationStructureRefitOptions options);
+
+    void copyAccelerationStructure(const class AccelerationStructure* sourceAccelerationStructure, const class AccelerationStructure* destinationAccelerationStructure);
+
+    void writeCompactedAccelerationStructureSize(const class AccelerationStructure* accelerationStructure, const class Buffer* buffer, NS::UInteger offset);
+
+    void writeCompactedAccelerationStructureSize(const class AccelerationStructure* accelerationStructure, const class Buffer* buffer, NS::UInteger offset, MTL::DataType sizeDataType);
+
+    void copyAndCompactAccelerationStructure(const class AccelerationStructure* sourceAccelerationStructure, const class AccelerationStructure* destinationAccelerationStructure);
+
+    void updateFence(const class Fence* fence);
+
+    void waitForFence(const class Fence* fence);
+
+    void useResource(const class Resource* resource, MTL::ResourceUsage usage);
+
+    void useResources(const class Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage);
+
+    void useHeap(const class Heap* heap);
+
+    void useHeaps(const class Heap* const heaps[], NS::UInteger count);
+
+    void sampleCountersInBuffer(const class CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
+};
+
+class AccelerationStructurePassSampleBufferAttachmentDescriptor : public NS::Copying<AccelerationStructurePassSampleBufferAttachmentDescriptor>
+{
+public:
+    static class AccelerationStructurePassSampleBufferAttachmentDescriptor* alloc();
+
+    class AccelerationStructurePassSampleBufferAttachmentDescriptor*        init();
+
+    class CounterSampleBuffer*                                              sampleBuffer() const;
+    void                                                                    setSampleBuffer(const class CounterSampleBuffer* sampleBuffer);
+
+    NS::UInteger                                                            startOfEncoderSampleIndex() const;
+    void                                                                    setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex);
+
+    NS::UInteger                                                            endOfEncoderSampleIndex() const;
+    void                                                                    setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex);
+};
+
+class AccelerationStructurePassSampleBufferAttachmentDescriptorArray : public NS::Referencing<AccelerationStructurePassSampleBufferAttachmentDescriptorArray>
+{
+public:
+    static class AccelerationStructurePassSampleBufferAttachmentDescriptorArray* alloc();
+
+    class AccelerationStructurePassSampleBufferAttachmentDescriptorArray*        init();
+
+    class AccelerationStructurePassSampleBufferAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                                         setObject(const class AccelerationStructurePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class AccelerationStructurePassDescriptor : public NS::Copying<AccelerationStructurePassDescriptor>
+{
+public:
+    static class AccelerationStructurePassDescriptor*                     alloc();
+
+    class AccelerationStructurePassDescriptor*                            init();
+
+    static class AccelerationStructurePassDescriptor*                     accelerationStructurePassDescriptor();
+
+    class AccelerationStructurePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
+};
+
+}
+
+// method: buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(buildAccelerationStructure_descriptor_scratchBuffer_scratchBufferOffset_), accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset);
+}
+
+// method: refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset);
+}
+
+// method: refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:options:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset, MTL::AccelerationStructureRefitOptions options)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_options_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset, options);
+}
+
+// method: copyAccelerationStructure:toAccelerationStructure:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure);
+}
+
+// method: writeCompactedAccelerationStructureSize:toBuffer:offset:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_), accelerationStructure, buffer, offset);
+}
+
+// method: writeCompactedAccelerationStructureSize:toBuffer:offset:sizeDataType:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset, MTL::DataType sizeDataType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_sizeDataType_), accelerationStructure, buffer, offset, sizeDataType);
+}
+
+// method: copyAndCompactAccelerationStructure:toAccelerationStructure:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure);
+}
+
+// method: updateFence:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::updateFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_), fence);
+}
+
+// method: waitForFence:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::waitForFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_), fence);
+}
+
+// method: useResource:usage:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage);
+}
+
+// method: useResources:count:usage:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage);
+}
+
+// method: useHeap:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useHeap(const MTL::Heap* heap)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_), heap);
+}
+
+// method: useHeaps:count:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count);
+}
+
+// method: sampleCountersInBuffer:atSampleIndex:withBarrier:
+_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor>();
+}
+
+// property: sampleBuffer
+_MTL_INLINE MTL::CounterSampleBuffer* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::sampleBuffer() const
+{
+    return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
+}
+
+_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
+}
+
+// property: startOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex);
+}
+
+// property: endOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AccelerationStructurePassDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::init()
+{
+    return NS::Object::init<MTL::AccelerationStructurePassDescriptor>();
+}
+
+// static method: accelerationStructurePassDescriptor
+_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::accelerationStructurePassDescriptor()
+{
+    return Object::sendMessage<MTL::AccelerationStructurePassDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassDescriptor), _MTL_PRIVATE_SEL(accelerationStructurePassDescriptor));
+}
+
+// property: sampleBufferAttachments
+_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassDescriptor::sampleBufferAttachments() const
+{
+    return Object::sendMessage<MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructureTypes.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructureTypes.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..146ffc207e5ea24a866973daaedce9b8d65b99e7
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLAccelerationStructureTypes.hpp
@@ -0,0 +1,169 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLAccelerationStructureTypes.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLDefines.hpp"
+#include "MTLPrivate.hpp"
+#include "MTLResource.hpp"
+#include "MTLStageInputOutputDescriptor.hpp"
+
+#include "../Foundation/NSRange.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTL
+{
+struct PackedFloat3
+{
+    PackedFloat3();
+    PackedFloat3(float x, float y, float z);
+
+    float& operator[](int idx);
+    float  operator[](int idx) const;
+
+    union
+    {
+        struct
+        {
+            float x;
+            float y;
+            float z;
+        };
+
+        float elements[3];
+    };
+} _MTL_PACKED;
+
+struct PackedFloat4x3
+{
+    PackedFloat4x3();
+    PackedFloat4x3(const PackedFloat3& col0, const PackedFloat3& col1, const PackedFloat3& col2, const PackedFloat3& col3);
+
+    PackedFloat3&       operator[](int idx);
+    const PackedFloat3& operator[](int idx) const;
+
+    PackedFloat3        columns[4];
+} _MTL_PACKED;
+
+struct AxisAlignedBoundingBox
+{
+    AxisAlignedBoundingBox();
+    AxisAlignedBoundingBox(PackedFloat3 p);
+    AxisAlignedBoundingBox(PackedFloat3 min, PackedFloat3 max);
+
+    PackedFloat3 min;
+    PackedFloat3 max;
+} _MTL_PACKED;
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::PackedFloat3::PackedFloat3()
+    : x(0.0f)
+    , y(0.0f)
+    , z(0.0f)
+{
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::PackedFloat3::PackedFloat3(float _x, float _y, float _z)
+    : x(_x)
+    , y(_y)
+    , z(_z)
+{
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE float& MTL::PackedFloat3::operator[](int idx)
+{
+    return elements[idx];
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE float MTL::PackedFloat3::operator[](int idx) const
+{
+    return elements[idx];
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::PackedFloat4x3::PackedFloat4x3()
+{
+    columns[0] = PackedFloat3(0.0f, 0.0f, 0.0f);
+    columns[1] = PackedFloat3(0.0f, 0.0f, 0.0f);
+    columns[2] = PackedFloat3(0.0f, 0.0f, 0.0f);
+    columns[3] = PackedFloat3(0.0f, 0.0f, 0.0f);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::PackedFloat4x3::PackedFloat4x3(const PackedFloat3& col0, const PackedFloat3& col1, const PackedFloat3& col2, const PackedFloat3& col3)
+{
+    columns[0] = col0;
+    columns[1] = col1;
+    columns[2] = col2;
+    columns[3] = col3;
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::PackedFloat3& MTL::PackedFloat4x3::operator[](int idx)
+{
+    return columns[idx];
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE const MTL::PackedFloat3& MTL::PackedFloat4x3::operator[](int idx) const
+{
+    return columns[idx];
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox()
+    : min(INFINITY, INFINITY, INFINITY)
+    , max(-INFINITY, -INFINITY, -INFINITY)
+{
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox(PackedFloat3 p)
+    : min(p)
+    , max(p)
+{
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox(PackedFloat3 _min, PackedFloat3 _max)
+    : min(_min)
+    , max(_max)
+{
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLArgument.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLArgument.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..29159e5a0a296efd6cbff89f6362ac5855b5d3cb
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLArgument.hpp
@@ -0,0 +1,848 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLArgument.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLArgument.hpp"
+#include "MTLTexture.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, DataType) {
+    DataTypeNone = 0,
+    DataTypeStruct = 1,
+    DataTypeArray = 2,
+    DataTypeFloat = 3,
+    DataTypeFloat2 = 4,
+    DataTypeFloat3 = 5,
+    DataTypeFloat4 = 6,
+    DataTypeFloat2x2 = 7,
+    DataTypeFloat2x3 = 8,
+    DataTypeFloat2x4 = 9,
+    DataTypeFloat3x2 = 10,
+    DataTypeFloat3x3 = 11,
+    DataTypeFloat3x4 = 12,
+    DataTypeFloat4x2 = 13,
+    DataTypeFloat4x3 = 14,
+    DataTypeFloat4x4 = 15,
+    DataTypeHalf = 16,
+    DataTypeHalf2 = 17,
+    DataTypeHalf3 = 18,
+    DataTypeHalf4 = 19,
+    DataTypeHalf2x2 = 20,
+    DataTypeHalf2x3 = 21,
+    DataTypeHalf2x4 = 22,
+    DataTypeHalf3x2 = 23,
+    DataTypeHalf3x3 = 24,
+    DataTypeHalf3x4 = 25,
+    DataTypeHalf4x2 = 26,
+    DataTypeHalf4x3 = 27,
+    DataTypeHalf4x4 = 28,
+    DataTypeInt = 29,
+    DataTypeInt2 = 30,
+    DataTypeInt3 = 31,
+    DataTypeInt4 = 32,
+    DataTypeUInt = 33,
+    DataTypeUInt2 = 34,
+    DataTypeUInt3 = 35,
+    DataTypeUInt4 = 36,
+    DataTypeShort = 37,
+    DataTypeShort2 = 38,
+    DataTypeShort3 = 39,
+    DataTypeShort4 = 40,
+    DataTypeUShort = 41,
+    DataTypeUShort2 = 42,
+    DataTypeUShort3 = 43,
+    DataTypeUShort4 = 44,
+    DataTypeChar = 45,
+    DataTypeChar2 = 46,
+    DataTypeChar3 = 47,
+    DataTypeChar4 = 48,
+    DataTypeUChar = 49,
+    DataTypeUChar2 = 50,
+    DataTypeUChar3 = 51,
+    DataTypeUChar4 = 52,
+    DataTypeBool = 53,
+    DataTypeBool2 = 54,
+    DataTypeBool3 = 55,
+    DataTypeBool4 = 56,
+    DataTypeTexture = 58,
+    DataTypeSampler = 59,
+    DataTypePointer = 60,
+    DataTypeR8Unorm = 62,
+    DataTypeR8Snorm = 63,
+    DataTypeR16Unorm = 64,
+    DataTypeR16Snorm = 65,
+    DataTypeRG8Unorm = 66,
+    DataTypeRG8Snorm = 67,
+    DataTypeRG16Unorm = 68,
+    DataTypeRG16Snorm = 69,
+    DataTypeRGBA8Unorm = 70,
+    DataTypeRGBA8Unorm_sRGB = 71,
+    DataTypeRGBA8Snorm = 72,
+    DataTypeRGBA16Unorm = 73,
+    DataTypeRGBA16Snorm = 74,
+    DataTypeRGB10A2Unorm = 75,
+    DataTypeRG11B10Float = 76,
+    DataTypeRGB9E5Float = 77,
+    DataTypeRenderPipeline = 78,
+    DataTypeComputePipeline = 79,
+    DataTypeIndirectCommandBuffer = 80,
+    DataTypeLong = 81,
+    DataTypeLong2 = 82,
+    DataTypeLong3 = 83,
+    DataTypeLong4 = 84,
+    DataTypeULong = 85,
+    DataTypeULong2 = 86,
+    DataTypeULong3 = 87,
+    DataTypeULong4 = 88,
+    DataTypeVisibleFunctionTable = 115,
+    DataTypeIntersectionFunctionTable = 116,
+    DataTypePrimitiveAccelerationStructure = 117,
+    DataTypeInstanceAccelerationStructure = 118,
+    DataTypeBFloat = 121,
+    DataTypeBFloat2 = 122,
+    DataTypeBFloat3 = 123,
+    DataTypeBFloat4 = 124,
+};
+
+_MTL_ENUM(NS::Integer, BindingType) {
+    BindingTypeBuffer = 0,
+    BindingTypeThreadgroupMemory = 1,
+    BindingTypeTexture = 2,
+    BindingTypeSampler = 3,
+    BindingTypeImageblockData = 16,
+    BindingTypeImageblock = 17,
+    BindingTypeVisibleFunctionTable = 24,
+    BindingTypePrimitiveAccelerationStructure = 25,
+    BindingTypeInstanceAccelerationStructure = 26,
+    BindingTypeIntersectionFunctionTable = 27,
+    BindingTypeObjectPayload = 34,
+};
+
+_MTL_ENUM(NS::UInteger, ArgumentType) {
+    ArgumentTypeBuffer = 0,
+    ArgumentTypeThreadgroupMemory = 1,
+    ArgumentTypeTexture = 2,
+    ArgumentTypeSampler = 3,
+    ArgumentTypeImageblockData = 16,
+    ArgumentTypeImageblock = 17,
+    ArgumentTypeVisibleFunctionTable = 24,
+    ArgumentTypePrimitiveAccelerationStructure = 25,
+    ArgumentTypeInstanceAccelerationStructure = 26,
+    ArgumentTypeIntersectionFunctionTable = 27,
+};
+
+_MTL_ENUM(NS::UInteger, BindingAccess) {
+    ArgumentAccessReadOnly = 0,
+    BindingAccessReadOnly = 0,
+    ArgumentAccessReadWrite = 1,
+    BindingAccessReadWrite = 1,
+    BindingAccessWriteOnly = 2,
+    ArgumentAccessWriteOnly = 2,
+};
+
+class Type : public NS::Referencing<Type>
+{
+public:
+    static class Type* alloc();
+
+    class Type*        init();
+
+    MTL::DataType      dataType() const;
+};
+
+class StructMember : public NS::Referencing<StructMember>
+{
+public:
+    static class StructMember*  alloc();
+
+    class StructMember*         init();
+
+    NS::String*                 name() const;
+
+    NS::UInteger                offset() const;
+
+    MTL::DataType               dataType() const;
+
+    class StructType*           structType();
+
+    class ArrayType*            arrayType();
+
+    class TextureReferenceType* textureReferenceType();
+
+    class PointerType*          pointerType();
+
+    NS::UInteger                argumentIndex() const;
+};
+
+class StructType : public NS::Referencing<StructType, Type>
+{
+public:
+    static class StructType* alloc();
+
+    class StructType*        init();
+
+    NS::Array*               members() const;
+
+    class StructMember*      memberByName(const NS::String* name);
+};
+
+class ArrayType : public NS::Referencing<ArrayType, Type>
+{
+public:
+    static class ArrayType*     alloc();
+
+    class ArrayType*            init();
+
+    MTL::DataType               elementType() const;
+
+    NS::UInteger                arrayLength() const;
+
+    NS::UInteger                stride() const;
+
+    NS::UInteger                argumentIndexStride() const;
+
+    class StructType*           elementStructType();
+
+    class ArrayType*            elementArrayType();
+
+    class TextureReferenceType* elementTextureReferenceType();
+
+    class PointerType*          elementPointerType();
+};
+
+class PointerType : public NS::Referencing<PointerType, Type>
+{
+public:
+    static class PointerType* alloc();
+
+    class PointerType*        init();
+
+    MTL::DataType             elementType() const;
+
+    MTL::BindingAccess        access() const;
+
+    NS::UInteger              alignment() const;
+
+    NS::UInteger              dataSize() const;
+
+    bool                      elementIsArgumentBuffer() const;
+
+    class StructType*         elementStructType();
+
+    class ArrayType*          elementArrayType();
+};
+
+class TextureReferenceType : public NS::Referencing<TextureReferenceType, Type>
+{
+public:
+    static class TextureReferenceType* alloc();
+
+    class TextureReferenceType*        init();
+
+    MTL::DataType                      textureDataType() const;
+
+    MTL::TextureType                   textureType() const;
+
+    MTL::BindingAccess                 access() const;
+
+    bool                               isDepthTexture() const;
+};
+
+class Argument : public NS::Referencing<Argument>
+{
+public:
+    static class Argument* alloc();
+
+    class Argument*        init();
+
+    NS::String*            name() const;
+
+    MTL::ArgumentType      type() const;
+
+    MTL::BindingAccess     access() const;
+
+    NS::UInteger           index() const;
+
+    bool                   active() const;
+
+    NS::UInteger           bufferAlignment() const;
+
+    NS::UInteger           bufferDataSize() const;
+
+    MTL::DataType          bufferDataType() const;
+
+    class StructType*      bufferStructType() const;
+
+    class PointerType*     bufferPointerType() const;
+
+    NS::UInteger           threadgroupMemoryAlignment() const;
+
+    NS::UInteger           threadgroupMemoryDataSize() const;
+
+    MTL::TextureType       textureType() const;
+
+    MTL::DataType          textureDataType() const;
+
+    bool                   isDepthTexture() const;
+
+    NS::UInteger           arrayLength() const;
+};
+
+class Binding : public NS::Referencing<Binding>
+{
+public:
+    NS::String*        name() const;
+
+    MTL::BindingType   type() const;
+
+    MTL::BindingAccess access() const;
+
+    NS::UInteger       index() const;
+
+    bool               used() const;
+
+    bool               argument() const;
+};
+
+class BufferBinding : public NS::Referencing<BufferBinding, Binding>
+{
+public:
+    NS::UInteger       bufferAlignment() const;
+
+    NS::UInteger       bufferDataSize() const;
+
+    MTL::DataType      bufferDataType() const;
+
+    class StructType*  bufferStructType() const;
+
+    class PointerType* bufferPointerType() const;
+};
+
+class ThreadgroupBinding : public NS::Referencing<ThreadgroupBinding, Binding>
+{
+public:
+    NS::UInteger threadgroupMemoryAlignment() const;
+
+    NS::UInteger threadgroupMemoryDataSize() const;
+};
+
+class TextureBinding : public NS::Referencing<TextureBinding, Binding>
+{
+public:
+    MTL::TextureType textureType() const;
+
+    MTL::DataType    textureDataType() const;
+
+    bool             depthTexture() const;
+
+    NS::UInteger     arrayLength() const;
+};
+
+class ObjectPayloadBinding : public NS::Referencing<ObjectPayloadBinding, Binding>
+{
+public:
+    NS::UInteger objectPayloadAlignment() const;
+
+    NS::UInteger objectPayloadDataSize() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::Type* MTL::Type::alloc()
+{
+    return NS::Object::alloc<MTL::Type>(_MTL_PRIVATE_CLS(MTLType));
+}
+
+// method: init
+_MTL_INLINE MTL::Type* MTL::Type::init()
+{
+    return NS::Object::init<MTL::Type>();
+}
+
+// property: dataType
+_MTL_INLINE MTL::DataType MTL::Type::dataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(dataType));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::StructMember* MTL::StructMember::alloc()
+{
+    return NS::Object::alloc<MTL::StructMember>(_MTL_PRIVATE_CLS(MTLStructMember));
+}
+
+// method: init
+_MTL_INLINE MTL::StructMember* MTL::StructMember::init()
+{
+    return NS::Object::init<MTL::StructMember>();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::StructMember::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: offset
+_MTL_INLINE NS::UInteger MTL::StructMember::offset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(offset));
+}
+
+// property: dataType
+_MTL_INLINE MTL::DataType MTL::StructMember::dataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(dataType));
+}
+
+// method: structType
+_MTL_INLINE MTL::StructType* MTL::StructMember::structType()
+{
+    return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(structType));
+}
+
+// method: arrayType
+_MTL_INLINE MTL::ArrayType* MTL::StructMember::arrayType()
+{
+    return Object::sendMessage<MTL::ArrayType*>(this, _MTL_PRIVATE_SEL(arrayType));
+}
+
+// method: textureReferenceType
+_MTL_INLINE MTL::TextureReferenceType* MTL::StructMember::textureReferenceType()
+{
+    return Object::sendMessage<MTL::TextureReferenceType*>(this, _MTL_PRIVATE_SEL(textureReferenceType));
+}
+
+// method: pointerType
+_MTL_INLINE MTL::PointerType* MTL::StructMember::pointerType()
+{
+    return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(pointerType));
+}
+
+// property: argumentIndex
+_MTL_INLINE NS::UInteger MTL::StructMember::argumentIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(argumentIndex));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::StructType* MTL::StructType::alloc()
+{
+    return NS::Object::alloc<MTL::StructType>(_MTL_PRIVATE_CLS(MTLStructType));
+}
+
+// method: init
+_MTL_INLINE MTL::StructType* MTL::StructType::init()
+{
+    return NS::Object::init<MTL::StructType>();
+}
+
+// property: members
+_MTL_INLINE NS::Array* MTL::StructType::members() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(members));
+}
+
+// method: memberByName:
+_MTL_INLINE MTL::StructMember* MTL::StructType::memberByName(const NS::String* name)
+{
+    return Object::sendMessage<MTL::StructMember*>(this, _MTL_PRIVATE_SEL(memberByName_), name);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ArrayType* MTL::ArrayType::alloc()
+{
+    return NS::Object::alloc<MTL::ArrayType>(_MTL_PRIVATE_CLS(MTLArrayType));
+}
+
+// method: init
+_MTL_INLINE MTL::ArrayType* MTL::ArrayType::init()
+{
+    return NS::Object::init<MTL::ArrayType>();
+}
+
+// property: elementType
+_MTL_INLINE MTL::DataType MTL::ArrayType::elementType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(elementType));
+}
+
+// property: arrayLength
+_MTL_INLINE NS::UInteger MTL::ArrayType::arrayLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
+}
+
+// property: stride
+_MTL_INLINE NS::UInteger MTL::ArrayType::stride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(stride));
+}
+
+// property: argumentIndexStride
+_MTL_INLINE NS::UInteger MTL::ArrayType::argumentIndexStride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(argumentIndexStride));
+}
+
+// method: elementStructType
+_MTL_INLINE MTL::StructType* MTL::ArrayType::elementStructType()
+{
+    return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(elementStructType));
+}
+
+// method: elementArrayType
+_MTL_INLINE MTL::ArrayType* MTL::ArrayType::elementArrayType()
+{
+    return Object::sendMessage<MTL::ArrayType*>(this, _MTL_PRIVATE_SEL(elementArrayType));
+}
+
+// method: elementTextureReferenceType
+_MTL_INLINE MTL::TextureReferenceType* MTL::ArrayType::elementTextureReferenceType()
+{
+    return Object::sendMessage<MTL::TextureReferenceType*>(this, _MTL_PRIVATE_SEL(elementTextureReferenceType));
+}
+
+// method: elementPointerType
+_MTL_INLINE MTL::PointerType* MTL::ArrayType::elementPointerType()
+{
+    return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(elementPointerType));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::PointerType* MTL::PointerType::alloc()
+{
+    return NS::Object::alloc<MTL::PointerType>(_MTL_PRIVATE_CLS(MTLPointerType));
+}
+
+// method: init
+_MTL_INLINE MTL::PointerType* MTL::PointerType::init()
+{
+    return NS::Object::init<MTL::PointerType>();
+}
+
+// property: elementType
+_MTL_INLINE MTL::DataType MTL::PointerType::elementType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(elementType));
+}
+
+// property: access
+_MTL_INLINE MTL::BindingAccess MTL::PointerType::access() const
+{
+    return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
+}
+
+// property: alignment
+_MTL_INLINE NS::UInteger MTL::PointerType::alignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(alignment));
+}
+
+// property: dataSize
+_MTL_INLINE NS::UInteger MTL::PointerType::dataSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(dataSize));
+}
+
+// property: elementIsArgumentBuffer
+_MTL_INLINE bool MTL::PointerType::elementIsArgumentBuffer() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(elementIsArgumentBuffer));
+}
+
+// method: elementStructType
+_MTL_INLINE MTL::StructType* MTL::PointerType::elementStructType()
+{
+    return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(elementStructType));
+}
+
+// method: elementArrayType
+_MTL_INLINE MTL::ArrayType* MTL::PointerType::elementArrayType()
+{
+    return Object::sendMessage<MTL::ArrayType*>(this, _MTL_PRIVATE_SEL(elementArrayType));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::TextureReferenceType* MTL::TextureReferenceType::alloc()
+{
+    return NS::Object::alloc<MTL::TextureReferenceType>(_MTL_PRIVATE_CLS(MTLTextureReferenceType));
+}
+
+// method: init
+_MTL_INLINE MTL::TextureReferenceType* MTL::TextureReferenceType::init()
+{
+    return NS::Object::init<MTL::TextureReferenceType>();
+}
+
+// property: textureDataType
+_MTL_INLINE MTL::DataType MTL::TextureReferenceType::textureDataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(textureDataType));
+}
+
+// property: textureType
+_MTL_INLINE MTL::TextureType MTL::TextureReferenceType::textureType() const
+{
+    return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
+}
+
+// property: access
+_MTL_INLINE MTL::BindingAccess MTL::TextureReferenceType::access() const
+{
+    return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
+}
+
+// property: isDepthTexture
+_MTL_INLINE bool MTL::TextureReferenceType::isDepthTexture() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthTexture));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::Argument* MTL::Argument::alloc()
+{
+    return NS::Object::alloc<MTL::Argument>(_MTL_PRIVATE_CLS(MTLArgument));
+}
+
+// method: init
+_MTL_INLINE MTL::Argument* MTL::Argument::init()
+{
+    return NS::Object::init<MTL::Argument>();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::Argument::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: type
+_MTL_INLINE MTL::ArgumentType MTL::Argument::type() const
+{
+    return Object::sendMessage<MTL::ArgumentType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+// property: access
+_MTL_INLINE MTL::BindingAccess MTL::Argument::access() const
+{
+    return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
+}
+
+// property: index
+_MTL_INLINE NS::UInteger MTL::Argument::index() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(index));
+}
+
+// property: active
+_MTL_INLINE bool MTL::Argument::active() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
+}
+
+// property: bufferAlignment
+_MTL_INLINE NS::UInteger MTL::Argument::bufferAlignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferAlignment));
+}
+
+// property: bufferDataSize
+_MTL_INLINE NS::UInteger MTL::Argument::bufferDataSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferDataSize));
+}
+
+// property: bufferDataType
+_MTL_INLINE MTL::DataType MTL::Argument::bufferDataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(bufferDataType));
+}
+
+// property: bufferStructType
+_MTL_INLINE MTL::StructType* MTL::Argument::bufferStructType() const
+{
+    return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(bufferStructType));
+}
+
+// property: bufferPointerType
+_MTL_INLINE MTL::PointerType* MTL::Argument::bufferPointerType() const
+{
+    return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(bufferPointerType));
+}
+
+// property: threadgroupMemoryAlignment
+_MTL_INLINE NS::UInteger MTL::Argument::threadgroupMemoryAlignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryAlignment));
+}
+
+// property: threadgroupMemoryDataSize
+_MTL_INLINE NS::UInteger MTL::Argument::threadgroupMemoryDataSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryDataSize));
+}
+
+// property: textureType
+_MTL_INLINE MTL::TextureType MTL::Argument::textureType() const
+{
+    return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
+}
+
+// property: textureDataType
+_MTL_INLINE MTL::DataType MTL::Argument::textureDataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(textureDataType));
+}
+
+// property: isDepthTexture
+_MTL_INLINE bool MTL::Argument::isDepthTexture() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthTexture));
+}
+
+// property: arrayLength
+_MTL_INLINE NS::UInteger MTL::Argument::arrayLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::Binding::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: type
+_MTL_INLINE MTL::BindingType MTL::Binding::type() const
+{
+    return Object::sendMessage<MTL::BindingType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+// property: access
+_MTL_INLINE MTL::BindingAccess MTL::Binding::access() const
+{
+    return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
+}
+
+// property: index
+_MTL_INLINE NS::UInteger MTL::Binding::index() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(index));
+}
+
+// property: used
+_MTL_INLINE bool MTL::Binding::used() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isUsed));
+}
+
+// property: argument
+_MTL_INLINE bool MTL::Binding::argument() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isArgument));
+}
+
+// property: bufferAlignment
+_MTL_INLINE NS::UInteger MTL::BufferBinding::bufferAlignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferAlignment));
+}
+
+// property: bufferDataSize
+_MTL_INLINE NS::UInteger MTL::BufferBinding::bufferDataSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferDataSize));
+}
+
+// property: bufferDataType
+_MTL_INLINE MTL::DataType MTL::BufferBinding::bufferDataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(bufferDataType));
+}
+
+// property: bufferStructType
+_MTL_INLINE MTL::StructType* MTL::BufferBinding::bufferStructType() const
+{
+    return Object::sendMessage<MTL::StructType*>(this, _MTL_PRIVATE_SEL(bufferStructType));
+}
+
+// property: bufferPointerType
+_MTL_INLINE MTL::PointerType* MTL::BufferBinding::bufferPointerType() const
+{
+    return Object::sendMessage<MTL::PointerType*>(this, _MTL_PRIVATE_SEL(bufferPointerType));
+}
+
+// property: threadgroupMemoryAlignment
+_MTL_INLINE NS::UInteger MTL::ThreadgroupBinding::threadgroupMemoryAlignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryAlignment));
+}
+
+// property: threadgroupMemoryDataSize
+_MTL_INLINE NS::UInteger MTL::ThreadgroupBinding::threadgroupMemoryDataSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryDataSize));
+}
+
+// property: textureType
+_MTL_INLINE MTL::TextureType MTL::TextureBinding::textureType() const
+{
+    return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
+}
+
+// property: textureDataType
+_MTL_INLINE MTL::DataType MTL::TextureBinding::textureDataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(textureDataType));
+}
+
+// property: depthTexture
+_MTL_INLINE bool MTL::TextureBinding::depthTexture() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthTexture));
+}
+
+// property: arrayLength
+_MTL_INLINE NS::UInteger MTL::TextureBinding::arrayLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
+}
+
+// property: objectPayloadAlignment
+_MTL_INLINE NS::UInteger MTL::ObjectPayloadBinding::objectPayloadAlignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(objectPayloadAlignment));
+}
+
+// property: objectPayloadDataSize
+_MTL_INLINE NS::UInteger MTL::ObjectPayloadBinding::objectPayloadDataSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(objectPayloadDataSize));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLArgumentEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLArgumentEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a81859c7eba7c5508a6c7b52a47cf6bee418c2c6
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLArgumentEncoder.hpp
@@ -0,0 +1,244 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLArgumentEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+
+static const NS::UInteger AttributeStrideStatic = NS::UIntegerMax;
+
+class ArgumentEncoder : public NS::Referencing<ArgumentEncoder>
+{
+public:
+    class Device*          device() const;
+
+    NS::String*            label() const;
+    void                   setLabel(const NS::String* label);
+
+    NS::UInteger           encodedLength() const;
+
+    NS::UInteger           alignment() const;
+
+    void                   setArgumentBuffer(const class Buffer* argumentBuffer, NS::UInteger offset);
+
+    void                   setArgumentBuffer(const class Buffer* argumentBuffer, NS::UInteger startOffset, NS::UInteger arrayElement);
+
+    void                   setBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void                   setBuffers(const class Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
+
+    void                   setTexture(const class Texture* texture, NS::UInteger index);
+
+    void                   setTextures(const class Texture* const textures[], NS::Range range);
+
+    void                   setSamplerState(const class SamplerState* sampler, NS::UInteger index);
+
+    void                   setSamplerStates(const class SamplerState* const samplers[], NS::Range range);
+
+    void*                  constantData(NS::UInteger index);
+
+    void                   setRenderPipelineState(const class RenderPipelineState* pipeline, NS::UInteger index);
+
+    void                   setRenderPipelineStates(const class RenderPipelineState* const pipelines[], NS::Range range);
+
+    void                   setComputePipelineState(const class ComputePipelineState* pipeline, NS::UInteger index);
+
+    void                   setComputePipelineStates(const class ComputePipelineState* const pipelines[], NS::Range range);
+
+    void                   setIndirectCommandBuffer(const class IndirectCommandBuffer* indirectCommandBuffer, NS::UInteger index);
+
+    void                   setIndirectCommandBuffers(const class IndirectCommandBuffer* const buffers[], NS::Range range);
+
+    void                   setAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger index);
+
+    class ArgumentEncoder* newArgumentEncoder(NS::UInteger index);
+
+    void                   setVisibleFunctionTable(const class VisibleFunctionTable* visibleFunctionTable, NS::UInteger index);
+
+    void                   setVisibleFunctionTables(const class VisibleFunctionTable* const visibleFunctionTables[], NS::Range range);
+
+    void                   setIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger index);
+
+    void                   setIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
+};
+
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::ArgumentEncoder::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::ArgumentEncoder::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::ArgumentEncoder::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: encodedLength
+_MTL_INLINE NS::UInteger MTL::ArgumentEncoder::encodedLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(encodedLength));
+}
+
+// property: alignment
+_MTL_INLINE NS::UInteger MTL::ArgumentEncoder::alignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(alignment));
+}
+
+// method: setArgumentBuffer:offset:
+_MTL_INLINE void MTL::ArgumentEncoder::setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentBuffer_offset_), argumentBuffer, offset);
+}
+
+// method: setArgumentBuffer:startOffset:arrayElement:
+_MTL_INLINE void MTL::ArgumentEncoder::setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger startOffset, NS::UInteger arrayElement)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentBuffer_startOffset_arrayElement_), argumentBuffer, startOffset, arrayElement);
+}
+
+// method: setBuffer:offset:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setBuffers:offsets:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// method: setTexture:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setTexture(const MTL::Texture* texture, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), texture, index);
+}
+
+// method: setTextures:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setTextures(const MTL::Texture* const textures[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTextures_withRange_), textures, range);
+}
+
+// method: setSamplerState:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), sampler, index);
+}
+
+// method: setSamplerStates:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerStates_withRange_), samplers, range);
+}
+
+// method: constantDataAtIndex:
+_MTL_INLINE void* MTL::ArgumentEncoder::constantData(NS::UInteger index)
+{
+    return Object::sendMessage<void*>(this, _MTL_PRIVATE_SEL(constantDataAtIndex_), index);
+}
+
+// method: setRenderPipelineState:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipeline, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineState_atIndex_), pipeline, index);
+}
+
+// method: setRenderPipelineStates:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setRenderPipelineStates(const MTL::RenderPipelineState* const pipelines[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineStates_withRange_), pipelines, range);
+}
+
+// method: setComputePipelineState:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setComputePipelineState(const MTL::ComputePipelineState* pipeline, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineState_atIndex_), pipeline, index);
+}
+
+// method: setComputePipelineStates:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setComputePipelineStates(const MTL::ComputePipelineState* const pipelines[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineStates_withRange_), pipelines, range);
+}
+
+// method: setIndirectCommandBuffer:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndirectCommandBuffer_atIndex_), indirectCommandBuffer, index);
+}
+
+// method: setIndirectCommandBuffers:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setIndirectCommandBuffers(const MTL::IndirectCommandBuffer* const buffers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndirectCommandBuffers_withRange_), buffers, range);
+}
+
+// method: setAccelerationStructure:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAccelerationStructure_atIndex_), accelerationStructure, index);
+}
+
+// method: newArgumentEncoderForBufferAtIndex:
+_MTL_INLINE MTL::ArgumentEncoder* MTL::ArgumentEncoder::newArgumentEncoder(NS::UInteger index)
+{
+    return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderForBufferAtIndex_), index);
+}
+
+// method: setVisibleFunctionTable:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atIndex_), visibleFunctionTable, index);
+}
+
+// method: setVisibleFunctionTables:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withRange_), visibleFunctionTables, range);
+}
+
+// method: setIntersectionFunctionTable:atIndex:
+_MTL_INLINE void MTL::ArgumentEncoder::setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTable_atIndex_), intersectionFunctionTable, index);
+}
+
+// method: setIntersectionFunctionTables:withRange:
+_MTL_INLINE void MTL::ArgumentEncoder::setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTables_withRange_), intersectionFunctionTables, range);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBinaryArchive.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBinaryArchive.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1c77c07811efcaaf4465ae677816101e9831a477
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBinaryArchive.hpp
@@ -0,0 +1,139 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLBinaryArchive.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, BinaryArchiveError) {
+    BinaryArchiveErrorNone = 0,
+    BinaryArchiveErrorInvalidFile = 1,
+    BinaryArchiveErrorUnexpectedElement = 2,
+    BinaryArchiveErrorCompilationFailure = 3,
+    BinaryArchiveErrorInternalError = 4,
+};
+
+class BinaryArchiveDescriptor : public NS::Copying<BinaryArchiveDescriptor>
+{
+public:
+    static class BinaryArchiveDescriptor* alloc();
+
+    class BinaryArchiveDescriptor*        init();
+
+    NS::URL*                              url() const;
+    void                                  setUrl(const NS::URL* url);
+};
+
+class BinaryArchive : public NS::Referencing<BinaryArchive>
+{
+public:
+    NS::String*   label() const;
+    void          setLabel(const NS::String* label);
+
+    class Device* device() const;
+
+    bool          addComputePipelineFunctions(const class ComputePipelineDescriptor* descriptor, NS::Error** error);
+
+    bool          addRenderPipelineFunctions(const class RenderPipelineDescriptor* descriptor, NS::Error** error);
+
+    bool          addTileRenderPipelineFunctions(const class TileRenderPipelineDescriptor* descriptor, NS::Error** error);
+
+    bool          serializeToURL(const NS::URL* url, NS::Error** error);
+
+    bool          addFunction(const class FunctionDescriptor* descriptor, const class Library* library, NS::Error** error);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::BinaryArchiveDescriptor* MTL::BinaryArchiveDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::BinaryArchiveDescriptor>(_MTL_PRIVATE_CLS(MTLBinaryArchiveDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::BinaryArchiveDescriptor* MTL::BinaryArchiveDescriptor::init()
+{
+    return NS::Object::init<MTL::BinaryArchiveDescriptor>();
+}
+
+// property: url
+_MTL_INLINE NS::URL* MTL::BinaryArchiveDescriptor::url() const
+{
+    return Object::sendMessage<NS::URL*>(this, _MTL_PRIVATE_SEL(url));
+}
+
+_MTL_INLINE void MTL::BinaryArchiveDescriptor::setUrl(const NS::URL* url)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setUrl_), url);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::BinaryArchive::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::BinaryArchive::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::BinaryArchive::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// method: addComputePipelineFunctionsWithDescriptor:error:
+_MTL_INLINE bool MTL::BinaryArchive::addComputePipelineFunctions(const MTL::ComputePipelineDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addComputePipelineFunctionsWithDescriptor_error_), descriptor, error);
+}
+
+// method: addRenderPipelineFunctionsWithDescriptor:error:
+_MTL_INLINE bool MTL::BinaryArchive::addRenderPipelineFunctions(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addRenderPipelineFunctionsWithDescriptor_error_), descriptor, error);
+}
+
+// method: addTileRenderPipelineFunctionsWithDescriptor:error:
+_MTL_INLINE bool MTL::BinaryArchive::addTileRenderPipelineFunctions(const MTL::TileRenderPipelineDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addTileRenderPipelineFunctionsWithDescriptor_error_), descriptor, error);
+}
+
+// method: serializeToURL:error:
+_MTL_INLINE bool MTL::BinaryArchive::serializeToURL(const NS::URL* url, NS::Error** error)
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(serializeToURL_error_), url, error);
+}
+
+// method: addFunctionWithDescriptor:library:error:
+_MTL_INLINE bool MTL::BinaryArchive::addFunction(const MTL::FunctionDescriptor* descriptor, const MTL::Library* library, NS::Error** error)
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(addFunctionWithDescriptor_library_error_), descriptor, library, error);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBlitCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBlitCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8d4845a8214cd0bbdcd1a7cf949e6aa7506dd9ec
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBlitCommandEncoder.hpp
@@ -0,0 +1,246 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLBlitCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLBlitCommandEncoder.hpp"
+#include "MTLCommandEncoder.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_OPTIONS(NS::UInteger, BlitOption) {
+    BlitOptionNone = 0,
+    BlitOptionDepthFromDepthStencil = 1,
+    BlitOptionStencilFromDepthStencil = 2,
+    BlitOptionRowLinearPVRTC = 4,
+};
+
+class BlitCommandEncoder : public NS::Referencing<BlitCommandEncoder, CommandEncoder>
+{
+public:
+    void synchronizeResource(const class Resource* resource);
+
+    void synchronizeTexture(const class Texture* texture, NS::UInteger slice, NS::UInteger level);
+
+    void copyFromTexture(const class Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const class Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin);
+
+    void copyFromBuffer(const class Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const class Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin);
+
+    void copyFromBuffer(const class Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const class Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options);
+
+    void copyFromTexture(const class Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const class Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage);
+
+    void copyFromTexture(const class Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const class Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options);
+
+    void generateMipmaps(const class Texture* texture);
+
+    void fillBuffer(const class Buffer* buffer, NS::Range range, uint8_t value);
+
+    void copyFromTexture(const class Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const class Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount);
+
+    void copyFromTexture(const class Texture* sourceTexture, const class Texture* destinationTexture);
+
+    void copyFromBuffer(const class Buffer* sourceBuffer, NS::UInteger sourceOffset, const class Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size);
+
+    void updateFence(const class Fence* fence);
+
+    void waitForFence(const class Fence* fence);
+
+    void getTextureAccessCounters(const class Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice, bool resetCounters, const class Buffer* countersBuffer, NS::UInteger countersBufferOffset);
+
+    void resetTextureAccessCounters(const class Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice);
+
+    void optimizeContentsForGPUAccess(const class Texture* texture);
+
+    void optimizeContentsForGPUAccess(const class Texture* texture, NS::UInteger slice, NS::UInteger level);
+
+    void optimizeContentsForCPUAccess(const class Texture* texture);
+
+    void optimizeContentsForCPUAccess(const class Texture* texture, NS::UInteger slice, NS::UInteger level);
+
+    void resetCommandsInBuffer(const class IndirectCommandBuffer* buffer, NS::Range range);
+
+    void copyIndirectCommandBuffer(const class IndirectCommandBuffer* source, NS::Range sourceRange, const class IndirectCommandBuffer* destination, NS::UInteger destinationIndex);
+
+    void optimizeIndirectCommandBuffer(const class IndirectCommandBuffer* indirectCommandBuffer, NS::Range range);
+
+    void sampleCountersInBuffer(const class CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
+
+    void resolveCounters(const class CounterSampleBuffer* sampleBuffer, NS::Range range, const class Buffer* destinationBuffer, NS::UInteger destinationOffset);
+};
+
+}
+
+// method: synchronizeResource:
+_MTL_INLINE void MTL::BlitCommandEncoder::synchronizeResource(const MTL::Resource* resource)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(synchronizeResource_), resource);
+}
+
+// method: synchronizeTexture:slice:level:
+_MTL_INLINE void MTL::BlitCommandEncoder::synchronizeTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(synchronizeTexture_slice_level_), texture, slice, level);
+}
+
+// method: copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin);
+}
+
+// method: copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin);
+}
+
+// method: copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options);
+}
+
+// method: copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage);
+}
+
+// method: copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options);
+}
+
+// method: generateMipmapsForTexture:
+_MTL_INLINE void MTL::BlitCommandEncoder::generateMipmaps(const MTL::Texture* texture)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(generateMipmapsForTexture_), texture);
+}
+
+// method: fillBuffer:range:value:
+_MTL_INLINE void MTL::BlitCommandEncoder::fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(fillBuffer_range_value_), buffer, range, value);
+}
+
+// method: copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_), sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount);
+}
+
+// method: copyFromTexture:toTexture:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromTexture_toTexture_), sourceTexture, destinationTexture);
+}
+
+// method: copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_), sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size);
+}
+
+// method: updateFence:
+_MTL_INLINE void MTL::BlitCommandEncoder::updateFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_), fence);
+}
+
+// method: waitForFence:
+_MTL_INLINE void MTL::BlitCommandEncoder::waitForFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_), fence);
+}
+
+// method: getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:
+_MTL_INLINE void MTL::BlitCommandEncoder::getTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice, bool resetCounters, const MTL::Buffer* countersBuffer, NS::UInteger countersBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(getTextureAccessCounters_region_mipLevel_slice_resetCounters_countersBuffer_countersBufferOffset_), texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset);
+}
+
+// method: resetTextureAccessCounters:region:mipLevel:slice:
+_MTL_INLINE void MTL::BlitCommandEncoder::resetTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resetTextureAccessCounters_region_mipLevel_slice_), texture, region, mipLevel, slice);
+}
+
+// method: optimizeContentsForGPUAccess:
+_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_), texture);
+}
+
+// method: optimizeContentsForGPUAccess:slice:level:
+_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_slice_level_), texture, slice, level);
+}
+
+// method: optimizeContentsForCPUAccess:
+_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_), texture);
+}
+
+// method: optimizeContentsForCPUAccess:slice:level:
+_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_slice_level_), texture, slice, level);
+}
+
+// method: resetCommandsInBuffer:withRange:
+_MTL_INLINE void MTL::BlitCommandEncoder::resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resetCommandsInBuffer_withRange_), buffer, range);
+}
+
+// method: copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:
+_MTL_INLINE void MTL::BlitCommandEncoder::copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_), source, sourceRange, destination, destinationIndex);
+}
+
+// method: optimizeIndirectCommandBuffer:withRange:
+_MTL_INLINE void MTL::BlitCommandEncoder::optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(optimizeIndirectCommandBuffer_withRange_), indirectCommandBuffer, range);
+}
+
+// method: sampleCountersInBuffer:atSampleIndex:withBarrier:
+_MTL_INLINE void MTL::BlitCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
+}
+
+// method: resolveCounters:inRange:destinationBuffer:destinationOffset:
+_MTL_INLINE void MTL::BlitCommandEncoder::resolveCounters(const MTL::CounterSampleBuffer* sampleBuffer, NS::Range range, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resolveCounters_inRange_destinationBuffer_destinationOffset_), sampleBuffer, range, destinationBuffer, destinationOffset);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBlitPass.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBlitPass.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..849875259fe69764aa90d1ec9600b456f1217ec4
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBlitPass.hpp
@@ -0,0 +1,165 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLBlitPass.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+class BlitPassSampleBufferAttachmentDescriptor : public NS::Copying<BlitPassSampleBufferAttachmentDescriptor>
+{
+public:
+    static class BlitPassSampleBufferAttachmentDescriptor* alloc();
+
+    class BlitPassSampleBufferAttachmentDescriptor*        init();
+
+    class CounterSampleBuffer*                             sampleBuffer() const;
+    void                                                   setSampleBuffer(const class CounterSampleBuffer* sampleBuffer);
+
+    NS::UInteger                                           startOfEncoderSampleIndex() const;
+    void                                                   setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex);
+
+    NS::UInteger                                           endOfEncoderSampleIndex() const;
+    void                                                   setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex);
+};
+
+class BlitPassSampleBufferAttachmentDescriptorArray : public NS::Referencing<BlitPassSampleBufferAttachmentDescriptorArray>
+{
+public:
+    static class BlitPassSampleBufferAttachmentDescriptorArray* alloc();
+
+    class BlitPassSampleBufferAttachmentDescriptorArray*        init();
+
+    class BlitPassSampleBufferAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                        setObject(const class BlitPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class BlitPassDescriptor : public NS::Copying<BlitPassDescriptor>
+{
+public:
+    static class BlitPassDescriptor*                     alloc();
+
+    class BlitPassDescriptor*                            init();
+
+    static class BlitPassDescriptor*                     blitPassDescriptor();
+
+    class BlitPassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::BlitPassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLBlitPassSampleBufferAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::BlitPassSampleBufferAttachmentDescriptor>();
+}
+
+// property: sampleBuffer
+_MTL_INLINE MTL::CounterSampleBuffer* MTL::BlitPassSampleBufferAttachmentDescriptor::sampleBuffer() const
+{
+    return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
+}
+
+_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
+}
+
+// property: startOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::BlitPassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex);
+}
+
+// property: endOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::BlitPassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassSampleBufferAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::BlitPassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLBlitPassSampleBufferAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassSampleBufferAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::BlitPassSampleBufferAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::BlitPassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptorArray::setObject(const MTL::BlitPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::BlitPassDescriptor>(_MTL_PRIVATE_CLS(MTLBlitPassDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::init()
+{
+    return NS::Object::init<MTL::BlitPassDescriptor>();
+}
+
+// static method: blitPassDescriptor
+_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::blitPassDescriptor()
+{
+    return Object::sendMessage<MTL::BlitPassDescriptor*>(_MTL_PRIVATE_CLS(MTLBlitPassDescriptor), _MTL_PRIVATE_SEL(blitPassDescriptor));
+}
+
+// property: sampleBufferAttachments
+_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassDescriptor::sampleBufferAttachments() const
+{
+    return Object::sendMessage<MTL::BlitPassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBuffer.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBuffer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..684ee8e24d62e9f2c18e8a27d5cce1b32580332a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLBuffer.hpp
@@ -0,0 +1,109 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLBuffer.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLResource.hpp"
+
+namespace MTL
+{
+class Buffer : public NS::Referencing<Buffer, Resource>
+{
+public:
+    NS::UInteger   length() const;
+
+    void*          contents();
+
+    void           didModifyRange(NS::Range range);
+
+    class Texture* newTexture(const class TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow);
+
+    void           addDebugMarker(const NS::String* marker, NS::Range range);
+
+    void           removeAllDebugMarkers();
+
+    class Buffer*  remoteStorageBuffer() const;
+
+    class Buffer*  newRemoteBufferViewForDevice(const class Device* device);
+
+    uint64_t       gpuAddress() const;
+};
+
+}
+
+// property: length
+_MTL_INLINE NS::UInteger MTL::Buffer::length() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(length));
+}
+
+// method: contents
+_MTL_INLINE void* MTL::Buffer::contents()
+{
+    return Object::sendMessage<void*>(this, _MTL_PRIVATE_SEL(contents));
+}
+
+// method: didModifyRange:
+_MTL_INLINE void MTL::Buffer::didModifyRange(NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(didModifyRange_), range);
+}
+
+// method: newTextureWithDescriptor:offset:bytesPerRow:
+_MTL_INLINE MTL::Texture* MTL::Buffer::newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_offset_bytesPerRow_), descriptor, offset, bytesPerRow);
+}
+
+// method: addDebugMarker:range:
+_MTL_INLINE void MTL::Buffer::addDebugMarker(const NS::String* marker, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addDebugMarker_range_), marker, range);
+}
+
+// method: removeAllDebugMarkers
+_MTL_INLINE void MTL::Buffer::removeAllDebugMarkers()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(removeAllDebugMarkers));
+}
+
+// property: remoteStorageBuffer
+_MTL_INLINE MTL::Buffer* MTL::Buffer::remoteStorageBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(remoteStorageBuffer));
+}
+
+// method: newRemoteBufferViewForDevice:
+_MTL_INLINE MTL::Buffer* MTL::Buffer::newRemoteBufferViewForDevice(const MTL::Device* device)
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newRemoteBufferViewForDevice_), device);
+}
+
+// property: gpuAddress
+_MTL_INLINE uint64_t MTL::Buffer::gpuAddress() const
+{
+    return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(gpuAddress));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCaptureManager.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCaptureManager.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ebe7ddd2ade6fa24ec6608c636b81107fb487124
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCaptureManager.hpp
@@ -0,0 +1,220 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLCaptureManager.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLCaptureManager.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::Integer, CaptureError) {
+    CaptureErrorNotSupported = 1,
+    CaptureErrorAlreadyCapturing = 2,
+    CaptureErrorInvalidDescriptor = 3,
+};
+
+_MTL_ENUM(NS::Integer, CaptureDestination) {
+    CaptureDestinationDeveloperTools = 1,
+    CaptureDestinationGPUTraceDocument = 2,
+};
+
+class CaptureDescriptor : public NS::Copying<CaptureDescriptor>
+{
+public:
+    static class CaptureDescriptor* alloc();
+
+    class CaptureDescriptor*        init();
+
+    id                              captureObject() const;
+    void                            setCaptureObject(id captureObject);
+
+    MTL::CaptureDestination         destination() const;
+    void                            setDestination(MTL::CaptureDestination destination);
+
+    NS::URL*                        outputURL() const;
+    void                            setOutputURL(const NS::URL* outputURL);
+};
+
+class CaptureManager : public NS::Referencing<CaptureManager>
+{
+public:
+    static class CaptureManager* alloc();
+
+    static class CaptureManager* sharedCaptureManager();
+
+    MTL::CaptureManager*         init();
+
+    class CaptureScope*          newCaptureScope(const class Device* device);
+
+    class CaptureScope*          newCaptureScope(const class CommandQueue* commandQueue);
+
+    bool                         supportsDestination(MTL::CaptureDestination destination);
+
+    bool                         startCapture(const class CaptureDescriptor* descriptor, NS::Error** error);
+
+    void                         startCapture(const class Device* device);
+
+    void                         startCapture(const class CommandQueue* commandQueue);
+
+    void                         startCapture(const class CaptureScope* captureScope);
+
+    void                         stopCapture();
+
+    class CaptureScope*          defaultCaptureScope() const;
+    void                         setDefaultCaptureScope(const class CaptureScope* defaultCaptureScope);
+
+    bool                         isCapturing() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::CaptureDescriptor* MTL::CaptureDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::CaptureDescriptor>(_MTL_PRIVATE_CLS(MTLCaptureDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::CaptureDescriptor* MTL::CaptureDescriptor::init()
+{
+    return NS::Object::init<MTL::CaptureDescriptor>();
+}
+
+// property: captureObject
+_MTL_INLINE id MTL::CaptureDescriptor::captureObject() const
+{
+    return Object::sendMessage<id>(this, _MTL_PRIVATE_SEL(captureObject));
+}
+
+_MTL_INLINE void MTL::CaptureDescriptor::setCaptureObject(id captureObject)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCaptureObject_), captureObject);
+}
+
+// property: destination
+_MTL_INLINE MTL::CaptureDestination MTL::CaptureDescriptor::destination() const
+{
+    return Object::sendMessage<MTL::CaptureDestination>(this, _MTL_PRIVATE_SEL(destination));
+}
+
+_MTL_INLINE void MTL::CaptureDescriptor::setDestination(MTL::CaptureDestination destination)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestination_), destination);
+}
+
+// property: outputURL
+_MTL_INLINE NS::URL* MTL::CaptureDescriptor::outputURL() const
+{
+    return Object::sendMessage<NS::URL*>(this, _MTL_PRIVATE_SEL(outputURL));
+}
+
+_MTL_INLINE void MTL::CaptureDescriptor::setOutputURL(const NS::URL* outputURL)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOutputURL_), outputURL);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::alloc()
+{
+    return NS::Object::alloc<MTL::CaptureManager>(_MTL_PRIVATE_CLS(MTLCaptureManager));
+}
+
+// static method: sharedCaptureManager
+_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::sharedCaptureManager()
+{
+    return Object::sendMessage<MTL::CaptureManager*>(_MTL_PRIVATE_CLS(MTLCaptureManager), _MTL_PRIVATE_SEL(sharedCaptureManager));
+}
+
+// method: init
+_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::init()
+{
+    return NS::Object::init<MTL::CaptureManager>();
+}
+
+// method: newCaptureScopeWithDevice:
+_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL::Device* device)
+{
+    return Object::sendMessage<MTL::CaptureScope*>(this, _MTL_PRIVATE_SEL(newCaptureScopeWithDevice_), device);
+}
+
+// method: newCaptureScopeWithCommandQueue:
+_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL::CommandQueue* commandQueue)
+{
+    return Object::sendMessage<MTL::CaptureScope*>(this, _MTL_PRIVATE_SEL(newCaptureScopeWithCommandQueue_), commandQueue);
+}
+
+// method: supportsDestination:
+_MTL_INLINE bool MTL::CaptureManager::supportsDestination(MTL::CaptureDestination destination)
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsDestination_), destination);
+}
+
+// method: startCaptureWithDescriptor:error:
+_MTL_INLINE bool MTL::CaptureManager::startCapture(const MTL::CaptureDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(startCaptureWithDescriptor_error_), descriptor, error);
+}
+
+// method: startCaptureWithDevice:
+_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::Device* device)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(startCaptureWithDevice_), device);
+}
+
+// method: startCaptureWithCommandQueue:
+_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::CommandQueue* commandQueue)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(startCaptureWithCommandQueue_), commandQueue);
+}
+
+// method: startCaptureWithScope:
+_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::CaptureScope* captureScope)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(startCaptureWithScope_), captureScope);
+}
+
+// method: stopCapture
+_MTL_INLINE void MTL::CaptureManager::stopCapture()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(stopCapture));
+}
+
+// property: defaultCaptureScope
+_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::defaultCaptureScope() const
+{
+    return Object::sendMessage<MTL::CaptureScope*>(this, _MTL_PRIVATE_SEL(defaultCaptureScope));
+}
+
+_MTL_INLINE void MTL::CaptureManager::setDefaultCaptureScope(const MTL::CaptureScope* defaultCaptureScope)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDefaultCaptureScope_), defaultCaptureScope);
+}
+
+// property: isCapturing
+_MTL_INLINE bool MTL::CaptureManager::isCapturing() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isCapturing));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCaptureScope.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCaptureScope.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6d5d1d6fd8ae186505593698b8518f4e7ac71b25
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCaptureScope.hpp
@@ -0,0 +1,92 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLCaptureScope.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLDefines.hpp"
+#include "MTLPrivate.hpp"
+
+#include "../Foundation/NSObject.hpp"
+#include "../Foundation/NSString.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTL
+{
+class CaptureScope : public NS::Referencing<CaptureScope>
+{
+public:
+    class Device*       device() const;
+
+    NS::String*         label() const;
+    void                setLabel(const NS::String* pLabel);
+
+    class CommandQueue* commandQueue() const;
+
+    void                beginScope();
+    void                endScope();
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::Device* MTL::CaptureScope::device() const
+{
+    return Object::sendMessage<Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE NS::String* MTL::CaptureScope::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE void MTL::CaptureScope::setLabel(const NS::String* pLabel)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), pLabel);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE MTL::CommandQueue* MTL::CaptureScope::commandQueue() const
+{
+    return Object::sendMessage<CommandQueue*>(this, _MTL_PRIVATE_SEL(commandQueue));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE void MTL::CaptureScope::beginScope()
+{
+    return Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(beginScope));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTL_INLINE void MTL::CaptureScope::endScope()
+{
+    return Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(endScope));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandBuffer.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandBuffer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f8e2bfb6829d1f4d041b472bc57d1b20df417e5d
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandBuffer.hpp
@@ -0,0 +1,474 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLCommandBuffer.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLCommandBuffer.hpp"
+#include <functional>
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, CommandBufferStatus) {
+    CommandBufferStatusNotEnqueued = 0,
+    CommandBufferStatusEnqueued = 1,
+    CommandBufferStatusCommitted = 2,
+    CommandBufferStatusScheduled = 3,
+    CommandBufferStatusCompleted = 4,
+    CommandBufferStatusError = 5,
+};
+
+_MTL_ENUM(NS::UInteger, CommandBufferError) {
+    CommandBufferErrorNone = 0,
+    CommandBufferErrorInternal = 1,
+    CommandBufferErrorTimeout = 2,
+    CommandBufferErrorPageFault = 3,
+    CommandBufferErrorAccessRevoked = 4,
+    CommandBufferErrorBlacklisted = 4,
+    CommandBufferErrorNotPermitted = 7,
+    CommandBufferErrorOutOfMemory = 8,
+    CommandBufferErrorInvalidResource = 9,
+    CommandBufferErrorMemoryless = 10,
+    CommandBufferErrorDeviceRemoved = 11,
+    CommandBufferErrorStackOverflow = 12,
+};
+
+_MTL_OPTIONS(NS::UInteger, CommandBufferErrorOption) {
+    CommandBufferErrorOptionNone = 0,
+    CommandBufferErrorOptionEncoderExecutionStatus = 1,
+};
+
+_MTL_ENUM(NS::Integer, CommandEncoderErrorState) {
+    CommandEncoderErrorStateUnknown = 0,
+    CommandEncoderErrorStateCompleted = 1,
+    CommandEncoderErrorStateAffected = 2,
+    CommandEncoderErrorStatePending = 3,
+    CommandEncoderErrorStateFaulted = 4,
+};
+
+class CommandBufferDescriptor : public NS::Copying<CommandBufferDescriptor>
+{
+public:
+    static class CommandBufferDescriptor* alloc();
+
+    class CommandBufferDescriptor*        init();
+
+    bool                                  retainedReferences() const;
+    void                                  setRetainedReferences(bool retainedReferences);
+
+    MTL::CommandBufferErrorOption         errorOptions() const;
+    void                                  setErrorOptions(MTL::CommandBufferErrorOption errorOptions);
+};
+
+class CommandBufferEncoderInfo : public NS::Referencing<CommandBufferEncoderInfo>
+{
+public:
+    NS::String*                   label() const;
+
+    NS::Array*                    debugSignposts() const;
+
+    MTL::CommandEncoderErrorState errorState() const;
+};
+
+_MTL_ENUM(NS::UInteger, DispatchType) {
+    DispatchTypeSerial = 0,
+    DispatchTypeConcurrent = 1,
+};
+
+class CommandBuffer;
+
+using CommandBufferHandler = void (^)(CommandBuffer*);
+
+using HandlerFunction = std::function<void(CommandBuffer*)>;
+
+class CommandBuffer : public NS::Referencing<CommandBuffer>
+{
+public:
+    void                                       addScheduledHandler(const HandlerFunction& function);
+
+    void                                       addCompletedHandler(const HandlerFunction& function);
+
+    class Device*                              device() const;
+
+    class CommandQueue*                        commandQueue() const;
+
+    bool                                       retainedReferences() const;
+
+    MTL::CommandBufferErrorOption              errorOptions() const;
+
+    NS::String*                                label() const;
+    void                                       setLabel(const NS::String* label);
+
+    CFTimeInterval                             kernelStartTime() const;
+
+    CFTimeInterval                             kernelEndTime() const;
+
+    class LogContainer*                        logs() const;
+
+    CFTimeInterval                             GPUStartTime() const;
+
+    CFTimeInterval                             GPUEndTime() const;
+
+    void                                       enqueue();
+
+    void                                       commit();
+
+    void                                       addScheduledHandler(const MTL::CommandBufferHandler block);
+
+    void                                       presentDrawable(const class Drawable* drawable);
+
+    void                                       presentDrawableAtTime(const class Drawable* drawable, CFTimeInterval presentationTime);
+
+    void                                       presentDrawableAfterMinimumDuration(const class Drawable* drawable, CFTimeInterval duration);
+
+    void                                       waitUntilScheduled();
+
+    void                                       addCompletedHandler(const MTL::CommandBufferHandler block);
+
+    void                                       waitUntilCompleted();
+
+    MTL::CommandBufferStatus                   status() const;
+
+    NS::Error*                                 error() const;
+
+    class BlitCommandEncoder*                  blitCommandEncoder();
+
+    class RenderCommandEncoder*                renderCommandEncoder(const class RenderPassDescriptor* renderPassDescriptor);
+
+    class ComputeCommandEncoder*               computeCommandEncoder(const class ComputePassDescriptor* computePassDescriptor);
+
+    class BlitCommandEncoder*                  blitCommandEncoder(const class BlitPassDescriptor* blitPassDescriptor);
+
+    class ComputeCommandEncoder*               computeCommandEncoder();
+
+    class ComputeCommandEncoder*               computeCommandEncoder(MTL::DispatchType dispatchType);
+
+    void                                       encodeWait(const class Event* event, uint64_t value);
+
+    void                                       encodeSignalEvent(const class Event* event, uint64_t value);
+
+    class ParallelRenderCommandEncoder*        parallelRenderCommandEncoder(const class RenderPassDescriptor* renderPassDescriptor);
+
+    class ResourceStateCommandEncoder*         resourceStateCommandEncoder();
+
+    class ResourceStateCommandEncoder*         resourceStateCommandEncoder(const class ResourceStatePassDescriptor* resourceStatePassDescriptor);
+
+    class AccelerationStructureCommandEncoder* accelerationStructureCommandEncoder();
+
+    class AccelerationStructureCommandEncoder* accelerationStructureCommandEncoder(const class AccelerationStructurePassDescriptor* descriptor);
+
+    void                                       pushDebugGroup(const NS::String* string);
+
+    void                                       popDebugGroup();
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::CommandBufferDescriptor* MTL::CommandBufferDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::CommandBufferDescriptor>(_MTL_PRIVATE_CLS(MTLCommandBufferDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::CommandBufferDescriptor* MTL::CommandBufferDescriptor::init()
+{
+    return NS::Object::init<MTL::CommandBufferDescriptor>();
+}
+
+// property: retainedReferences
+_MTL_INLINE bool MTL::CommandBufferDescriptor::retainedReferences() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(retainedReferences));
+}
+
+_MTL_INLINE void MTL::CommandBufferDescriptor::setRetainedReferences(bool retainedReferences)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRetainedReferences_), retainedReferences);
+}
+
+// property: errorOptions
+_MTL_INLINE MTL::CommandBufferErrorOption MTL::CommandBufferDescriptor::errorOptions() const
+{
+    return Object::sendMessage<MTL::CommandBufferErrorOption>(this, _MTL_PRIVATE_SEL(errorOptions));
+}
+
+_MTL_INLINE void MTL::CommandBufferDescriptor::setErrorOptions(MTL::CommandBufferErrorOption errorOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setErrorOptions_), errorOptions);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::CommandBufferEncoderInfo::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// property: debugSignposts
+_MTL_INLINE NS::Array* MTL::CommandBufferEncoderInfo::debugSignposts() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(debugSignposts));
+}
+
+// property: errorState
+_MTL_INLINE MTL::CommandEncoderErrorState MTL::CommandBufferEncoderInfo::errorState() const
+{
+    return Object::sendMessage<MTL::CommandEncoderErrorState>(this, _MTL_PRIVATE_SEL(errorState));
+}
+
+_MTL_INLINE void MTL::CommandBuffer::addScheduledHandler(const HandlerFunction& function)
+{
+    __block HandlerFunction blockFunction = function;
+
+    addScheduledHandler(^(MTL::CommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); });
+}
+
+_MTL_INLINE void MTL::CommandBuffer::addCompletedHandler(const HandlerFunction& function)
+{
+    __block HandlerFunction blockFunction = function;
+
+    addCompletedHandler(^(MTL::CommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); });
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::CommandBuffer::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: commandQueue
+_MTL_INLINE MTL::CommandQueue* MTL::CommandBuffer::commandQueue() const
+{
+    return Object::sendMessage<MTL::CommandQueue*>(this, _MTL_PRIVATE_SEL(commandQueue));
+}
+
+// property: retainedReferences
+_MTL_INLINE bool MTL::CommandBuffer::retainedReferences() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(retainedReferences));
+}
+
+// property: errorOptions
+_MTL_INLINE MTL::CommandBufferErrorOption MTL::CommandBuffer::errorOptions() const
+{
+    return Object::sendMessage<MTL::CommandBufferErrorOption>(this, _MTL_PRIVATE_SEL(errorOptions));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::CommandBuffer::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::CommandBuffer::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: kernelStartTime
+_MTL_INLINE CFTimeInterval MTL::CommandBuffer::kernelStartTime() const
+{
+    return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(kernelStartTime));
+}
+
+// property: kernelEndTime
+_MTL_INLINE CFTimeInterval MTL::CommandBuffer::kernelEndTime() const
+{
+    return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(kernelEndTime));
+}
+
+// property: logs
+_MTL_INLINE MTL::LogContainer* MTL::CommandBuffer::logs() const
+{
+    return Object::sendMessage<MTL::LogContainer*>(this, _MTL_PRIVATE_SEL(logs));
+}
+
+// property: GPUStartTime
+_MTL_INLINE CFTimeInterval MTL::CommandBuffer::GPUStartTime() const
+{
+    return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(GPUStartTime));
+}
+
+// property: GPUEndTime
+_MTL_INLINE CFTimeInterval MTL::CommandBuffer::GPUEndTime() const
+{
+    return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(GPUEndTime));
+}
+
+// method: enqueue
+_MTL_INLINE void MTL::CommandBuffer::enqueue()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(enqueue));
+}
+
+// method: commit
+_MTL_INLINE void MTL::CommandBuffer::commit()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(commit));
+}
+
+// method: addScheduledHandler:
+_MTL_INLINE void MTL::CommandBuffer::addScheduledHandler(const MTL::CommandBufferHandler block)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addScheduledHandler_), block);
+}
+
+// method: presentDrawable:
+_MTL_INLINE void MTL::CommandBuffer::presentDrawable(const MTL::Drawable* drawable)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentDrawable_), drawable);
+}
+
+// method: presentDrawable:atTime:
+_MTL_INLINE void MTL::CommandBuffer::presentDrawableAtTime(const MTL::Drawable* drawable, CFTimeInterval presentationTime)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentDrawable_atTime_), drawable, presentationTime);
+}
+
+// method: presentDrawable:afterMinimumDuration:
+_MTL_INLINE void MTL::CommandBuffer::presentDrawableAfterMinimumDuration(const MTL::Drawable* drawable, CFTimeInterval duration)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentDrawable_afterMinimumDuration_), drawable, duration);
+}
+
+// method: waitUntilScheduled
+_MTL_INLINE void MTL::CommandBuffer::waitUntilScheduled()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitUntilScheduled));
+}
+
+// method: addCompletedHandler:
+_MTL_INLINE void MTL::CommandBuffer::addCompletedHandler(const MTL::CommandBufferHandler block)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addCompletedHandler_), block);
+}
+
+// method: waitUntilCompleted
+_MTL_INLINE void MTL::CommandBuffer::waitUntilCompleted()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitUntilCompleted));
+}
+
+// property: status
+_MTL_INLINE MTL::CommandBufferStatus MTL::CommandBuffer::status() const
+{
+    return Object::sendMessage<MTL::CommandBufferStatus>(this, _MTL_PRIVATE_SEL(status));
+}
+
+// property: error
+_MTL_INLINE NS::Error* MTL::CommandBuffer::error() const
+{
+    return Object::sendMessage<NS::Error*>(this, _MTL_PRIVATE_SEL(error));
+}
+
+// method: blitCommandEncoder
+_MTL_INLINE MTL::BlitCommandEncoder* MTL::CommandBuffer::blitCommandEncoder()
+{
+    return Object::sendMessage<MTL::BlitCommandEncoder*>(this, _MTL_PRIVATE_SEL(blitCommandEncoder));
+}
+
+// method: renderCommandEncoderWithDescriptor:
+_MTL_INLINE MTL::RenderCommandEncoder* MTL::CommandBuffer::renderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor)
+{
+    return Object::sendMessage<MTL::RenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(renderCommandEncoderWithDescriptor_), renderPassDescriptor);
+}
+
+// method: computeCommandEncoderWithDescriptor:
+_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder(const MTL::ComputePassDescriptor* computePassDescriptor)
+{
+    return Object::sendMessage<MTL::ComputeCommandEncoder*>(this, _MTL_PRIVATE_SEL(computeCommandEncoderWithDescriptor_), computePassDescriptor);
+}
+
+// method: blitCommandEncoderWithDescriptor:
+_MTL_INLINE MTL::BlitCommandEncoder* MTL::CommandBuffer::blitCommandEncoder(const MTL::BlitPassDescriptor* blitPassDescriptor)
+{
+    return Object::sendMessage<MTL::BlitCommandEncoder*>(this, _MTL_PRIVATE_SEL(blitCommandEncoderWithDescriptor_), blitPassDescriptor);
+}
+
+// method: computeCommandEncoder
+_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder()
+{
+    return Object::sendMessage<MTL::ComputeCommandEncoder*>(this, _MTL_PRIVATE_SEL(computeCommandEncoder));
+}
+
+// method: computeCommandEncoderWithDispatchType:
+_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder(MTL::DispatchType dispatchType)
+{
+    return Object::sendMessage<MTL::ComputeCommandEncoder*>(this, _MTL_PRIVATE_SEL(computeCommandEncoderWithDispatchType_), dispatchType);
+}
+
+// method: encodeWaitForEvent:value:
+_MTL_INLINE void MTL::CommandBuffer::encodeWait(const MTL::Event* event, uint64_t value)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(encodeWaitForEvent_value_), event, value);
+}
+
+// method: encodeSignalEvent:value:
+_MTL_INLINE void MTL::CommandBuffer::encodeSignalEvent(const MTL::Event* event, uint64_t value)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(encodeSignalEvent_value_), event, value);
+}
+
+// method: parallelRenderCommandEncoderWithDescriptor:
+_MTL_INLINE MTL::ParallelRenderCommandEncoder* MTL::CommandBuffer::parallelRenderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor)
+{
+    return Object::sendMessage<MTL::ParallelRenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(parallelRenderCommandEncoderWithDescriptor_), renderPassDescriptor);
+}
+
+// method: resourceStateCommandEncoder
+_MTL_INLINE MTL::ResourceStateCommandEncoder* MTL::CommandBuffer::resourceStateCommandEncoder()
+{
+    return Object::sendMessage<MTL::ResourceStateCommandEncoder*>(this, _MTL_PRIVATE_SEL(resourceStateCommandEncoder));
+}
+
+// method: resourceStateCommandEncoderWithDescriptor:
+_MTL_INLINE MTL::ResourceStateCommandEncoder* MTL::CommandBuffer::resourceStateCommandEncoder(const MTL::ResourceStatePassDescriptor* resourceStatePassDescriptor)
+{
+    return Object::sendMessage<MTL::ResourceStateCommandEncoder*>(this, _MTL_PRIVATE_SEL(resourceStateCommandEncoderWithDescriptor_), resourceStatePassDescriptor);
+}
+
+// method: accelerationStructureCommandEncoder
+_MTL_INLINE MTL::AccelerationStructureCommandEncoder* MTL::CommandBuffer::accelerationStructureCommandEncoder()
+{
+    return Object::sendMessage<MTL::AccelerationStructureCommandEncoder*>(this, _MTL_PRIVATE_SEL(accelerationStructureCommandEncoder));
+}
+
+// method: accelerationStructureCommandEncoderWithDescriptor:
+_MTL_INLINE MTL::AccelerationStructureCommandEncoder* MTL::CommandBuffer::accelerationStructureCommandEncoder(const MTL::AccelerationStructurePassDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::AccelerationStructureCommandEncoder*>(this, _MTL_PRIVATE_SEL(accelerationStructureCommandEncoderWithDescriptor_), descriptor);
+}
+
+// method: pushDebugGroup:
+_MTL_INLINE void MTL::CommandBuffer::pushDebugGroup(const NS::String* string)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
+}
+
+// method: popDebugGroup
+_MTL_INLINE void MTL::CommandBuffer::popDebugGroup()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..9a4d97c7803e37f33bddc6e859c34b62ecbe8535
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandEncoder.hpp
@@ -0,0 +1,101 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+_MTL_OPTIONS(NS::UInteger, ResourceUsage) {
+    ResourceUsageRead = 1,
+    ResourceUsageWrite = 2,
+    ResourceUsageSample = 4,
+};
+
+_MTL_OPTIONS(NS::UInteger, BarrierScope) {
+    BarrierScopeBuffers = 1,
+    BarrierScopeTextures = 2,
+    BarrierScopeRenderTargets = 4,
+};
+
+class CommandEncoder : public NS::Referencing<CommandEncoder>
+{
+public:
+    class Device* device() const;
+
+    NS::String*   label() const;
+    void          setLabel(const NS::String* label);
+
+    void          endEncoding();
+
+    void          insertDebugSignpost(const NS::String* string);
+
+    void          pushDebugGroup(const NS::String* string);
+
+    void          popDebugGroup();
+};
+
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::CommandEncoder::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::CommandEncoder::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::CommandEncoder::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// method: endEncoding
+_MTL_INLINE void MTL::CommandEncoder::endEncoding()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(endEncoding));
+}
+
+// method: insertDebugSignpost:
+_MTL_INLINE void MTL::CommandEncoder::insertDebugSignpost(const NS::String* string)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(insertDebugSignpost_), string);
+}
+
+// method: pushDebugGroup:
+_MTL_INLINE void MTL::CommandEncoder::pushDebugGroup(const NS::String* string)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
+}
+
+// method: popDebugGroup
+_MTL_INLINE void MTL::CommandEncoder::popDebugGroup()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandQueue.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandQueue.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..07b2984483b65320d4e8ce5503b53fdf32f4701e
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCommandQueue.hpp
@@ -0,0 +1,89 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLCommandQueue.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+class CommandQueue : public NS::Referencing<CommandQueue>
+{
+public:
+    NS::String*          label() const;
+    void                 setLabel(const NS::String* label);
+
+    class Device*        device() const;
+
+    class CommandBuffer* commandBuffer();
+
+    class CommandBuffer* commandBuffer(const class CommandBufferDescriptor* descriptor);
+
+    class CommandBuffer* commandBufferWithUnretainedReferences();
+
+    void                 insertDebugCaptureBoundary();
+};
+
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::CommandQueue::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::CommandQueue::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::CommandQueue::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// method: commandBuffer
+_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBuffer()
+{
+    return Object::sendMessage<MTL::CommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBuffer));
+}
+
+// method: commandBufferWithDescriptor:
+_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBuffer(const MTL::CommandBufferDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::CommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBufferWithDescriptor_), descriptor);
+}
+
+// method: commandBufferWithUnretainedReferences
+_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBufferWithUnretainedReferences()
+{
+    return Object::sendMessage<MTL::CommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBufferWithUnretainedReferences));
+}
+
+// method: insertDebugCaptureBoundary
+_MTL_INLINE void MTL::CommandQueue::insertDebugCaptureBoundary()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(insertDebugCaptureBoundary));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputeCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputeCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..50a3b24185ee3a56863d95eb124e356b06814674
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputeCommandEncoder.hpp
@@ -0,0 +1,362 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLComputeCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLCommandBuffer.hpp"
+#include "MTLCommandEncoder.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+struct DispatchThreadgroupsIndirectArguments
+{
+    uint32_t threadgroupsPerGrid[3];
+} _MTL_PACKED;
+
+struct StageInRegionIndirectArguments
+{
+    uint32_t stageInOrigin[3];
+    uint32_t stageInSize[3];
+} _MTL_PACKED;
+
+class ComputeCommandEncoder : public NS::Referencing<ComputeCommandEncoder, CommandEncoder>
+{
+public:
+    MTL::DispatchType dispatchType() const;
+
+    void              setComputePipelineState(const class ComputePipelineState* state);
+
+    void              setBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
+
+    void              setBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void              setBufferOffset(NS::UInteger offset, NS::UInteger index);
+
+    void              setBuffers(const class Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
+
+    void              setBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
+
+    void              setBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range);
+
+    void              setBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
+
+    void              setBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index);
+
+    void              setVisibleFunctionTable(const class VisibleFunctionTable* visibleFunctionTable, NS::UInteger bufferIndex);
+
+    void              setVisibleFunctionTables(const class VisibleFunctionTable* const visibleFunctionTables[], NS::Range range);
+
+    void              setIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
+
+    void              setIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
+
+    void              setAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
+
+    void              setTexture(const class Texture* texture, NS::UInteger index);
+
+    void              setTextures(const class Texture* const textures[], NS::Range range);
+
+    void              setSamplerState(const class SamplerState* sampler, NS::UInteger index);
+
+    void              setSamplerStates(const class SamplerState* const samplers[], NS::Range range);
+
+    void              setSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
+
+    void              setSamplerStates(const class SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
+
+    void              setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
+
+    void              setImageblockWidth(NS::UInteger width, NS::UInteger height);
+
+    void              setStageInRegion(MTL::Region region);
+
+    void              setStageInRegion(const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
+
+    void              dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup);
+
+    void              dispatchThreadgroups(const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerThreadgroup);
+
+    void              dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup);
+
+    void              updateFence(const class Fence* fence);
+
+    void              waitForFence(const class Fence* fence);
+
+    void              useResource(const class Resource* resource, MTL::ResourceUsage usage);
+
+    void              useResources(const class Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage);
+
+    void              useHeap(const class Heap* heap);
+
+    void              useHeaps(const class Heap* const heaps[], NS::UInteger count);
+
+    void              executeCommandsInBuffer(const class IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange);
+
+    void              executeCommandsInBuffer(const class IndirectCommandBuffer* indirectCommandbuffer, const class Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset);
+
+    void              memoryBarrier(MTL::BarrierScope scope);
+
+    void              memoryBarrier(const class Resource* const resources[], NS::UInteger count);
+
+    void              sampleCountersInBuffer(const class CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
+};
+
+}
+
+// property: dispatchType
+_MTL_INLINE MTL::DispatchType MTL::ComputeCommandEncoder::dispatchType() const
+{
+    return Object::sendMessage<MTL::DispatchType>(this, _MTL_PRIVATE_SEL(dispatchType));
+}
+
+// method: setComputePipelineState:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setComputePipelineState(const MTL::ComputePipelineState* state)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineState_), state);
+}
+
+// method: setBytes:length:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBytes_length_atIndex_), bytes, length, index);
+}
+
+// method: setBuffer:offset:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setBufferOffset:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBufferOffset(NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBufferOffset_atIndex_), offset, index);
+}
+
+// method: setBuffers:offsets:withRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// method: setBuffer:offset:attributeStride:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
+}
+
+// method: setBuffers:offsets:attributeStrides:withRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_attributeStrides_withRange_), buffers, offsets, strides, range);
+}
+
+// method: setBufferOffset:attributeStride:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBufferOffset_attributeStride_atIndex_), offset, stride, index);
+}
+
+// method: setBytes:length:attributeStride:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBytes_length_attributeStride_atIndex_), bytes, length, stride, index);
+}
+
+// method: setVisibleFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atBufferIndex_), visibleFunctionTable, bufferIndex);
+}
+
+// method: setVisibleFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withBufferRange_), visibleFunctionTables, range);
+}
+
+// method: setIntersectionFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
+}
+
+// method: setIntersectionFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
+}
+
+// method: setAccelerationStructure:atBufferIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
+}
+
+// method: setTexture:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setTexture(const MTL::Texture* texture, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), texture, index);
+}
+
+// method: setTextures:withRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setTextures(const MTL::Texture* const textures[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTextures_withRange_), textures, range);
+}
+
+// method: setSamplerState:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), sampler, index);
+}
+
+// method: setSamplerStates:withRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerStates_withRange_), samplers, range);
+}
+
+// method: setSamplerState:lodMinClamp:lodMaxClamp:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
+}
+
+// method: setSamplerStates:lodMinClamps:lodMaxClamps:withRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
+}
+
+// method: setThreadgroupMemoryLength:atIndex:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index);
+}
+
+// method: setImageblockWidth:height:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setImageblockWidth(NS::UInteger width, NS::UInteger height)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height);
+}
+
+// method: setStageInRegion:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setStageInRegion(MTL::Region region)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInRegion_), region);
+}
+
+// method: setStageInRegionWithIndirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::ComputeCommandEncoder::setStageInRegion(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInRegionWithIndirectBuffer_indirectBufferOffset_), indirectBuffer, indirectBufferOffset);
+}
+
+// method: dispatchThreadgroups:threadsPerThreadgroup:
+_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup);
+}
+
+// method: dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:
+_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerThreadgroup_), indirectBuffer, indirectBufferOffset, threadsPerThreadgroup);
+}
+
+// method: dispatchThreads:threadsPerThreadgroup:
+_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup);
+}
+
+// method: updateFence:
+_MTL_INLINE void MTL::ComputeCommandEncoder::updateFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_), fence);
+}
+
+// method: waitForFence:
+_MTL_INLINE void MTL::ComputeCommandEncoder::waitForFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_), fence);
+}
+
+// method: useResource:usage:
+_MTL_INLINE void MTL::ComputeCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage);
+}
+
+// method: useResources:count:usage:
+_MTL_INLINE void MTL::ComputeCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage);
+}
+
+// method: useHeap:
+_MTL_INLINE void MTL::ComputeCommandEncoder::useHeap(const MTL::Heap* heap)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_), heap);
+}
+
+// method: useHeaps:count:
+_MTL_INLINE void MTL::ComputeCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count);
+}
+
+// method: executeCommandsInBuffer:withRange:
+_MTL_INLINE void MTL::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange);
+}
+
+// method: executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_), indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset);
+}
+
+// method: memoryBarrierWithScope:
+_MTL_INLINE void MTL::ComputeCommandEncoder::memoryBarrier(MTL::BarrierScope scope)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithScope_), scope);
+}
+
+// method: memoryBarrierWithResources:count:
+_MTL_INLINE void MTL::ComputeCommandEncoder::memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithResources_count_), resources, count);
+}
+
+// method: sampleCountersInBuffer:atSampleIndex:withBarrier:
+_MTL_INLINE void MTL::ComputeCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputePass.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputePass.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bbc718418706abe0560c28fcae9dec76fdda6d83
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputePass.hpp
@@ -0,0 +1,181 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLComputePass.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLCommandBuffer.hpp"
+
+namespace MTL
+{
+class ComputePassSampleBufferAttachmentDescriptor : public NS::Copying<ComputePassSampleBufferAttachmentDescriptor>
+{
+public:
+    static class ComputePassSampleBufferAttachmentDescriptor* alloc();
+
+    class ComputePassSampleBufferAttachmentDescriptor*        init();
+
+    class CounterSampleBuffer*                                sampleBuffer() const;
+    void                                                      setSampleBuffer(const class CounterSampleBuffer* sampleBuffer);
+
+    NS::UInteger                                              startOfEncoderSampleIndex() const;
+    void                                                      setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex);
+
+    NS::UInteger                                              endOfEncoderSampleIndex() const;
+    void                                                      setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex);
+};
+
+class ComputePassSampleBufferAttachmentDescriptorArray : public NS::Referencing<ComputePassSampleBufferAttachmentDescriptorArray>
+{
+public:
+    static class ComputePassSampleBufferAttachmentDescriptorArray* alloc();
+
+    class ComputePassSampleBufferAttachmentDescriptorArray*        init();
+
+    class ComputePassSampleBufferAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                           setObject(const class ComputePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class ComputePassDescriptor : public NS::Copying<ComputePassDescriptor>
+{
+public:
+    static class ComputePassDescriptor*                     alloc();
+
+    class ComputePassDescriptor*                            init();
+
+    static class ComputePassDescriptor*                     computePassDescriptor();
+
+    MTL::DispatchType                                       dispatchType() const;
+    void                                                    setDispatchType(MTL::DispatchType dispatchType);
+
+    class ComputePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::ComputePassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLComputePassSampleBufferAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::ComputePassSampleBufferAttachmentDescriptor>();
+}
+
+// property: sampleBuffer
+_MTL_INLINE MTL::CounterSampleBuffer* MTL::ComputePassSampleBufferAttachmentDescriptor::sampleBuffer() const
+{
+    return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
+}
+
+_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
+}
+
+// property: startOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::ComputePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex);
+}
+
+// property: endOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::ComputePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassSampleBufferAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::ComputePassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLComputePassSampleBufferAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassSampleBufferAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::ComputePassSampleBufferAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::ComputePassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::ComputePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::ComputePassDescriptor>(_MTL_PRIVATE_CLS(MTLComputePassDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::init()
+{
+    return NS::Object::init<MTL::ComputePassDescriptor>();
+}
+
+// static method: computePassDescriptor
+_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::computePassDescriptor()
+{
+    return Object::sendMessage<MTL::ComputePassDescriptor*>(_MTL_PRIVATE_CLS(MTLComputePassDescriptor), _MTL_PRIVATE_SEL(computePassDescriptor));
+}
+
+// property: dispatchType
+_MTL_INLINE MTL::DispatchType MTL::ComputePassDescriptor::dispatchType() const
+{
+    return Object::sendMessage<MTL::DispatchType>(this, _MTL_PRIVATE_SEL(dispatchType));
+}
+
+_MTL_INLINE void MTL::ComputePassDescriptor::setDispatchType(MTL::DispatchType dispatchType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDispatchType_), dispatchType);
+}
+
+// property: sampleBufferAttachments
+_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassDescriptor::sampleBufferAttachments() const
+{
+    return Object::sendMessage<MTL::ComputePassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputePipeline.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputePipeline.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3065b8f27e879e85e330c858b783c899113f3720
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLComputePipeline.hpp
@@ -0,0 +1,373 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLComputePipeline.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+class ComputePipelineReflection : public NS::Referencing<ComputePipelineReflection>
+{
+public:
+    static class ComputePipelineReflection* alloc();
+
+    class ComputePipelineReflection*        init();
+
+    NS::Array*                              bindings() const;
+
+    NS::Array*                              arguments() const;
+};
+
+class ComputePipelineDescriptor : public NS::Copying<ComputePipelineDescriptor>
+{
+public:
+    static class ComputePipelineDescriptor* alloc();
+
+    class ComputePipelineDescriptor*        init();
+
+    NS::String*                             label() const;
+    void                                    setLabel(const NS::String* label);
+
+    class Function*                         computeFunction() const;
+    void                                    setComputeFunction(const class Function* computeFunction);
+
+    bool                                    threadGroupSizeIsMultipleOfThreadExecutionWidth() const;
+    void                                    setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth);
+
+    NS::UInteger                            maxTotalThreadsPerThreadgroup() const;
+    void                                    setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
+
+    class StageInputOutputDescriptor*       stageInputDescriptor() const;
+    void                                    setStageInputDescriptor(const class StageInputOutputDescriptor* stageInputDescriptor);
+
+    class PipelineBufferDescriptorArray*    buffers() const;
+
+    bool                                    supportIndirectCommandBuffers() const;
+    void                                    setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers);
+
+    NS::Array*                              insertLibraries() const;
+    void                                    setInsertLibraries(const NS::Array* insertLibraries);
+
+    NS::Array*                              preloadedLibraries() const;
+    void                                    setPreloadedLibraries(const NS::Array* preloadedLibraries);
+
+    NS::Array*                              binaryArchives() const;
+    void                                    setBinaryArchives(const NS::Array* binaryArchives);
+
+    void                                    reset();
+
+    class LinkedFunctions*                  linkedFunctions() const;
+    void                                    setLinkedFunctions(const class LinkedFunctions* linkedFunctions);
+
+    bool                                    supportAddingBinaryFunctions() const;
+    void                                    setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions);
+
+    NS::UInteger                            maxCallStackDepth() const;
+    void                                    setMaxCallStackDepth(NS::UInteger maxCallStackDepth);
+};
+
+class ComputePipelineState : public NS::Referencing<ComputePipelineState>
+{
+public:
+    NS::String*                      label() const;
+
+    class Device*                    device() const;
+
+    NS::UInteger                     maxTotalThreadsPerThreadgroup() const;
+
+    NS::UInteger                     threadExecutionWidth() const;
+
+    NS::UInteger                     staticThreadgroupMemoryLength() const;
+
+    NS::UInteger                     imageblockMemoryLength(MTL::Size imageblockDimensions);
+
+    bool                             supportIndirectCommandBuffers() const;
+
+    MTL::ResourceID                  gpuResourceID() const;
+
+    class FunctionHandle*            functionHandle(const class Function* function);
+
+    class ComputePipelineState*      newComputePipelineState(const NS::Array* functions, NS::Error** error);
+
+    class VisibleFunctionTable*      newVisibleFunctionTable(const class VisibleFunctionTableDescriptor* descriptor);
+
+    class IntersectionFunctionTable* newIntersectionFunctionTable(const class IntersectionFunctionTableDescriptor* descriptor);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineReflection::alloc()
+{
+    return NS::Object::alloc<MTL::ComputePipelineReflection>(_MTL_PRIVATE_CLS(MTLComputePipelineReflection));
+}
+
+// method: init
+_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineReflection::init()
+{
+    return NS::Object::init<MTL::ComputePipelineReflection>();
+}
+
+// property: bindings
+_MTL_INLINE NS::Array* MTL::ComputePipelineReflection::bindings() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(bindings));
+}
+
+// property: arguments
+_MTL_INLINE NS::Array* MTL::ComputePipelineReflection::arguments() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(arguments));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ComputePipelineDescriptor* MTL::ComputePipelineDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::ComputePipelineDescriptor>(_MTL_PRIVATE_CLS(MTLComputePipelineDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::ComputePipelineDescriptor* MTL::ComputePipelineDescriptor::init()
+{
+    return NS::Object::init<MTL::ComputePipelineDescriptor>();
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::ComputePipelineDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: computeFunction
+_MTL_INLINE MTL::Function* MTL::ComputePipelineDescriptor::computeFunction() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(computeFunction));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setComputeFunction(const MTL::Function* computeFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputeFunction_), computeFunction);
+}
+
+// property: threadGroupSizeIsMultipleOfThreadExecutionWidth
+_MTL_INLINE bool MTL::ComputePipelineDescriptor::threadGroupSizeIsMultipleOfThreadExecutionWidth() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_), threadGroupSizeIsMultipleOfThreadExecutionWidth);
+}
+
+// property: maxTotalThreadsPerThreadgroup
+_MTL_INLINE NS::UInteger MTL::ComputePipelineDescriptor::maxTotalThreadsPerThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
+}
+
+// property: stageInputDescriptor
+_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::ComputePipelineDescriptor::stageInputDescriptor() const
+{
+    return Object::sendMessage<MTL::StageInputOutputDescriptor*>(this, _MTL_PRIVATE_SEL(stageInputDescriptor));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setStageInputDescriptor(const MTL::StageInputOutputDescriptor* stageInputDescriptor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInputDescriptor_), stageInputDescriptor);
+}
+
+// property: buffers
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::ComputePipelineDescriptor::buffers() const
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(buffers));
+}
+
+// property: supportIndirectCommandBuffers
+_MTL_INLINE bool MTL::ComputePipelineDescriptor::supportIndirectCommandBuffers() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers);
+}
+
+// property: insertLibraries
+_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::insertLibraries() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(insertLibraries));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setInsertLibraries(const NS::Array* insertLibraries)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInsertLibraries_), insertLibraries);
+}
+
+// property: preloadedLibraries
+_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::preloadedLibraries() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(preloadedLibraries));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries);
+}
+
+// property: binaryArchives
+_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::binaryArchives() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
+}
+
+// method: reset
+_MTL_INLINE void MTL::ComputePipelineDescriptor::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
+
+// property: linkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::ComputePipelineDescriptor::linkedFunctions() const
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(linkedFunctions));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLinkedFunctions_), linkedFunctions);
+}
+
+// property: supportAddingBinaryFunctions
+_MTL_INLINE bool MTL::ComputePipelineDescriptor::supportAddingBinaryFunctions() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingBinaryFunctions));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingBinaryFunctions_), supportAddingBinaryFunctions);
+}
+
+// property: maxCallStackDepth
+_MTL_INLINE NS::UInteger MTL::ComputePipelineDescriptor::maxCallStackDepth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCallStackDepth));
+}
+
+_MTL_INLINE void MTL::ComputePipelineDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::ComputePipelineState::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::ComputePipelineState::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: maxTotalThreadsPerThreadgroup
+_MTL_INLINE NS::UInteger MTL::ComputePipelineState::maxTotalThreadsPerThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
+}
+
+// property: threadExecutionWidth
+_MTL_INLINE NS::UInteger MTL::ComputePipelineState::threadExecutionWidth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadExecutionWidth));
+}
+
+// property: staticThreadgroupMemoryLength
+_MTL_INLINE NS::UInteger MTL::ComputePipelineState::staticThreadgroupMemoryLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(staticThreadgroupMemoryLength));
+}
+
+// method: imageblockMemoryLengthForDimensions:
+_MTL_INLINE NS::UInteger MTL::ComputePipelineState::imageblockMemoryLength(MTL::Size imageblockDimensions)
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockMemoryLengthForDimensions_), imageblockDimensions);
+}
+
+// property: supportIndirectCommandBuffers
+_MTL_INLINE bool MTL::ComputePipelineState::supportIndirectCommandBuffers() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::ComputePipelineState::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
+
+// method: functionHandleWithFunction:
+_MTL_INLINE MTL::FunctionHandle* MTL::ComputePipelineState::functionHandle(const MTL::Function* function)
+{
+    return Object::sendMessage<MTL::FunctionHandle*>(this, _MTL_PRIVATE_SEL(functionHandleWithFunction_), function);
+}
+
+// method: newComputePipelineStateWithAdditionalBinaryFunctions:error:
+_MTL_INLINE MTL::ComputePipelineState* MTL::ComputePipelineState::newComputePipelineState(const NS::Array* functions, NS::Error** error)
+{
+    return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithAdditionalBinaryFunctions_error_), functions, error);
+}
+
+// method: newVisibleFunctionTableWithDescriptor:
+_MTL_INLINE MTL::VisibleFunctionTable* MTL::ComputePipelineState::newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::VisibleFunctionTable*>(this, _MTL_PRIVATE_SEL(newVisibleFunctionTableWithDescriptor_), descriptor);
+}
+
+// method: newIntersectionFunctionTableWithDescriptor:
+_MTL_INLINE MTL::IntersectionFunctionTable* MTL::ComputePipelineState::newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::IntersectionFunctionTable*>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionTableWithDescriptor_), descriptor);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCounters.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCounters.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c552f7ed4b9c166ee3d22b3529f117ab0cfa15f5
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLCounters.hpp
@@ -0,0 +1,258 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLCounters.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLResource.hpp"
+
+namespace MTL
+{
+struct CounterResultTimestamp
+{
+    uint64_t timestamp;
+} _MTL_PACKED;
+
+struct CounterResultStageUtilization
+{
+    uint64_t totalCycles;
+    uint64_t vertexCycles;
+    uint64_t tessellationCycles;
+    uint64_t postTessellationVertexCycles;
+    uint64_t fragmentCycles;
+    uint64_t renderTargetCycles;
+} _MTL_PACKED;
+
+struct CounterResultStatistic
+{
+    uint64_t tessellationInputPatches;
+    uint64_t vertexInvocations;
+    uint64_t postTessellationVertexInvocations;
+    uint64_t clipperInvocations;
+    uint64_t clipperPrimitivesOut;
+    uint64_t fragmentInvocations;
+    uint64_t fragmentsPassed;
+    uint64_t computeKernelInvocations;
+} _MTL_PACKED;
+
+_MTL_CONST(NS::ErrorDomain, CounterErrorDomain);
+
+using CommonCounter = NS::String*;
+
+_MTL_CONST(CommonCounter, CommonCounterTimestamp);
+_MTL_CONST(CommonCounter, CommonCounterTessellationInputPatches);
+_MTL_CONST(CommonCounter, CommonCounterVertexInvocations);
+_MTL_CONST(CommonCounter, CommonCounterPostTessellationVertexInvocations);
+_MTL_CONST(CommonCounter, CommonCounterClipperInvocations);
+_MTL_CONST(CommonCounter, CommonCounterClipperPrimitivesOut);
+_MTL_CONST(CommonCounter, CommonCounterFragmentInvocations);
+_MTL_CONST(CommonCounter, CommonCounterFragmentsPassed);
+_MTL_CONST(CommonCounter, CommonCounterComputeKernelInvocations);
+_MTL_CONST(CommonCounter, CommonCounterTotalCycles);
+_MTL_CONST(CommonCounter, CommonCounterVertexCycles);
+_MTL_CONST(CommonCounter, CommonCounterTessellationCycles);
+_MTL_CONST(CommonCounter, CommonCounterPostTessellationVertexCycles);
+_MTL_CONST(CommonCounter, CommonCounterFragmentCycles);
+_MTL_CONST(CommonCounter, CommonCounterRenderTargetWriteCycles);
+
+using CommonCounterSet = NS::String*;
+
+_MTL_CONST(CommonCounterSet, CommonCounterSetTimestamp);
+_MTL_CONST(CommonCounterSet, CommonCounterSetStageUtilization);
+_MTL_CONST(CommonCounterSet, CommonCounterSetStatistic);
+
+class Counter : public NS::Referencing<Counter>
+{
+public:
+    NS::String* name() const;
+};
+
+class CounterSet : public NS::Referencing<CounterSet>
+{
+public:
+    NS::String* name() const;
+
+    NS::Array*  counters() const;
+};
+
+class CounterSampleBufferDescriptor : public NS::Copying<CounterSampleBufferDescriptor>
+{
+public:
+    static class CounterSampleBufferDescriptor* alloc();
+
+    class CounterSampleBufferDescriptor*        init();
+
+    class CounterSet*                           counterSet() const;
+    void                                        setCounterSet(const class CounterSet* counterSet);
+
+    NS::String*                                 label() const;
+    void                                        setLabel(const NS::String* label);
+
+    MTL::StorageMode                            storageMode() const;
+    void                                        setStorageMode(MTL::StorageMode storageMode);
+
+    NS::UInteger                                sampleCount() const;
+    void                                        setSampleCount(NS::UInteger sampleCount);
+};
+
+class CounterSampleBuffer : public NS::Referencing<CounterSampleBuffer>
+{
+public:
+    class Device* device() const;
+
+    NS::String*   label() const;
+
+    NS::UInteger  sampleCount() const;
+
+    NS::Data*     resolveCounterRange(NS::Range range);
+};
+
+_MTL_ENUM(NS::Integer, CounterSampleBufferError) {
+    CounterSampleBufferErrorOutOfMemory = 0,
+    CounterSampleBufferErrorInvalid = 1,
+    CounterSampleBufferErrorInternal = 2,
+};
+
+}
+
+_MTL_PRIVATE_DEF_STR(NS::ErrorDomain, CounterErrorDomain);
+
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterTimestamp);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterTessellationInputPatches);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterVertexInvocations);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterPostTessellationVertexInvocations);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterClipperInvocations);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterClipperPrimitivesOut);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterFragmentInvocations);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterFragmentsPassed);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterComputeKernelInvocations);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterTotalCycles);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterVertexCycles);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterTessellationCycles);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterPostTessellationVertexCycles);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterFragmentCycles);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounter, CommonCounterRenderTargetWriteCycles);
+
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounterSet, CommonCounterSetTimestamp);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounterSet, CommonCounterSetStageUtilization);
+_MTL_PRIVATE_DEF_STR(MTL::CommonCounterSet, CommonCounterSetStatistic);
+
+// property: name
+_MTL_INLINE NS::String* MTL::Counter::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::CounterSet::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: counters
+_MTL_INLINE NS::Array* MTL::CounterSet::counters() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(counters));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::CounterSampleBufferDescriptor* MTL::CounterSampleBufferDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::CounterSampleBufferDescriptor>(_MTL_PRIVATE_CLS(MTLCounterSampleBufferDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::CounterSampleBufferDescriptor* MTL::CounterSampleBufferDescriptor::init()
+{
+    return NS::Object::init<MTL::CounterSampleBufferDescriptor>();
+}
+
+// property: counterSet
+_MTL_INLINE MTL::CounterSet* MTL::CounterSampleBufferDescriptor::counterSet() const
+{
+    return Object::sendMessage<MTL::CounterSet*>(this, _MTL_PRIVATE_SEL(counterSet));
+}
+
+_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setCounterSet(const MTL::CounterSet* counterSet)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCounterSet_), counterSet);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::CounterSampleBufferDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: storageMode
+_MTL_INLINE MTL::StorageMode MTL::CounterSampleBufferDescriptor::storageMode() const
+{
+    return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
+}
+
+_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setStorageMode(MTL::StorageMode storageMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode);
+}
+
+// property: sampleCount
+_MTL_INLINE NS::UInteger MTL::CounterSampleBufferDescriptor::sampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
+}
+
+_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setSampleCount(NS::UInteger sampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::CounterSampleBuffer::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::CounterSampleBuffer::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// property: sampleCount
+_MTL_INLINE NS::UInteger MTL::CounterSampleBuffer::sampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
+}
+
+// method: resolveCounterRange:
+_MTL_INLINE NS::Data* MTL::CounterSampleBuffer::resolveCounterRange(NS::Range range)
+{
+    return Object::sendMessage<NS::Data*>(this, _MTL_PRIVATE_SEL(resolveCounterRange_), range);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDefines.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDefines.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7dd8ff95d8b1447ec2b66d1fbd9210dbd2ce9a7a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDefines.hpp
@@ -0,0 +1,41 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLDefines.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "../Foundation/NSDefines.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _MTL_EXPORT _NS_EXPORT
+#define _MTL_EXTERN _NS_EXTERN
+#define _MTL_INLINE _NS_INLINE
+#define _MTL_PACKED _NS_PACKED
+
+#define _MTL_CONST(type, name) _NS_CONST(type, name)
+#define _MTL_ENUM(type, name) _NS_ENUM(type, name)
+#define _MTL_OPTIONS(type, name) _NS_OPTIONS(type, name)
+
+#define _MTL_VALIDATE_SIZE(ns, name) _NS_VALIDATE_SIZE(ns, name)
+#define _MTL_VALIDATE_ENUM(ns, name) _NS_VALIDATE_ENUM(ns, name)
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDepthStencil.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDepthStencil.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba8bd8b0027d6516ae5974052745f27fcd164154
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDepthStencil.hpp
@@ -0,0 +1,269 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLDepthStencil.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLDepthStencil.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, CompareFunction) {
+    CompareFunctionNever = 0,
+    CompareFunctionLess = 1,
+    CompareFunctionEqual = 2,
+    CompareFunctionLessEqual = 3,
+    CompareFunctionGreater = 4,
+    CompareFunctionNotEqual = 5,
+    CompareFunctionGreaterEqual = 6,
+    CompareFunctionAlways = 7,
+};
+
+_MTL_ENUM(NS::UInteger, StencilOperation) {
+    StencilOperationKeep = 0,
+    StencilOperationZero = 1,
+    StencilOperationReplace = 2,
+    StencilOperationIncrementClamp = 3,
+    StencilOperationDecrementClamp = 4,
+    StencilOperationInvert = 5,
+    StencilOperationIncrementWrap = 6,
+    StencilOperationDecrementWrap = 7,
+};
+
+class StencilDescriptor : public NS::Copying<StencilDescriptor>
+{
+public:
+    static class StencilDescriptor* alloc();
+
+    class StencilDescriptor*        init();
+
+    MTL::CompareFunction            stencilCompareFunction() const;
+    void                            setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction);
+
+    MTL::StencilOperation           stencilFailureOperation() const;
+    void                            setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation);
+
+    MTL::StencilOperation           depthFailureOperation() const;
+    void                            setDepthFailureOperation(MTL::StencilOperation depthFailureOperation);
+
+    MTL::StencilOperation           depthStencilPassOperation() const;
+    void                            setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation);
+
+    uint32_t                        readMask() const;
+    void                            setReadMask(uint32_t readMask);
+
+    uint32_t                        writeMask() const;
+    void                            setWriteMask(uint32_t writeMask);
+};
+
+class DepthStencilDescriptor : public NS::Copying<DepthStencilDescriptor>
+{
+public:
+    static class DepthStencilDescriptor* alloc();
+
+    class DepthStencilDescriptor*        init();
+
+    MTL::CompareFunction                 depthCompareFunction() const;
+    void                                 setDepthCompareFunction(MTL::CompareFunction depthCompareFunction);
+
+    bool                                 depthWriteEnabled() const;
+    void                                 setDepthWriteEnabled(bool depthWriteEnabled);
+
+    class StencilDescriptor*             frontFaceStencil() const;
+    void                                 setFrontFaceStencil(const class StencilDescriptor* frontFaceStencil);
+
+    class StencilDescriptor*             backFaceStencil() const;
+    void                                 setBackFaceStencil(const class StencilDescriptor* backFaceStencil);
+
+    NS::String*                          label() const;
+    void                                 setLabel(const NS::String* label);
+};
+
+class DepthStencilState : public NS::Referencing<DepthStencilState>
+{
+public:
+    NS::String*   label() const;
+
+    class Device* device() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::StencilDescriptor>(_MTL_PRIVATE_CLS(MTLStencilDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::init()
+{
+    return NS::Object::init<MTL::StencilDescriptor>();
+}
+
+// property: stencilCompareFunction
+_MTL_INLINE MTL::CompareFunction MTL::StencilDescriptor::stencilCompareFunction() const
+{
+    return Object::sendMessage<MTL::CompareFunction>(this, _MTL_PRIVATE_SEL(stencilCompareFunction));
+}
+
+_MTL_INLINE void MTL::StencilDescriptor::setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilCompareFunction_), stencilCompareFunction);
+}
+
+// property: stencilFailureOperation
+_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::stencilFailureOperation() const
+{
+    return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(stencilFailureOperation));
+}
+
+_MTL_INLINE void MTL::StencilDescriptor::setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilFailureOperation_), stencilFailureOperation);
+}
+
+// property: depthFailureOperation
+_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthFailureOperation() const
+{
+    return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(depthFailureOperation));
+}
+
+_MTL_INLINE void MTL::StencilDescriptor::setDepthFailureOperation(MTL::StencilOperation depthFailureOperation)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthFailureOperation_), depthFailureOperation);
+}
+
+// property: depthStencilPassOperation
+_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthStencilPassOperation() const
+{
+    return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(depthStencilPassOperation));
+}
+
+_MTL_INLINE void MTL::StencilDescriptor::setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilPassOperation_), depthStencilPassOperation);
+}
+
+// property: readMask
+_MTL_INLINE uint32_t MTL::StencilDescriptor::readMask() const
+{
+    return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(readMask));
+}
+
+_MTL_INLINE void MTL::StencilDescriptor::setReadMask(uint32_t readMask)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setReadMask_), readMask);
+}
+
+// property: writeMask
+_MTL_INLINE uint32_t MTL::StencilDescriptor::writeMask() const
+{
+    return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(writeMask));
+}
+
+_MTL_INLINE void MTL::StencilDescriptor::setWriteMask(uint32_t writeMask)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::DepthStencilDescriptor>(_MTL_PRIVATE_CLS(MTLDepthStencilDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::init()
+{
+    return NS::Object::init<MTL::DepthStencilDescriptor>();
+}
+
+// property: depthCompareFunction
+_MTL_INLINE MTL::CompareFunction MTL::DepthStencilDescriptor::depthCompareFunction() const
+{
+    return Object::sendMessage<MTL::CompareFunction>(this, _MTL_PRIVATE_SEL(depthCompareFunction));
+}
+
+_MTL_INLINE void MTL::DepthStencilDescriptor::setDepthCompareFunction(MTL::CompareFunction depthCompareFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthCompareFunction_), depthCompareFunction);
+}
+
+// property: depthWriteEnabled
+_MTL_INLINE bool MTL::DepthStencilDescriptor::depthWriteEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthWriteEnabled));
+}
+
+_MTL_INLINE void MTL::DepthStencilDescriptor::setDepthWriteEnabled(bool depthWriteEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthWriteEnabled_), depthWriteEnabled);
+}
+
+// property: frontFaceStencil
+_MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::frontFaceStencil() const
+{
+    return Object::sendMessage<MTL::StencilDescriptor*>(this, _MTL_PRIVATE_SEL(frontFaceStencil));
+}
+
+_MTL_INLINE void MTL::DepthStencilDescriptor::setFrontFaceStencil(const MTL::StencilDescriptor* frontFaceStencil)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFrontFaceStencil_), frontFaceStencil);
+}
+
+// property: backFaceStencil
+_MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::backFaceStencil() const
+{
+    return Object::sendMessage<MTL::StencilDescriptor*>(this, _MTL_PRIVATE_SEL(backFaceStencil));
+}
+
+_MTL_INLINE void MTL::DepthStencilDescriptor::setBackFaceStencil(const MTL::StencilDescriptor* backFaceStencil)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBackFaceStencil_), backFaceStencil);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::DepthStencilDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::DepthStencilDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::DepthStencilState::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::DepthStencilState::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDevice.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDevice.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6c799752e9d5668d88ea82883bf2002a9e27bb2
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDevice.hpp
@@ -0,0 +1,1426 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLDevice.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLArgument.hpp"
+#include "MTLDevice.hpp"
+#include "MTLPixelFormat.hpp"
+#include "MTLResource.hpp"
+#include "MTLTexture.hpp"
+#include "MTLTypes.hpp"
+#include <IOSurface/IOSurfaceRef.h>
+#include <functional>
+
+namespace MTL
+{
+_MTL_ENUM(NS::Integer, IOCompressionMethod) {
+    IOCompressionMethodZlib = 0,
+    IOCompressionMethodLZFSE = 1,
+    IOCompressionMethodLZ4 = 2,
+    IOCompressionMethodLZMA = 3,
+    IOCompressionMethodLZBitmap = 4,
+};
+
+_MTL_ENUM(NS::UInteger, FeatureSet) {
+    FeatureSet_iOS_GPUFamily1_v1 = 0,
+    FeatureSet_iOS_GPUFamily2_v1 = 1,
+    FeatureSet_iOS_GPUFamily1_v2 = 2,
+    FeatureSet_iOS_GPUFamily2_v2 = 3,
+    FeatureSet_iOS_GPUFamily3_v1 = 4,
+    FeatureSet_iOS_GPUFamily1_v3 = 5,
+    FeatureSet_iOS_GPUFamily2_v3 = 6,
+    FeatureSet_iOS_GPUFamily3_v2 = 7,
+    FeatureSet_iOS_GPUFamily1_v4 = 8,
+    FeatureSet_iOS_GPUFamily2_v4 = 9,
+    FeatureSet_iOS_GPUFamily3_v3 = 10,
+    FeatureSet_iOS_GPUFamily4_v1 = 11,
+    FeatureSet_iOS_GPUFamily1_v5 = 12,
+    FeatureSet_iOS_GPUFamily2_v5 = 13,
+    FeatureSet_iOS_GPUFamily3_v4 = 14,
+    FeatureSet_iOS_GPUFamily4_v2 = 15,
+    FeatureSet_iOS_GPUFamily5_v1 = 16,
+    FeatureSet_macOS_GPUFamily1_v1 = 10000,
+    FeatureSet_OSX_GPUFamily1_v1 = 10000,
+    FeatureSet_macOS_GPUFamily1_v2 = 10001,
+    FeatureSet_OSX_GPUFamily1_v2 = 10001,
+    FeatureSet_OSX_ReadWriteTextureTier2 = 10002,
+    FeatureSet_macOS_ReadWriteTextureTier2 = 10002,
+    FeatureSet_macOS_GPUFamily1_v3 = 10003,
+    FeatureSet_macOS_GPUFamily1_v4 = 10004,
+    FeatureSet_macOS_GPUFamily2_v1 = 10005,
+    FeatureSet_watchOS_GPUFamily1_v1 = 20000,
+    FeatureSet_WatchOS_GPUFamily1_v1 = 20000,
+    FeatureSet_watchOS_GPUFamily2_v1 = 20001,
+    FeatureSet_WatchOS_GPUFamily2_v1 = 20001,
+    FeatureSet_tvOS_GPUFamily1_v1 = 30000,
+    FeatureSet_TVOS_GPUFamily1_v1 = 30000,
+    FeatureSet_tvOS_GPUFamily1_v2 = 30001,
+    FeatureSet_tvOS_GPUFamily1_v3 = 30002,
+    FeatureSet_tvOS_GPUFamily2_v1 = 30003,
+    FeatureSet_tvOS_GPUFamily1_v4 = 30004,
+    FeatureSet_tvOS_GPUFamily2_v2 = 30005,
+};
+
+_MTL_ENUM(NS::Integer, GPUFamily) {
+    GPUFamilyApple1 = 1001,
+    GPUFamilyApple2 = 1002,
+    GPUFamilyApple3 = 1003,
+    GPUFamilyApple4 = 1004,
+    GPUFamilyApple5 = 1005,
+    GPUFamilyApple6 = 1006,
+    GPUFamilyApple7 = 1007,
+    GPUFamilyApple8 = 1008,
+    GPUFamilyMac1 = 2001,
+    GPUFamilyMac2 = 2002,
+    GPUFamilyCommon1 = 3001,
+    GPUFamilyCommon2 = 3002,
+    GPUFamilyCommon3 = 3003,
+    GPUFamilyMacCatalyst1 = 4001,
+    GPUFamilyMacCatalyst2 = 4002,
+    GPUFamilyMetal3 = 5001,
+};
+
+_MTL_ENUM(NS::UInteger, DeviceLocation) {
+    DeviceLocationBuiltIn = 0,
+    DeviceLocationSlot = 1,
+    DeviceLocationExternal = 2,
+    DeviceLocationUnspecified = NS::UIntegerMax,
+};
+
+_MTL_OPTIONS(NS::UInteger, PipelineOption) {
+    PipelineOptionNone = 0,
+    PipelineOptionArgumentInfo = 1,
+    PipelineOptionBufferTypeInfo = 2,
+    PipelineOptionFailOnBinaryArchiveMiss = 4,
+};
+
+_MTL_ENUM(NS::UInteger, ReadWriteTextureTier) {
+    ReadWriteTextureTierNone = 0,
+    ReadWriteTextureTier1 = 1,
+    ReadWriteTextureTier2 = 2,
+};
+
+_MTL_ENUM(NS::UInteger, ArgumentBuffersTier) {
+    ArgumentBuffersTier1 = 0,
+    ArgumentBuffersTier2 = 1,
+};
+
+_MTL_ENUM(NS::UInteger, SparseTextureRegionAlignmentMode) {
+    SparseTextureRegionAlignmentModeOutward = 0,
+    SparseTextureRegionAlignmentModeInward = 1,
+};
+
+_MTL_ENUM(NS::Integer, SparsePageSize) {
+    SparsePageSize16 = 101,
+    SparsePageSize64 = 102,
+    SparsePageSize256 = 103,
+};
+
+struct AccelerationStructureSizes
+{
+    NS::UInteger accelerationStructureSize;
+    NS::UInteger buildScratchBufferSize;
+    NS::UInteger refitScratchBufferSize;
+} _MTL_PACKED;
+
+_MTL_ENUM(NS::UInteger, CounterSamplingPoint) {
+    CounterSamplingPointAtStageBoundary = 0,
+    CounterSamplingPointAtDrawBoundary = 1,
+    CounterSamplingPointAtDispatchBoundary = 2,
+    CounterSamplingPointAtTileDispatchBoundary = 3,
+    CounterSamplingPointAtBlitBoundary = 4,
+};
+
+struct SizeAndAlign
+{
+    NS::UInteger size;
+    NS::UInteger align;
+} _MTL_PACKED;
+
+class ArgumentDescriptor : public NS::Copying<ArgumentDescriptor>
+{
+public:
+    static class ArgumentDescriptor* alloc();
+
+    class ArgumentDescriptor*        init();
+
+    static class ArgumentDescriptor* argumentDescriptor();
+
+    MTL::DataType                    dataType() const;
+    void                             setDataType(MTL::DataType dataType);
+
+    NS::UInteger                     index() const;
+    void                             setIndex(NS::UInteger index);
+
+    NS::UInteger                     arrayLength() const;
+    void                             setArrayLength(NS::UInteger arrayLength);
+
+    MTL::BindingAccess               access() const;
+    void                             setAccess(MTL::BindingAccess access);
+
+    MTL::TextureType                 textureType() const;
+    void                             setTextureType(MTL::TextureType textureType);
+
+    NS::UInteger                     constantBlockAlignment() const;
+    void                             setConstantBlockAlignment(NS::UInteger constantBlockAlignment);
+};
+
+class Architecture : public NS::Copying<Architecture>
+{
+public:
+    static class Architecture* alloc();
+
+    class Architecture*        init();
+
+    NS::String*                name() const;
+};
+
+using DeviceNotificationName = NS::String*;
+_MTL_CONST(DeviceNotificationName, DeviceWasAddedNotification);
+_MTL_CONST(DeviceNotificationName, DeviceRemovalRequestedNotification);
+_MTL_CONST(DeviceNotificationName, DeviceWasRemovedNotification);
+_MTL_CONST(NS::ErrorUserInfoKey, CommandBufferEncoderInfoErrorKey);
+
+using DeviceNotificationHandlerBlock = void (^)(class Device* pDevice, DeviceNotificationName notifyName);
+
+using DeviceNotificationHandlerFunction = std::function<void(class Device* pDevice, DeviceNotificationName notifyName)>;
+
+using AutoreleasedComputePipelineReflection = class ComputePipelineReflection*;
+
+using AutoreleasedRenderPipelineReflection = class RenderPipelineReflection*;
+
+using NewLibraryCompletionHandler = void (^)(class Library*, NS::Error*);
+
+using NewLibraryCompletionHandlerFunction = std::function<void(class Library*, NS::Error*)>;
+
+using NewRenderPipelineStateCompletionHandler = void (^)(class RenderPipelineState*, NS::Error*);
+
+using NewRenderPipelineStateCompletionHandlerFunction = std::function<void(class RenderPipelineState*, NS::Error*)>;
+
+using NewRenderPipelineStateWithReflectionCompletionHandler = void (^)(class RenderPipelineState*, class RenderPipelineReflection*, NS::Error*);
+
+using NewRenderPipelineStateWithReflectionCompletionHandlerFunction = std::function<void(class RenderPipelineState*, class RenderPipelineReflection*, NS::Error*)>;
+
+using NewComputePipelineStateCompletionHandler = void (^)(class ComputePipelineState*, NS::Error*);
+
+using NewComputePipelineStateCompletionHandlerFunction = std::function<void(class ComputePipelineState*, NS::Error*)>;
+
+using NewComputePipelineStateWithReflectionCompletionHandler = void (^)(class ComputePipelineState*, class ComputePipelineReflection*, NS::Error*);
+
+using NewComputePipelineStateWithReflectionCompletionHandlerFunction = std::function<void(class ComputePipelineState*, class ComputePipelineReflection*, NS::Error*)>;
+
+using Timestamp = std::uint64_t;
+
+MTL::Device* CreateSystemDefaultDevice();
+
+NS::Array*   CopyAllDevices();
+
+NS::Array*   CopyAllDevicesWithObserver(NS::Object** pOutObserver, DeviceNotificationHandlerBlock handler);
+
+NS::Array*   CopyAllDevicesWithObserver(NS::Object** pOutObserver, const DeviceNotificationHandlerFunction& handler);
+
+void         RemoveDeviceObserver(const NS::Object* pObserver);
+
+class Device : public NS::Referencing<Device>
+{
+public:
+    void                            newLibrary(const NS::String* pSource, const class CompileOptions* pOptions, const NewLibraryCompletionHandlerFunction& completionHandler);
+
+    void                            newLibrary(const class StitchedLibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& completionHandler);
+
+    void                            newRenderPipelineState(const class RenderPipelineDescriptor* pDescriptor, const NewRenderPipelineStateCompletionHandlerFunction& completionHandler);
+
+    void                            newRenderPipelineState(const class RenderPipelineDescriptor* pDescriptor, PipelineOption options, const NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler);
+
+    void                            newRenderPipelineState(const class TileRenderPipelineDescriptor* pDescriptor, PipelineOption options, const NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler);
+
+    void                            newComputePipelineState(const class Function* pFunction, const NewComputePipelineStateCompletionHandlerFunction& completionHandler);
+
+    void                            newComputePipelineState(const class Function* pFunction, PipelineOption options, const NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler);
+
+    void                            newComputePipelineState(const class ComputePipelineDescriptor* pDescriptor, PipelineOption options, const NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler);
+
+    bool                            isHeadless() const;
+
+    NS::String*                     name() const;
+
+    uint64_t                        registryID() const;
+
+    class Architecture*             architecture() const;
+
+    MTL::Size                       maxThreadsPerThreadgroup() const;
+
+    bool                            lowPower() const;
+
+    bool                            headless() const;
+
+    bool                            removable() const;
+
+    bool                            hasUnifiedMemory() const;
+
+    uint64_t                        recommendedMaxWorkingSetSize() const;
+
+    MTL::DeviceLocation             location() const;
+
+    NS::UInteger                    locationNumber() const;
+
+    uint64_t                        maxTransferRate() const;
+
+    bool                            depth24Stencil8PixelFormatSupported() const;
+
+    MTL::ReadWriteTextureTier       readWriteTextureSupport() const;
+
+    MTL::ArgumentBuffersTier        argumentBuffersSupport() const;
+
+    bool                            rasterOrderGroupsSupported() const;
+
+    bool                            supports32BitFloatFiltering() const;
+
+    bool                            supports32BitMSAA() const;
+
+    bool                            supportsQueryTextureLOD() const;
+
+    bool                            supportsBCTextureCompression() const;
+
+    bool                            supportsPullModelInterpolation() const;
+
+    bool                            barycentricCoordsSupported() const;
+
+    bool                            supportsShaderBarycentricCoordinates() const;
+
+    NS::UInteger                    currentAllocatedSize() const;
+
+    class CommandQueue*             newCommandQueue();
+
+    class CommandQueue*             newCommandQueue(NS::UInteger maxCommandBufferCount);
+
+    MTL::SizeAndAlign               heapTextureSizeAndAlign(const class TextureDescriptor* desc);
+
+    MTL::SizeAndAlign               heapBufferSizeAndAlign(NS::UInteger length, MTL::ResourceOptions options);
+
+    class Heap*                     newHeap(const class HeapDescriptor* descriptor);
+
+    class Buffer*                   newBuffer(NS::UInteger length, MTL::ResourceOptions options);
+
+    class Buffer*                   newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options);
+
+    class Buffer*                   newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options, void (^deallocator)(void*, NS::UInteger));
+
+    class DepthStencilState*        newDepthStencilState(const class DepthStencilDescriptor* descriptor);
+
+    class Texture*                  newTexture(const class TextureDescriptor* descriptor);
+
+    class Texture*                  newTexture(const class TextureDescriptor* descriptor, const IOSurfaceRef iosurface, NS::UInteger plane);
+
+    class Texture*                  newSharedTexture(const class TextureDescriptor* descriptor);
+
+    class Texture*                  newSharedTexture(const class SharedTextureHandle* sharedHandle);
+
+    class SamplerState*             newSamplerState(const class SamplerDescriptor* descriptor);
+
+    class Library*                  newDefaultLibrary();
+
+    class Library*                  newDefaultLibrary(const NS::Bundle* bundle, NS::Error** error);
+
+    class Library*                  newLibrary(const NS::String* filepath, NS::Error** error);
+
+    class Library*                  newLibrary(const NS::URL* url, NS::Error** error);
+
+    class Library*                  newLibrary(const dispatch_data_t data, NS::Error** error);
+
+    class Library*                  newLibrary(const NS::String* source, const class CompileOptions* options, NS::Error** error);
+
+    void                            newLibrary(const NS::String* source, const class CompileOptions* options, const MTL::NewLibraryCompletionHandler completionHandler);
+
+    class Library*                  newLibrary(const class StitchedLibraryDescriptor* descriptor, NS::Error** error);
+
+    void                            newLibrary(const class StitchedLibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler);
+
+    class RenderPipelineState*      newRenderPipelineState(const class RenderPipelineDescriptor* descriptor, NS::Error** error);
+
+    class RenderPipelineState*      newRenderPipelineState(const class RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error);
+
+    void                            newRenderPipelineState(const class RenderPipelineDescriptor* descriptor, const MTL::NewRenderPipelineStateCompletionHandler completionHandler);
+
+    void                            newRenderPipelineState(const class RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler);
+
+    class ComputePipelineState*     newComputePipelineState(const class Function* computeFunction, NS::Error** error);
+
+    class ComputePipelineState*     newComputePipelineState(const class Function* computeFunction, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error);
+
+    void                            newComputePipelineState(const class Function* computeFunction, const MTL::NewComputePipelineStateCompletionHandler completionHandler);
+
+    void                            newComputePipelineState(const class Function* computeFunction, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler);
+
+    class ComputePipelineState*     newComputePipelineState(const class ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error);
+
+    void                            newComputePipelineState(const class ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler);
+
+    class Fence*                    newFence();
+
+    bool                            supportsFeatureSet(MTL::FeatureSet featureSet);
+
+    bool                            supportsFamily(MTL::GPUFamily gpuFamily);
+
+    bool                            supportsTextureSampleCount(NS::UInteger sampleCount);
+
+    NS::UInteger                    minimumLinearTextureAlignmentForPixelFormat(MTL::PixelFormat format);
+
+    NS::UInteger                    minimumTextureBufferAlignmentForPixelFormat(MTL::PixelFormat format);
+
+    class RenderPipelineState*      newRenderPipelineState(const class TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error);
+
+    void                            newRenderPipelineState(const class TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler);
+
+    class RenderPipelineState*      newRenderPipelineState(const class MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error);
+
+    void                            newRenderPipelineState(const class MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler);
+
+    NS::UInteger                    maxThreadgroupMemoryLength() const;
+
+    NS::UInteger                    maxArgumentBufferSamplerCount() const;
+
+    bool                            programmableSamplePositionsSupported() const;
+
+    void                            getDefaultSamplePositions(MTL::SamplePosition* positions, NS::UInteger count);
+
+    class ArgumentEncoder*          newArgumentEncoder(const NS::Array* arguments);
+
+    bool                            supportsRasterizationRateMap(NS::UInteger layerCount);
+
+    class RasterizationRateMap*     newRasterizationRateMap(const class RasterizationRateMapDescriptor* descriptor);
+
+    class IndirectCommandBuffer*    newIndirectCommandBuffer(const class IndirectCommandBufferDescriptor* descriptor, NS::UInteger maxCount, MTL::ResourceOptions options);
+
+    class Event*                    newEvent();
+
+    class SharedEvent*              newSharedEvent();
+
+    class SharedEvent*              newSharedEvent(const class SharedEventHandle* sharedEventHandle);
+
+    uint64_t                        peerGroupID() const;
+
+    uint32_t                        peerIndex() const;
+
+    uint32_t                        peerCount() const;
+
+    class IOFileHandle*             newIOHandle(const NS::URL* url, NS::Error** error);
+
+    class IOCommandQueue*           newIOCommandQueue(const class IOCommandQueueDescriptor* descriptor, NS::Error** error);
+
+    class IOFileHandle*             newIOHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error);
+
+    class IOFileHandle*             newIOFileHandle(const NS::URL* url, NS::Error** error);
+
+    class IOFileHandle*             newIOFileHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error);
+
+    MTL::Size                       sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount);
+
+    NS::UInteger                    sparseTileSizeInBytes() const;
+
+    void                            convertSparsePixelRegions(const MTL::Region* pixelRegions, MTL::Region* tileRegions, MTL::Size tileSize, MTL::SparseTextureRegionAlignmentMode mode, NS::UInteger numRegions);
+
+    void                            convertSparseTileRegions(const MTL::Region* tileRegions, MTL::Region* pixelRegions, MTL::Size tileSize, NS::UInteger numRegions);
+
+    NS::UInteger                    sparseTileSizeInBytes(MTL::SparsePageSize sparsePageSize);
+
+    MTL::Size                       sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount, MTL::SparsePageSize sparsePageSize);
+
+    NS::UInteger                    maxBufferLength() const;
+
+    NS::Array*                      counterSets() const;
+
+    class CounterSampleBuffer*      newCounterSampleBuffer(const class CounterSampleBufferDescriptor* descriptor, NS::Error** error);
+
+    void                            sampleTimestamps(MTL::Timestamp* cpuTimestamp, MTL::Timestamp* gpuTimestamp);
+
+    class ArgumentEncoder*          newArgumentEncoder(const class BufferBinding* bufferBinding);
+
+    bool                            supportsCounterSampling(MTL::CounterSamplingPoint samplingPoint);
+
+    bool                            supportsVertexAmplificationCount(NS::UInteger count);
+
+    bool                            supportsDynamicLibraries() const;
+
+    bool                            supportsRenderDynamicLibraries() const;
+
+    class DynamicLibrary*           newDynamicLibrary(const class Library* library, NS::Error** error);
+
+    class DynamicLibrary*           newDynamicLibrary(const NS::URL* url, NS::Error** error);
+
+    class BinaryArchive*            newBinaryArchive(const class BinaryArchiveDescriptor* descriptor, NS::Error** error);
+
+    bool                            supportsRaytracing() const;
+
+    MTL::AccelerationStructureSizes accelerationStructureSizes(const class AccelerationStructureDescriptor* descriptor);
+
+    class AccelerationStructure*    newAccelerationStructure(NS::UInteger size);
+
+    class AccelerationStructure*    newAccelerationStructure(const class AccelerationStructureDescriptor* descriptor);
+
+    MTL::SizeAndAlign               heapAccelerationStructureSizeAndAlign(NS::UInteger size);
+
+    MTL::SizeAndAlign               heapAccelerationStructureSizeAndAlign(const class AccelerationStructureDescriptor* descriptor);
+
+    bool                            supportsFunctionPointers() const;
+
+    bool                            supportsFunctionPointersFromRender() const;
+
+    bool                            supportsRaytracingFromRender() const;
+
+    bool                            supportsPrimitiveMotionBlur() const;
+
+    bool                            shouldMaximizeConcurrentCompilation() const;
+    void                            setShouldMaximizeConcurrentCompilation(bool shouldMaximizeConcurrentCompilation);
+
+    NS::UInteger                    maximumConcurrentCompilationTaskCount() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ArgumentDescriptor* MTL::ArgumentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::ArgumentDescriptor>(_MTL_PRIVATE_CLS(MTLArgumentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::ArgumentDescriptor* MTL::ArgumentDescriptor::init()
+{
+    return NS::Object::init<MTL::ArgumentDescriptor>();
+}
+
+// static method: argumentDescriptor
+_MTL_INLINE MTL::ArgumentDescriptor* MTL::ArgumentDescriptor::argumentDescriptor()
+{
+    return Object::sendMessage<MTL::ArgumentDescriptor*>(_MTL_PRIVATE_CLS(MTLArgumentDescriptor), _MTL_PRIVATE_SEL(argumentDescriptor));
+}
+
+// property: dataType
+_MTL_INLINE MTL::DataType MTL::ArgumentDescriptor::dataType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(dataType));
+}
+
+_MTL_INLINE void MTL::ArgumentDescriptor::setDataType(MTL::DataType dataType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDataType_), dataType);
+}
+
+// property: index
+_MTL_INLINE NS::UInteger MTL::ArgumentDescriptor::index() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(index));
+}
+
+_MTL_INLINE void MTL::ArgumentDescriptor::setIndex(NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndex_), index);
+}
+
+// property: arrayLength
+_MTL_INLINE NS::UInteger MTL::ArgumentDescriptor::arrayLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
+}
+
+_MTL_INLINE void MTL::ArgumentDescriptor::setArrayLength(NS::UInteger arrayLength)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArrayLength_), arrayLength);
+}
+
+// property: access
+_MTL_INLINE MTL::BindingAccess MTL::ArgumentDescriptor::access() const
+{
+    return Object::sendMessage<MTL::BindingAccess>(this, _MTL_PRIVATE_SEL(access));
+}
+
+_MTL_INLINE void MTL::ArgumentDescriptor::setAccess(MTL::BindingAccess access)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAccess_), access);
+}
+
+// property: textureType
+_MTL_INLINE MTL::TextureType MTL::ArgumentDescriptor::textureType() const
+{
+    return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
+}
+
+_MTL_INLINE void MTL::ArgumentDescriptor::setTextureType(MTL::TextureType textureType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTextureType_), textureType);
+}
+
+// property: constantBlockAlignment
+_MTL_INLINE NS::UInteger MTL::ArgumentDescriptor::constantBlockAlignment() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(constantBlockAlignment));
+}
+
+_MTL_INLINE void MTL::ArgumentDescriptor::setConstantBlockAlignment(NS::UInteger constantBlockAlignment)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantBlockAlignment_), constantBlockAlignment);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::Architecture* MTL::Architecture::alloc()
+{
+    return NS::Object::alloc<MTL::Architecture>(_MTL_PRIVATE_CLS(MTLArchitecture));
+}
+
+// method: init
+_MTL_INLINE MTL::Architecture* MTL::Architecture::init()
+{
+    return NS::Object::init<MTL::Architecture>();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::Architecture::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+_MTL_PRIVATE_DEF_WEAK_CONST(MTL::DeviceNotificationName, DeviceWasAddedNotification);
+_MTL_PRIVATE_DEF_WEAK_CONST(MTL::DeviceNotificationName, DeviceRemovalRequestedNotification);
+_MTL_PRIVATE_DEF_WEAK_CONST(MTL::DeviceNotificationName, DeviceWasRemovedNotification);
+_MTL_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, CommandBufferEncoderInfoErrorKey);
+
+#if defined(MTL_PRIVATE_IMPLEMENTATION)
+
+extern "C" MTL::Device* MTLCreateSystemDefaultDevice();
+
+extern "C" NS::Array*   MTLCopyAllDevices();
+
+extern "C" NS::Array*   MTLCopyAllDevicesWithObserver(NS::Object**, MTL::DeviceNotificationHandlerBlock);
+
+extern "C" void         MTLRemoveDeviceObserver(const NS::Object*);
+
+#include <TargetConditionals.h>
+
+_NS_EXPORT MTL::Device* MTL::CreateSystemDefaultDevice()
+{
+    return ::MTLCreateSystemDefaultDevice();
+}
+
+_NS_EXPORT NS::Array* MTL::CopyAllDevices()
+{
+#if TARGET_OS_OSX
+    return ::MTLCopyAllDevices();
+#else
+    return nullptr;
+#endif // TARGET_OS_OSX
+}
+
+_NS_EXPORT NS::Array* MTL::CopyAllDevicesWithObserver(NS::Object** pOutObserver, DeviceNotificationHandlerBlock handler)
+{
+#if TARGET_OS_OSX
+    return ::MTLCopyAllDevicesWithObserver(pOutObserver, handler);
+#else
+    (void)pOutObserver;
+    (void)handler;
+
+    return nullptr;
+#endif // TARGET_OS_OSX
+}
+
+_NS_EXPORT NS::Array* MTL::CopyAllDevicesWithObserver(NS::Object** pOutObserver, const DeviceNotificationHandlerFunction& handler)
+{
+    __block DeviceNotificationHandlerFunction function = handler;
+
+    return CopyAllDevicesWithObserver(pOutObserver, ^(Device* pDevice, DeviceNotificationName pNotificationName) { function(pDevice, pNotificationName); });
+}
+
+_NS_EXPORT void MTL::RemoveDeviceObserver(const NS::Object* pObserver)
+{
+#if TARGET_OS_OSX
+    ::MTLRemoveDeviceObserver(pObserver);
+#endif // TARGET_OS_OSX
+}
+
+#endif // MTL_PRIVATE_IMPLEMENTATION
+
+_MTL_INLINE void MTL::Device::newLibrary(const NS::String* pSource, const CompileOptions* pOptions, const NewLibraryCompletionHandlerFunction& completionHandler)
+{
+    __block NewLibraryCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newLibrary(pSource, pOptions, ^(Library* pLibrary, NS::Error* pError) { blockCompletionHandler(pLibrary, pError); });
+}
+
+_MTL_INLINE void MTL::Device::newLibrary(const class StitchedLibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& completionHandler)
+{
+    __block NewLibraryCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newLibrary(pDescriptor, ^(Library* pLibrary, NS::Error* pError) { blockCompletionHandler(pLibrary, pError); });
+}
+
+_MTL_INLINE void MTL::Device::newRenderPipelineState(const RenderPipelineDescriptor* pDescriptor, const NewRenderPipelineStateCompletionHandlerFunction& completionHandler)
+{
+    __block NewRenderPipelineStateCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newRenderPipelineState(pDescriptor, ^(RenderPipelineState* pPipelineState, NS::Error* pError) { blockCompletionHandler(pPipelineState, pError); });
+}
+
+_MTL_INLINE void MTL::Device::newRenderPipelineState(const RenderPipelineDescriptor* pDescriptor, PipelineOption options, const NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler)
+{
+    __block NewRenderPipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newRenderPipelineState(pDescriptor, options, ^(RenderPipelineState* pPipelineState, class RenderPipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); });
+}
+
+_MTL_INLINE void MTL::Device::newRenderPipelineState(const TileRenderPipelineDescriptor* pDescriptor, PipelineOption options, const NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler)
+{
+    __block NewRenderPipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newRenderPipelineState(pDescriptor, options, ^(RenderPipelineState* pPipelineState, class RenderPipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); });
+}
+
+_MTL_INLINE void MTL::Device::newComputePipelineState(const class Function* pFunction, const NewComputePipelineStateCompletionHandlerFunction& completionHandler)
+{
+    __block NewComputePipelineStateCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newComputePipelineState(pFunction, ^(ComputePipelineState* pPipelineState, NS::Error* pError) { blockCompletionHandler(pPipelineState, pError); });
+}
+
+_MTL_INLINE void MTL::Device::newComputePipelineState(const Function* pFunction, PipelineOption options, const NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler)
+{
+    __block NewComputePipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newComputePipelineState(pFunction, options, ^(ComputePipelineState* pPipelineState, ComputePipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); });
+}
+
+_MTL_INLINE void MTL::Device::newComputePipelineState(const ComputePipelineDescriptor* pDescriptor, PipelineOption options, const NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler)
+{
+    __block NewComputePipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler;
+
+    newComputePipelineState(pDescriptor, options, ^(ComputePipelineState* pPipelineState, ComputePipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); });
+}
+
+_MTL_INLINE bool MTL::Device::isHeadless() const
+{
+    return headless();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::Device::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: registryID
+_MTL_INLINE uint64_t MTL::Device::registryID() const
+{
+    return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(registryID));
+}
+
+// property: architecture
+_MTL_INLINE MTL::Architecture* MTL::Device::architecture() const
+{
+    return Object::sendMessage<MTL::Architecture*>(this, _MTL_PRIVATE_SEL(architecture));
+}
+
+// property: maxThreadsPerThreadgroup
+_MTL_INLINE MTL::Size MTL::Device::maxThreadsPerThreadgroup() const
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(maxThreadsPerThreadgroup));
+}
+
+// property: lowPower
+_MTL_INLINE bool MTL::Device::lowPower() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isLowPower));
+}
+
+// property: headless
+_MTL_INLINE bool MTL::Device::headless() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isHeadless));
+}
+
+// property: removable
+_MTL_INLINE bool MTL::Device::removable() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRemovable));
+}
+
+// property: hasUnifiedMemory
+_MTL_INLINE bool MTL::Device::hasUnifiedMemory() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(hasUnifiedMemory));
+}
+
+// property: recommendedMaxWorkingSetSize
+_MTL_INLINE uint64_t MTL::Device::recommendedMaxWorkingSetSize() const
+{
+    return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(recommendedMaxWorkingSetSize));
+}
+
+// property: location
+_MTL_INLINE MTL::DeviceLocation MTL::Device::location() const
+{
+    return Object::sendMessage<MTL::DeviceLocation>(this, _MTL_PRIVATE_SEL(location));
+}
+
+// property: locationNumber
+_MTL_INLINE NS::UInteger MTL::Device::locationNumber() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(locationNumber));
+}
+
+// property: maxTransferRate
+_MTL_INLINE uint64_t MTL::Device::maxTransferRate() const
+{
+    return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(maxTransferRate));
+}
+
+// property: depth24Stencil8PixelFormatSupported
+_MTL_INLINE bool MTL::Device::depth24Stencil8PixelFormatSupported() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(isDepth24Stencil8PixelFormatSupported));
+}
+
+// property: readWriteTextureSupport
+_MTL_INLINE MTL::ReadWriteTextureTier MTL::Device::readWriteTextureSupport() const
+{
+    return Object::sendMessage<MTL::ReadWriteTextureTier>(this, _MTL_PRIVATE_SEL(readWriteTextureSupport));
+}
+
+// property: argumentBuffersSupport
+_MTL_INLINE MTL::ArgumentBuffersTier MTL::Device::argumentBuffersSupport() const
+{
+    return Object::sendMessage<MTL::ArgumentBuffersTier>(this, _MTL_PRIVATE_SEL(argumentBuffersSupport));
+}
+
+// property: rasterOrderGroupsSupported
+_MTL_INLINE bool MTL::Device::rasterOrderGroupsSupported() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(areRasterOrderGroupsSupported));
+}
+
+// property: supports32BitFloatFiltering
+_MTL_INLINE bool MTL::Device::supports32BitFloatFiltering() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supports32BitFloatFiltering));
+}
+
+// property: supports32BitMSAA
+_MTL_INLINE bool MTL::Device::supports32BitMSAA() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supports32BitMSAA));
+}
+
+// property: supportsQueryTextureLOD
+_MTL_INLINE bool MTL::Device::supportsQueryTextureLOD() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsQueryTextureLOD));
+}
+
+// property: supportsBCTextureCompression
+_MTL_INLINE bool MTL::Device::supportsBCTextureCompression() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsBCTextureCompression));
+}
+
+// property: supportsPullModelInterpolation
+_MTL_INLINE bool MTL::Device::supportsPullModelInterpolation() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsPullModelInterpolation));
+}
+
+// property: barycentricCoordsSupported
+_MTL_INLINE bool MTL::Device::barycentricCoordsSupported() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(areBarycentricCoordsSupported));
+}
+
+// property: supportsShaderBarycentricCoordinates
+_MTL_INLINE bool MTL::Device::supportsShaderBarycentricCoordinates() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsShaderBarycentricCoordinates));
+}
+
+// property: currentAllocatedSize
+_MTL_INLINE NS::UInteger MTL::Device::currentAllocatedSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(currentAllocatedSize));
+}
+
+// method: newCommandQueue
+_MTL_INLINE MTL::CommandQueue* MTL::Device::newCommandQueue()
+{
+    return Object::sendMessage<MTL::CommandQueue*>(this, _MTL_PRIVATE_SEL(newCommandQueue));
+}
+
+// method: newCommandQueueWithMaxCommandBufferCount:
+_MTL_INLINE MTL::CommandQueue* MTL::Device::newCommandQueue(NS::UInteger maxCommandBufferCount)
+{
+    return Object::sendMessage<MTL::CommandQueue*>(this, _MTL_PRIVATE_SEL(newCommandQueueWithMaxCommandBufferCount_), maxCommandBufferCount);
+}
+
+// method: heapTextureSizeAndAlignWithDescriptor:
+_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapTextureSizeAndAlign(const MTL::TextureDescriptor* desc)
+{
+    return Object::sendMessage<MTL::SizeAndAlign>(this, _MTL_PRIVATE_SEL(heapTextureSizeAndAlignWithDescriptor_), desc);
+}
+
+// method: heapBufferSizeAndAlignWithLength:options:
+_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapBufferSizeAndAlign(NS::UInteger length, MTL::ResourceOptions options)
+{
+    return Object::sendMessage<MTL::SizeAndAlign>(this, _MTL_PRIVATE_SEL(heapBufferSizeAndAlignWithLength_options_), length, options);
+}
+
+// method: newHeapWithDescriptor:
+_MTL_INLINE MTL::Heap* MTL::Device::newHeap(const MTL::HeapDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::Heap*>(this, _MTL_PRIVATE_SEL(newHeapWithDescriptor_), descriptor);
+}
+
+// method: newBufferWithLength:options:
+_MTL_INLINE MTL::Buffer* MTL::Device::newBuffer(NS::UInteger length, MTL::ResourceOptions options)
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_), length, options);
+}
+
+// method: newBufferWithBytes:length:options:
+_MTL_INLINE MTL::Buffer* MTL::Device::newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options)
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newBufferWithBytes_length_options_), pointer, length, options);
+}
+
+// method: newBufferWithBytesNoCopy:length:options:deallocator:
+_MTL_INLINE MTL::Buffer* MTL::Device::newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options, void (^deallocator)(void*, NS::UInteger))
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newBufferWithBytesNoCopy_length_options_deallocator_), pointer, length, options, deallocator);
+}
+
+// method: newDepthStencilStateWithDescriptor:
+_MTL_INLINE MTL::DepthStencilState* MTL::Device::newDepthStencilState(const MTL::DepthStencilDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::DepthStencilState*>(this, _MTL_PRIVATE_SEL(newDepthStencilStateWithDescriptor_), descriptor);
+}
+
+// method: newTextureWithDescriptor:
+_MTL_INLINE MTL::Texture* MTL::Device::newTexture(const MTL::TextureDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_), descriptor);
+}
+
+// method: newTextureWithDescriptor:iosurface:plane:
+_MTL_INLINE MTL::Texture* MTL::Device::newTexture(const MTL::TextureDescriptor* descriptor, const IOSurfaceRef iosurface, NS::UInteger plane)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_iosurface_plane_), descriptor, iosurface, plane);
+}
+
+// method: newSharedTextureWithDescriptor:
+_MTL_INLINE MTL::Texture* MTL::Device::newSharedTexture(const MTL::TextureDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newSharedTextureWithDescriptor_), descriptor);
+}
+
+// method: newSharedTextureWithHandle:
+_MTL_INLINE MTL::Texture* MTL::Device::newSharedTexture(const MTL::SharedTextureHandle* sharedHandle)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newSharedTextureWithHandle_), sharedHandle);
+}
+
+// method: newSamplerStateWithDescriptor:
+_MTL_INLINE MTL::SamplerState* MTL::Device::newSamplerState(const MTL::SamplerDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::SamplerState*>(this, _MTL_PRIVATE_SEL(newSamplerStateWithDescriptor_), descriptor);
+}
+
+// method: newDefaultLibrary
+_MTL_INLINE MTL::Library* MTL::Device::newDefaultLibrary()
+{
+    return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newDefaultLibrary));
+}
+
+// method: newDefaultLibraryWithBundle:error:
+_MTL_INLINE MTL::Library* MTL::Device::newDefaultLibrary(const NS::Bundle* bundle, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newDefaultLibraryWithBundle_error_), bundle, error);
+}
+
+// method: newLibraryWithFile:error:
+_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const NS::String* filepath, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newLibraryWithFile_error_), filepath, error);
+}
+
+// method: newLibraryWithURL:error:
+_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const NS::URL* url, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newLibraryWithURL_error_), url, error);
+}
+
+// method: newLibraryWithData:error:
+_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const dispatch_data_t data, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newLibraryWithData_error_), data, error);
+}
+
+// method: newLibraryWithSource:options:error:
+_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const NS::String* source, const MTL::CompileOptions* options, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newLibraryWithSource_options_error_), source, options, error);
+}
+
+// method: newLibraryWithSource:options:completionHandler:
+_MTL_INLINE void MTL::Device::newLibrary(const NS::String* source, const MTL::CompileOptions* options, const MTL::NewLibraryCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newLibraryWithSource_options_completionHandler_), source, options, completionHandler);
+}
+
+// method: newLibraryWithStitchedDescriptor:error:
+_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const MTL::StitchedLibraryDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Library*>(this, _MTL_PRIVATE_SEL(newLibraryWithStitchedDescriptor_error_), descriptor, error);
+}
+
+// method: newLibraryWithStitchedDescriptor:completionHandler:
+_MTL_INLINE void MTL::Device::newLibrary(const MTL::StitchedLibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newLibraryWithStitchedDescriptor_completionHandler_), descriptor, completionHandler);
+}
+
+// method: newRenderPipelineStateWithDescriptor:error:
+_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_error_), descriptor, error);
+}
+
+// method: newRenderPipelineStateWithDescriptor:options:reflection:error:
+_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error)
+{
+    return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_options_reflection_error_), descriptor, options, reflection, error);
+}
+
+// method: newRenderPipelineStateWithDescriptor:completionHandler:
+_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, const MTL::NewRenderPipelineStateCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_completionHandler_), descriptor, completionHandler);
+}
+
+// method: newRenderPipelineStateWithDescriptor:options:completionHandler:
+_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_options_completionHandler_), descriptor, options, completionHandler);
+}
+
+// method: newComputePipelineStateWithFunction:error:
+_MTL_INLINE MTL::ComputePipelineState* MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, NS::Error** error)
+{
+    return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_error_), computeFunction, error);
+}
+
+// method: newComputePipelineStateWithFunction:options:reflection:error:
+_MTL_INLINE MTL::ComputePipelineState* MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error)
+{
+    return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_options_reflection_error_), computeFunction, options, reflection, error);
+}
+
+// method: newComputePipelineStateWithFunction:completionHandler:
+_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, const MTL::NewComputePipelineStateCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_completionHandler_), computeFunction, completionHandler);
+}
+
+// method: newComputePipelineStateWithFunction:options:completionHandler:
+_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_options_completionHandler_), computeFunction, options, completionHandler);
+}
+
+// method: newComputePipelineStateWithDescriptor:options:reflection:error:
+_MTL_INLINE MTL::ComputePipelineState* MTL::Device::newComputePipelineState(const MTL::ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error)
+{
+    return Object::sendMessage<MTL::ComputePipelineState*>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_options_reflection_error_), descriptor, options, reflection, error);
+}
+
+// method: newComputePipelineStateWithDescriptor:options:completionHandler:
+_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_options_completionHandler_), descriptor, options, completionHandler);
+}
+
+// method: newFence
+_MTL_INLINE MTL::Fence* MTL::Device::newFence()
+{
+    return Object::sendMessage<MTL::Fence*>(this, _MTL_PRIVATE_SEL(newFence));
+}
+
+// method: supportsFeatureSet:
+_MTL_INLINE bool MTL::Device::supportsFeatureSet(MTL::FeatureSet featureSet)
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsFeatureSet_), featureSet);
+}
+
+// method: supportsFamily:
+_MTL_INLINE bool MTL::Device::supportsFamily(MTL::GPUFamily gpuFamily)
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsFamily_), gpuFamily);
+}
+
+// method: supportsTextureSampleCount:
+_MTL_INLINE bool MTL::Device::supportsTextureSampleCount(NS::UInteger sampleCount)
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsTextureSampleCount_), sampleCount);
+}
+
+// method: minimumLinearTextureAlignmentForPixelFormat:
+_MTL_INLINE NS::UInteger MTL::Device::minimumLinearTextureAlignmentForPixelFormat(MTL::PixelFormat format)
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(minimumLinearTextureAlignmentForPixelFormat_), format);
+}
+
+// method: minimumTextureBufferAlignmentForPixelFormat:
+_MTL_INLINE NS::UInteger MTL::Device::minimumTextureBufferAlignmentForPixelFormat(MTL::PixelFormat format)
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(minimumTextureBufferAlignmentForPixelFormat_), format);
+}
+
+// method: newRenderPipelineStateWithTileDescriptor:options:reflection:error:
+_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error)
+{
+    return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithTileDescriptor_options_reflection_error_), descriptor, options, reflection, error);
+}
+
+// method: newRenderPipelineStateWithTileDescriptor:options:completionHandler:
+_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithTileDescriptor_options_completionHandler_), descriptor, options, completionHandler);
+}
+
+// method: newRenderPipelineStateWithMeshDescriptor:options:reflection:error:
+_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error)
+{
+    return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithMeshDescriptor_options_reflection_error_), descriptor, options, reflection, error);
+}
+
+// method: newRenderPipelineStateWithMeshDescriptor:options:completionHandler:
+_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithMeshDescriptor_options_completionHandler_), descriptor, options, completionHandler);
+}
+
+// property: maxThreadgroupMemoryLength
+_MTL_INLINE NS::UInteger MTL::Device::maxThreadgroupMemoryLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxThreadgroupMemoryLength));
+}
+
+// property: maxArgumentBufferSamplerCount
+_MTL_INLINE NS::UInteger MTL::Device::maxArgumentBufferSamplerCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxArgumentBufferSamplerCount));
+}
+
+// property: programmableSamplePositionsSupported
+_MTL_INLINE bool MTL::Device::programmableSamplePositionsSupported() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(areProgrammableSamplePositionsSupported));
+}
+
+// method: getDefaultSamplePositions:count:
+_MTL_INLINE void MTL::Device::getDefaultSamplePositions(MTL::SamplePosition* positions, NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(getDefaultSamplePositions_count_), positions, count);
+}
+
+// method: newArgumentEncoderWithArguments:
+_MTL_INLINE MTL::ArgumentEncoder* MTL::Device::newArgumentEncoder(const NS::Array* arguments)
+{
+    return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithArguments_), arguments);
+}
+
+// method: supportsRasterizationRateMapWithLayerCount:
+_MTL_INLINE bool MTL::Device::supportsRasterizationRateMap(NS::UInteger layerCount)
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsRasterizationRateMapWithLayerCount_), layerCount);
+}
+
+// method: newRasterizationRateMapWithDescriptor:
+_MTL_INLINE MTL::RasterizationRateMap* MTL::Device::newRasterizationRateMap(const MTL::RasterizationRateMapDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::RasterizationRateMap*>(this, _MTL_PRIVATE_SEL(newRasterizationRateMapWithDescriptor_), descriptor);
+}
+
+// method: newIndirectCommandBufferWithDescriptor:maxCommandCount:options:
+_MTL_INLINE MTL::IndirectCommandBuffer* MTL::Device::newIndirectCommandBuffer(const MTL::IndirectCommandBufferDescriptor* descriptor, NS::UInteger maxCount, MTL::ResourceOptions options)
+{
+    return Object::sendMessage<MTL::IndirectCommandBuffer*>(this, _MTL_PRIVATE_SEL(newIndirectCommandBufferWithDescriptor_maxCommandCount_options_), descriptor, maxCount, options);
+}
+
+// method: newEvent
+_MTL_INLINE MTL::Event* MTL::Device::newEvent()
+{
+    return Object::sendMessage<MTL::Event*>(this, _MTL_PRIVATE_SEL(newEvent));
+}
+
+// method: newSharedEvent
+_MTL_INLINE MTL::SharedEvent* MTL::Device::newSharedEvent()
+{
+    return Object::sendMessage<MTL::SharedEvent*>(this, _MTL_PRIVATE_SEL(newSharedEvent));
+}
+
+// method: newSharedEventWithHandle:
+_MTL_INLINE MTL::SharedEvent* MTL::Device::newSharedEvent(const MTL::SharedEventHandle* sharedEventHandle)
+{
+    return Object::sendMessage<MTL::SharedEvent*>(this, _MTL_PRIVATE_SEL(newSharedEventWithHandle_), sharedEventHandle);
+}
+
+// property: peerGroupID
+_MTL_INLINE uint64_t MTL::Device::peerGroupID() const
+{
+    return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(peerGroupID));
+}
+
+// property: peerIndex
+_MTL_INLINE uint32_t MTL::Device::peerIndex() const
+{
+    return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(peerIndex));
+}
+
+// property: peerCount
+_MTL_INLINE uint32_t MTL::Device::peerCount() const
+{
+    return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(peerCount));
+}
+
+// method: newIOHandleWithURL:error:
+_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOHandle(const NS::URL* url, NS::Error** error)
+{
+    return Object::sendMessage<MTL::IOFileHandle*>(this, _MTL_PRIVATE_SEL(newIOHandleWithURL_error_), url, error);
+}
+
+// method: newIOCommandQueueWithDescriptor:error:
+_MTL_INLINE MTL::IOCommandQueue* MTL::Device::newIOCommandQueue(const MTL::IOCommandQueueDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<MTL::IOCommandQueue*>(this, _MTL_PRIVATE_SEL(newIOCommandQueueWithDescriptor_error_), descriptor, error);
+}
+
+// method: newIOHandleWithURL:compressionMethod:error:
+_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error)
+{
+    return Object::sendMessage<MTL::IOFileHandle*>(this, _MTL_PRIVATE_SEL(newIOHandleWithURL_compressionMethod_error_), url, compressionMethod, error);
+}
+
+// method: newIOFileHandleWithURL:error:
+_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOFileHandle(const NS::URL* url, NS::Error** error)
+{
+    return Object::sendMessage<MTL::IOFileHandle*>(this, _MTL_PRIVATE_SEL(newIOFileHandleWithURL_error_), url, error);
+}
+
+// method: newIOFileHandleWithURL:compressionMethod:error:
+_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOFileHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error)
+{
+    return Object::sendMessage<MTL::IOFileHandle*>(this, _MTL_PRIVATE_SEL(newIOFileHandleWithURL_compressionMethod_error_), url, compressionMethod, error);
+}
+
+// method: sparseTileSizeWithTextureType:pixelFormat:sampleCount:
+_MTL_INLINE MTL::Size MTL::Device::sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount)
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_), textureType, pixelFormat, sampleCount);
+}
+
+// property: sparseTileSizeInBytes
+_MTL_INLINE NS::UInteger MTL::Device::sparseTileSizeInBytes() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sparseTileSizeInBytes));
+}
+
+// method: convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:
+_MTL_INLINE void MTL::Device::convertSparsePixelRegions(const MTL::Region* pixelRegions, MTL::Region* tileRegions, MTL::Size tileSize, MTL::SparseTextureRegionAlignmentMode mode, NS::UInteger numRegions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(convertSparsePixelRegions_toTileRegions_withTileSize_alignmentMode_numRegions_), pixelRegions, tileRegions, tileSize, mode, numRegions);
+}
+
+// method: convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:
+_MTL_INLINE void MTL::Device::convertSparseTileRegions(const MTL::Region* tileRegions, MTL::Region* pixelRegions, MTL::Size tileSize, NS::UInteger numRegions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(convertSparseTileRegions_toPixelRegions_withTileSize_numRegions_), tileRegions, pixelRegions, tileSize, numRegions);
+}
+
+// method: sparseTileSizeInBytesForSparsePageSize:
+_MTL_INLINE NS::UInteger MTL::Device::sparseTileSizeInBytes(MTL::SparsePageSize sparsePageSize)
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sparseTileSizeInBytesForSparsePageSize_), sparsePageSize);
+}
+
+// method: sparseTileSizeWithTextureType:pixelFormat:sampleCount:sparsePageSize:
+_MTL_INLINE MTL::Size MTL::Device::sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount, MTL::SparsePageSize sparsePageSize)
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_sparsePageSize_), textureType, pixelFormat, sampleCount, sparsePageSize);
+}
+
+// property: maxBufferLength
+_MTL_INLINE NS::UInteger MTL::Device::maxBufferLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxBufferLength));
+}
+
+// property: counterSets
+_MTL_INLINE NS::Array* MTL::Device::counterSets() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(counterSets));
+}
+
+// method: newCounterSampleBufferWithDescriptor:error:
+_MTL_INLINE MTL::CounterSampleBuffer* MTL::Device::newCounterSampleBuffer(const MTL::CounterSampleBufferDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(newCounterSampleBufferWithDescriptor_error_), descriptor, error);
+}
+
+// method: sampleTimestamps:gpuTimestamp:
+_MTL_INLINE void MTL::Device::sampleTimestamps(MTL::Timestamp* cpuTimestamp, MTL::Timestamp* gpuTimestamp)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleTimestamps_gpuTimestamp_), cpuTimestamp, gpuTimestamp);
+}
+
+// method: newArgumentEncoderWithBufferBinding:
+_MTL_INLINE MTL::ArgumentEncoder* MTL::Device::newArgumentEncoder(const MTL::BufferBinding* bufferBinding)
+{
+    return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferBinding_), bufferBinding);
+}
+
+// method: supportsCounterSampling:
+_MTL_INLINE bool MTL::Device::supportsCounterSampling(MTL::CounterSamplingPoint samplingPoint)
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsCounterSampling_), samplingPoint);
+}
+
+// method: supportsVertexAmplificationCount:
+_MTL_INLINE bool MTL::Device::supportsVertexAmplificationCount(NS::UInteger count)
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsVertexAmplificationCount_), count);
+}
+
+// property: supportsDynamicLibraries
+_MTL_INLINE bool MTL::Device::supportsDynamicLibraries() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsDynamicLibraries));
+}
+
+// property: supportsRenderDynamicLibraries
+_MTL_INLINE bool MTL::Device::supportsRenderDynamicLibraries() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsRenderDynamicLibraries));
+}
+
+// method: newDynamicLibrary:error:
+_MTL_INLINE MTL::DynamicLibrary* MTL::Device::newDynamicLibrary(const MTL::Library* library, NS::Error** error)
+{
+    return Object::sendMessage<MTL::DynamicLibrary*>(this, _MTL_PRIVATE_SEL(newDynamicLibrary_error_), library, error);
+}
+
+// method: newDynamicLibraryWithURL:error:
+_MTL_INLINE MTL::DynamicLibrary* MTL::Device::newDynamicLibrary(const NS::URL* url, NS::Error** error)
+{
+    return Object::sendMessage<MTL::DynamicLibrary*>(this, _MTL_PRIVATE_SEL(newDynamicLibraryWithURL_error_), url, error);
+}
+
+// method: newBinaryArchiveWithDescriptor:error:
+_MTL_INLINE MTL::BinaryArchive* MTL::Device::newBinaryArchive(const MTL::BinaryArchiveDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<MTL::BinaryArchive*>(this, _MTL_PRIVATE_SEL(newBinaryArchiveWithDescriptor_error_), descriptor, error);
+}
+
+// property: supportsRaytracing
+_MTL_INLINE bool MTL::Device::supportsRaytracing() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsRaytracing));
+}
+
+// method: accelerationStructureSizesWithDescriptor:
+_MTL_INLINE MTL::AccelerationStructureSizes MTL::Device::accelerationStructureSizes(const MTL::AccelerationStructureDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::AccelerationStructureSizes>(this, _MTL_PRIVATE_SEL(accelerationStructureSizesWithDescriptor_), descriptor);
+}
+
+// method: newAccelerationStructureWithSize:
+_MTL_INLINE MTL::AccelerationStructure* MTL::Device::newAccelerationStructure(NS::UInteger size)
+{
+    return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_), size);
+}
+
+// method: newAccelerationStructureWithDescriptor:
+_MTL_INLINE MTL::AccelerationStructure* MTL::Device::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_), descriptor);
+}
+
+// method: heapAccelerationStructureSizeAndAlignWithSize:
+_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapAccelerationStructureSizeAndAlign(NS::UInteger size)
+{
+    return Object::sendMessage<MTL::SizeAndAlign>(this, _MTL_PRIVATE_SEL(heapAccelerationStructureSizeAndAlignWithSize_), size);
+}
+
+// method: heapAccelerationStructureSizeAndAlignWithDescriptor:
+_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapAccelerationStructureSizeAndAlign(const MTL::AccelerationStructureDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::SizeAndAlign>(this, _MTL_PRIVATE_SEL(heapAccelerationStructureSizeAndAlignWithDescriptor_), descriptor);
+}
+
+// property: supportsFunctionPointers
+_MTL_INLINE bool MTL::Device::supportsFunctionPointers() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsFunctionPointers));
+}
+
+// property: supportsFunctionPointersFromRender
+_MTL_INLINE bool MTL::Device::supportsFunctionPointersFromRender() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsFunctionPointersFromRender));
+}
+
+// property: supportsRaytracingFromRender
+_MTL_INLINE bool MTL::Device::supportsRaytracingFromRender() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsRaytracingFromRender));
+}
+
+// property: supportsPrimitiveMotionBlur
+_MTL_INLINE bool MTL::Device::supportsPrimitiveMotionBlur() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportsPrimitiveMotionBlur));
+}
+
+// property: shouldMaximizeConcurrentCompilation
+_MTL_INLINE bool MTL::Device::shouldMaximizeConcurrentCompilation() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(shouldMaximizeConcurrentCompilation));
+}
+
+_MTL_INLINE void MTL::Device::setShouldMaximizeConcurrentCompilation(bool shouldMaximizeConcurrentCompilation)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setShouldMaximizeConcurrentCompilation_), shouldMaximizeConcurrentCompilation);
+}
+
+// property: maximumConcurrentCompilationTaskCount
+_MTL_INLINE NS::UInteger MTL::Device::maximumConcurrentCompilationTaskCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maximumConcurrentCompilationTaskCount));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDrawable.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDrawable.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..58945d03672a22e0e637e18ec2e5775ce19aefc0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDrawable.hpp
@@ -0,0 +1,99 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLDrawable.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <functional>
+
+namespace MTL
+{
+using DrawablePresentedHandler = void (^)(class Drawable*);
+
+using DrawablePresentedHandlerFunction = std::function<void(class Drawable*)>;
+
+class Drawable : public NS::Referencing<Drawable>
+{
+public:
+    void           addPresentedHandler(const MTL::DrawablePresentedHandlerFunction& function);
+
+    void           present();
+
+    void           presentAtTime(CFTimeInterval presentationTime);
+
+    void           presentAfterMinimumDuration(CFTimeInterval duration);
+
+    void           addPresentedHandler(const MTL::DrawablePresentedHandler block);
+
+    CFTimeInterval presentedTime() const;
+
+    NS::UInteger   drawableID() const;
+};
+
+}
+
+_MTL_INLINE void MTL::Drawable::addPresentedHandler(const MTL::DrawablePresentedHandlerFunction& function)
+{
+    __block DrawablePresentedHandlerFunction blockFunction = function;
+
+    addPresentedHandler(^(Drawable* pDrawable) { blockFunction(pDrawable); });
+}
+
+// method: present
+_MTL_INLINE void MTL::Drawable::present()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(present));
+}
+
+// method: presentAtTime:
+_MTL_INLINE void MTL::Drawable::presentAtTime(CFTimeInterval presentationTime)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentAtTime_), presentationTime);
+}
+
+// method: presentAfterMinimumDuration:
+_MTL_INLINE void MTL::Drawable::presentAfterMinimumDuration(CFTimeInterval duration)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(presentAfterMinimumDuration_), duration);
+}
+
+// method: addPresentedHandler:
+_MTL_INLINE void MTL::Drawable::addPresentedHandler(const MTL::DrawablePresentedHandler block)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addPresentedHandler_), block);
+}
+
+// property: presentedTime
+_MTL_INLINE CFTimeInterval MTL::Drawable::presentedTime() const
+{
+    return Object::sendMessage<CFTimeInterval>(this, _MTL_PRIVATE_SEL(presentedTime));
+}
+
+// property: drawableID
+_MTL_INLINE NS::UInteger MTL::Drawable::drawableID() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(drawableID));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDynamicLibrary.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDynamicLibrary.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f951d12587d54ddd5ef0b5d61ab2236cda55201c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLDynamicLibrary.hpp
@@ -0,0 +1,82 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLDynamicLibrary.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, DynamicLibraryError) {
+    DynamicLibraryErrorNone = 0,
+    DynamicLibraryErrorInvalidFile = 1,
+    DynamicLibraryErrorCompilationFailure = 2,
+    DynamicLibraryErrorUnresolvedInstallName = 3,
+    DynamicLibraryErrorDependencyLoadFailure = 4,
+    DynamicLibraryErrorUnsupported = 5,
+};
+
+class DynamicLibrary : public NS::Referencing<DynamicLibrary>
+{
+public:
+    NS::String*   label() const;
+    void          setLabel(const NS::String* label);
+
+    class Device* device() const;
+
+    NS::String*   installName() const;
+
+    bool          serializeToURL(const NS::URL* url, NS::Error** error);
+};
+
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::DynamicLibrary::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::DynamicLibrary::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::DynamicLibrary::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: installName
+_MTL_INLINE NS::String* MTL::DynamicLibrary::installName() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(installName));
+}
+
+// method: serializeToURL:error:
+_MTL_INLINE bool MTL::DynamicLibrary::serializeToURL(const NS::URL* url, NS::Error** error)
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(serializeToURL_error_), url, error);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLEvent.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLEvent.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..965fc39e4af6b05c35328fea2f97caa3a7a369ab
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLEvent.hpp
@@ -0,0 +1,159 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLEvent.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLEvent.hpp"
+
+namespace MTL
+{
+class Event : public NS::Referencing<Event>
+{
+public:
+    class Device* device() const;
+
+    NS::String*   label() const;
+    void          setLabel(const NS::String* label);
+};
+
+class SharedEventListener : public NS::Referencing<SharedEventListener>
+{
+public:
+    static class SharedEventListener* alloc();
+
+    MTL::SharedEventListener*         init();
+
+    MTL::SharedEventListener*         init(const dispatch_queue_t dispatchQueue);
+
+    dispatch_queue_t                  dispatchQueue() const;
+};
+
+using SharedEventNotificationBlock = void (^)(SharedEvent* pEvent, std::uint64_t value);
+
+class SharedEvent : public NS::Referencing<SharedEvent, Event>
+{
+public:
+    void                     notifyListener(const class SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationBlock block);
+
+    class SharedEventHandle* newSharedEventHandle();
+
+    uint64_t                 signaledValue() const;
+    void                     setSignaledValue(uint64_t signaledValue);
+};
+
+class SharedEventHandle : public NS::SecureCoding<SharedEventHandle>
+{
+public:
+    static class SharedEventHandle* alloc();
+
+    class SharedEventHandle*        init();
+
+    NS::String*                     label() const;
+};
+
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::Event::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::Event::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::Event::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::alloc()
+{
+    return NS::Object::alloc<MTL::SharedEventListener>(_MTL_PRIVATE_CLS(MTLSharedEventListener));
+}
+
+// method: init
+_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::init()
+{
+    return NS::Object::init<MTL::SharedEventListener>();
+}
+
+// method: initWithDispatchQueue:
+_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::init(const dispatch_queue_t dispatchQueue)
+{
+    return Object::sendMessage<MTL::SharedEventListener*>(this, _MTL_PRIVATE_SEL(initWithDispatchQueue_), dispatchQueue);
+}
+
+// property: dispatchQueue
+_MTL_INLINE dispatch_queue_t MTL::SharedEventListener::dispatchQueue() const
+{
+    return Object::sendMessage<dispatch_queue_t>(this, _MTL_PRIVATE_SEL(dispatchQueue));
+}
+
+// method: notifyListener:atValue:block:
+_MTL_INLINE void MTL::SharedEvent::notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationBlock block)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(notifyListener_atValue_block_), listener, value, block);
+}
+
+// method: newSharedEventHandle
+_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEvent::newSharedEventHandle()
+{
+    return Object::sendMessage<MTL::SharedEventHandle*>(this, _MTL_PRIVATE_SEL(newSharedEventHandle));
+}
+
+// property: signaledValue
+_MTL_INLINE uint64_t MTL::SharedEvent::signaledValue() const
+{
+    return Object::sendMessage<uint64_t>(this, _MTL_PRIVATE_SEL(signaledValue));
+}
+
+_MTL_INLINE void MTL::SharedEvent::setSignaledValue(uint64_t signaledValue)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSignaledValue_), signaledValue);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEventHandle::alloc()
+{
+    return NS::Object::alloc<MTL::SharedEventHandle>(_MTL_PRIVATE_CLS(MTLSharedEventHandle));
+}
+
+// method: init
+_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEventHandle::init()
+{
+    return NS::Object::init<MTL::SharedEventHandle>();
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::SharedEventHandle::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFence.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFence.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8ef24ca72c3d1328164f5bc2d4ed6ff9be015d0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFence.hpp
@@ -0,0 +1,57 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLFence.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+class Fence : public NS::Referencing<Fence>
+{
+public:
+    class Device* device() const;
+
+    NS::String*   label() const;
+    void          setLabel(const NS::String* label);
+};
+
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::Fence::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::Fence::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::Fence::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionConstantValues.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionConstantValues.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..d23d98fc46ecdbf96f8b3fca44c0168846ad4b96
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionConstantValues.hpp
@@ -0,0 +1,85 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLFunctionConstantValues.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLArgument.hpp"
+
+namespace MTL
+{
+class FunctionConstantValues : public NS::Copying<FunctionConstantValues>
+{
+public:
+    static class FunctionConstantValues* alloc();
+
+    class FunctionConstantValues*        init();
+
+    void                                 setConstantValue(const void* value, MTL::DataType type, NS::UInteger index);
+
+    void                                 setConstantValues(const void* values, MTL::DataType type, NS::Range range);
+
+    void                                 setConstantValue(const void* value, MTL::DataType type, const NS::String* name);
+
+    void                                 reset();
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionConstantValues::alloc()
+{
+    return NS::Object::alloc<MTL::FunctionConstantValues>(_MTL_PRIVATE_CLS(MTLFunctionConstantValues));
+}
+
+// method: init
+_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionConstantValues::init()
+{
+    return NS::Object::init<MTL::FunctionConstantValues>();
+}
+
+// method: setConstantValue:type:atIndex:
+_MTL_INLINE void MTL::FunctionConstantValues::setConstantValue(const void* value, MTL::DataType type, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValue_type_atIndex_), value, type, index);
+}
+
+// method: setConstantValues:type:withRange:
+_MTL_INLINE void MTL::FunctionConstantValues::setConstantValues(const void* values, MTL::DataType type, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValues_type_withRange_), values, type, range);
+}
+
+// method: setConstantValue:type:withName:
+_MTL_INLINE void MTL::FunctionConstantValues::setConstantValue(const void* value, MTL::DataType type, const NS::String* name)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValue_type_withName_), value, type, name);
+}
+
+// method: reset
+_MTL_INLINE void MTL::FunctionConstantValues::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionDescriptor.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionDescriptor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec82d9815547bf38b97ca8235db74d2353c68663
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionDescriptor.hpp
@@ -0,0 +1,157 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLFunctionDescriptor.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLFunctionDescriptor.hpp"
+
+namespace MTL
+{
+_MTL_OPTIONS(NS::UInteger, FunctionOptions) {
+    FunctionOptionNone = 0,
+    FunctionOptionCompileToBinary = 1,
+    FunctionOptionStoreFunctionInMetalScript = 2,
+};
+
+class FunctionDescriptor : public NS::Copying<FunctionDescriptor>
+{
+public:
+    static class FunctionDescriptor* alloc();
+
+    class FunctionDescriptor*        init();
+
+    static class FunctionDescriptor* functionDescriptor();
+
+    NS::String*                      name() const;
+    void                             setName(const NS::String* name);
+
+    NS::String*                      specializedName() const;
+    void                             setSpecializedName(const NS::String* specializedName);
+
+    class FunctionConstantValues*    constantValues() const;
+    void                             setConstantValues(const class FunctionConstantValues* constantValues);
+
+    MTL::FunctionOptions             options() const;
+    void                             setOptions(MTL::FunctionOptions options);
+
+    NS::Array*                       binaryArchives() const;
+    void                             setBinaryArchives(const NS::Array* binaryArchives);
+};
+
+class IntersectionFunctionDescriptor : public NS::Copying<IntersectionFunctionDescriptor, MTL::FunctionDescriptor>
+{
+public:
+    static class IntersectionFunctionDescriptor* alloc();
+
+    class IntersectionFunctionDescriptor*        init();
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::FunctionDescriptor>(_MTL_PRIVATE_CLS(MTLFunctionDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::init()
+{
+    return NS::Object::init<MTL::FunctionDescriptor>();
+}
+
+// static method: functionDescriptor
+_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::functionDescriptor()
+{
+    return Object::sendMessage<MTL::FunctionDescriptor*>(_MTL_PRIVATE_CLS(MTLFunctionDescriptor), _MTL_PRIVATE_SEL(functionDescriptor));
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::FunctionDescriptor::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+_MTL_INLINE void MTL::FunctionDescriptor::setName(const NS::String* name)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setName_), name);
+}
+
+// property: specializedName
+_MTL_INLINE NS::String* MTL::FunctionDescriptor::specializedName() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(specializedName));
+}
+
+_MTL_INLINE void MTL::FunctionDescriptor::setSpecializedName(const NS::String* specializedName)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSpecializedName_), specializedName);
+}
+
+// property: constantValues
+_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionDescriptor::constantValues() const
+{
+    return Object::sendMessage<MTL::FunctionConstantValues*>(this, _MTL_PRIVATE_SEL(constantValues));
+}
+
+_MTL_INLINE void MTL::FunctionDescriptor::setConstantValues(const MTL::FunctionConstantValues* constantValues)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setConstantValues_), constantValues);
+}
+
+// property: options
+_MTL_INLINE MTL::FunctionOptions MTL::FunctionDescriptor::options() const
+{
+    return Object::sendMessage<MTL::FunctionOptions>(this, _MTL_PRIVATE_SEL(options));
+}
+
+_MTL_INLINE void MTL::FunctionDescriptor::setOptions(MTL::FunctionOptions options)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptions_), options);
+}
+
+// property: binaryArchives
+_MTL_INLINE NS::Array* MTL::FunctionDescriptor::binaryArchives() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
+}
+
+_MTL_INLINE void MTL::FunctionDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::IntersectionFunctionDescriptor* MTL::IntersectionFunctionDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::IntersectionFunctionDescriptor>(_MTL_PRIVATE_CLS(MTLIntersectionFunctionDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::IntersectionFunctionDescriptor* MTL::IntersectionFunctionDescriptor::init()
+{
+    return NS::Object::init<MTL::IntersectionFunctionDescriptor>();
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionHandle.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionHandle.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..30f71f2e54b1bbadf0315f683981617bbe83fcd0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionHandle.hpp
@@ -0,0 +1,61 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLFunctionHandle.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLLibrary.hpp"
+
+namespace MTL
+{
+class FunctionHandle : public NS::Referencing<FunctionHandle>
+{
+public:
+    MTL::FunctionType functionType() const;
+
+    NS::String*       name() const;
+
+    class Device*     device() const;
+};
+
+}
+
+// property: functionType
+_MTL_INLINE MTL::FunctionType MTL::FunctionHandle::functionType() const
+{
+    return Object::sendMessage<MTL::FunctionType>(this, _MTL_PRIVATE_SEL(functionType));
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::FunctionHandle::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::FunctionHandle::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionLog.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionLog.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a8995256b0ed34796a2ebca6067917c907a324e
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionLog.hpp
@@ -0,0 +1,114 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLFunctionLog.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLFunctionLog.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, FunctionLogType) {
+    FunctionLogTypeValidation = 0,
+};
+
+class LogContainer : public NS::Referencing<LogContainer, NS::FastEnumeration>
+{
+public:
+};
+
+class FunctionLogDebugLocation : public NS::Referencing<FunctionLogDebugLocation>
+{
+public:
+    NS::String*  functionName() const;
+
+    NS::URL*     URL() const;
+
+    NS::UInteger line() const;
+
+    NS::UInteger column() const;
+};
+
+class FunctionLog : public NS::Referencing<FunctionLog>
+{
+public:
+    MTL::FunctionLogType            type() const;
+
+    NS::String*                     encoderLabel() const;
+
+    class Function*                 function() const;
+
+    class FunctionLogDebugLocation* debugLocation() const;
+};
+
+}
+
+// property: functionName
+_MTL_INLINE NS::String* MTL::FunctionLogDebugLocation::functionName() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(functionName));
+}
+
+// property: URL
+_MTL_INLINE NS::URL* MTL::FunctionLogDebugLocation::URL() const
+{
+    return Object::sendMessage<NS::URL*>(this, _MTL_PRIVATE_SEL(URL));
+}
+
+// property: line
+_MTL_INLINE NS::UInteger MTL::FunctionLogDebugLocation::line() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(line));
+}
+
+// property: column
+_MTL_INLINE NS::UInteger MTL::FunctionLogDebugLocation::column() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(column));
+}
+
+// property: type
+_MTL_INLINE MTL::FunctionLogType MTL::FunctionLog::type() const
+{
+    return Object::sendMessage<MTL::FunctionLogType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+// property: encoderLabel
+_MTL_INLINE NS::String* MTL::FunctionLog::encoderLabel() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(encoderLabel));
+}
+
+// property: function
+_MTL_INLINE MTL::Function* MTL::FunctionLog::function() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(function));
+}
+
+// property: debugLocation
+_MTL_INLINE MTL::FunctionLogDebugLocation* MTL::FunctionLog::debugLocation() const
+{
+    return Object::sendMessage<MTL::FunctionLogDebugLocation*>(this, _MTL_PRIVATE_SEL(debugLocation));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionStitching.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionStitching.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ae7d6a444e10206f874d12475b1fb8f47918dd1
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLFunctionStitching.hpp
@@ -0,0 +1,307 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLFunctionStitching.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLFunctionStitching.hpp"
+
+namespace MTL
+{
+class FunctionStitchingAttribute : public NS::Referencing<FunctionStitchingAttribute>
+{
+public:
+};
+
+class FunctionStitchingAttributeAlwaysInline : public NS::Referencing<FunctionStitchingAttributeAlwaysInline, FunctionStitchingAttribute>
+{
+public:
+    static class FunctionStitchingAttributeAlwaysInline* alloc();
+
+    class FunctionStitchingAttributeAlwaysInline*        init();
+};
+
+class FunctionStitchingNode : public NS::Copying<FunctionStitchingNode>
+{
+public:
+};
+
+class FunctionStitchingInputNode : public NS::Referencing<FunctionStitchingInputNode, FunctionStitchingNode>
+{
+public:
+    static class FunctionStitchingInputNode* alloc();
+
+    class FunctionStitchingInputNode*        init();
+
+    NS::UInteger                             argumentIndex() const;
+    void                                     setArgumentIndex(NS::UInteger argumentIndex);
+
+    MTL::FunctionStitchingInputNode*         init(NS::UInteger argument);
+};
+
+class FunctionStitchingFunctionNode : public NS::Referencing<FunctionStitchingFunctionNode, FunctionStitchingNode>
+{
+public:
+    static class FunctionStitchingFunctionNode* alloc();
+
+    class FunctionStitchingFunctionNode*        init();
+
+    NS::String*                                 name() const;
+    void                                        setName(const NS::String* name);
+
+    NS::Array*                                  arguments() const;
+    void                                        setArguments(const NS::Array* arguments);
+
+    NS::Array*                                  controlDependencies() const;
+    void                                        setControlDependencies(const NS::Array* controlDependencies);
+
+    MTL::FunctionStitchingFunctionNode*         init(const NS::String* name, const NS::Array* arguments, const NS::Array* controlDependencies);
+};
+
+class FunctionStitchingGraph : public NS::Copying<FunctionStitchingGraph>
+{
+public:
+    static class FunctionStitchingGraph* alloc();
+
+    class FunctionStitchingGraph*        init();
+
+    NS::String*                          functionName() const;
+    void                                 setFunctionName(const NS::String* functionName);
+
+    NS::Array*                           nodes() const;
+    void                                 setNodes(const NS::Array* nodes);
+
+    class FunctionStitchingFunctionNode* outputNode() const;
+    void                                 setOutputNode(const class FunctionStitchingFunctionNode* outputNode);
+
+    NS::Array*                           attributes() const;
+    void                                 setAttributes(const NS::Array* attributes);
+
+    MTL::FunctionStitchingGraph*         init(const NS::String* functionName, const NS::Array* nodes, const class FunctionStitchingFunctionNode* outputNode, const NS::Array* attributes);
+};
+
+class StitchedLibraryDescriptor : public NS::Copying<StitchedLibraryDescriptor>
+{
+public:
+    static class StitchedLibraryDescriptor* alloc();
+
+    class StitchedLibraryDescriptor*        init();
+
+    NS::Array*                              functionGraphs() const;
+    void                                    setFunctionGraphs(const NS::Array* functionGraphs);
+
+    NS::Array*                              functions() const;
+    void                                    setFunctions(const NS::Array* functions);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::FunctionStitchingAttributeAlwaysInline* MTL::FunctionStitchingAttributeAlwaysInline::alloc()
+{
+    return NS::Object::alloc<MTL::FunctionStitchingAttributeAlwaysInline>(_MTL_PRIVATE_CLS(MTLFunctionStitchingAttributeAlwaysInline));
+}
+
+// method: init
+_MTL_INLINE MTL::FunctionStitchingAttributeAlwaysInline* MTL::FunctionStitchingAttributeAlwaysInline::init()
+{
+    return NS::Object::init<MTL::FunctionStitchingAttributeAlwaysInline>();
+}
+
+// static method: alloc
+_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::alloc()
+{
+    return NS::Object::alloc<MTL::FunctionStitchingInputNode>(_MTL_PRIVATE_CLS(MTLFunctionStitchingInputNode));
+}
+
+// method: init
+_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::init()
+{
+    return NS::Object::init<MTL::FunctionStitchingInputNode>();
+}
+
+// property: argumentIndex
+_MTL_INLINE NS::UInteger MTL::FunctionStitchingInputNode::argumentIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(argumentIndex));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingInputNode::setArgumentIndex(NS::UInteger argumentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArgumentIndex_), argumentIndex);
+}
+
+// method: initWithArgumentIndex:
+_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::init(NS::UInteger argument)
+{
+    return Object::sendMessage<MTL::FunctionStitchingInputNode*>(this, _MTL_PRIVATE_SEL(initWithArgumentIndex_), argument);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::alloc()
+{
+    return NS::Object::alloc<MTL::FunctionStitchingFunctionNode>(_MTL_PRIVATE_CLS(MTLFunctionStitchingFunctionNode));
+}
+
+// method: init
+_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::init()
+{
+    return NS::Object::init<MTL::FunctionStitchingFunctionNode>();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::FunctionStitchingFunctionNode::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setName(const NS::String* name)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setName_), name);
+}
+
+// property: arguments
+_MTL_INLINE NS::Array* MTL::FunctionStitchingFunctionNode::arguments() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(arguments));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setArguments(const NS::Array* arguments)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArguments_), arguments);
+}
+
+// property: controlDependencies
+_MTL_INLINE NS::Array* MTL::FunctionStitchingFunctionNode::controlDependencies() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(controlDependencies));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setControlDependencies(const NS::Array* controlDependencies)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlDependencies_), controlDependencies);
+}
+
+// method: initWithName:arguments:controlDependencies:
+_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::init(const NS::String* name, const NS::Array* arguments, const NS::Array* controlDependencies)
+{
+    return Object::sendMessage<MTL::FunctionStitchingFunctionNode*>(this, _MTL_PRIVATE_SEL(initWithName_arguments_controlDependencies_), name, arguments, controlDependencies);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::alloc()
+{
+    return NS::Object::alloc<MTL::FunctionStitchingGraph>(_MTL_PRIVATE_CLS(MTLFunctionStitchingGraph));
+}
+
+// method: init
+_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::init()
+{
+    return NS::Object::init<MTL::FunctionStitchingGraph>();
+}
+
+// property: functionName
+_MTL_INLINE NS::String* MTL::FunctionStitchingGraph::functionName() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(functionName));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingGraph::setFunctionName(const NS::String* functionName)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionName_), functionName);
+}
+
+// property: nodes
+_MTL_INLINE NS::Array* MTL::FunctionStitchingGraph::nodes() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(nodes));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingGraph::setNodes(const NS::Array* nodes)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setNodes_), nodes);
+}
+
+// property: outputNode
+_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingGraph::outputNode() const
+{
+    return Object::sendMessage<MTL::FunctionStitchingFunctionNode*>(this, _MTL_PRIVATE_SEL(outputNode));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingGraph::setOutputNode(const MTL::FunctionStitchingFunctionNode* outputNode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOutputNode_), outputNode);
+}
+
+// property: attributes
+_MTL_INLINE NS::Array* MTL::FunctionStitchingGraph::attributes() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(attributes));
+}
+
+_MTL_INLINE void MTL::FunctionStitchingGraph::setAttributes(const NS::Array* attributes)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAttributes_), attributes);
+}
+
+// method: initWithFunctionName:nodes:outputNode:attributes:
+_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::init(const NS::String* functionName, const NS::Array* nodes, const MTL::FunctionStitchingFunctionNode* outputNode, const NS::Array* attributes)
+{
+    return Object::sendMessage<MTL::FunctionStitchingGraph*>(this, _MTL_PRIVATE_SEL(initWithFunctionName_nodes_outputNode_attributes_), functionName, nodes, outputNode, attributes);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::StitchedLibraryDescriptor* MTL::StitchedLibraryDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::StitchedLibraryDescriptor>(_MTL_PRIVATE_CLS(MTLStitchedLibraryDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::StitchedLibraryDescriptor* MTL::StitchedLibraryDescriptor::init()
+{
+    return NS::Object::init<MTL::StitchedLibraryDescriptor>();
+}
+
+// property: functionGraphs
+_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::functionGraphs() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functionGraphs));
+}
+
+_MTL_INLINE void MTL::StitchedLibraryDescriptor::setFunctionGraphs(const NS::Array* functionGraphs)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionGraphs_), functionGraphs);
+}
+
+// property: functions
+_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::functions() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functions));
+}
+
+_MTL_INLINE void MTL::StitchedLibraryDescriptor::setFunctions(const NS::Array* functions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctions_), functions);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLHeaderBridge.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLHeaderBridge.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..23c3cec6073cd34a10b08c972c6df9fdbf9e39d9
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLHeaderBridge.hpp
@@ -0,0 +1,2436 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLHeaderBridge.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+#include "MTLPrivate.hpp"
+
+namespace MTL::Private::Class
+{
+
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureCurveGeometryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureGeometryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureTriangleGeometryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLArchitecture);
+_MTL_PRIVATE_DEF_CLS(MTLArgument);
+_MTL_PRIVATE_DEF_CLS(MTLArgumentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLArrayType);
+_MTL_PRIVATE_DEF_CLS(MTLAttribute);
+_MTL_PRIVATE_DEF_CLS(MTLAttributeDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLAttributeDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLBinaryArchiveDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLBlitPassDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLBlitPassSampleBufferAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLBlitPassSampleBufferAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLBufferLayoutDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLBufferLayoutDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLCaptureDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLCaptureManager);
+_MTL_PRIVATE_DEF_CLS(MTLCommandBufferDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLCompileOptions);
+_MTL_PRIVATE_DEF_CLS(MTLComputePassDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLComputePassSampleBufferAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLComputePassSampleBufferAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLComputePipelineDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLComputePipelineReflection);
+_MTL_PRIVATE_DEF_CLS(MTLCounterSampleBufferDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLDepthStencilDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLFunctionConstant);
+_MTL_PRIVATE_DEF_CLS(MTLFunctionConstantValues);
+_MTL_PRIVATE_DEF_CLS(MTLFunctionDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingAttributeAlwaysInline);
+_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingFunctionNode);
+_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingGraph);
+_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingInputNode);
+_MTL_PRIVATE_DEF_CLS(MTLHeapDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLIOCommandQueueDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLIndirectCommandBufferDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLIndirectInstanceAccelerationStructureDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLInstanceAccelerationStructureDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLIntersectionFunctionDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLIntersectionFunctionTableDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLLinkedFunctions);
+_MTL_PRIVATE_DEF_CLS(MTLMeshRenderPipelineDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLMotionKeyframeData);
+_MTL_PRIVATE_DEF_CLS(MTLPipelineBufferDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLPipelineBufferDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLPointerType);
+_MTL_PRIVATE_DEF_CLS(MTLPrimitiveAccelerationStructureDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateLayerArray);
+_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateLayerDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateMapDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateSampleArray);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassColorAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassColorAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassDepthAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassSampleBufferAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassSampleBufferAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPassStencilAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineColorAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineColorAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineFunctionsDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineReflection);
+_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLSamplerDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLSharedEventHandle);
+_MTL_PRIVATE_DEF_CLS(MTLSharedEventListener);
+_MTL_PRIVATE_DEF_CLS(MTLSharedTextureHandle);
+_MTL_PRIVATE_DEF_CLS(MTLStageInputOutputDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLStencilDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLStitchedLibraryDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLStructMember);
+_MTL_PRIVATE_DEF_CLS(MTLStructType);
+_MTL_PRIVATE_DEF_CLS(MTLTextureDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLTextureReferenceType);
+_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineColorAttachmentDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineColorAttachmentDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLType);
+_MTL_PRIVATE_DEF_CLS(MTLVertexAttribute);
+_MTL_PRIVATE_DEF_CLS(MTLVertexAttributeDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLVertexAttributeDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLVertexBufferLayoutDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLVertexBufferLayoutDescriptorArray);
+_MTL_PRIVATE_DEF_CLS(MTLVertexDescriptor);
+_MTL_PRIVATE_DEF_CLS(MTLVisibleFunctionTableDescriptor);
+
+}
+
+namespace MTL::Private::Protocol
+{
+
+_MTL_PRIVATE_DEF_PRO(MTLAccelerationStructure);
+_MTL_PRIVATE_DEF_PRO(MTLAccelerationStructureCommandEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLArgumentEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLBinaryArchive);
+_MTL_PRIVATE_DEF_PRO(MTLBinding);
+_MTL_PRIVATE_DEF_PRO(MTLBlitCommandEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLBuffer);
+_MTL_PRIVATE_DEF_PRO(MTLBufferBinding);
+_MTL_PRIVATE_DEF_PRO(MTLCommandBuffer);
+_MTL_PRIVATE_DEF_PRO(MTLCommandBufferEncoderInfo);
+_MTL_PRIVATE_DEF_PRO(MTLCommandEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLCommandQueue);
+_MTL_PRIVATE_DEF_PRO(MTLComputeCommandEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLComputePipelineState);
+_MTL_PRIVATE_DEF_PRO(MTLCounter);
+_MTL_PRIVATE_DEF_PRO(MTLCounterSampleBuffer);
+_MTL_PRIVATE_DEF_PRO(MTLCounterSet);
+_MTL_PRIVATE_DEF_PRO(MTLDepthStencilState);
+_MTL_PRIVATE_DEF_PRO(MTLDevice);
+_MTL_PRIVATE_DEF_PRO(MTLDrawable);
+_MTL_PRIVATE_DEF_PRO(MTLDynamicLibrary);
+_MTL_PRIVATE_DEF_PRO(MTLEvent);
+_MTL_PRIVATE_DEF_PRO(MTLFence);
+_MTL_PRIVATE_DEF_PRO(MTLFunction);
+_MTL_PRIVATE_DEF_PRO(MTLFunctionHandle);
+_MTL_PRIVATE_DEF_PRO(MTLFunctionLog);
+_MTL_PRIVATE_DEF_PRO(MTLFunctionLogDebugLocation);
+_MTL_PRIVATE_DEF_PRO(MTLFunctionStitchingAttribute);
+_MTL_PRIVATE_DEF_PRO(MTLFunctionStitchingNode);
+_MTL_PRIVATE_DEF_PRO(MTLHeap);
+_MTL_PRIVATE_DEF_PRO(MTLIOCommandBuffer);
+_MTL_PRIVATE_DEF_PRO(MTLIOCommandQueue);
+_MTL_PRIVATE_DEF_PRO(MTLIOFileHandle);
+_MTL_PRIVATE_DEF_PRO(MTLIOScratchBuffer);
+_MTL_PRIVATE_DEF_PRO(MTLIOScratchBufferAllocator);
+_MTL_PRIVATE_DEF_PRO(MTLIndirectCommandBuffer);
+_MTL_PRIVATE_DEF_PRO(MTLIndirectComputeCommand);
+_MTL_PRIVATE_DEF_PRO(MTLIndirectRenderCommand);
+_MTL_PRIVATE_DEF_PRO(MTLIntersectionFunctionTable);
+_MTL_PRIVATE_DEF_PRO(MTLLibrary);
+_MTL_PRIVATE_DEF_PRO(MTLLogContainer);
+_MTL_PRIVATE_DEF_PRO(MTLObjectPayloadBinding);
+_MTL_PRIVATE_DEF_PRO(MTLParallelRenderCommandEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLRasterizationRateMap);
+_MTL_PRIVATE_DEF_PRO(MTLRenderCommandEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLRenderPipelineState);
+_MTL_PRIVATE_DEF_PRO(MTLResource);
+_MTL_PRIVATE_DEF_PRO(MTLResourceStateCommandEncoder);
+_MTL_PRIVATE_DEF_PRO(MTLSamplerState);
+_MTL_PRIVATE_DEF_PRO(MTLSharedEvent);
+_MTL_PRIVATE_DEF_PRO(MTLTexture);
+_MTL_PRIVATE_DEF_PRO(MTLTextureBinding);
+_MTL_PRIVATE_DEF_PRO(MTLThreadgroupBinding);
+_MTL_PRIVATE_DEF_PRO(MTLVisibleFunctionTable);
+
+}
+
+namespace MTL::Private::Selector
+{
+
+_MTL_PRIVATE_DEF_SEL(GPUEndTime,
+    "GPUEndTime");
+_MTL_PRIVATE_DEF_SEL(GPUStartTime,
+    "GPUStartTime");
+_MTL_PRIVATE_DEF_SEL(URL,
+    "URL");
+_MTL_PRIVATE_DEF_SEL(accelerationStructureCommandEncoder,
+    "accelerationStructureCommandEncoder");
+_MTL_PRIVATE_DEF_SEL(accelerationStructureCommandEncoderWithDescriptor_,
+    "accelerationStructureCommandEncoderWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(accelerationStructurePassDescriptor,
+    "accelerationStructurePassDescriptor");
+_MTL_PRIVATE_DEF_SEL(accelerationStructureSizesWithDescriptor_,
+    "accelerationStructureSizesWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(access,
+    "access");
+_MTL_PRIVATE_DEF_SEL(addBarrier,
+    "addBarrier");
+_MTL_PRIVATE_DEF_SEL(addCompletedHandler_,
+    "addCompletedHandler:");
+_MTL_PRIVATE_DEF_SEL(addComputePipelineFunctionsWithDescriptor_error_,
+    "addComputePipelineFunctionsWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(addDebugMarker_range_,
+    "addDebugMarker:range:");
+_MTL_PRIVATE_DEF_SEL(addFunctionWithDescriptor_library_error_,
+    "addFunctionWithDescriptor:library:error:");
+_MTL_PRIVATE_DEF_SEL(addPresentedHandler_,
+    "addPresentedHandler:");
+_MTL_PRIVATE_DEF_SEL(addRenderPipelineFunctionsWithDescriptor_error_,
+    "addRenderPipelineFunctionsWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(addScheduledHandler_,
+    "addScheduledHandler:");
+_MTL_PRIVATE_DEF_SEL(addTileRenderPipelineFunctionsWithDescriptor_error_,
+    "addTileRenderPipelineFunctionsWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(alignment,
+    "alignment");
+_MTL_PRIVATE_DEF_SEL(allocatedSize,
+    "allocatedSize");
+_MTL_PRIVATE_DEF_SEL(allowDuplicateIntersectionFunctionInvocation,
+    "allowDuplicateIntersectionFunctionInvocation");
+_MTL_PRIVATE_DEF_SEL(allowGPUOptimizedContents,
+    "allowGPUOptimizedContents");
+_MTL_PRIVATE_DEF_SEL(allowReferencingUndefinedSymbols,
+    "allowReferencingUndefinedSymbols");
+_MTL_PRIVATE_DEF_SEL(alphaBlendOperation,
+    "alphaBlendOperation");
+_MTL_PRIVATE_DEF_SEL(architecture,
+    "architecture");
+_MTL_PRIVATE_DEF_SEL(areBarycentricCoordsSupported,
+    "areBarycentricCoordsSupported");
+_MTL_PRIVATE_DEF_SEL(areProgrammableSamplePositionsSupported,
+    "areProgrammableSamplePositionsSupported");
+_MTL_PRIVATE_DEF_SEL(areRasterOrderGroupsSupported,
+    "areRasterOrderGroupsSupported");
+_MTL_PRIVATE_DEF_SEL(argumentBuffersSupport,
+    "argumentBuffersSupport");
+_MTL_PRIVATE_DEF_SEL(argumentDescriptor,
+    "argumentDescriptor");
+_MTL_PRIVATE_DEF_SEL(argumentIndex,
+    "argumentIndex");
+_MTL_PRIVATE_DEF_SEL(argumentIndexStride,
+    "argumentIndexStride");
+_MTL_PRIVATE_DEF_SEL(arguments,
+    "arguments");
+_MTL_PRIVATE_DEF_SEL(arrayLength,
+    "arrayLength");
+_MTL_PRIVATE_DEF_SEL(arrayType,
+    "arrayType");
+_MTL_PRIVATE_DEF_SEL(attributeIndex,
+    "attributeIndex");
+_MTL_PRIVATE_DEF_SEL(attributeType,
+    "attributeType");
+_MTL_PRIVATE_DEF_SEL(attributes,
+    "attributes");
+_MTL_PRIVATE_DEF_SEL(backFaceStencil,
+    "backFaceStencil");
+_MTL_PRIVATE_DEF_SEL(binaryArchives,
+    "binaryArchives");
+_MTL_PRIVATE_DEF_SEL(binaryFunctions,
+    "binaryFunctions");
+_MTL_PRIVATE_DEF_SEL(bindings,
+    "bindings");
+_MTL_PRIVATE_DEF_SEL(blitCommandEncoder,
+    "blitCommandEncoder");
+_MTL_PRIVATE_DEF_SEL(blitCommandEncoderWithDescriptor_,
+    "blitCommandEncoderWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(blitPassDescriptor,
+    "blitPassDescriptor");
+_MTL_PRIVATE_DEF_SEL(borderColor,
+    "borderColor");
+_MTL_PRIVATE_DEF_SEL(boundingBoxBuffer,
+    "boundingBoxBuffer");
+_MTL_PRIVATE_DEF_SEL(boundingBoxBufferOffset,
+    "boundingBoxBufferOffset");
+_MTL_PRIVATE_DEF_SEL(boundingBoxBuffers,
+    "boundingBoxBuffers");
+_MTL_PRIVATE_DEF_SEL(boundingBoxCount,
+    "boundingBoxCount");
+_MTL_PRIVATE_DEF_SEL(boundingBoxStride,
+    "boundingBoxStride");
+_MTL_PRIVATE_DEF_SEL(buffer,
+    "buffer");
+_MTL_PRIVATE_DEF_SEL(bufferAlignment,
+    "bufferAlignment");
+_MTL_PRIVATE_DEF_SEL(bufferBytesPerRow,
+    "bufferBytesPerRow");
+_MTL_PRIVATE_DEF_SEL(bufferDataSize,
+    "bufferDataSize");
+_MTL_PRIVATE_DEF_SEL(bufferDataType,
+    "bufferDataType");
+_MTL_PRIVATE_DEF_SEL(bufferIndex,
+    "bufferIndex");
+_MTL_PRIVATE_DEF_SEL(bufferOffset,
+    "bufferOffset");
+_MTL_PRIVATE_DEF_SEL(bufferPointerType,
+    "bufferPointerType");
+_MTL_PRIVATE_DEF_SEL(bufferStructType,
+    "bufferStructType");
+_MTL_PRIVATE_DEF_SEL(buffers,
+    "buffers");
+_MTL_PRIVATE_DEF_SEL(buildAccelerationStructure_descriptor_scratchBuffer_scratchBufferOffset_,
+    "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(captureObject,
+    "captureObject");
+_MTL_PRIVATE_DEF_SEL(clearBarrier,
+    "clearBarrier");
+_MTL_PRIVATE_DEF_SEL(clearColor,
+    "clearColor");
+_MTL_PRIVATE_DEF_SEL(clearDepth,
+    "clearDepth");
+_MTL_PRIVATE_DEF_SEL(clearStencil,
+    "clearStencil");
+_MTL_PRIVATE_DEF_SEL(colorAttachments,
+    "colorAttachments");
+_MTL_PRIVATE_DEF_SEL(column,
+    "column");
+_MTL_PRIVATE_DEF_SEL(commandBuffer,
+    "commandBuffer");
+_MTL_PRIVATE_DEF_SEL(commandBufferWithDescriptor_,
+    "commandBufferWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(commandBufferWithUnretainedReferences,
+    "commandBufferWithUnretainedReferences");
+_MTL_PRIVATE_DEF_SEL(commandQueue,
+    "commandQueue");
+_MTL_PRIVATE_DEF_SEL(commandTypes,
+    "commandTypes");
+_MTL_PRIVATE_DEF_SEL(commit,
+    "commit");
+_MTL_PRIVATE_DEF_SEL(compareFunction,
+    "compareFunction");
+_MTL_PRIVATE_DEF_SEL(compileSymbolVisibility,
+    "compileSymbolVisibility");
+_MTL_PRIVATE_DEF_SEL(compressionType,
+    "compressionType");
+_MTL_PRIVATE_DEF_SEL(computeCommandEncoder,
+    "computeCommandEncoder");
+_MTL_PRIVATE_DEF_SEL(computeCommandEncoderWithDescriptor_,
+    "computeCommandEncoderWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(computeCommandEncoderWithDispatchType_,
+    "computeCommandEncoderWithDispatchType:");
+_MTL_PRIVATE_DEF_SEL(computeFunction,
+    "computeFunction");
+_MTL_PRIVATE_DEF_SEL(computePassDescriptor,
+    "computePassDescriptor");
+_MTL_PRIVATE_DEF_SEL(concurrentDispatchThreadgroups_threadsPerThreadgroup_,
+    "concurrentDispatchThreadgroups:threadsPerThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(concurrentDispatchThreads_threadsPerThreadgroup_,
+    "concurrentDispatchThreads:threadsPerThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(constantBlockAlignment,
+    "constantBlockAlignment");
+_MTL_PRIVATE_DEF_SEL(constantDataAtIndex_,
+    "constantDataAtIndex:");
+_MTL_PRIVATE_DEF_SEL(constantValues,
+    "constantValues");
+_MTL_PRIVATE_DEF_SEL(contents,
+    "contents");
+_MTL_PRIVATE_DEF_SEL(controlDependencies,
+    "controlDependencies");
+_MTL_PRIVATE_DEF_SEL(controlPointBuffer,
+    "controlPointBuffer");
+_MTL_PRIVATE_DEF_SEL(controlPointBufferOffset,
+    "controlPointBufferOffset");
+_MTL_PRIVATE_DEF_SEL(controlPointBuffers,
+    "controlPointBuffers");
+_MTL_PRIVATE_DEF_SEL(controlPointCount,
+    "controlPointCount");
+_MTL_PRIVATE_DEF_SEL(controlPointFormat,
+    "controlPointFormat");
+_MTL_PRIVATE_DEF_SEL(controlPointStride,
+    "controlPointStride");
+_MTL_PRIVATE_DEF_SEL(convertSparsePixelRegions_toTileRegions_withTileSize_alignmentMode_numRegions_,
+    "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:");
+_MTL_PRIVATE_DEF_SEL(convertSparseTileRegions_toPixelRegions_withTileSize_numRegions_,
+    "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:");
+_MTL_PRIVATE_DEF_SEL(copyAccelerationStructure_toAccelerationStructure_,
+    "copyAccelerationStructure:toAccelerationStructure:");
+_MTL_PRIVATE_DEF_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_,
+    "copyAndCompactAccelerationStructure:toAccelerationStructure:");
+_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_,
+    "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:");
+_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_,
+    "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:");
+_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_,
+    "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:");
+_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_,
+    "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:");
+_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_,
+    "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:");
+_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_,
+    "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:");
+_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_,
+    "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:");
+_MTL_PRIVATE_DEF_SEL(copyFromTexture_toTexture_,
+    "copyFromTexture:toTexture:");
+_MTL_PRIVATE_DEF_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_,
+    "copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:");
+_MTL_PRIVATE_DEF_SEL(copyParameterDataToBuffer_offset_,
+    "copyParameterDataToBuffer:offset:");
+_MTL_PRIVATE_DEF_SEL(copyStatusToBuffer_offset_,
+    "copyStatusToBuffer:offset:");
+_MTL_PRIVATE_DEF_SEL(counterSet,
+    "counterSet");
+_MTL_PRIVATE_DEF_SEL(counterSets,
+    "counterSets");
+_MTL_PRIVATE_DEF_SEL(counters,
+    "counters");
+_MTL_PRIVATE_DEF_SEL(cpuCacheMode,
+    "cpuCacheMode");
+_MTL_PRIVATE_DEF_SEL(currentAllocatedSize,
+    "currentAllocatedSize");
+_MTL_PRIVATE_DEF_SEL(curveBasis,
+    "curveBasis");
+_MTL_PRIVATE_DEF_SEL(curveType,
+    "curveType");
+_MTL_PRIVATE_DEF_SEL(data,
+    "data");
+_MTL_PRIVATE_DEF_SEL(dataSize,
+    "dataSize");
+_MTL_PRIVATE_DEF_SEL(dataType,
+    "dataType");
+_MTL_PRIVATE_DEF_SEL(dealloc,
+    "dealloc");
+_MTL_PRIVATE_DEF_SEL(debugLocation,
+    "debugLocation");
+_MTL_PRIVATE_DEF_SEL(debugSignposts,
+    "debugSignposts");
+_MTL_PRIVATE_DEF_SEL(defaultCaptureScope,
+    "defaultCaptureScope");
+_MTL_PRIVATE_DEF_SEL(defaultRasterSampleCount,
+    "defaultRasterSampleCount");
+_MTL_PRIVATE_DEF_SEL(depth,
+    "depth");
+_MTL_PRIVATE_DEF_SEL(depthAttachment,
+    "depthAttachment");
+_MTL_PRIVATE_DEF_SEL(depthAttachmentPixelFormat,
+    "depthAttachmentPixelFormat");
+_MTL_PRIVATE_DEF_SEL(depthCompareFunction,
+    "depthCompareFunction");
+_MTL_PRIVATE_DEF_SEL(depthFailureOperation,
+    "depthFailureOperation");
+_MTL_PRIVATE_DEF_SEL(depthPlane,
+    "depthPlane");
+_MTL_PRIVATE_DEF_SEL(depthResolveFilter,
+    "depthResolveFilter");
+_MTL_PRIVATE_DEF_SEL(depthStencilPassOperation,
+    "depthStencilPassOperation");
+_MTL_PRIVATE_DEF_SEL(descriptor,
+    "descriptor");
+_MTL_PRIVATE_DEF_SEL(destination,
+    "destination");
+_MTL_PRIVATE_DEF_SEL(destinationAlphaBlendFactor,
+    "destinationAlphaBlendFactor");
+_MTL_PRIVATE_DEF_SEL(destinationRGBBlendFactor,
+    "destinationRGBBlendFactor");
+_MTL_PRIVATE_DEF_SEL(device,
+    "device");
+_MTL_PRIVATE_DEF_SEL(didModifyRange_,
+    "didModifyRange:");
+_MTL_PRIVATE_DEF_SEL(dispatchQueue,
+    "dispatchQueue");
+_MTL_PRIVATE_DEF_SEL(dispatchThreadgroups_threadsPerThreadgroup_,
+    "dispatchThreadgroups:threadsPerThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(dispatchThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerThreadgroup_,
+    "dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(dispatchThreads_threadsPerThreadgroup_,
+    "dispatchThreads:threadsPerThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(dispatchThreadsPerTile_,
+    "dispatchThreadsPerTile:");
+_MTL_PRIVATE_DEF_SEL(dispatchType,
+    "dispatchType");
+_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_,
+    "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_,
+    "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:");
+_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_,
+    "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:");
+_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_,
+    "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_,
+    "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:");
+_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_,
+    "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:");
+_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_,
+    "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_,
+    "drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(drawMeshThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_,
+    "drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_,
+    "drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_,
+    "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_,
+    "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:");
+_MTL_PRIVATE_DEF_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_,
+    "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:");
+_MTL_PRIVATE_DEF_SEL(drawPrimitives_indirectBuffer_indirectBufferOffset_,
+    "drawPrimitives:indirectBuffer:indirectBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_,
+    "drawPrimitives:vertexStart:vertexCount:");
+_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_,
+    "drawPrimitives:vertexStart:vertexCount:instanceCount:");
+_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_,
+    "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:");
+_MTL_PRIVATE_DEF_SEL(drawableID,
+    "drawableID");
+_MTL_PRIVATE_DEF_SEL(elementArrayType,
+    "elementArrayType");
+_MTL_PRIVATE_DEF_SEL(elementIsArgumentBuffer,
+    "elementIsArgumentBuffer");
+_MTL_PRIVATE_DEF_SEL(elementPointerType,
+    "elementPointerType");
+_MTL_PRIVATE_DEF_SEL(elementStructType,
+    "elementStructType");
+_MTL_PRIVATE_DEF_SEL(elementTextureReferenceType,
+    "elementTextureReferenceType");
+_MTL_PRIVATE_DEF_SEL(elementType,
+    "elementType");
+_MTL_PRIVATE_DEF_SEL(encodeSignalEvent_value_,
+    "encodeSignalEvent:value:");
+_MTL_PRIVATE_DEF_SEL(encodeWaitForEvent_value_,
+    "encodeWaitForEvent:value:");
+_MTL_PRIVATE_DEF_SEL(encodedLength,
+    "encodedLength");
+_MTL_PRIVATE_DEF_SEL(encoderLabel,
+    "encoderLabel");
+_MTL_PRIVATE_DEF_SEL(curveEndCaps,
+    "curveEndCaps");
+_MTL_PRIVATE_DEF_SEL(endEncoding,
+    "endEncoding");
+_MTL_PRIVATE_DEF_SEL(endOfEncoderSampleIndex,
+    "endOfEncoderSampleIndex");
+_MTL_PRIVATE_DEF_SEL(endOfFragmentSampleIndex,
+    "endOfFragmentSampleIndex");
+_MTL_PRIVATE_DEF_SEL(endOfVertexSampleIndex,
+    "endOfVertexSampleIndex");
+_MTL_PRIVATE_DEF_SEL(enqueue,
+    "enqueue");
+_MTL_PRIVATE_DEF_SEL(enqueueBarrier,
+    "enqueueBarrier");
+_MTL_PRIVATE_DEF_SEL(error,
+    "error");
+_MTL_PRIVATE_DEF_SEL(errorOptions,
+    "errorOptions");
+_MTL_PRIVATE_DEF_SEL(errorState,
+    "errorState");
+_MTL_PRIVATE_DEF_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_,
+    "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(executeCommandsInBuffer_withRange_,
+    "executeCommandsInBuffer:withRange:");
+_MTL_PRIVATE_DEF_SEL(fastMathEnabled,
+    "fastMathEnabled");
+_MTL_PRIVATE_DEF_SEL(fillBuffer_range_value_,
+    "fillBuffer:range:value:");
+_MTL_PRIVATE_DEF_SEL(firstMipmapInTail,
+    "firstMipmapInTail");
+_MTL_PRIVATE_DEF_SEL(format,
+    "format");
+_MTL_PRIVATE_DEF_SEL(fragmentAdditionalBinaryFunctions,
+    "fragmentAdditionalBinaryFunctions");
+_MTL_PRIVATE_DEF_SEL(fragmentArguments,
+    "fragmentArguments");
+_MTL_PRIVATE_DEF_SEL(fragmentBindings,
+    "fragmentBindings");
+_MTL_PRIVATE_DEF_SEL(fragmentBuffers,
+    "fragmentBuffers");
+_MTL_PRIVATE_DEF_SEL(fragmentFunction,
+    "fragmentFunction");
+_MTL_PRIVATE_DEF_SEL(fragmentLinkedFunctions,
+    "fragmentLinkedFunctions");
+_MTL_PRIVATE_DEF_SEL(fragmentPreloadedLibraries,
+    "fragmentPreloadedLibraries");
+_MTL_PRIVATE_DEF_SEL(frontFaceStencil,
+    "frontFaceStencil");
+_MTL_PRIVATE_DEF_SEL(function,
+    "function");
+_MTL_PRIVATE_DEF_SEL(functionConstantsDictionary,
+    "functionConstantsDictionary");
+_MTL_PRIVATE_DEF_SEL(functionCount,
+    "functionCount");
+_MTL_PRIVATE_DEF_SEL(functionDescriptor,
+    "functionDescriptor");
+_MTL_PRIVATE_DEF_SEL(functionGraphs,
+    "functionGraphs");
+_MTL_PRIVATE_DEF_SEL(functionHandleWithFunction_,
+    "functionHandleWithFunction:");
+_MTL_PRIVATE_DEF_SEL(functionHandleWithFunction_stage_,
+    "functionHandleWithFunction:stage:");
+_MTL_PRIVATE_DEF_SEL(functionName,
+    "functionName");
+_MTL_PRIVATE_DEF_SEL(functionNames,
+    "functionNames");
+_MTL_PRIVATE_DEF_SEL(functionType,
+    "functionType");
+_MTL_PRIVATE_DEF_SEL(functions,
+    "functions");
+_MTL_PRIVATE_DEF_SEL(generateMipmapsForTexture_,
+    "generateMipmapsForTexture:");
+_MTL_PRIVATE_DEF_SEL(geometryDescriptors,
+    "geometryDescriptors");
+_MTL_PRIVATE_DEF_SEL(getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_,
+    "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:");
+_MTL_PRIVATE_DEF_SEL(getBytes_bytesPerRow_fromRegion_mipmapLevel_,
+    "getBytes:bytesPerRow:fromRegion:mipmapLevel:");
+_MTL_PRIVATE_DEF_SEL(getDefaultSamplePositions_count_,
+    "getDefaultSamplePositions:count:");
+_MTL_PRIVATE_DEF_SEL(getSamplePositions_count_,
+    "getSamplePositions:count:");
+_MTL_PRIVATE_DEF_SEL(getTextureAccessCounters_region_mipLevel_slice_resetCounters_countersBuffer_countersBufferOffset_,
+    "getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(gpuAddress,
+    "gpuAddress");
+_MTL_PRIVATE_DEF_SEL(gpuResourceID,
+    "gpuResourceID");
+_MTL_PRIVATE_DEF_SEL(groups,
+    "groups");
+_MTL_PRIVATE_DEF_SEL(hasUnifiedMemory,
+    "hasUnifiedMemory");
+_MTL_PRIVATE_DEF_SEL(hazardTrackingMode,
+    "hazardTrackingMode");
+_MTL_PRIVATE_DEF_SEL(heap,
+    "heap");
+_MTL_PRIVATE_DEF_SEL(heapAccelerationStructureSizeAndAlignWithDescriptor_,
+    "heapAccelerationStructureSizeAndAlignWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(heapAccelerationStructureSizeAndAlignWithSize_,
+    "heapAccelerationStructureSizeAndAlignWithSize:");
+_MTL_PRIVATE_DEF_SEL(heapBufferSizeAndAlignWithLength_options_,
+    "heapBufferSizeAndAlignWithLength:options:");
+_MTL_PRIVATE_DEF_SEL(heapOffset,
+    "heapOffset");
+_MTL_PRIVATE_DEF_SEL(heapTextureSizeAndAlignWithDescriptor_,
+    "heapTextureSizeAndAlignWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(height,
+    "height");
+_MTL_PRIVATE_DEF_SEL(horizontal,
+    "horizontal");
+_MTL_PRIVATE_DEF_SEL(horizontalSampleStorage,
+    "horizontalSampleStorage");
+_MTL_PRIVATE_DEF_SEL(imageblockMemoryLengthForDimensions_,
+    "imageblockMemoryLengthForDimensions:");
+_MTL_PRIVATE_DEF_SEL(imageblockSampleLength,
+    "imageblockSampleLength");
+_MTL_PRIVATE_DEF_SEL(index,
+    "index");
+_MTL_PRIVATE_DEF_SEL(indexBuffer,
+    "indexBuffer");
+_MTL_PRIVATE_DEF_SEL(indexBufferIndex,
+    "indexBufferIndex");
+_MTL_PRIVATE_DEF_SEL(indexBufferOffset,
+    "indexBufferOffset");
+_MTL_PRIVATE_DEF_SEL(indexType,
+    "indexType");
+_MTL_PRIVATE_DEF_SEL(indirectComputeCommandAtIndex_,
+    "indirectComputeCommandAtIndex:");
+_MTL_PRIVATE_DEF_SEL(indirectRenderCommandAtIndex_,
+    "indirectRenderCommandAtIndex:");
+_MTL_PRIVATE_DEF_SEL(inheritBuffers,
+    "inheritBuffers");
+_MTL_PRIVATE_DEF_SEL(inheritPipelineState,
+    "inheritPipelineState");
+_MTL_PRIVATE_DEF_SEL(init,
+    "init");
+_MTL_PRIVATE_DEF_SEL(initWithArgumentIndex_,
+    "initWithArgumentIndex:");
+_MTL_PRIVATE_DEF_SEL(initWithDispatchQueue_,
+    "initWithDispatchQueue:");
+_MTL_PRIVATE_DEF_SEL(initWithFunctionName_nodes_outputNode_attributes_,
+    "initWithFunctionName:nodes:outputNode:attributes:");
+_MTL_PRIVATE_DEF_SEL(initWithName_arguments_controlDependencies_,
+    "initWithName:arguments:controlDependencies:");
+_MTL_PRIVATE_DEF_SEL(initWithSampleCount_,
+    "initWithSampleCount:");
+_MTL_PRIVATE_DEF_SEL(initWithSampleCount_horizontal_vertical_,
+    "initWithSampleCount:horizontal:vertical:");
+_MTL_PRIVATE_DEF_SEL(inputPrimitiveTopology,
+    "inputPrimitiveTopology");
+_MTL_PRIVATE_DEF_SEL(insertDebugCaptureBoundary,
+    "insertDebugCaptureBoundary");
+_MTL_PRIVATE_DEF_SEL(insertDebugSignpost_,
+    "insertDebugSignpost:");
+_MTL_PRIVATE_DEF_SEL(insertLibraries,
+    "insertLibraries");
+_MTL_PRIVATE_DEF_SEL(installName,
+    "installName");
+_MTL_PRIVATE_DEF_SEL(instanceCount,
+    "instanceCount");
+_MTL_PRIVATE_DEF_SEL(instanceCountBuffer,
+    "instanceCountBuffer");
+_MTL_PRIVATE_DEF_SEL(instanceCountBufferOffset,
+    "instanceCountBufferOffset");
+_MTL_PRIVATE_DEF_SEL(instanceDescriptorBuffer,
+    "instanceDescriptorBuffer");
+_MTL_PRIVATE_DEF_SEL(instanceDescriptorBufferOffset,
+    "instanceDescriptorBufferOffset");
+_MTL_PRIVATE_DEF_SEL(instanceDescriptorStride,
+    "instanceDescriptorStride");
+_MTL_PRIVATE_DEF_SEL(instanceDescriptorType,
+    "instanceDescriptorType");
+_MTL_PRIVATE_DEF_SEL(instancedAccelerationStructures,
+    "instancedAccelerationStructures");
+_MTL_PRIVATE_DEF_SEL(intersectionFunctionTableDescriptor,
+    "intersectionFunctionTableDescriptor");
+_MTL_PRIVATE_DEF_SEL(intersectionFunctionTableOffset,
+    "intersectionFunctionTableOffset");
+_MTL_PRIVATE_DEF_SEL(iosurface,
+    "iosurface");
+_MTL_PRIVATE_DEF_SEL(iosurfacePlane,
+    "iosurfacePlane");
+_MTL_PRIVATE_DEF_SEL(isActive,
+    "isActive");
+_MTL_PRIVATE_DEF_SEL(isAliasable,
+    "isAliasable");
+_MTL_PRIVATE_DEF_SEL(isAlphaToCoverageEnabled,
+    "isAlphaToCoverageEnabled");
+_MTL_PRIVATE_DEF_SEL(isAlphaToOneEnabled,
+    "isAlphaToOneEnabled");
+_MTL_PRIVATE_DEF_SEL(isArgument,
+    "isArgument");
+_MTL_PRIVATE_DEF_SEL(isBlendingEnabled,
+    "isBlendingEnabled");
+_MTL_PRIVATE_DEF_SEL(isCapturing,
+    "isCapturing");
+_MTL_PRIVATE_DEF_SEL(isDepth24Stencil8PixelFormatSupported,
+    "isDepth24Stencil8PixelFormatSupported");
+_MTL_PRIVATE_DEF_SEL(isDepthTexture,
+    "isDepthTexture");
+_MTL_PRIVATE_DEF_SEL(isDepthWriteEnabled,
+    "isDepthWriteEnabled");
+_MTL_PRIVATE_DEF_SEL(isFramebufferOnly,
+    "isFramebufferOnly");
+_MTL_PRIVATE_DEF_SEL(isHeadless,
+    "isHeadless");
+_MTL_PRIVATE_DEF_SEL(isLowPower,
+    "isLowPower");
+_MTL_PRIVATE_DEF_SEL(isPatchControlPointData,
+    "isPatchControlPointData");
+_MTL_PRIVATE_DEF_SEL(isPatchData,
+    "isPatchData");
+_MTL_PRIVATE_DEF_SEL(isRasterizationEnabled,
+    "isRasterizationEnabled");
+_MTL_PRIVATE_DEF_SEL(isRemovable,
+    "isRemovable");
+_MTL_PRIVATE_DEF_SEL(isShareable,
+    "isShareable");
+_MTL_PRIVATE_DEF_SEL(isSparse,
+    "isSparse");
+_MTL_PRIVATE_DEF_SEL(isTessellationFactorScaleEnabled,
+    "isTessellationFactorScaleEnabled");
+_MTL_PRIVATE_DEF_SEL(isUsed,
+    "isUsed");
+_MTL_PRIVATE_DEF_SEL(kernelEndTime,
+    "kernelEndTime");
+_MTL_PRIVATE_DEF_SEL(kernelStartTime,
+    "kernelStartTime");
+_MTL_PRIVATE_DEF_SEL(label,
+    "label");
+_MTL_PRIVATE_DEF_SEL(languageVersion,
+    "languageVersion");
+_MTL_PRIVATE_DEF_SEL(layerAtIndex_,
+    "layerAtIndex:");
+_MTL_PRIVATE_DEF_SEL(layerCount,
+    "layerCount");
+_MTL_PRIVATE_DEF_SEL(layers,
+    "layers");
+_MTL_PRIVATE_DEF_SEL(layouts,
+    "layouts");
+_MTL_PRIVATE_DEF_SEL(length,
+    "length");
+_MTL_PRIVATE_DEF_SEL(level,
+    "level");
+_MTL_PRIVATE_DEF_SEL(libraries,
+    "libraries");
+_MTL_PRIVATE_DEF_SEL(libraryType,
+    "libraryType");
+_MTL_PRIVATE_DEF_SEL(line,
+    "line");
+_MTL_PRIVATE_DEF_SEL(linkedFunctions,
+    "linkedFunctions");
+_MTL_PRIVATE_DEF_SEL(loadAction,
+    "loadAction");
+_MTL_PRIVATE_DEF_SEL(loadBuffer_offset_size_sourceHandle_sourceHandleOffset_,
+    "loadBuffer:offset:size:sourceHandle:sourceHandleOffset:");
+_MTL_PRIVATE_DEF_SEL(loadBytes_size_sourceHandle_sourceHandleOffset_,
+    "loadBytes:size:sourceHandle:sourceHandleOffset:");
+_MTL_PRIVATE_DEF_SEL(loadTexture_slice_level_size_sourceBytesPerRow_sourceBytesPerImage_destinationOrigin_sourceHandle_sourceHandleOffset_,
+    "loadTexture:slice:level:size:sourceBytesPerRow:sourceBytesPerImage:destinationOrigin:sourceHandle:sourceHandleOffset:");
+_MTL_PRIVATE_DEF_SEL(location,
+    "location");
+_MTL_PRIVATE_DEF_SEL(locationNumber,
+    "locationNumber");
+_MTL_PRIVATE_DEF_SEL(lodAverage,
+    "lodAverage");
+_MTL_PRIVATE_DEF_SEL(lodMaxClamp,
+    "lodMaxClamp");
+_MTL_PRIVATE_DEF_SEL(lodMinClamp,
+    "lodMinClamp");
+_MTL_PRIVATE_DEF_SEL(logs,
+    "logs");
+_MTL_PRIVATE_DEF_SEL(magFilter,
+    "magFilter");
+_MTL_PRIVATE_DEF_SEL(makeAliasable,
+    "makeAliasable");
+_MTL_PRIVATE_DEF_SEL(mapPhysicalToScreenCoordinates_forLayer_,
+    "mapPhysicalToScreenCoordinates:forLayer:");
+_MTL_PRIVATE_DEF_SEL(mapScreenToPhysicalCoordinates_forLayer_,
+    "mapScreenToPhysicalCoordinates:forLayer:");
+_MTL_PRIVATE_DEF_SEL(maxAnisotropy,
+    "maxAnisotropy");
+_MTL_PRIVATE_DEF_SEL(maxArgumentBufferSamplerCount,
+    "maxArgumentBufferSamplerCount");
+_MTL_PRIVATE_DEF_SEL(maxAvailableSizeWithAlignment_,
+    "maxAvailableSizeWithAlignment:");
+_MTL_PRIVATE_DEF_SEL(maxBufferLength,
+    "maxBufferLength");
+_MTL_PRIVATE_DEF_SEL(maxCallStackDepth,
+    "maxCallStackDepth");
+_MTL_PRIVATE_DEF_SEL(maxCommandBufferCount,
+    "maxCommandBufferCount");
+_MTL_PRIVATE_DEF_SEL(maxCommandsInFlight,
+    "maxCommandsInFlight");
+_MTL_PRIVATE_DEF_SEL(maxFragmentBufferBindCount,
+    "maxFragmentBufferBindCount");
+_MTL_PRIVATE_DEF_SEL(maxFragmentCallStackDepth,
+    "maxFragmentCallStackDepth");
+_MTL_PRIVATE_DEF_SEL(maxInstanceCount,
+    "maxInstanceCount");
+_MTL_PRIVATE_DEF_SEL(maxKernelBufferBindCount,
+    "maxKernelBufferBindCount");
+_MTL_PRIVATE_DEF_SEL(maxKernelThreadgroupMemoryBindCount,
+    "maxKernelThreadgroupMemoryBindCount");
+_MTL_PRIVATE_DEF_SEL(maxMotionTransformCount,
+    "maxMotionTransformCount");
+_MTL_PRIVATE_DEF_SEL(maxSampleCount,
+    "maxSampleCount");
+_MTL_PRIVATE_DEF_SEL(maxTessellationFactor,
+    "maxTessellationFactor");
+_MTL_PRIVATE_DEF_SEL(maxThreadgroupMemoryLength,
+    "maxThreadgroupMemoryLength");
+_MTL_PRIVATE_DEF_SEL(maxThreadsPerThreadgroup,
+    "maxThreadsPerThreadgroup");
+_MTL_PRIVATE_DEF_SEL(maxTotalThreadgroupsPerMeshGrid,
+    "maxTotalThreadgroupsPerMeshGrid");
+_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerMeshThreadgroup,
+    "maxTotalThreadsPerMeshThreadgroup");
+_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerObjectThreadgroup,
+    "maxTotalThreadsPerObjectThreadgroup");
+_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerThreadgroup,
+    "maxTotalThreadsPerThreadgroup");
+_MTL_PRIVATE_DEF_SEL(maxTransferRate,
+    "maxTransferRate");
+_MTL_PRIVATE_DEF_SEL(maxVertexAmplificationCount,
+    "maxVertexAmplificationCount");
+_MTL_PRIVATE_DEF_SEL(maxVertexBufferBindCount,
+    "maxVertexBufferBindCount");
+_MTL_PRIVATE_DEF_SEL(maxVertexCallStackDepth,
+    "maxVertexCallStackDepth");
+_MTL_PRIVATE_DEF_SEL(maximumConcurrentCompilationTaskCount,
+    "maximumConcurrentCompilationTaskCount");
+_MTL_PRIVATE_DEF_SEL(memberByName_,
+    "memberByName:");
+_MTL_PRIVATE_DEF_SEL(members,
+    "members");
+_MTL_PRIVATE_DEF_SEL(memoryBarrierWithResources_count_,
+    "memoryBarrierWithResources:count:");
+_MTL_PRIVATE_DEF_SEL(memoryBarrierWithResources_count_afterStages_beforeStages_,
+    "memoryBarrierWithResources:count:afterStages:beforeStages:");
+_MTL_PRIVATE_DEF_SEL(memoryBarrierWithScope_,
+    "memoryBarrierWithScope:");
+_MTL_PRIVATE_DEF_SEL(memoryBarrierWithScope_afterStages_beforeStages_,
+    "memoryBarrierWithScope:afterStages:beforeStages:");
+_MTL_PRIVATE_DEF_SEL(meshBindings,
+    "meshBindings");
+_MTL_PRIVATE_DEF_SEL(meshBuffers,
+    "meshBuffers");
+_MTL_PRIVATE_DEF_SEL(meshFunction,
+    "meshFunction");
+_MTL_PRIVATE_DEF_SEL(meshLinkedFunctions,
+    "meshLinkedFunctions");
+_MTL_PRIVATE_DEF_SEL(meshThreadExecutionWidth,
+    "meshThreadExecutionWidth");
+_MTL_PRIVATE_DEF_SEL(meshThreadgroupSizeIsMultipleOfThreadExecutionWidth,
+    "meshThreadgroupSizeIsMultipleOfThreadExecutionWidth");
+_MTL_PRIVATE_DEF_SEL(minFilter,
+    "minFilter");
+_MTL_PRIVATE_DEF_SEL(minimumLinearTextureAlignmentForPixelFormat_,
+    "minimumLinearTextureAlignmentForPixelFormat:");
+_MTL_PRIVATE_DEF_SEL(minimumTextureBufferAlignmentForPixelFormat_,
+    "minimumTextureBufferAlignmentForPixelFormat:");
+_MTL_PRIVATE_DEF_SEL(mipFilter,
+    "mipFilter");
+_MTL_PRIVATE_DEF_SEL(mipmapLevelCount,
+    "mipmapLevelCount");
+_MTL_PRIVATE_DEF_SEL(motionEndBorderMode,
+    "motionEndBorderMode");
+_MTL_PRIVATE_DEF_SEL(motionEndTime,
+    "motionEndTime");
+_MTL_PRIVATE_DEF_SEL(motionKeyframeCount,
+    "motionKeyframeCount");
+_MTL_PRIVATE_DEF_SEL(motionStartBorderMode,
+    "motionStartBorderMode");
+_MTL_PRIVATE_DEF_SEL(motionStartTime,
+    "motionStartTime");
+_MTL_PRIVATE_DEF_SEL(motionTransformBuffer,
+    "motionTransformBuffer");
+_MTL_PRIVATE_DEF_SEL(motionTransformBufferOffset,
+    "motionTransformBufferOffset");
+_MTL_PRIVATE_DEF_SEL(motionTransformCount,
+    "motionTransformCount");
+_MTL_PRIVATE_DEF_SEL(motionTransformCountBuffer,
+    "motionTransformCountBuffer");
+_MTL_PRIVATE_DEF_SEL(motionTransformCountBufferOffset,
+    "motionTransformCountBufferOffset");
+_MTL_PRIVATE_DEF_SEL(moveTextureMappingsFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_,
+    "moveTextureMappingsFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:");
+_MTL_PRIVATE_DEF_SEL(mutability,
+    "mutability");
+_MTL_PRIVATE_DEF_SEL(name,
+    "name");
+_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithDescriptor_,
+    "newAccelerationStructureWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithDescriptor_offset_,
+    "newAccelerationStructureWithDescriptor:offset:");
+_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithSize_,
+    "newAccelerationStructureWithSize:");
+_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithSize_offset_,
+    "newAccelerationStructureWithSize:offset:");
+_MTL_PRIVATE_DEF_SEL(newArgumentEncoderForBufferAtIndex_,
+    "newArgumentEncoderForBufferAtIndex:");
+_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithArguments_,
+    "newArgumentEncoderWithArguments:");
+_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferBinding_,
+    "newArgumentEncoderWithBufferBinding:");
+_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferIndex_,
+    "newArgumentEncoderWithBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferIndex_reflection_,
+    "newArgumentEncoderWithBufferIndex:reflection:");
+_MTL_PRIVATE_DEF_SEL(newBinaryArchiveWithDescriptor_error_,
+    "newBinaryArchiveWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(newBufferWithBytes_length_options_,
+    "newBufferWithBytes:length:options:");
+_MTL_PRIVATE_DEF_SEL(newBufferWithBytesNoCopy_length_options_deallocator_,
+    "newBufferWithBytesNoCopy:length:options:deallocator:");
+_MTL_PRIVATE_DEF_SEL(newBufferWithLength_options_,
+    "newBufferWithLength:options:");
+_MTL_PRIVATE_DEF_SEL(newBufferWithLength_options_offset_,
+    "newBufferWithLength:options:offset:");
+_MTL_PRIVATE_DEF_SEL(newCaptureScopeWithCommandQueue_,
+    "newCaptureScopeWithCommandQueue:");
+_MTL_PRIVATE_DEF_SEL(newCaptureScopeWithDevice_,
+    "newCaptureScopeWithDevice:");
+_MTL_PRIVATE_DEF_SEL(newCommandQueue,
+    "newCommandQueue");
+_MTL_PRIVATE_DEF_SEL(newCommandQueueWithMaxCommandBufferCount_,
+    "newCommandQueueWithMaxCommandBufferCount:");
+_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithAdditionalBinaryFunctions_error_,
+    "newComputePipelineStateWithAdditionalBinaryFunctions:error:");
+_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_options_completionHandler_,
+    "newComputePipelineStateWithDescriptor:options:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_options_reflection_error_,
+    "newComputePipelineStateWithDescriptor:options:reflection:error:");
+_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_completionHandler_,
+    "newComputePipelineStateWithFunction:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_error_,
+    "newComputePipelineStateWithFunction:error:");
+_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_options_completionHandler_,
+    "newComputePipelineStateWithFunction:options:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_options_reflection_error_,
+    "newComputePipelineStateWithFunction:options:reflection:error:");
+_MTL_PRIVATE_DEF_SEL(newCounterSampleBufferWithDescriptor_error_,
+    "newCounterSampleBufferWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(newDefaultLibrary,
+    "newDefaultLibrary");
+_MTL_PRIVATE_DEF_SEL(newDefaultLibraryWithBundle_error_,
+    "newDefaultLibraryWithBundle:error:");
+_MTL_PRIVATE_DEF_SEL(newDepthStencilStateWithDescriptor_,
+    "newDepthStencilStateWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newDynamicLibrary_error_,
+    "newDynamicLibrary:error:");
+_MTL_PRIVATE_DEF_SEL(newDynamicLibraryWithURL_error_,
+    "newDynamicLibraryWithURL:error:");
+_MTL_PRIVATE_DEF_SEL(newEvent,
+    "newEvent");
+_MTL_PRIVATE_DEF_SEL(newFence,
+    "newFence");
+_MTL_PRIVATE_DEF_SEL(newFunctionWithDescriptor_completionHandler_,
+    "newFunctionWithDescriptor:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newFunctionWithDescriptor_error_,
+    "newFunctionWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(newFunctionWithName_,
+    "newFunctionWithName:");
+_MTL_PRIVATE_DEF_SEL(newFunctionWithName_constantValues_completionHandler_,
+    "newFunctionWithName:constantValues:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newFunctionWithName_constantValues_error_,
+    "newFunctionWithName:constantValues:error:");
+_MTL_PRIVATE_DEF_SEL(newHeapWithDescriptor_,
+    "newHeapWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newIOCommandQueueWithDescriptor_error_,
+    "newIOCommandQueueWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(newIOFileHandleWithURL_compressionMethod_error_,
+    "newIOFileHandleWithURL:compressionMethod:error:");
+_MTL_PRIVATE_DEF_SEL(newIOFileHandleWithURL_error_,
+    "newIOFileHandleWithURL:error:");
+_MTL_PRIVATE_DEF_SEL(newIOHandleWithURL_compressionMethod_error_,
+    "newIOHandleWithURL:compressionMethod:error:");
+_MTL_PRIVATE_DEF_SEL(newIOHandleWithURL_error_,
+    "newIOHandleWithURL:error:");
+_MTL_PRIVATE_DEF_SEL(newIndirectCommandBufferWithDescriptor_maxCommandCount_options_,
+    "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:");
+_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionTableWithDescriptor_,
+    "newIntersectionFunctionTableWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionTableWithDescriptor_stage_,
+    "newIntersectionFunctionTableWithDescriptor:stage:");
+_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionWithDescriptor_completionHandler_,
+    "newIntersectionFunctionWithDescriptor:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionWithDescriptor_error_,
+    "newIntersectionFunctionWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(newLibraryWithData_error_,
+    "newLibraryWithData:error:");
+_MTL_PRIVATE_DEF_SEL(newLibraryWithFile_error_,
+    "newLibraryWithFile:error:");
+_MTL_PRIVATE_DEF_SEL(newLibraryWithSource_options_completionHandler_,
+    "newLibraryWithSource:options:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newLibraryWithSource_options_error_,
+    "newLibraryWithSource:options:error:");
+_MTL_PRIVATE_DEF_SEL(newLibraryWithStitchedDescriptor_completionHandler_,
+    "newLibraryWithStitchedDescriptor:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newLibraryWithStitchedDescriptor_error_,
+    "newLibraryWithStitchedDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(newLibraryWithURL_error_,
+    "newLibraryWithURL:error:");
+_MTL_PRIVATE_DEF_SEL(newRasterizationRateMapWithDescriptor_,
+    "newRasterizationRateMapWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newRemoteBufferViewForDevice_,
+    "newRemoteBufferViewForDevice:");
+_MTL_PRIVATE_DEF_SEL(newRemoteTextureViewForDevice_,
+    "newRemoteTextureViewForDevice:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithAdditionalBinaryFunctions_error_,
+    "newRenderPipelineStateWithAdditionalBinaryFunctions:error:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_completionHandler_,
+    "newRenderPipelineStateWithDescriptor:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_error_,
+    "newRenderPipelineStateWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_options_completionHandler_,
+    "newRenderPipelineStateWithDescriptor:options:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_options_reflection_error_,
+    "newRenderPipelineStateWithDescriptor:options:reflection:error:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithMeshDescriptor_options_completionHandler_,
+    "newRenderPipelineStateWithMeshDescriptor:options:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithMeshDescriptor_options_reflection_error_,
+    "newRenderPipelineStateWithMeshDescriptor:options:reflection:error:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithTileDescriptor_options_completionHandler_,
+    "newRenderPipelineStateWithTileDescriptor:options:completionHandler:");
+_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithTileDescriptor_options_reflection_error_,
+    "newRenderPipelineStateWithTileDescriptor:options:reflection:error:");
+_MTL_PRIVATE_DEF_SEL(newSamplerStateWithDescriptor_,
+    "newSamplerStateWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newScratchBufferWithMinimumSize_,
+    "newScratchBufferWithMinimumSize:");
+_MTL_PRIVATE_DEF_SEL(newSharedEvent,
+    "newSharedEvent");
+_MTL_PRIVATE_DEF_SEL(newSharedEventHandle,
+    "newSharedEventHandle");
+_MTL_PRIVATE_DEF_SEL(newSharedEventWithHandle_,
+    "newSharedEventWithHandle:");
+_MTL_PRIVATE_DEF_SEL(newSharedTextureHandle,
+    "newSharedTextureHandle");
+_MTL_PRIVATE_DEF_SEL(newSharedTextureWithDescriptor_,
+    "newSharedTextureWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newSharedTextureWithHandle_,
+    "newSharedTextureWithHandle:");
+_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_,
+    "newTextureViewWithPixelFormat:");
+_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_,
+    "newTextureViewWithPixelFormat:textureType:levels:slices:");
+_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_,
+    "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:");
+_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_,
+    "newTextureWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_iosurface_plane_,
+    "newTextureWithDescriptor:iosurface:plane:");
+_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_offset_,
+    "newTextureWithDescriptor:offset:");
+_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_offset_bytesPerRow_,
+    "newTextureWithDescriptor:offset:bytesPerRow:");
+_MTL_PRIVATE_DEF_SEL(newVisibleFunctionTableWithDescriptor_,
+    "newVisibleFunctionTableWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(newVisibleFunctionTableWithDescriptor_stage_,
+    "newVisibleFunctionTableWithDescriptor:stage:");
+_MTL_PRIVATE_DEF_SEL(nodes,
+    "nodes");
+_MTL_PRIVATE_DEF_SEL(normalizedCoordinates,
+    "normalizedCoordinates");
+_MTL_PRIVATE_DEF_SEL(notifyListener_atValue_block_,
+    "notifyListener:atValue:block:");
+_MTL_PRIVATE_DEF_SEL(objectAtIndexedSubscript_,
+    "objectAtIndexedSubscript:");
+_MTL_PRIVATE_DEF_SEL(objectBindings,
+    "objectBindings");
+_MTL_PRIVATE_DEF_SEL(objectBuffers,
+    "objectBuffers");
+_MTL_PRIVATE_DEF_SEL(objectFunction,
+    "objectFunction");
+_MTL_PRIVATE_DEF_SEL(objectLinkedFunctions,
+    "objectLinkedFunctions");
+_MTL_PRIVATE_DEF_SEL(objectPayloadAlignment,
+    "objectPayloadAlignment");
+_MTL_PRIVATE_DEF_SEL(objectPayloadDataSize,
+    "objectPayloadDataSize");
+_MTL_PRIVATE_DEF_SEL(objectThreadExecutionWidth,
+    "objectThreadExecutionWidth");
+_MTL_PRIVATE_DEF_SEL(objectThreadgroupSizeIsMultipleOfThreadExecutionWidth,
+    "objectThreadgroupSizeIsMultipleOfThreadExecutionWidth");
+_MTL_PRIVATE_DEF_SEL(offset,
+    "offset");
+_MTL_PRIVATE_DEF_SEL(opaque,
+    "opaque");
+_MTL_PRIVATE_DEF_SEL(optimizationLevel,
+    "optimizationLevel");
+_MTL_PRIVATE_DEF_SEL(optimizeContentsForCPUAccess_,
+    "optimizeContentsForCPUAccess:");
+_MTL_PRIVATE_DEF_SEL(optimizeContentsForCPUAccess_slice_level_,
+    "optimizeContentsForCPUAccess:slice:level:");
+_MTL_PRIVATE_DEF_SEL(optimizeContentsForGPUAccess_,
+    "optimizeContentsForGPUAccess:");
+_MTL_PRIVATE_DEF_SEL(optimizeContentsForGPUAccess_slice_level_,
+    "optimizeContentsForGPUAccess:slice:level:");
+_MTL_PRIVATE_DEF_SEL(optimizeIndirectCommandBuffer_withRange_,
+    "optimizeIndirectCommandBuffer:withRange:");
+_MTL_PRIVATE_DEF_SEL(options,
+    "options");
+_MTL_PRIVATE_DEF_SEL(outputNode,
+    "outputNode");
+_MTL_PRIVATE_DEF_SEL(outputURL,
+    "outputURL");
+_MTL_PRIVATE_DEF_SEL(parallelRenderCommandEncoderWithDescriptor_,
+    "parallelRenderCommandEncoderWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(parameterBufferSizeAndAlign,
+    "parameterBufferSizeAndAlign");
+_MTL_PRIVATE_DEF_SEL(parentRelativeLevel,
+    "parentRelativeLevel");
+_MTL_PRIVATE_DEF_SEL(parentRelativeSlice,
+    "parentRelativeSlice");
+_MTL_PRIVATE_DEF_SEL(parentTexture,
+    "parentTexture");
+_MTL_PRIVATE_DEF_SEL(patchControlPointCount,
+    "patchControlPointCount");
+_MTL_PRIVATE_DEF_SEL(patchType,
+    "patchType");
+_MTL_PRIVATE_DEF_SEL(payloadMemoryLength,
+    "payloadMemoryLength");
+_MTL_PRIVATE_DEF_SEL(peerCount,
+    "peerCount");
+_MTL_PRIVATE_DEF_SEL(peerGroupID,
+    "peerGroupID");
+_MTL_PRIVATE_DEF_SEL(peerIndex,
+    "peerIndex");
+_MTL_PRIVATE_DEF_SEL(physicalGranularity,
+    "physicalGranularity");
+_MTL_PRIVATE_DEF_SEL(physicalSizeForLayer_,
+    "physicalSizeForLayer:");
+_MTL_PRIVATE_DEF_SEL(pixelFormat,
+    "pixelFormat");
+_MTL_PRIVATE_DEF_SEL(pointerType,
+    "pointerType");
+_MTL_PRIVATE_DEF_SEL(popDebugGroup,
+    "popDebugGroup");
+_MTL_PRIVATE_DEF_SEL(preloadedLibraries,
+    "preloadedLibraries");
+_MTL_PRIVATE_DEF_SEL(preprocessorMacros,
+    "preprocessorMacros");
+_MTL_PRIVATE_DEF_SEL(present,
+    "present");
+_MTL_PRIVATE_DEF_SEL(presentAfterMinimumDuration_,
+    "presentAfterMinimumDuration:");
+_MTL_PRIVATE_DEF_SEL(presentAtTime_,
+    "presentAtTime:");
+_MTL_PRIVATE_DEF_SEL(presentDrawable_,
+    "presentDrawable:");
+_MTL_PRIVATE_DEF_SEL(presentDrawable_afterMinimumDuration_,
+    "presentDrawable:afterMinimumDuration:");
+_MTL_PRIVATE_DEF_SEL(presentDrawable_atTime_,
+    "presentDrawable:atTime:");
+_MTL_PRIVATE_DEF_SEL(presentedTime,
+    "presentedTime");
+_MTL_PRIVATE_DEF_SEL(preserveInvariance,
+    "preserveInvariance");
+_MTL_PRIVATE_DEF_SEL(primitiveDataBuffer,
+    "primitiveDataBuffer");
+_MTL_PRIVATE_DEF_SEL(primitiveDataBufferOffset,
+    "primitiveDataBufferOffset");
+_MTL_PRIVATE_DEF_SEL(primitiveDataElementSize,
+    "primitiveDataElementSize");
+_MTL_PRIVATE_DEF_SEL(primitiveDataStride,
+    "primitiveDataStride");
+_MTL_PRIVATE_DEF_SEL(priority,
+    "priority");
+_MTL_PRIVATE_DEF_SEL(privateFunctions,
+    "privateFunctions");
+_MTL_PRIVATE_DEF_SEL(pushDebugGroup_,
+    "pushDebugGroup:");
+_MTL_PRIVATE_DEF_SEL(rAddressMode,
+    "rAddressMode");
+_MTL_PRIVATE_DEF_SEL(radiusBuffer,
+    "radiusBuffer");
+_MTL_PRIVATE_DEF_SEL(radiusBufferOffset,
+    "radiusBufferOffset");
+_MTL_PRIVATE_DEF_SEL(radiusBuffers,
+    "radiusBuffers");
+_MTL_PRIVATE_DEF_SEL(radiusFormat,
+    "radiusFormat");
+_MTL_PRIVATE_DEF_SEL(radiusStride,
+    "radiusStride");
+_MTL_PRIVATE_DEF_SEL(rasterSampleCount,
+    "rasterSampleCount");
+_MTL_PRIVATE_DEF_SEL(rasterizationRateMap,
+    "rasterizationRateMap");
+_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_,
+    "rasterizationRateMapDescriptorWithScreenSize:");
+_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_layer_,
+    "rasterizationRateMapDescriptorWithScreenSize:layer:");
+_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_,
+    "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:");
+_MTL_PRIVATE_DEF_SEL(readMask,
+    "readMask");
+_MTL_PRIVATE_DEF_SEL(readWriteTextureSupport,
+    "readWriteTextureSupport");
+_MTL_PRIVATE_DEF_SEL(recommendedMaxWorkingSetSize,
+    "recommendedMaxWorkingSetSize");
+_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_,
+    "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_options_,
+    "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:options:");
+_MTL_PRIVATE_DEF_SEL(registryID,
+    "registryID");
+_MTL_PRIVATE_DEF_SEL(remoteStorageBuffer,
+    "remoteStorageBuffer");
+_MTL_PRIVATE_DEF_SEL(remoteStorageTexture,
+    "remoteStorageTexture");
+_MTL_PRIVATE_DEF_SEL(removeAllDebugMarkers,
+    "removeAllDebugMarkers");
+_MTL_PRIVATE_DEF_SEL(renderCommandEncoder,
+    "renderCommandEncoder");
+_MTL_PRIVATE_DEF_SEL(renderCommandEncoderWithDescriptor_,
+    "renderCommandEncoderWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(renderPassDescriptor,
+    "renderPassDescriptor");
+_MTL_PRIVATE_DEF_SEL(renderTargetArrayLength,
+    "renderTargetArrayLength");
+_MTL_PRIVATE_DEF_SEL(renderTargetHeight,
+    "renderTargetHeight");
+_MTL_PRIVATE_DEF_SEL(renderTargetWidth,
+    "renderTargetWidth");
+_MTL_PRIVATE_DEF_SEL(replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_,
+    "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:");
+_MTL_PRIVATE_DEF_SEL(replaceRegion_mipmapLevel_withBytes_bytesPerRow_,
+    "replaceRegion:mipmapLevel:withBytes:bytesPerRow:");
+_MTL_PRIVATE_DEF_SEL(required,
+    "required");
+_MTL_PRIVATE_DEF_SEL(reset,
+    "reset");
+_MTL_PRIVATE_DEF_SEL(resetCommandsInBuffer_withRange_,
+    "resetCommandsInBuffer:withRange:");
+_MTL_PRIVATE_DEF_SEL(resetTextureAccessCounters_region_mipLevel_slice_,
+    "resetTextureAccessCounters:region:mipLevel:slice:");
+_MTL_PRIVATE_DEF_SEL(resetWithRange_,
+    "resetWithRange:");
+_MTL_PRIVATE_DEF_SEL(resolveCounterRange_,
+    "resolveCounterRange:");
+_MTL_PRIVATE_DEF_SEL(resolveCounters_inRange_destinationBuffer_destinationOffset_,
+    "resolveCounters:inRange:destinationBuffer:destinationOffset:");
+_MTL_PRIVATE_DEF_SEL(resolveDepthPlane,
+    "resolveDepthPlane");
+_MTL_PRIVATE_DEF_SEL(resolveLevel,
+    "resolveLevel");
+_MTL_PRIVATE_DEF_SEL(resolveSlice,
+    "resolveSlice");
+_MTL_PRIVATE_DEF_SEL(resolveTexture,
+    "resolveTexture");
+_MTL_PRIVATE_DEF_SEL(resourceOptions,
+    "resourceOptions");
+_MTL_PRIVATE_DEF_SEL(resourceStateCommandEncoder,
+    "resourceStateCommandEncoder");
+_MTL_PRIVATE_DEF_SEL(resourceStateCommandEncoderWithDescriptor_,
+    "resourceStateCommandEncoderWithDescriptor:");
+_MTL_PRIVATE_DEF_SEL(resourceStatePassDescriptor,
+    "resourceStatePassDescriptor");
+_MTL_PRIVATE_DEF_SEL(retainedReferences,
+    "retainedReferences");
+_MTL_PRIVATE_DEF_SEL(rgbBlendOperation,
+    "rgbBlendOperation");
+_MTL_PRIVATE_DEF_SEL(rootResource,
+    "rootResource");
+_MTL_PRIVATE_DEF_SEL(sAddressMode,
+    "sAddressMode");
+_MTL_PRIVATE_DEF_SEL(sampleBuffer,
+    "sampleBuffer");
+_MTL_PRIVATE_DEF_SEL(sampleBufferAttachments,
+    "sampleBufferAttachments");
+_MTL_PRIVATE_DEF_SEL(sampleCount,
+    "sampleCount");
+_MTL_PRIVATE_DEF_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_,
+    "sampleCountersInBuffer:atSampleIndex:withBarrier:");
+_MTL_PRIVATE_DEF_SEL(sampleTimestamps_gpuTimestamp_,
+    "sampleTimestamps:gpuTimestamp:");
+_MTL_PRIVATE_DEF_SEL(scratchBufferAllocator,
+    "scratchBufferAllocator");
+_MTL_PRIVATE_DEF_SEL(screenSize,
+    "screenSize");
+_MTL_PRIVATE_DEF_SEL(segmentControlPointCount,
+    "segmentControlPointCount");
+_MTL_PRIVATE_DEF_SEL(segmentCount,
+    "segmentCount");
+_MTL_PRIVATE_DEF_SEL(serializeToURL_error_,
+    "serializeToURL:error:");
+_MTL_PRIVATE_DEF_SEL(setAccelerationStructure_atBufferIndex_,
+    "setAccelerationStructure:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setAccelerationStructure_atIndex_,
+    "setAccelerationStructure:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setAccess_,
+    "setAccess:");
+_MTL_PRIVATE_DEF_SEL(setAllowDuplicateIntersectionFunctionInvocation_,
+    "setAllowDuplicateIntersectionFunctionInvocation:");
+_MTL_PRIVATE_DEF_SEL(setAllowGPUOptimizedContents_,
+    "setAllowGPUOptimizedContents:");
+_MTL_PRIVATE_DEF_SEL(setAllowReferencingUndefinedSymbols_,
+    "setAllowReferencingUndefinedSymbols:");
+_MTL_PRIVATE_DEF_SEL(setAlphaBlendOperation_,
+    "setAlphaBlendOperation:");
+_MTL_PRIVATE_DEF_SEL(setAlphaToCoverageEnabled_,
+    "setAlphaToCoverageEnabled:");
+_MTL_PRIVATE_DEF_SEL(setAlphaToOneEnabled_,
+    "setAlphaToOneEnabled:");
+_MTL_PRIVATE_DEF_SEL(setArgumentBuffer_offset_,
+    "setArgumentBuffer:offset:");
+_MTL_PRIVATE_DEF_SEL(setArgumentBuffer_startOffset_arrayElement_,
+    "setArgumentBuffer:startOffset:arrayElement:");
+_MTL_PRIVATE_DEF_SEL(setArgumentIndex_,
+    "setArgumentIndex:");
+_MTL_PRIVATE_DEF_SEL(setArguments_,
+    "setArguments:");
+_MTL_PRIVATE_DEF_SEL(setArrayLength_,
+    "setArrayLength:");
+_MTL_PRIVATE_DEF_SEL(setAttributes_,
+    "setAttributes:");
+_MTL_PRIVATE_DEF_SEL(setBackFaceStencil_,
+    "setBackFaceStencil:");
+_MTL_PRIVATE_DEF_SEL(setBarrier,
+    "setBarrier");
+_MTL_PRIVATE_DEF_SEL(setBinaryArchives_,
+    "setBinaryArchives:");
+_MTL_PRIVATE_DEF_SEL(setBinaryFunctions_,
+    "setBinaryFunctions:");
+_MTL_PRIVATE_DEF_SEL(setBlendColorRed_green_blue_alpha_,
+    "setBlendColorRed:green:blue:alpha:");
+_MTL_PRIVATE_DEF_SEL(setBlendingEnabled_,
+    "setBlendingEnabled:");
+_MTL_PRIVATE_DEF_SEL(setBorderColor_,
+    "setBorderColor:");
+_MTL_PRIVATE_DEF_SEL(setBoundingBoxBuffer_,
+    "setBoundingBoxBuffer:");
+_MTL_PRIVATE_DEF_SEL(setBoundingBoxBufferOffset_,
+    "setBoundingBoxBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setBoundingBoxBuffers_,
+    "setBoundingBoxBuffers:");
+_MTL_PRIVATE_DEF_SEL(setBoundingBoxCount_,
+    "setBoundingBoxCount:");
+_MTL_PRIVATE_DEF_SEL(setBoundingBoxStride_,
+    "setBoundingBoxStride:");
+_MTL_PRIVATE_DEF_SEL(setBuffer_,
+    "setBuffer:");
+_MTL_PRIVATE_DEF_SEL(setBuffer_offset_atIndex_,
+    "setBuffer:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setBuffer_offset_attributeStride_atIndex_,
+    "setBuffer:offset:attributeStride:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setBufferIndex_,
+    "setBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setBufferOffset_atIndex_,
+    "setBufferOffset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setBufferOffset_attributeStride_atIndex_,
+    "setBufferOffset:attributeStride:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setBuffers_offsets_attributeStrides_withRange_,
+    "setBuffers:offsets:attributeStrides:withRange:");
+_MTL_PRIVATE_DEF_SEL(setBuffers_offsets_withRange_,
+    "setBuffers:offsets:withRange:");
+_MTL_PRIVATE_DEF_SEL(setBytes_length_atIndex_,
+    "setBytes:length:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setBytes_length_attributeStride_atIndex_,
+    "setBytes:length:attributeStride:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setCaptureObject_,
+    "setCaptureObject:");
+_MTL_PRIVATE_DEF_SEL(setClearColor_,
+    "setClearColor:");
+_MTL_PRIVATE_DEF_SEL(setClearDepth_,
+    "setClearDepth:");
+_MTL_PRIVATE_DEF_SEL(setClearStencil_,
+    "setClearStencil:");
+_MTL_PRIVATE_DEF_SEL(setColorStoreAction_atIndex_,
+    "setColorStoreAction:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setColorStoreActionOptions_atIndex_,
+    "setColorStoreActionOptions:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setCommandTypes_,
+    "setCommandTypes:");
+_MTL_PRIVATE_DEF_SEL(setCompareFunction_,
+    "setCompareFunction:");
+_MTL_PRIVATE_DEF_SEL(setCompileSymbolVisibility_,
+    "setCompileSymbolVisibility:");
+_MTL_PRIVATE_DEF_SEL(setCompressionType_,
+    "setCompressionType:");
+_MTL_PRIVATE_DEF_SEL(setComputeFunction_,
+    "setComputeFunction:");
+_MTL_PRIVATE_DEF_SEL(setComputePipelineState_,
+    "setComputePipelineState:");
+_MTL_PRIVATE_DEF_SEL(setComputePipelineState_atIndex_,
+    "setComputePipelineState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setComputePipelineStates_withRange_,
+    "setComputePipelineStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setConstantBlockAlignment_,
+    "setConstantBlockAlignment:");
+_MTL_PRIVATE_DEF_SEL(setConstantValue_type_atIndex_,
+    "setConstantValue:type:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setConstantValue_type_withName_,
+    "setConstantValue:type:withName:");
+_MTL_PRIVATE_DEF_SEL(setConstantValues_,
+    "setConstantValues:");
+_MTL_PRIVATE_DEF_SEL(setConstantValues_type_withRange_,
+    "setConstantValues:type:withRange:");
+_MTL_PRIVATE_DEF_SEL(setControlDependencies_,
+    "setControlDependencies:");
+_MTL_PRIVATE_DEF_SEL(setControlPointBuffer_,
+    "setControlPointBuffer:");
+_MTL_PRIVATE_DEF_SEL(setControlPointBufferOffset_,
+    "setControlPointBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setControlPointBuffers_,
+    "setControlPointBuffers:");
+_MTL_PRIVATE_DEF_SEL(setControlPointCount_,
+    "setControlPointCount:");
+_MTL_PRIVATE_DEF_SEL(setControlPointFormat_,
+    "setControlPointFormat:");
+_MTL_PRIVATE_DEF_SEL(setControlPointStride_,
+    "setControlPointStride:");
+_MTL_PRIVATE_DEF_SEL(setCounterSet_,
+    "setCounterSet:");
+_MTL_PRIVATE_DEF_SEL(setCpuCacheMode_,
+    "setCpuCacheMode:");
+_MTL_PRIVATE_DEF_SEL(setCullMode_,
+    "setCullMode:");
+_MTL_PRIVATE_DEF_SEL(setCurveBasis_,
+    "setCurveBasis:");
+_MTL_PRIVATE_DEF_SEL(setCurveType_,
+    "setCurveType:");
+_MTL_PRIVATE_DEF_SEL(setDataType_,
+    "setDataType:");
+_MTL_PRIVATE_DEF_SEL(setDefaultCaptureScope_,
+    "setDefaultCaptureScope:");
+_MTL_PRIVATE_DEF_SEL(setDefaultRasterSampleCount_,
+    "setDefaultRasterSampleCount:");
+_MTL_PRIVATE_DEF_SEL(setDepth_,
+    "setDepth:");
+_MTL_PRIVATE_DEF_SEL(setDepthAttachment_,
+    "setDepthAttachment:");
+_MTL_PRIVATE_DEF_SEL(setDepthAttachmentPixelFormat_,
+    "setDepthAttachmentPixelFormat:");
+_MTL_PRIVATE_DEF_SEL(setDepthBias_slopeScale_clamp_,
+    "setDepthBias:slopeScale:clamp:");
+_MTL_PRIVATE_DEF_SEL(setDepthClipMode_,
+    "setDepthClipMode:");
+_MTL_PRIVATE_DEF_SEL(setDepthCompareFunction_,
+    "setDepthCompareFunction:");
+_MTL_PRIVATE_DEF_SEL(setDepthFailureOperation_,
+    "setDepthFailureOperation:");
+_MTL_PRIVATE_DEF_SEL(setDepthPlane_,
+    "setDepthPlane:");
+_MTL_PRIVATE_DEF_SEL(setDepthResolveFilter_,
+    "setDepthResolveFilter:");
+_MTL_PRIVATE_DEF_SEL(setDepthStencilPassOperation_,
+    "setDepthStencilPassOperation:");
+_MTL_PRIVATE_DEF_SEL(setDepthStencilState_,
+    "setDepthStencilState:");
+_MTL_PRIVATE_DEF_SEL(setDepthStoreAction_,
+    "setDepthStoreAction:");
+_MTL_PRIVATE_DEF_SEL(setDepthStoreActionOptions_,
+    "setDepthStoreActionOptions:");
+_MTL_PRIVATE_DEF_SEL(setDepthWriteEnabled_,
+    "setDepthWriteEnabled:");
+_MTL_PRIVATE_DEF_SEL(setDestination_,
+    "setDestination:");
+_MTL_PRIVATE_DEF_SEL(setDestinationAlphaBlendFactor_,
+    "setDestinationAlphaBlendFactor:");
+_MTL_PRIVATE_DEF_SEL(setDestinationRGBBlendFactor_,
+    "setDestinationRGBBlendFactor:");
+_MTL_PRIVATE_DEF_SEL(setDispatchType_,
+    "setDispatchType:");
+_MTL_PRIVATE_DEF_SEL(setCurveEndCaps_,
+    "setCurveEndCaps:");
+_MTL_PRIVATE_DEF_SEL(setEndOfEncoderSampleIndex_,
+    "setEndOfEncoderSampleIndex:");
+_MTL_PRIVATE_DEF_SEL(setEndOfFragmentSampleIndex_,
+    "setEndOfFragmentSampleIndex:");
+_MTL_PRIVATE_DEF_SEL(setEndOfVertexSampleIndex_,
+    "setEndOfVertexSampleIndex:");
+_MTL_PRIVATE_DEF_SEL(setErrorOptions_,
+    "setErrorOptions:");
+_MTL_PRIVATE_DEF_SEL(setFastMathEnabled_,
+    "setFastMathEnabled:");
+_MTL_PRIVATE_DEF_SEL(setFormat_,
+    "setFormat:");
+_MTL_PRIVATE_DEF_SEL(setFragmentAccelerationStructure_atBufferIndex_,
+    "setFragmentAccelerationStructure:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentAdditionalBinaryFunctions_,
+    "setFragmentAdditionalBinaryFunctions:");
+_MTL_PRIVATE_DEF_SEL(setFragmentBuffer_offset_atIndex_,
+    "setFragmentBuffer:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentBufferOffset_atIndex_,
+    "setFragmentBufferOffset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentBuffers_offsets_withRange_,
+    "setFragmentBuffers:offsets:withRange:");
+_MTL_PRIVATE_DEF_SEL(setFragmentBytes_length_atIndex_,
+    "setFragmentBytes:length:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentFunction_,
+    "setFragmentFunction:");
+_MTL_PRIVATE_DEF_SEL(setFragmentIntersectionFunctionTable_atBufferIndex_,
+    "setFragmentIntersectionFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentIntersectionFunctionTables_withBufferRange_,
+    "setFragmentIntersectionFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setFragmentLinkedFunctions_,
+    "setFragmentLinkedFunctions:");
+_MTL_PRIVATE_DEF_SEL(setFragmentPreloadedLibraries_,
+    "setFragmentPreloadedLibraries:");
+_MTL_PRIVATE_DEF_SEL(setFragmentSamplerState_atIndex_,
+    "setFragmentSamplerState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_,
+    "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_,
+    "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:");
+_MTL_PRIVATE_DEF_SEL(setFragmentSamplerStates_withRange_,
+    "setFragmentSamplerStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setFragmentTexture_atIndex_,
+    "setFragmentTexture:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentTextures_withRange_,
+    "setFragmentTextures:withRange:");
+_MTL_PRIVATE_DEF_SEL(setFragmentVisibleFunctionTable_atBufferIndex_,
+    "setFragmentVisibleFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setFragmentVisibleFunctionTables_withBufferRange_,
+    "setFragmentVisibleFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setFrontFaceStencil_,
+    "setFrontFaceStencil:");
+_MTL_PRIVATE_DEF_SEL(setFrontFacingWinding_,
+    "setFrontFacingWinding:");
+_MTL_PRIVATE_DEF_SEL(setFunction_atIndex_,
+    "setFunction:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setFunctionCount_,
+    "setFunctionCount:");
+_MTL_PRIVATE_DEF_SEL(setFunctionGraphs_,
+    "setFunctionGraphs:");
+_MTL_PRIVATE_DEF_SEL(setFunctionName_,
+    "setFunctionName:");
+_MTL_PRIVATE_DEF_SEL(setFunctions_,
+    "setFunctions:");
+_MTL_PRIVATE_DEF_SEL(setFunctions_withRange_,
+    "setFunctions:withRange:");
+_MTL_PRIVATE_DEF_SEL(setGeometryDescriptors_,
+    "setGeometryDescriptors:");
+_MTL_PRIVATE_DEF_SEL(setGroups_,
+    "setGroups:");
+_MTL_PRIVATE_DEF_SEL(setHazardTrackingMode_,
+    "setHazardTrackingMode:");
+_MTL_PRIVATE_DEF_SEL(setHeight_,
+    "setHeight:");
+_MTL_PRIVATE_DEF_SEL(setImageblockSampleLength_,
+    "setImageblockSampleLength:");
+_MTL_PRIVATE_DEF_SEL(setImageblockWidth_height_,
+    "setImageblockWidth:height:");
+_MTL_PRIVATE_DEF_SEL(setIndex_,
+    "setIndex:");
+_MTL_PRIVATE_DEF_SEL(setIndexBuffer_,
+    "setIndexBuffer:");
+_MTL_PRIVATE_DEF_SEL(setIndexBufferIndex_,
+    "setIndexBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setIndexBufferOffset_,
+    "setIndexBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setIndexType_,
+    "setIndexType:");
+_MTL_PRIVATE_DEF_SEL(setIndirectCommandBuffer_atIndex_,
+    "setIndirectCommandBuffer:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setIndirectCommandBuffers_withRange_,
+    "setIndirectCommandBuffers:withRange:");
+_MTL_PRIVATE_DEF_SEL(setInheritBuffers_,
+    "setInheritBuffers:");
+_MTL_PRIVATE_DEF_SEL(setInheritPipelineState_,
+    "setInheritPipelineState:");
+_MTL_PRIVATE_DEF_SEL(setInputPrimitiveTopology_,
+    "setInputPrimitiveTopology:");
+_MTL_PRIVATE_DEF_SEL(setInsertLibraries_,
+    "setInsertLibraries:");
+_MTL_PRIVATE_DEF_SEL(setInstallName_,
+    "setInstallName:");
+_MTL_PRIVATE_DEF_SEL(setInstanceCount_,
+    "setInstanceCount:");
+_MTL_PRIVATE_DEF_SEL(setInstanceCountBuffer_,
+    "setInstanceCountBuffer:");
+_MTL_PRIVATE_DEF_SEL(setInstanceCountBufferOffset_,
+    "setInstanceCountBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorBuffer_,
+    "setInstanceDescriptorBuffer:");
+_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorBufferOffset_,
+    "setInstanceDescriptorBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorStride_,
+    "setInstanceDescriptorStride:");
+_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorType_,
+    "setInstanceDescriptorType:");
+_MTL_PRIVATE_DEF_SEL(setInstancedAccelerationStructures_,
+    "setInstancedAccelerationStructures:");
+_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTable_atBufferIndex_,
+    "setIntersectionFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTable_atIndex_,
+    "setIntersectionFunctionTable:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTableOffset_,
+    "setIntersectionFunctionTableOffset:");
+_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTables_withBufferRange_,
+    "setIntersectionFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTables_withRange_,
+    "setIntersectionFunctionTables:withRange:");
+_MTL_PRIVATE_DEF_SEL(setKernelBuffer_offset_atIndex_,
+    "setKernelBuffer:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setKernelBuffer_offset_attributeStride_atIndex_,
+    "setKernelBuffer:offset:attributeStride:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setLabel_,
+    "setLabel:");
+_MTL_PRIVATE_DEF_SEL(setLanguageVersion_,
+    "setLanguageVersion:");
+_MTL_PRIVATE_DEF_SEL(setLayer_atIndex_,
+    "setLayer:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setLevel_,
+    "setLevel:");
+_MTL_PRIVATE_DEF_SEL(setLibraries_,
+    "setLibraries:");
+_MTL_PRIVATE_DEF_SEL(setLibraryType_,
+    "setLibraryType:");
+_MTL_PRIVATE_DEF_SEL(setLinkedFunctions_,
+    "setLinkedFunctions:");
+_MTL_PRIVATE_DEF_SEL(setLoadAction_,
+    "setLoadAction:");
+_MTL_PRIVATE_DEF_SEL(setLodAverage_,
+    "setLodAverage:");
+_MTL_PRIVATE_DEF_SEL(setLodMaxClamp_,
+    "setLodMaxClamp:");
+_MTL_PRIVATE_DEF_SEL(setLodMinClamp_,
+    "setLodMinClamp:");
+_MTL_PRIVATE_DEF_SEL(setMagFilter_,
+    "setMagFilter:");
+_MTL_PRIVATE_DEF_SEL(setMaxAnisotropy_,
+    "setMaxAnisotropy:");
+_MTL_PRIVATE_DEF_SEL(setMaxCallStackDepth_,
+    "setMaxCallStackDepth:");
+_MTL_PRIVATE_DEF_SEL(setMaxCommandBufferCount_,
+    "setMaxCommandBufferCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxCommandsInFlight_,
+    "setMaxCommandsInFlight:");
+_MTL_PRIVATE_DEF_SEL(setMaxFragmentBufferBindCount_,
+    "setMaxFragmentBufferBindCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxFragmentCallStackDepth_,
+    "setMaxFragmentCallStackDepth:");
+_MTL_PRIVATE_DEF_SEL(setMaxInstanceCount_,
+    "setMaxInstanceCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxKernelBufferBindCount_,
+    "setMaxKernelBufferBindCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxKernelThreadgroupMemoryBindCount_,
+    "setMaxKernelThreadgroupMemoryBindCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxMotionTransformCount_,
+    "setMaxMotionTransformCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxTessellationFactor_,
+    "setMaxTessellationFactor:");
+_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadgroupsPerMeshGrid_,
+    "setMaxTotalThreadgroupsPerMeshGrid:");
+_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerMeshThreadgroup_,
+    "setMaxTotalThreadsPerMeshThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerObjectThreadgroup_,
+    "setMaxTotalThreadsPerObjectThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerThreadgroup_,
+    "setMaxTotalThreadsPerThreadgroup:");
+_MTL_PRIVATE_DEF_SEL(setMaxVertexAmplificationCount_,
+    "setMaxVertexAmplificationCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxVertexBufferBindCount_,
+    "setMaxVertexBufferBindCount:");
+_MTL_PRIVATE_DEF_SEL(setMaxVertexCallStackDepth_,
+    "setMaxVertexCallStackDepth:");
+_MTL_PRIVATE_DEF_SEL(setMeshBuffer_offset_atIndex_,
+    "setMeshBuffer:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setMeshBufferOffset_atIndex_,
+    "setMeshBufferOffset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setMeshBuffers_offsets_withRange_,
+    "setMeshBuffers:offsets:withRange:");
+_MTL_PRIVATE_DEF_SEL(setMeshBytes_length_atIndex_,
+    "setMeshBytes:length:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setMeshFunction_,
+    "setMeshFunction:");
+_MTL_PRIVATE_DEF_SEL(setMeshLinkedFunctions_,
+    "setMeshLinkedFunctions:");
+_MTL_PRIVATE_DEF_SEL(setMeshSamplerState_atIndex_,
+    "setMeshSamplerState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setMeshSamplerState_lodMinClamp_lodMaxClamp_atIndex_,
+    "setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setMeshSamplerStates_lodMinClamps_lodMaxClamps_withRange_,
+    "setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange:");
+_MTL_PRIVATE_DEF_SEL(setMeshSamplerStates_withRange_,
+    "setMeshSamplerStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setMeshTexture_atIndex_,
+    "setMeshTexture:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setMeshTextures_withRange_,
+    "setMeshTextures:withRange:");
+_MTL_PRIVATE_DEF_SEL(setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth_,
+    "setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth:");
+_MTL_PRIVATE_DEF_SEL(setMinFilter_,
+    "setMinFilter:");
+_MTL_PRIVATE_DEF_SEL(setMipFilter_,
+    "setMipFilter:");
+_MTL_PRIVATE_DEF_SEL(setMipmapLevelCount_,
+    "setMipmapLevelCount:");
+_MTL_PRIVATE_DEF_SEL(setMotionEndBorderMode_,
+    "setMotionEndBorderMode:");
+_MTL_PRIVATE_DEF_SEL(setMotionEndTime_,
+    "setMotionEndTime:");
+_MTL_PRIVATE_DEF_SEL(setMotionKeyframeCount_,
+    "setMotionKeyframeCount:");
+_MTL_PRIVATE_DEF_SEL(setMotionStartBorderMode_,
+    "setMotionStartBorderMode:");
+_MTL_PRIVATE_DEF_SEL(setMotionStartTime_,
+    "setMotionStartTime:");
+_MTL_PRIVATE_DEF_SEL(setMotionTransformBuffer_,
+    "setMotionTransformBuffer:");
+_MTL_PRIVATE_DEF_SEL(setMotionTransformBufferOffset_,
+    "setMotionTransformBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setMotionTransformCount_,
+    "setMotionTransformCount:");
+_MTL_PRIVATE_DEF_SEL(setMotionTransformCountBuffer_,
+    "setMotionTransformCountBuffer:");
+_MTL_PRIVATE_DEF_SEL(setMotionTransformCountBufferOffset_,
+    "setMotionTransformCountBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setMutability_,
+    "setMutability:");
+_MTL_PRIVATE_DEF_SEL(setName_,
+    "setName:");
+_MTL_PRIVATE_DEF_SEL(setNodes_,
+    "setNodes:");
+_MTL_PRIVATE_DEF_SEL(setNormalizedCoordinates_,
+    "setNormalizedCoordinates:");
+_MTL_PRIVATE_DEF_SEL(setObject_atIndexedSubscript_,
+    "setObject:atIndexedSubscript:");
+_MTL_PRIVATE_DEF_SEL(setObjectBuffer_offset_atIndex_,
+    "setObjectBuffer:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setObjectBufferOffset_atIndex_,
+    "setObjectBufferOffset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setObjectBuffers_offsets_withRange_,
+    "setObjectBuffers:offsets:withRange:");
+_MTL_PRIVATE_DEF_SEL(setObjectBytes_length_atIndex_,
+    "setObjectBytes:length:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setObjectFunction_,
+    "setObjectFunction:");
+_MTL_PRIVATE_DEF_SEL(setObjectLinkedFunctions_,
+    "setObjectLinkedFunctions:");
+_MTL_PRIVATE_DEF_SEL(setObjectSamplerState_atIndex_,
+    "setObjectSamplerState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setObjectSamplerState_lodMinClamp_lodMaxClamp_atIndex_,
+    "setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setObjectSamplerStates_lodMinClamps_lodMaxClamps_withRange_,
+    "setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange:");
+_MTL_PRIVATE_DEF_SEL(setObjectSamplerStates_withRange_,
+    "setObjectSamplerStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setObjectTexture_atIndex_,
+    "setObjectTexture:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setObjectTextures_withRange_,
+    "setObjectTextures:withRange:");
+_MTL_PRIVATE_DEF_SEL(setObjectThreadgroupMemoryLength_atIndex_,
+    "setObjectThreadgroupMemoryLength:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth_,
+    "setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth:");
+_MTL_PRIVATE_DEF_SEL(setOffset_,
+    "setOffset:");
+_MTL_PRIVATE_DEF_SEL(setOpaque_,
+    "setOpaque:");
+_MTL_PRIVATE_DEF_SEL(setOpaqueCurveIntersectionFunctionWithSignature_atIndex_,
+    "setOpaqueCurveIntersectionFunctionWithSignature:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setOpaqueCurveIntersectionFunctionWithSignature_withRange_,
+    "setOpaqueCurveIntersectionFunctionWithSignature:withRange:");
+_MTL_PRIVATE_DEF_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_,
+    "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_withRange_,
+    "setOpaqueTriangleIntersectionFunctionWithSignature:withRange:");
+_MTL_PRIVATE_DEF_SEL(setOptimizationLevel_,
+    "setOptimizationLevel:");
+_MTL_PRIVATE_DEF_SEL(setOptions_,
+    "setOptions:");
+_MTL_PRIVATE_DEF_SEL(setOutputNode_,
+    "setOutputNode:");
+_MTL_PRIVATE_DEF_SEL(setOutputURL_,
+    "setOutputURL:");
+_MTL_PRIVATE_DEF_SEL(setPayloadMemoryLength_,
+    "setPayloadMemoryLength:");
+_MTL_PRIVATE_DEF_SEL(setPixelFormat_,
+    "setPixelFormat:");
+_MTL_PRIVATE_DEF_SEL(setPreloadedLibraries_,
+    "setPreloadedLibraries:");
+_MTL_PRIVATE_DEF_SEL(setPreprocessorMacros_,
+    "setPreprocessorMacros:");
+_MTL_PRIVATE_DEF_SEL(setPreserveInvariance_,
+    "setPreserveInvariance:");
+_MTL_PRIVATE_DEF_SEL(setPrimitiveDataBuffer_,
+    "setPrimitiveDataBuffer:");
+_MTL_PRIVATE_DEF_SEL(setPrimitiveDataBufferOffset_,
+    "setPrimitiveDataBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setPrimitiveDataElementSize_,
+    "setPrimitiveDataElementSize:");
+_MTL_PRIVATE_DEF_SEL(setPrimitiveDataStride_,
+    "setPrimitiveDataStride:");
+_MTL_PRIVATE_DEF_SEL(setPriority_,
+    "setPriority:");
+_MTL_PRIVATE_DEF_SEL(setPrivateFunctions_,
+    "setPrivateFunctions:");
+_MTL_PRIVATE_DEF_SEL(setPurgeableState_,
+    "setPurgeableState:");
+_MTL_PRIVATE_DEF_SEL(setRAddressMode_,
+    "setRAddressMode:");
+_MTL_PRIVATE_DEF_SEL(setRadiusBuffer_,
+    "setRadiusBuffer:");
+_MTL_PRIVATE_DEF_SEL(setRadiusBufferOffset_,
+    "setRadiusBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setRadiusBuffers_,
+    "setRadiusBuffers:");
+_MTL_PRIVATE_DEF_SEL(setRadiusFormat_,
+    "setRadiusFormat:");
+_MTL_PRIVATE_DEF_SEL(setRadiusStride_,
+    "setRadiusStride:");
+_MTL_PRIVATE_DEF_SEL(setRasterSampleCount_,
+    "setRasterSampleCount:");
+_MTL_PRIVATE_DEF_SEL(setRasterizationEnabled_,
+    "setRasterizationEnabled:");
+_MTL_PRIVATE_DEF_SEL(setRasterizationRateMap_,
+    "setRasterizationRateMap:");
+_MTL_PRIVATE_DEF_SEL(setReadMask_,
+    "setReadMask:");
+_MTL_PRIVATE_DEF_SEL(setRenderPipelineState_,
+    "setRenderPipelineState:");
+_MTL_PRIVATE_DEF_SEL(setRenderPipelineState_atIndex_,
+    "setRenderPipelineState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setRenderPipelineStates_withRange_,
+    "setRenderPipelineStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setRenderTargetArrayLength_,
+    "setRenderTargetArrayLength:");
+_MTL_PRIVATE_DEF_SEL(setRenderTargetHeight_,
+    "setRenderTargetHeight:");
+_MTL_PRIVATE_DEF_SEL(setRenderTargetWidth_,
+    "setRenderTargetWidth:");
+_MTL_PRIVATE_DEF_SEL(setResolveDepthPlane_,
+    "setResolveDepthPlane:");
+_MTL_PRIVATE_DEF_SEL(setResolveLevel_,
+    "setResolveLevel:");
+_MTL_PRIVATE_DEF_SEL(setResolveSlice_,
+    "setResolveSlice:");
+_MTL_PRIVATE_DEF_SEL(setResolveTexture_,
+    "setResolveTexture:");
+_MTL_PRIVATE_DEF_SEL(setResourceOptions_,
+    "setResourceOptions:");
+_MTL_PRIVATE_DEF_SEL(setRetainedReferences_,
+    "setRetainedReferences:");
+_MTL_PRIVATE_DEF_SEL(setRgbBlendOperation_,
+    "setRgbBlendOperation:");
+_MTL_PRIVATE_DEF_SEL(setSAddressMode_,
+    "setSAddressMode:");
+_MTL_PRIVATE_DEF_SEL(setSampleBuffer_,
+    "setSampleBuffer:");
+_MTL_PRIVATE_DEF_SEL(setSampleCount_,
+    "setSampleCount:");
+_MTL_PRIVATE_DEF_SEL(setSamplePositions_count_,
+    "setSamplePositions:count:");
+_MTL_PRIVATE_DEF_SEL(setSamplerState_atIndex_,
+    "setSamplerState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setSamplerState_lodMinClamp_lodMaxClamp_atIndex_,
+    "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setSamplerStates_lodMinClamps_lodMaxClamps_withRange_,
+    "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:");
+_MTL_PRIVATE_DEF_SEL(setSamplerStates_withRange_,
+    "setSamplerStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setScissorRect_,
+    "setScissorRect:");
+_MTL_PRIVATE_DEF_SEL(setScissorRects_count_,
+    "setScissorRects:count:");
+_MTL_PRIVATE_DEF_SEL(setScratchBufferAllocator_,
+    "setScratchBufferAllocator:");
+_MTL_PRIVATE_DEF_SEL(setScreenSize_,
+    "setScreenSize:");
+_MTL_PRIVATE_DEF_SEL(setSegmentControlPointCount_,
+    "setSegmentControlPointCount:");
+_MTL_PRIVATE_DEF_SEL(setSegmentCount_,
+    "setSegmentCount:");
+_MTL_PRIVATE_DEF_SEL(setShouldMaximizeConcurrentCompilation_,
+    "setShouldMaximizeConcurrentCompilation:");
+_MTL_PRIVATE_DEF_SEL(setSignaledValue_,
+    "setSignaledValue:");
+_MTL_PRIVATE_DEF_SEL(setSize_,
+    "setSize:");
+_MTL_PRIVATE_DEF_SEL(setSlice_,
+    "setSlice:");
+_MTL_PRIVATE_DEF_SEL(setSourceAlphaBlendFactor_,
+    "setSourceAlphaBlendFactor:");
+_MTL_PRIVATE_DEF_SEL(setSourceRGBBlendFactor_,
+    "setSourceRGBBlendFactor:");
+_MTL_PRIVATE_DEF_SEL(setSparsePageSize_,
+    "setSparsePageSize:");
+_MTL_PRIVATE_DEF_SEL(setSpecializedName_,
+    "setSpecializedName:");
+_MTL_PRIVATE_DEF_SEL(setStageInRegion_,
+    "setStageInRegion:");
+_MTL_PRIVATE_DEF_SEL(setStageInRegionWithIndirectBuffer_indirectBufferOffset_,
+    "setStageInRegionWithIndirectBuffer:indirectBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setStageInputDescriptor_,
+    "setStageInputDescriptor:");
+_MTL_PRIVATE_DEF_SEL(setStartOfEncoderSampleIndex_,
+    "setStartOfEncoderSampleIndex:");
+_MTL_PRIVATE_DEF_SEL(setStartOfFragmentSampleIndex_,
+    "setStartOfFragmentSampleIndex:");
+_MTL_PRIVATE_DEF_SEL(setStartOfVertexSampleIndex_,
+    "setStartOfVertexSampleIndex:");
+_MTL_PRIVATE_DEF_SEL(setStencilAttachment_,
+    "setStencilAttachment:");
+_MTL_PRIVATE_DEF_SEL(setStencilAttachmentPixelFormat_,
+    "setStencilAttachmentPixelFormat:");
+_MTL_PRIVATE_DEF_SEL(setStencilCompareFunction_,
+    "setStencilCompareFunction:");
+_MTL_PRIVATE_DEF_SEL(setStencilFailureOperation_,
+    "setStencilFailureOperation:");
+_MTL_PRIVATE_DEF_SEL(setStencilFrontReferenceValue_backReferenceValue_,
+    "setStencilFrontReferenceValue:backReferenceValue:");
+_MTL_PRIVATE_DEF_SEL(setStencilReferenceValue_,
+    "setStencilReferenceValue:");
+_MTL_PRIVATE_DEF_SEL(setStencilResolveFilter_,
+    "setStencilResolveFilter:");
+_MTL_PRIVATE_DEF_SEL(setStencilStoreAction_,
+    "setStencilStoreAction:");
+_MTL_PRIVATE_DEF_SEL(setStencilStoreActionOptions_,
+    "setStencilStoreActionOptions:");
+_MTL_PRIVATE_DEF_SEL(setStepFunction_,
+    "setStepFunction:");
+_MTL_PRIVATE_DEF_SEL(setStepRate_,
+    "setStepRate:");
+_MTL_PRIVATE_DEF_SEL(setStorageMode_,
+    "setStorageMode:");
+_MTL_PRIVATE_DEF_SEL(setStoreAction_,
+    "setStoreAction:");
+_MTL_PRIVATE_DEF_SEL(setStoreActionOptions_,
+    "setStoreActionOptions:");
+_MTL_PRIVATE_DEF_SEL(setStride_,
+    "setStride:");
+_MTL_PRIVATE_DEF_SEL(setSupportAddingBinaryFunctions_,
+    "setSupportAddingBinaryFunctions:");
+_MTL_PRIVATE_DEF_SEL(setSupportAddingFragmentBinaryFunctions_,
+    "setSupportAddingFragmentBinaryFunctions:");
+_MTL_PRIVATE_DEF_SEL(setSupportAddingVertexBinaryFunctions_,
+    "setSupportAddingVertexBinaryFunctions:");
+_MTL_PRIVATE_DEF_SEL(setSupportArgumentBuffers_,
+    "setSupportArgumentBuffers:");
+_MTL_PRIVATE_DEF_SEL(setSupportDynamicAttributeStride_,
+    "setSupportDynamicAttributeStride:");
+_MTL_PRIVATE_DEF_SEL(setSupportIndirectCommandBuffers_,
+    "setSupportIndirectCommandBuffers:");
+_MTL_PRIVATE_DEF_SEL(setSupportRayTracing_,
+    "setSupportRayTracing:");
+_MTL_PRIVATE_DEF_SEL(setSwizzle_,
+    "setSwizzle:");
+_MTL_PRIVATE_DEF_SEL(setTAddressMode_,
+    "setTAddressMode:");
+_MTL_PRIVATE_DEF_SEL(setTessellationControlPointIndexType_,
+    "setTessellationControlPointIndexType:");
+_MTL_PRIVATE_DEF_SEL(setTessellationFactorBuffer_offset_instanceStride_,
+    "setTessellationFactorBuffer:offset:instanceStride:");
+_MTL_PRIVATE_DEF_SEL(setTessellationFactorFormat_,
+    "setTessellationFactorFormat:");
+_MTL_PRIVATE_DEF_SEL(setTessellationFactorScale_,
+    "setTessellationFactorScale:");
+_MTL_PRIVATE_DEF_SEL(setTessellationFactorScaleEnabled_,
+    "setTessellationFactorScaleEnabled:");
+_MTL_PRIVATE_DEF_SEL(setTessellationFactorStepFunction_,
+    "setTessellationFactorStepFunction:");
+_MTL_PRIVATE_DEF_SEL(setTessellationOutputWindingOrder_,
+    "setTessellationOutputWindingOrder:");
+_MTL_PRIVATE_DEF_SEL(setTessellationPartitionMode_,
+    "setTessellationPartitionMode:");
+_MTL_PRIVATE_DEF_SEL(setTexture_,
+    "setTexture:");
+_MTL_PRIVATE_DEF_SEL(setTexture_atIndex_,
+    "setTexture:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setTextureType_,
+    "setTextureType:");
+_MTL_PRIVATE_DEF_SEL(setTextures_withRange_,
+    "setTextures:withRange:");
+_MTL_PRIVATE_DEF_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_,
+    "setThreadGroupSizeIsMultipleOfThreadExecutionWidth:");
+_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_,
+    "setThreadgroupMemoryLength:");
+_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_atIndex_,
+    "setThreadgroupMemoryLength:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_offset_atIndex_,
+    "setThreadgroupMemoryLength:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setThreadgroupSizeMatchesTileSize_,
+    "setThreadgroupSizeMatchesTileSize:");
+_MTL_PRIVATE_DEF_SEL(setTileAccelerationStructure_atBufferIndex_,
+    "setTileAccelerationStructure:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileAdditionalBinaryFunctions_,
+    "setTileAdditionalBinaryFunctions:");
+_MTL_PRIVATE_DEF_SEL(setTileBuffer_offset_atIndex_,
+    "setTileBuffer:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileBufferOffset_atIndex_,
+    "setTileBufferOffset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileBuffers_offsets_withRange_,
+    "setTileBuffers:offsets:withRange:");
+_MTL_PRIVATE_DEF_SEL(setTileBytes_length_atIndex_,
+    "setTileBytes:length:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileFunction_,
+    "setTileFunction:");
+_MTL_PRIVATE_DEF_SEL(setTileHeight_,
+    "setTileHeight:");
+_MTL_PRIVATE_DEF_SEL(setTileIntersectionFunctionTable_atBufferIndex_,
+    "setTileIntersectionFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileIntersectionFunctionTables_withBufferRange_,
+    "setTileIntersectionFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setTileSamplerState_atIndex_,
+    "setTileSamplerState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_,
+    "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_,
+    "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:");
+_MTL_PRIVATE_DEF_SEL(setTileSamplerStates_withRange_,
+    "setTileSamplerStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setTileTexture_atIndex_,
+    "setTileTexture:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileTextures_withRange_,
+    "setTileTextures:withRange:");
+_MTL_PRIVATE_DEF_SEL(setTileVisibleFunctionTable_atBufferIndex_,
+    "setTileVisibleFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setTileVisibleFunctionTables_withBufferRange_,
+    "setTileVisibleFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setTileWidth_,
+    "setTileWidth:");
+_MTL_PRIVATE_DEF_SEL(setTransformationMatrixBuffer_,
+    "setTransformationMatrixBuffer:");
+_MTL_PRIVATE_DEF_SEL(setTransformationMatrixBufferOffset_,
+    "setTransformationMatrixBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setTriangleCount_,
+    "setTriangleCount:");
+_MTL_PRIVATE_DEF_SEL(setTriangleFillMode_,
+    "setTriangleFillMode:");
+_MTL_PRIVATE_DEF_SEL(setType_,
+    "setType:");
+_MTL_PRIVATE_DEF_SEL(setUrl_,
+    "setUrl:");
+_MTL_PRIVATE_DEF_SEL(setUsage_,
+    "setUsage:");
+_MTL_PRIVATE_DEF_SEL(setVertexAccelerationStructure_atBufferIndex_,
+    "setVertexAccelerationStructure:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexAdditionalBinaryFunctions_,
+    "setVertexAdditionalBinaryFunctions:");
+_MTL_PRIVATE_DEF_SEL(setVertexAmplificationCount_viewMappings_,
+    "setVertexAmplificationCount:viewMappings:");
+_MTL_PRIVATE_DEF_SEL(setVertexBuffer_,
+    "setVertexBuffer:");
+_MTL_PRIVATE_DEF_SEL(setVertexBuffer_offset_atIndex_,
+    "setVertexBuffer:offset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexBuffer_offset_attributeStride_atIndex_,
+    "setVertexBuffer:offset:attributeStride:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_,
+    "setVertexBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_atIndex_,
+    "setVertexBufferOffset:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_attributeStride_atIndex_,
+    "setVertexBufferOffset:attributeStride:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexBuffers_,
+    "setVertexBuffers:");
+_MTL_PRIVATE_DEF_SEL(setVertexBuffers_offsets_attributeStrides_withRange_,
+    "setVertexBuffers:offsets:attributeStrides:withRange:");
+_MTL_PRIVATE_DEF_SEL(setVertexBuffers_offsets_withRange_,
+    "setVertexBuffers:offsets:withRange:");
+_MTL_PRIVATE_DEF_SEL(setVertexBytes_length_atIndex_,
+    "setVertexBytes:length:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexBytes_length_attributeStride_atIndex_,
+    "setVertexBytes:length:attributeStride:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexDescriptor_,
+    "setVertexDescriptor:");
+_MTL_PRIVATE_DEF_SEL(setVertexFormat_,
+    "setVertexFormat:");
+_MTL_PRIVATE_DEF_SEL(setVertexFunction_,
+    "setVertexFunction:");
+_MTL_PRIVATE_DEF_SEL(setVertexIntersectionFunctionTable_atBufferIndex_,
+    "setVertexIntersectionFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexIntersectionFunctionTables_withBufferRange_,
+    "setVertexIntersectionFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setVertexLinkedFunctions_,
+    "setVertexLinkedFunctions:");
+_MTL_PRIVATE_DEF_SEL(setVertexPreloadedLibraries_,
+    "setVertexPreloadedLibraries:");
+_MTL_PRIVATE_DEF_SEL(setVertexSamplerState_atIndex_,
+    "setVertexSamplerState:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_,
+    "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_,
+    "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:");
+_MTL_PRIVATE_DEF_SEL(setVertexSamplerStates_withRange_,
+    "setVertexSamplerStates:withRange:");
+_MTL_PRIVATE_DEF_SEL(setVertexStride_,
+    "setVertexStride:");
+_MTL_PRIVATE_DEF_SEL(setVertexTexture_atIndex_,
+    "setVertexTexture:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexTextures_withRange_,
+    "setVertexTextures:withRange:");
+_MTL_PRIVATE_DEF_SEL(setVertexVisibleFunctionTable_atBufferIndex_,
+    "setVertexVisibleFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setVertexVisibleFunctionTables_withBufferRange_,
+    "setVertexVisibleFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setViewport_,
+    "setViewport:");
+_MTL_PRIVATE_DEF_SEL(setViewports_count_,
+    "setViewports:count:");
+_MTL_PRIVATE_DEF_SEL(setVisibilityResultBuffer_,
+    "setVisibilityResultBuffer:");
+_MTL_PRIVATE_DEF_SEL(setVisibilityResultMode_offset_,
+    "setVisibilityResultMode:offset:");
+_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTable_atBufferIndex_,
+    "setVisibleFunctionTable:atBufferIndex:");
+_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTable_atIndex_,
+    "setVisibleFunctionTable:atIndex:");
+_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTables_withBufferRange_,
+    "setVisibleFunctionTables:withBufferRange:");
+_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTables_withRange_,
+    "setVisibleFunctionTables:withRange:");
+_MTL_PRIVATE_DEF_SEL(setWidth_,
+    "setWidth:");
+_MTL_PRIVATE_DEF_SEL(setWriteMask_,
+    "setWriteMask:");
+_MTL_PRIVATE_DEF_SEL(sharedCaptureManager,
+    "sharedCaptureManager");
+_MTL_PRIVATE_DEF_SEL(shouldMaximizeConcurrentCompilation,
+    "shouldMaximizeConcurrentCompilation");
+_MTL_PRIVATE_DEF_SEL(signalEvent_value_,
+    "signalEvent:value:");
+_MTL_PRIVATE_DEF_SEL(signaledValue,
+    "signaledValue");
+_MTL_PRIVATE_DEF_SEL(size,
+    "size");
+_MTL_PRIVATE_DEF_SEL(slice,
+    "slice");
+_MTL_PRIVATE_DEF_SEL(sourceAlphaBlendFactor,
+    "sourceAlphaBlendFactor");
+_MTL_PRIVATE_DEF_SEL(sourceRGBBlendFactor,
+    "sourceRGBBlendFactor");
+_MTL_PRIVATE_DEF_SEL(sparsePageSize,
+    "sparsePageSize");
+_MTL_PRIVATE_DEF_SEL(sparseTileSizeInBytes,
+    "sparseTileSizeInBytes");
+_MTL_PRIVATE_DEF_SEL(sparseTileSizeInBytesForSparsePageSize_,
+    "sparseTileSizeInBytesForSparsePageSize:");
+_MTL_PRIVATE_DEF_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_,
+    "sparseTileSizeWithTextureType:pixelFormat:sampleCount:");
+_MTL_PRIVATE_DEF_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_sparsePageSize_,
+    "sparseTileSizeWithTextureType:pixelFormat:sampleCount:sparsePageSize:");
+_MTL_PRIVATE_DEF_SEL(specializedName,
+    "specializedName");
+_MTL_PRIVATE_DEF_SEL(stageInputAttributes,
+    "stageInputAttributes");
+_MTL_PRIVATE_DEF_SEL(stageInputDescriptor,
+    "stageInputDescriptor");
+_MTL_PRIVATE_DEF_SEL(stageInputOutputDescriptor,
+    "stageInputOutputDescriptor");
+_MTL_PRIVATE_DEF_SEL(startCaptureWithCommandQueue_,
+    "startCaptureWithCommandQueue:");
+_MTL_PRIVATE_DEF_SEL(startCaptureWithDescriptor_error_,
+    "startCaptureWithDescriptor:error:");
+_MTL_PRIVATE_DEF_SEL(startCaptureWithDevice_,
+    "startCaptureWithDevice:");
+_MTL_PRIVATE_DEF_SEL(startCaptureWithScope_,
+    "startCaptureWithScope:");
+_MTL_PRIVATE_DEF_SEL(startOfEncoderSampleIndex,
+    "startOfEncoderSampleIndex");
+_MTL_PRIVATE_DEF_SEL(startOfFragmentSampleIndex,
+    "startOfFragmentSampleIndex");
+_MTL_PRIVATE_DEF_SEL(startOfVertexSampleIndex,
+    "startOfVertexSampleIndex");
+_MTL_PRIVATE_DEF_SEL(staticThreadgroupMemoryLength,
+    "staticThreadgroupMemoryLength");
+_MTL_PRIVATE_DEF_SEL(status,
+    "status");
+_MTL_PRIVATE_DEF_SEL(stencilAttachment,
+    "stencilAttachment");
+_MTL_PRIVATE_DEF_SEL(stencilAttachmentPixelFormat,
+    "stencilAttachmentPixelFormat");
+_MTL_PRIVATE_DEF_SEL(stencilCompareFunction,
+    "stencilCompareFunction");
+_MTL_PRIVATE_DEF_SEL(stencilFailureOperation,
+    "stencilFailureOperation");
+_MTL_PRIVATE_DEF_SEL(stencilResolveFilter,
+    "stencilResolveFilter");
+_MTL_PRIVATE_DEF_SEL(stepFunction,
+    "stepFunction");
+_MTL_PRIVATE_DEF_SEL(stepRate,
+    "stepRate");
+_MTL_PRIVATE_DEF_SEL(stopCapture,
+    "stopCapture");
+_MTL_PRIVATE_DEF_SEL(storageMode,
+    "storageMode");
+_MTL_PRIVATE_DEF_SEL(storeAction,
+    "storeAction");
+_MTL_PRIVATE_DEF_SEL(storeActionOptions,
+    "storeActionOptions");
+_MTL_PRIVATE_DEF_SEL(stride,
+    "stride");
+_MTL_PRIVATE_DEF_SEL(structType,
+    "structType");
+_MTL_PRIVATE_DEF_SEL(supportAddingBinaryFunctions,
+    "supportAddingBinaryFunctions");
+_MTL_PRIVATE_DEF_SEL(supportAddingFragmentBinaryFunctions,
+    "supportAddingFragmentBinaryFunctions");
+_MTL_PRIVATE_DEF_SEL(supportAddingVertexBinaryFunctions,
+    "supportAddingVertexBinaryFunctions");
+_MTL_PRIVATE_DEF_SEL(supportArgumentBuffers,
+    "supportArgumentBuffers");
+_MTL_PRIVATE_DEF_SEL(supportDynamicAttributeStride,
+    "supportDynamicAttributeStride");
+_MTL_PRIVATE_DEF_SEL(supportIndirectCommandBuffers,
+    "supportIndirectCommandBuffers");
+_MTL_PRIVATE_DEF_SEL(supportRayTracing,
+    "supportRayTracing");
+_MTL_PRIVATE_DEF_SEL(supports32BitFloatFiltering,
+    "supports32BitFloatFiltering");
+_MTL_PRIVATE_DEF_SEL(supports32BitMSAA,
+    "supports32BitMSAA");
+_MTL_PRIVATE_DEF_SEL(supportsBCTextureCompression,
+    "supportsBCTextureCompression");
+_MTL_PRIVATE_DEF_SEL(supportsCounterSampling_,
+    "supportsCounterSampling:");
+_MTL_PRIVATE_DEF_SEL(supportsDestination_,
+    "supportsDestination:");
+_MTL_PRIVATE_DEF_SEL(supportsDynamicLibraries,
+    "supportsDynamicLibraries");
+_MTL_PRIVATE_DEF_SEL(supportsFamily_,
+    "supportsFamily:");
+_MTL_PRIVATE_DEF_SEL(supportsFeatureSet_,
+    "supportsFeatureSet:");
+_MTL_PRIVATE_DEF_SEL(supportsFunctionPointers,
+    "supportsFunctionPointers");
+_MTL_PRIVATE_DEF_SEL(supportsFunctionPointersFromRender,
+    "supportsFunctionPointersFromRender");
+_MTL_PRIVATE_DEF_SEL(supportsPrimitiveMotionBlur,
+    "supportsPrimitiveMotionBlur");
+_MTL_PRIVATE_DEF_SEL(supportsPullModelInterpolation,
+    "supportsPullModelInterpolation");
+_MTL_PRIVATE_DEF_SEL(supportsQueryTextureLOD,
+    "supportsQueryTextureLOD");
+_MTL_PRIVATE_DEF_SEL(supportsRasterizationRateMapWithLayerCount_,
+    "supportsRasterizationRateMapWithLayerCount:");
+_MTL_PRIVATE_DEF_SEL(supportsRaytracing,
+    "supportsRaytracing");
+_MTL_PRIVATE_DEF_SEL(supportsRaytracingFromRender,
+    "supportsRaytracingFromRender");
+_MTL_PRIVATE_DEF_SEL(supportsRenderDynamicLibraries,
+    "supportsRenderDynamicLibraries");
+_MTL_PRIVATE_DEF_SEL(supportsShaderBarycentricCoordinates,
+    "supportsShaderBarycentricCoordinates");
+_MTL_PRIVATE_DEF_SEL(supportsTextureSampleCount_,
+    "supportsTextureSampleCount:");
+_MTL_PRIVATE_DEF_SEL(supportsVertexAmplificationCount_,
+    "supportsVertexAmplificationCount:");
+_MTL_PRIVATE_DEF_SEL(swizzle,
+    "swizzle");
+_MTL_PRIVATE_DEF_SEL(synchronizeResource_,
+    "synchronizeResource:");
+_MTL_PRIVATE_DEF_SEL(synchronizeTexture_slice_level_,
+    "synchronizeTexture:slice:level:");
+_MTL_PRIVATE_DEF_SEL(tAddressMode,
+    "tAddressMode");
+_MTL_PRIVATE_DEF_SEL(tailSizeInBytes,
+    "tailSizeInBytes");
+_MTL_PRIVATE_DEF_SEL(tessellationControlPointIndexType,
+    "tessellationControlPointIndexType");
+_MTL_PRIVATE_DEF_SEL(tessellationFactorFormat,
+    "tessellationFactorFormat");
+_MTL_PRIVATE_DEF_SEL(tessellationFactorStepFunction,
+    "tessellationFactorStepFunction");
+_MTL_PRIVATE_DEF_SEL(tessellationOutputWindingOrder,
+    "tessellationOutputWindingOrder");
+_MTL_PRIVATE_DEF_SEL(tessellationPartitionMode,
+    "tessellationPartitionMode");
+_MTL_PRIVATE_DEF_SEL(texture,
+    "texture");
+_MTL_PRIVATE_DEF_SEL(texture2DDescriptorWithPixelFormat_width_height_mipmapped_,
+    "texture2DDescriptorWithPixelFormat:width:height:mipmapped:");
+_MTL_PRIVATE_DEF_SEL(textureBarrier,
+    "textureBarrier");
+_MTL_PRIVATE_DEF_SEL(textureBufferDescriptorWithPixelFormat_width_resourceOptions_usage_,
+    "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:");
+_MTL_PRIVATE_DEF_SEL(textureCubeDescriptorWithPixelFormat_size_mipmapped_,
+    "textureCubeDescriptorWithPixelFormat:size:mipmapped:");
+_MTL_PRIVATE_DEF_SEL(textureDataType,
+    "textureDataType");
+_MTL_PRIVATE_DEF_SEL(textureReferenceType,
+    "textureReferenceType");
+_MTL_PRIVATE_DEF_SEL(textureType,
+    "textureType");
+_MTL_PRIVATE_DEF_SEL(threadExecutionWidth,
+    "threadExecutionWidth");
+_MTL_PRIVATE_DEF_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth,
+    "threadGroupSizeIsMultipleOfThreadExecutionWidth");
+_MTL_PRIVATE_DEF_SEL(threadgroupMemoryAlignment,
+    "threadgroupMemoryAlignment");
+_MTL_PRIVATE_DEF_SEL(threadgroupMemoryDataSize,
+    "threadgroupMemoryDataSize");
+_MTL_PRIVATE_DEF_SEL(threadgroupMemoryLength,
+    "threadgroupMemoryLength");
+_MTL_PRIVATE_DEF_SEL(threadgroupSizeMatchesTileSize,
+    "threadgroupSizeMatchesTileSize");
+_MTL_PRIVATE_DEF_SEL(tileAdditionalBinaryFunctions,
+    "tileAdditionalBinaryFunctions");
+_MTL_PRIVATE_DEF_SEL(tileArguments,
+    "tileArguments");
+_MTL_PRIVATE_DEF_SEL(tileBindings,
+    "tileBindings");
+_MTL_PRIVATE_DEF_SEL(tileBuffers,
+    "tileBuffers");
+_MTL_PRIVATE_DEF_SEL(tileFunction,
+    "tileFunction");
+_MTL_PRIVATE_DEF_SEL(tileHeight,
+    "tileHeight");
+_MTL_PRIVATE_DEF_SEL(tileWidth,
+    "tileWidth");
+_MTL_PRIVATE_DEF_SEL(transformationMatrixBuffer,
+    "transformationMatrixBuffer");
+_MTL_PRIVATE_DEF_SEL(transformationMatrixBufferOffset,
+    "transformationMatrixBufferOffset");
+_MTL_PRIVATE_DEF_SEL(triangleCount,
+    "triangleCount");
+_MTL_PRIVATE_DEF_SEL(tryCancel,
+    "tryCancel");
+_MTL_PRIVATE_DEF_SEL(type,
+    "type");
+_MTL_PRIVATE_DEF_SEL(updateFence_,
+    "updateFence:");
+_MTL_PRIVATE_DEF_SEL(updateFence_afterStages_,
+    "updateFence:afterStages:");
+_MTL_PRIVATE_DEF_SEL(updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_,
+    "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:");
+_MTL_PRIVATE_DEF_SEL(updateTextureMapping_mode_region_mipLevel_slice_,
+    "updateTextureMapping:mode:region:mipLevel:slice:");
+_MTL_PRIVATE_DEF_SEL(updateTextureMappings_mode_regions_mipLevels_slices_numRegions_,
+    "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:");
+_MTL_PRIVATE_DEF_SEL(url,
+    "url");
+_MTL_PRIVATE_DEF_SEL(usage,
+    "usage");
+_MTL_PRIVATE_DEF_SEL(useHeap_,
+    "useHeap:");
+_MTL_PRIVATE_DEF_SEL(useHeap_stages_,
+    "useHeap:stages:");
+_MTL_PRIVATE_DEF_SEL(useHeaps_count_,
+    "useHeaps:count:");
+_MTL_PRIVATE_DEF_SEL(useHeaps_count_stages_,
+    "useHeaps:count:stages:");
+_MTL_PRIVATE_DEF_SEL(useResource_usage_,
+    "useResource:usage:");
+_MTL_PRIVATE_DEF_SEL(useResource_usage_stages_,
+    "useResource:usage:stages:");
+_MTL_PRIVATE_DEF_SEL(useResources_count_usage_,
+    "useResources:count:usage:");
+_MTL_PRIVATE_DEF_SEL(useResources_count_usage_stages_,
+    "useResources:count:usage:stages:");
+_MTL_PRIVATE_DEF_SEL(usedSize,
+    "usedSize");
+_MTL_PRIVATE_DEF_SEL(vertexAdditionalBinaryFunctions,
+    "vertexAdditionalBinaryFunctions");
+_MTL_PRIVATE_DEF_SEL(vertexArguments,
+    "vertexArguments");
+_MTL_PRIVATE_DEF_SEL(vertexAttributes,
+    "vertexAttributes");
+_MTL_PRIVATE_DEF_SEL(vertexBindings,
+    "vertexBindings");
+_MTL_PRIVATE_DEF_SEL(vertexBuffer,
+    "vertexBuffer");
+_MTL_PRIVATE_DEF_SEL(vertexBufferOffset,
+    "vertexBufferOffset");
+_MTL_PRIVATE_DEF_SEL(vertexBuffers,
+    "vertexBuffers");
+_MTL_PRIVATE_DEF_SEL(vertexDescriptor,
+    "vertexDescriptor");
+_MTL_PRIVATE_DEF_SEL(vertexFormat,
+    "vertexFormat");
+_MTL_PRIVATE_DEF_SEL(vertexFunction,
+    "vertexFunction");
+_MTL_PRIVATE_DEF_SEL(vertexLinkedFunctions,
+    "vertexLinkedFunctions");
+_MTL_PRIVATE_DEF_SEL(vertexPreloadedLibraries,
+    "vertexPreloadedLibraries");
+_MTL_PRIVATE_DEF_SEL(vertexStride,
+    "vertexStride");
+_MTL_PRIVATE_DEF_SEL(vertical,
+    "vertical");
+_MTL_PRIVATE_DEF_SEL(verticalSampleStorage,
+    "verticalSampleStorage");
+_MTL_PRIVATE_DEF_SEL(visibilityResultBuffer,
+    "visibilityResultBuffer");
+_MTL_PRIVATE_DEF_SEL(visibleFunctionTableDescriptor,
+    "visibleFunctionTableDescriptor");
+_MTL_PRIVATE_DEF_SEL(waitForEvent_value_,
+    "waitForEvent:value:");
+_MTL_PRIVATE_DEF_SEL(waitForFence_,
+    "waitForFence:");
+_MTL_PRIVATE_DEF_SEL(waitForFence_beforeStages_,
+    "waitForFence:beforeStages:");
+_MTL_PRIVATE_DEF_SEL(waitUntilCompleted,
+    "waitUntilCompleted");
+_MTL_PRIVATE_DEF_SEL(waitUntilScheduled,
+    "waitUntilScheduled");
+_MTL_PRIVATE_DEF_SEL(width,
+    "width");
+_MTL_PRIVATE_DEF_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_,
+    "writeCompactedAccelerationStructureSize:toBuffer:offset:");
+_MTL_PRIVATE_DEF_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_sizeDataType_,
+    "writeCompactedAccelerationStructureSize:toBuffer:offset:sizeDataType:");
+_MTL_PRIVATE_DEF_SEL(writeMask,
+    "writeMask");
+
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLHeap.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLHeap.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bb5b83613bfff909dc7d5f7eba023b87f477c105
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLHeap.hpp
@@ -0,0 +1,329 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLHeap.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLDevice.hpp"
+#include "MTLHeap.hpp"
+#include "MTLResource.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::Integer, HeapType) {
+    HeapTypeAutomatic = 0,
+    HeapTypePlacement = 1,
+    HeapTypeSparse = 2,
+};
+
+class HeapDescriptor : public NS::Copying<HeapDescriptor>
+{
+public:
+    static class HeapDescriptor* alloc();
+
+    class HeapDescriptor*        init();
+
+    NS::UInteger                 size() const;
+    void                         setSize(NS::UInteger size);
+
+    MTL::StorageMode             storageMode() const;
+    void                         setStorageMode(MTL::StorageMode storageMode);
+
+    MTL::CPUCacheMode            cpuCacheMode() const;
+    void                         setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode);
+
+    MTL::SparsePageSize          sparsePageSize() const;
+    void                         setSparsePageSize(MTL::SparsePageSize sparsePageSize);
+
+    MTL::HazardTrackingMode      hazardTrackingMode() const;
+    void                         setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode);
+
+    MTL::ResourceOptions         resourceOptions() const;
+    void                         setResourceOptions(MTL::ResourceOptions resourceOptions);
+
+    MTL::HeapType                type() const;
+    void                         setType(MTL::HeapType type);
+};
+
+class Heap : public NS::Referencing<Heap>
+{
+public:
+    NS::String*                  label() const;
+    void                         setLabel(const NS::String* label);
+
+    class Device*                device() const;
+
+    MTL::StorageMode             storageMode() const;
+
+    MTL::CPUCacheMode            cpuCacheMode() const;
+
+    MTL::HazardTrackingMode      hazardTrackingMode() const;
+
+    MTL::ResourceOptions         resourceOptions() const;
+
+    NS::UInteger                 size() const;
+
+    NS::UInteger                 usedSize() const;
+
+    NS::UInteger                 currentAllocatedSize() const;
+
+    NS::UInteger                 maxAvailableSize(NS::UInteger alignment);
+
+    class Buffer*                newBuffer(NS::UInteger length, MTL::ResourceOptions options);
+
+    class Texture*               newTexture(const class TextureDescriptor* descriptor);
+
+    MTL::PurgeableState          setPurgeableState(MTL::PurgeableState state);
+
+    MTL::HeapType                type() const;
+
+    class Buffer*                newBuffer(NS::UInteger length, MTL::ResourceOptions options, NS::UInteger offset);
+
+    class Texture*               newTexture(const class TextureDescriptor* descriptor, NS::UInteger offset);
+
+    class AccelerationStructure* newAccelerationStructure(NS::UInteger size);
+
+    class AccelerationStructure* newAccelerationStructure(const class AccelerationStructureDescriptor* descriptor);
+
+    class AccelerationStructure* newAccelerationStructure(NS::UInteger size, NS::UInteger offset);
+
+    class AccelerationStructure* newAccelerationStructure(const class AccelerationStructureDescriptor* descriptor, NS::UInteger offset);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::HeapDescriptor* MTL::HeapDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::HeapDescriptor>(_MTL_PRIVATE_CLS(MTLHeapDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::HeapDescriptor* MTL::HeapDescriptor::init()
+{
+    return NS::Object::init<MTL::HeapDescriptor>();
+}
+
+// property: size
+_MTL_INLINE NS::UInteger MTL::HeapDescriptor::size() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
+}
+
+_MTL_INLINE void MTL::HeapDescriptor::setSize(NS::UInteger size)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSize_), size);
+}
+
+// property: storageMode
+_MTL_INLINE MTL::StorageMode MTL::HeapDescriptor::storageMode() const
+{
+    return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
+}
+
+_MTL_INLINE void MTL::HeapDescriptor::setStorageMode(MTL::StorageMode storageMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode);
+}
+
+// property: cpuCacheMode
+_MTL_INLINE MTL::CPUCacheMode MTL::HeapDescriptor::cpuCacheMode() const
+{
+    return Object::sendMessage<MTL::CPUCacheMode>(this, _MTL_PRIVATE_SEL(cpuCacheMode));
+}
+
+_MTL_INLINE void MTL::HeapDescriptor::setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCpuCacheMode_), cpuCacheMode);
+}
+
+// property: sparsePageSize
+_MTL_INLINE MTL::SparsePageSize MTL::HeapDescriptor::sparsePageSize() const
+{
+    return Object::sendMessage<MTL::SparsePageSize>(this, _MTL_PRIVATE_SEL(sparsePageSize));
+}
+
+_MTL_INLINE void MTL::HeapDescriptor::setSparsePageSize(MTL::SparsePageSize sparsePageSize)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSparsePageSize_), sparsePageSize);
+}
+
+// property: hazardTrackingMode
+_MTL_INLINE MTL::HazardTrackingMode MTL::HeapDescriptor::hazardTrackingMode() const
+{
+    return Object::sendMessage<MTL::HazardTrackingMode>(this, _MTL_PRIVATE_SEL(hazardTrackingMode));
+}
+
+_MTL_INLINE void MTL::HeapDescriptor::setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setHazardTrackingMode_), hazardTrackingMode);
+}
+
+// property: resourceOptions
+_MTL_INLINE MTL::ResourceOptions MTL::HeapDescriptor::resourceOptions() const
+{
+    return Object::sendMessage<MTL::ResourceOptions>(this, _MTL_PRIVATE_SEL(resourceOptions));
+}
+
+_MTL_INLINE void MTL::HeapDescriptor::setResourceOptions(MTL::ResourceOptions resourceOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResourceOptions_), resourceOptions);
+}
+
+// property: type
+_MTL_INLINE MTL::HeapType MTL::HeapDescriptor::type() const
+{
+    return Object::sendMessage<MTL::HeapType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+_MTL_INLINE void MTL::HeapDescriptor::setType(MTL::HeapType type)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setType_), type);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::Heap::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::Heap::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::Heap::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: storageMode
+_MTL_INLINE MTL::StorageMode MTL::Heap::storageMode() const
+{
+    return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
+}
+
+// property: cpuCacheMode
+_MTL_INLINE MTL::CPUCacheMode MTL::Heap::cpuCacheMode() const
+{
+    return Object::sendMessage<MTL::CPUCacheMode>(this, _MTL_PRIVATE_SEL(cpuCacheMode));
+}
+
+// property: hazardTrackingMode
+_MTL_INLINE MTL::HazardTrackingMode MTL::Heap::hazardTrackingMode() const
+{
+    return Object::sendMessage<MTL::HazardTrackingMode>(this, _MTL_PRIVATE_SEL(hazardTrackingMode));
+}
+
+// property: resourceOptions
+_MTL_INLINE MTL::ResourceOptions MTL::Heap::resourceOptions() const
+{
+    return Object::sendMessage<MTL::ResourceOptions>(this, _MTL_PRIVATE_SEL(resourceOptions));
+}
+
+// property: size
+_MTL_INLINE NS::UInteger MTL::Heap::size() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
+}
+
+// property: usedSize
+_MTL_INLINE NS::UInteger MTL::Heap::usedSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(usedSize));
+}
+
+// property: currentAllocatedSize
+_MTL_INLINE NS::UInteger MTL::Heap::currentAllocatedSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(currentAllocatedSize));
+}
+
+// method: maxAvailableSizeWithAlignment:
+_MTL_INLINE NS::UInteger MTL::Heap::maxAvailableSize(NS::UInteger alignment)
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxAvailableSizeWithAlignment_), alignment);
+}
+
+// method: newBufferWithLength:options:
+_MTL_INLINE MTL::Buffer* MTL::Heap::newBuffer(NS::UInteger length, MTL::ResourceOptions options)
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_), length, options);
+}
+
+// method: newTextureWithDescriptor:
+_MTL_INLINE MTL::Texture* MTL::Heap::newTexture(const MTL::TextureDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_), descriptor);
+}
+
+// method: setPurgeableState:
+_MTL_INLINE MTL::PurgeableState MTL::Heap::setPurgeableState(MTL::PurgeableState state)
+{
+    return Object::sendMessage<MTL::PurgeableState>(this, _MTL_PRIVATE_SEL(setPurgeableState_), state);
+}
+
+// property: type
+_MTL_INLINE MTL::HeapType MTL::Heap::type() const
+{
+    return Object::sendMessage<MTL::HeapType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+// method: newBufferWithLength:options:offset:
+_MTL_INLINE MTL::Buffer* MTL::Heap::newBuffer(NS::UInteger length, MTL::ResourceOptions options, NS::UInteger offset)
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_offset_), length, options, offset);
+}
+
+// method: newTextureWithDescriptor:offset:
+_MTL_INLINE MTL::Texture* MTL::Heap::newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_offset_), descriptor, offset);
+}
+
+// method: newAccelerationStructureWithSize:
+_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(NS::UInteger size)
+{
+    return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_), size);
+}
+
+// method: newAccelerationStructureWithDescriptor:
+_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor)
+{
+    return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_), descriptor);
+}
+
+// method: newAccelerationStructureWithSize:offset:
+_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(NS::UInteger size, NS::UInteger offset)
+{
+    return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_offset_), size, offset);
+}
+
+// method: newAccelerationStructureWithDescriptor:offset:
+_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor, NS::UInteger offset)
+{
+    return Object::sendMessage<MTL::AccelerationStructure*>(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_offset_), descriptor, offset);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCommandBuffer.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCommandBuffer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb28f3e7c51564320486d9ca7fe5533a570ca6dd
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCommandBuffer.hpp
@@ -0,0 +1,200 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLIOCommandBuffer.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLIOCommandBuffer.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::Integer, IOStatus) {
+    IOStatusPending = 0,
+    IOStatusCancelled = 1,
+    IOStatusError = 2,
+    IOStatusComplete = 3,
+};
+
+using IOCommandBufferHandler = void (^)(class IOCommandBuffer*);
+
+using IOCommandBufferHandlerFunction = std::function<void(class IOCommandBuffer*)>;
+
+class IOCommandBuffer : public NS::Referencing<IOCommandBuffer>
+{
+public:
+    void          addCompletedHandler(const MTL::IOCommandBufferHandlerFunction& function);
+
+    void          addCompletedHandler(const MTL::IOCommandBufferHandler block);
+
+    void          loadBytes(const void* pointer, NS::UInteger size, const class IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset);
+
+    void          loadBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger size, const class IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset);
+
+    void          loadTexture(const class Texture* texture, NS::UInteger slice, NS::UInteger level, MTL::Size size, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Origin destinationOrigin, const class IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset);
+
+    void          copyStatusToBuffer(const class Buffer* buffer, NS::UInteger offset);
+
+    void          commit();
+
+    void          waitUntilCompleted();
+
+    void          tryCancel();
+
+    void          addBarrier();
+
+    void          pushDebugGroup(const NS::String* string);
+
+    void          popDebugGroup();
+
+    void          enqueue();
+
+    void          wait(const class SharedEvent* event, uint64_t value);
+
+    void          signalEvent(const class SharedEvent* event, uint64_t value);
+
+    NS::String*   label() const;
+    void          setLabel(const NS::String* label);
+
+    MTL::IOStatus status() const;
+
+    NS::Error*    error() const;
+};
+
+}
+
+_MTL_INLINE void MTL::IOCommandBuffer::addCompletedHandler(const MTL::IOCommandBufferHandlerFunction& function)
+{
+    __block IOCommandBufferHandlerFunction blockFunction = function;
+
+    addCompletedHandler(^(IOCommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); });
+}
+
+// method: addCompletedHandler:
+_MTL_INLINE void MTL::IOCommandBuffer::addCompletedHandler(const MTL::IOCommandBufferHandler block)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addCompletedHandler_), block);
+}
+
+// method: loadBytes:size:sourceHandle:sourceHandleOffset:
+_MTL_INLINE void MTL::IOCommandBuffer::loadBytes(const void* pointer, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(loadBytes_size_sourceHandle_sourceHandleOffset_), pointer, size, sourceHandle, sourceHandleOffset);
+}
+
+// method: loadBuffer:offset:size:sourceHandle:sourceHandleOffset:
+_MTL_INLINE void MTL::IOCommandBuffer::loadBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(loadBuffer_offset_size_sourceHandle_sourceHandleOffset_), buffer, offset, size, sourceHandle, sourceHandleOffset);
+}
+
+// method: loadTexture:slice:level:size:sourceBytesPerRow:sourceBytesPerImage:destinationOrigin:sourceHandle:sourceHandleOffset:
+_MTL_INLINE void MTL::IOCommandBuffer::loadTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level, MTL::Size size, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Origin destinationOrigin, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(loadTexture_slice_level_size_sourceBytesPerRow_sourceBytesPerImage_destinationOrigin_sourceHandle_sourceHandleOffset_), texture, slice, level, size, sourceBytesPerRow, sourceBytesPerImage, destinationOrigin, sourceHandle, sourceHandleOffset);
+}
+
+// method: copyStatusToBuffer:offset:
+_MTL_INLINE void MTL::IOCommandBuffer::copyStatusToBuffer(const MTL::Buffer* buffer, NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyStatusToBuffer_offset_), buffer, offset);
+}
+
+// method: commit
+_MTL_INLINE void MTL::IOCommandBuffer::commit()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(commit));
+}
+
+// method: waitUntilCompleted
+_MTL_INLINE void MTL::IOCommandBuffer::waitUntilCompleted()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitUntilCompleted));
+}
+
+// method: tryCancel
+_MTL_INLINE void MTL::IOCommandBuffer::tryCancel()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(tryCancel));
+}
+
+// method: addBarrier
+_MTL_INLINE void MTL::IOCommandBuffer::addBarrier()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(addBarrier));
+}
+
+// method: pushDebugGroup:
+_MTL_INLINE void MTL::IOCommandBuffer::pushDebugGroup(const NS::String* string)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string);
+}
+
+// method: popDebugGroup
+_MTL_INLINE void MTL::IOCommandBuffer::popDebugGroup()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(popDebugGroup));
+}
+
+// method: enqueue
+_MTL_INLINE void MTL::IOCommandBuffer::enqueue()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(enqueue));
+}
+
+// method: waitForEvent:value:
+_MTL_INLINE void MTL::IOCommandBuffer::wait(const MTL::SharedEvent* event, uint64_t value)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForEvent_value_), event, value);
+}
+
+// method: signalEvent:value:
+_MTL_INLINE void MTL::IOCommandBuffer::signalEvent(const MTL::SharedEvent* event, uint64_t value)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(signalEvent_value_), event, value);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::IOCommandBuffer::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::IOCommandBuffer::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: status
+_MTL_INLINE MTL::IOStatus MTL::IOCommandBuffer::status() const
+{
+    return Object::sendMessage<MTL::IOStatus>(this, _MTL_PRIVATE_SEL(status));
+}
+
+// property: error
+_MTL_INLINE NS::Error* MTL::IOCommandBuffer::error() const
+{
+    return Object::sendMessage<NS::Error*>(this, _MTL_PRIVATE_SEL(error));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCommandQueue.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCommandQueue.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b5f5d1c2267eddd0ccfb6899da39790870320fea
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCommandQueue.hpp
@@ -0,0 +1,225 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLIOCommandQueue.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLIOCommandQueue.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::Integer, IOPriority) {
+    IOPriorityHigh = 0,
+    IOPriorityNormal = 1,
+    IOPriorityLow = 2,
+};
+
+_MTL_ENUM(NS::Integer, IOCommandQueueType) {
+    IOCommandQueueTypeConcurrent = 0,
+    IOCommandQueueTypeSerial = 1,
+};
+
+_MTL_CONST(NS::ErrorDomain, IOErrorDomain);
+
+_MTL_ENUM(NS::Integer, IOError) {
+    IOErrorURLInvalid = 1,
+    IOErrorInternal = 2,
+};
+
+class IOCommandQueue : public NS::Referencing<IOCommandQueue>
+{
+public:
+    void                   enqueueBarrier();
+
+    class IOCommandBuffer* commandBuffer();
+
+    class IOCommandBuffer* commandBufferWithUnretainedReferences();
+
+    NS::String*            label() const;
+    void                   setLabel(const NS::String* label);
+};
+
+class IOScratchBuffer : public NS::Referencing<IOScratchBuffer>
+{
+public:
+    class Buffer* buffer() const;
+};
+
+class IOScratchBufferAllocator : public NS::Referencing<IOScratchBufferAllocator>
+{
+public:
+    class IOScratchBuffer* newScratchBuffer(NS::UInteger minimumSize);
+};
+
+class IOCommandQueueDescriptor : public NS::Copying<IOCommandQueueDescriptor>
+{
+public:
+    static class IOCommandQueueDescriptor* alloc();
+
+    class IOCommandQueueDescriptor*        init();
+
+    NS::UInteger                           maxCommandBufferCount() const;
+    void                                   setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount);
+
+    MTL::IOPriority                        priority() const;
+    void                                   setPriority(MTL::IOPriority priority);
+
+    MTL::IOCommandQueueType                type() const;
+    void                                   setType(MTL::IOCommandQueueType type);
+
+    NS::UInteger                           maxCommandsInFlight() const;
+    void                                   setMaxCommandsInFlight(NS::UInteger maxCommandsInFlight);
+
+    class IOScratchBufferAllocator*        scratchBufferAllocator() const;
+    void                                   setScratchBufferAllocator(const class IOScratchBufferAllocator* scratchBufferAllocator);
+};
+
+class IOFileHandle : public NS::Referencing<IOFileHandle>
+{
+public:
+    NS::String* label() const;
+    void        setLabel(const NS::String* label);
+};
+
+}
+
+// method: enqueueBarrier
+_MTL_INLINE void MTL::IOCommandQueue::enqueueBarrier()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(enqueueBarrier));
+}
+
+// method: commandBuffer
+_MTL_INLINE MTL::IOCommandBuffer* MTL::IOCommandQueue::commandBuffer()
+{
+    return Object::sendMessage<MTL::IOCommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBuffer));
+}
+
+// method: commandBufferWithUnretainedReferences
+_MTL_INLINE MTL::IOCommandBuffer* MTL::IOCommandQueue::commandBufferWithUnretainedReferences()
+{
+    return Object::sendMessage<MTL::IOCommandBuffer*>(this, _MTL_PRIVATE_SEL(commandBufferWithUnretainedReferences));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::IOCommandQueue::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::IOCommandQueue::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: buffer
+_MTL_INLINE MTL::Buffer* MTL::IOScratchBuffer::buffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(buffer));
+}
+
+// method: newScratchBufferWithMinimumSize:
+_MTL_INLINE MTL::IOScratchBuffer* MTL::IOScratchBufferAllocator::newScratchBuffer(NS::UInteger minimumSize)
+{
+    return Object::sendMessage<MTL::IOScratchBuffer*>(this, _MTL_PRIVATE_SEL(newScratchBufferWithMinimumSize_), minimumSize);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::IOCommandQueueDescriptor* MTL::IOCommandQueueDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::IOCommandQueueDescriptor>(_MTL_PRIVATE_CLS(MTLIOCommandQueueDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::IOCommandQueueDescriptor* MTL::IOCommandQueueDescriptor::init()
+{
+    return NS::Object::init<MTL::IOCommandQueueDescriptor>();
+}
+
+// property: maxCommandBufferCount
+_MTL_INLINE NS::UInteger MTL::IOCommandQueueDescriptor::maxCommandBufferCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCommandBufferCount));
+}
+
+_MTL_INLINE void MTL::IOCommandQueueDescriptor::setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCommandBufferCount_), maxCommandBufferCount);
+}
+
+// property: priority
+_MTL_INLINE MTL::IOPriority MTL::IOCommandQueueDescriptor::priority() const
+{
+    return Object::sendMessage<MTL::IOPriority>(this, _MTL_PRIVATE_SEL(priority));
+}
+
+_MTL_INLINE void MTL::IOCommandQueueDescriptor::setPriority(MTL::IOPriority priority)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPriority_), priority);
+}
+
+// property: type
+_MTL_INLINE MTL::IOCommandQueueType MTL::IOCommandQueueDescriptor::type() const
+{
+    return Object::sendMessage<MTL::IOCommandQueueType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+_MTL_INLINE void MTL::IOCommandQueueDescriptor::setType(MTL::IOCommandQueueType type)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setType_), type);
+}
+
+// property: maxCommandsInFlight
+_MTL_INLINE NS::UInteger MTL::IOCommandQueueDescriptor::maxCommandsInFlight() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCommandsInFlight));
+}
+
+_MTL_INLINE void MTL::IOCommandQueueDescriptor::setMaxCommandsInFlight(NS::UInteger maxCommandsInFlight)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCommandsInFlight_), maxCommandsInFlight);
+}
+
+// property: scratchBufferAllocator
+_MTL_INLINE MTL::IOScratchBufferAllocator* MTL::IOCommandQueueDescriptor::scratchBufferAllocator() const
+{
+    return Object::sendMessage<MTL::IOScratchBufferAllocator*>(this, _MTL_PRIVATE_SEL(scratchBufferAllocator));
+}
+
+_MTL_INLINE void MTL::IOCommandQueueDescriptor::setScratchBufferAllocator(const MTL::IOScratchBufferAllocator* scratchBufferAllocator)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScratchBufferAllocator_), scratchBufferAllocator);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::IOFileHandle::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::IOFileHandle::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCompressor.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCompressor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad9e92d1c5a890093099a99766b43229b28a232b
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIOCompressor.hpp
@@ -0,0 +1,94 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLIOCompressor.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+#include "MTLDevice.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+using IOCompresionContext=void*;
+
+_MTL_ENUM(NS::Integer, IOCompressionStatus) {
+    IOCompressionStatusComplete = 0,
+    IOCompressionStatusError = 1,
+};
+
+size_t IOCompressionContextDefaultChunkSize();
+
+IOCompresionContext IOCreateCompressionContext(const char* path, IOCompressionMethod type, size_t chunkSize);
+
+void IOCompressionContextAppendData(IOCompresionContext context, const void* data, size_t size);
+
+IOCompressionStatus IOFlushAndDestroyCompressionContext(IOCompresionContext context);
+
+}
+
+#if defined(MTL_PRIVATE_IMPLEMENTATION)
+
+namespace MTL::Private {
+
+MTL_DEF_FUNC(MTLIOCompressionContextDefaultChunkSize, size_t (*)(void));
+
+MTL_DEF_FUNC( MTLIOCreateCompressionContext, void* (*)(const char*, MTL::IOCompressionMethod, size_t) );
+
+MTL_DEF_FUNC( MTLIOCompressionContextAppendData, void (*)(void*, const void*, size_t) );
+
+MTL_DEF_FUNC( MTLIOFlushAndDestroyCompressionContext, MTL::IOCompressionStatus (*)(void*) );
+
+}
+
+_NS_EXPORT size_t MTL::IOCompressionContextDefaultChunkSize()
+{
+    return MTL::Private::MTLIOCompressionContextDefaultChunkSize();
+}
+
+_NS_EXPORT void* MTL::IOCreateCompressionContext(const char* path, IOCompressionMethod type, size_t chunkSize)
+{
+    if ( MTL::Private::MTLIOCreateCompressionContext )
+    {
+        return MTL::Private::MTLIOCreateCompressionContext( path, type, chunkSize );
+    }
+    return nullptr;
+}
+
+_NS_EXPORT void MTL::IOCompressionContextAppendData(void* context, const void* data, size_t size)
+{
+    if ( MTL::Private::MTLIOCompressionContextAppendData )
+    {
+        MTL::Private::MTLIOCompressionContextAppendData( context, data, size );
+    }
+}
+
+_NS_EXPORT MTL::IOCompressionStatus MTL::IOFlushAndDestroyCompressionContext(void* context)
+{
+    if ( MTL::Private::MTLIOFlushAndDestroyCompressionContext )
+    {
+        return MTL::Private::MTLIOFlushAndDestroyCompressionContext( context );
+    }
+    return MTL::IOCompressionStatusError;
+}
+
+#endif
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIndirectCommandBuffer.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIndirectCommandBuffer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..52474a011a80b7034f8981abac479fff23592d29
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIndirectCommandBuffer.hpp
@@ -0,0 +1,240 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLIndirectCommandBuffer.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLIndirectCommandBuffer.hpp"
+#include "MTLResource.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_OPTIONS(NS::UInteger, IndirectCommandType) {
+    IndirectCommandTypeDraw = 1,
+    IndirectCommandTypeDrawIndexed = 2,
+    IndirectCommandTypeDrawPatches = 4,
+    IndirectCommandTypeDrawIndexedPatches = 8,
+    IndirectCommandTypeConcurrentDispatch = 32,
+    IndirectCommandTypeConcurrentDispatchThreads = 64,
+};
+
+struct IndirectCommandBufferExecutionRange
+{
+    uint32_t location;
+    uint32_t length;
+} _MTL_PACKED;
+
+class IndirectCommandBufferDescriptor : public NS::Copying<IndirectCommandBufferDescriptor>
+{
+public:
+    static class IndirectCommandBufferDescriptor* alloc();
+
+    class IndirectCommandBufferDescriptor*        init();
+
+    MTL::IndirectCommandType                      commandTypes() const;
+    void                                          setCommandTypes(MTL::IndirectCommandType commandTypes);
+
+    bool                                          inheritPipelineState() const;
+    void                                          setInheritPipelineState(bool inheritPipelineState);
+
+    bool                                          inheritBuffers() const;
+    void                                          setInheritBuffers(bool inheritBuffers);
+
+    NS::UInteger                                  maxVertexBufferBindCount() const;
+    void                                          setMaxVertexBufferBindCount(NS::UInteger maxVertexBufferBindCount);
+
+    NS::UInteger                                  maxFragmentBufferBindCount() const;
+    void                                          setMaxFragmentBufferBindCount(NS::UInteger maxFragmentBufferBindCount);
+
+    NS::UInteger                                  maxKernelBufferBindCount() const;
+    void                                          setMaxKernelBufferBindCount(NS::UInteger maxKernelBufferBindCount);
+
+    NS::UInteger                                  maxKernelThreadgroupMemoryBindCount() const;
+    void                                          setMaxKernelThreadgroupMemoryBindCount(NS::UInteger maxKernelThreadgroupMemoryBindCount);
+
+    bool                                          supportRayTracing() const;
+    void                                          setSupportRayTracing(bool supportRayTracing);
+
+    bool                                          supportDynamicAttributeStride() const;
+    void                                          setSupportDynamicAttributeStride(bool supportDynamicAttributeStride);
+};
+
+class IndirectCommandBuffer : public NS::Referencing<IndirectCommandBuffer, Resource>
+{
+public:
+    NS::UInteger                  size() const;
+
+    MTL::ResourceID               gpuResourceID() const;
+
+    void                          reset(NS::Range range);
+
+    class IndirectRenderCommand*  indirectRenderCommand(NS::UInteger commandIndex);
+
+    class IndirectComputeCommand* indirectComputeCommand(NS::UInteger commandIndex);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::IndirectCommandBufferDescriptor* MTL::IndirectCommandBufferDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::IndirectCommandBufferDescriptor>(_MTL_PRIVATE_CLS(MTLIndirectCommandBufferDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::IndirectCommandBufferDescriptor* MTL::IndirectCommandBufferDescriptor::init()
+{
+    return NS::Object::init<MTL::IndirectCommandBufferDescriptor>();
+}
+
+// property: commandTypes
+_MTL_INLINE MTL::IndirectCommandType MTL::IndirectCommandBufferDescriptor::commandTypes() const
+{
+    return Object::sendMessage<MTL::IndirectCommandType>(this, _MTL_PRIVATE_SEL(commandTypes));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setCommandTypes(MTL::IndirectCommandType commandTypes)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCommandTypes_), commandTypes);
+}
+
+// property: inheritPipelineState
+_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritPipelineState() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritPipelineState));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritPipelineState(bool inheritPipelineState)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritPipelineState_), inheritPipelineState);
+}
+
+// property: inheritBuffers
+_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritBuffers() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(inheritBuffers));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritBuffers(bool inheritBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInheritBuffers_), inheritBuffers);
+}
+
+// property: maxVertexBufferBindCount
+_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxVertexBufferBindCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexBufferBindCount));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxVertexBufferBindCount(NS::UInteger maxVertexBufferBindCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexBufferBindCount_), maxVertexBufferBindCount);
+}
+
+// property: maxFragmentBufferBindCount
+_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxFragmentBufferBindCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxFragmentBufferBindCount));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxFragmentBufferBindCount(NS::UInteger maxFragmentBufferBindCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxFragmentBufferBindCount_), maxFragmentBufferBindCount);
+}
+
+// property: maxKernelBufferBindCount
+_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxKernelBufferBindCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxKernelBufferBindCount));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxKernelBufferBindCount(NS::UInteger maxKernelBufferBindCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxKernelBufferBindCount_), maxKernelBufferBindCount);
+}
+
+// property: maxKernelThreadgroupMemoryBindCount
+_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxKernelThreadgroupMemoryBindCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxKernelThreadgroupMemoryBindCount));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxKernelThreadgroupMemoryBindCount(NS::UInteger maxKernelThreadgroupMemoryBindCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxKernelThreadgroupMemoryBindCount_), maxKernelThreadgroupMemoryBindCount);
+}
+
+// property: supportRayTracing
+_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportRayTracing() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportRayTracing));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportRayTracing(bool supportRayTracing)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportRayTracing_), supportRayTracing);
+}
+
+// property: supportDynamicAttributeStride
+_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportDynamicAttributeStride() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportDynamicAttributeStride));
+}
+
+_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportDynamicAttributeStride(bool supportDynamicAttributeStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportDynamicAttributeStride_), supportDynamicAttributeStride);
+}
+
+// property: size
+_MTL_INLINE NS::UInteger MTL::IndirectCommandBuffer::size() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::IndirectCommandBuffer::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
+
+// method: resetWithRange:
+_MTL_INLINE void MTL::IndirectCommandBuffer::reset(NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(resetWithRange_), range);
+}
+
+// method: indirectRenderCommandAtIndex:
+_MTL_INLINE MTL::IndirectRenderCommand* MTL::IndirectCommandBuffer::indirectRenderCommand(NS::UInteger commandIndex)
+{
+    return Object::sendMessage<MTL::IndirectRenderCommand*>(this, _MTL_PRIVATE_SEL(indirectRenderCommandAtIndex_), commandIndex);
+}
+
+// method: indirectComputeCommandAtIndex:
+_MTL_INLINE MTL::IndirectComputeCommand* MTL::IndirectCommandBuffer::indirectComputeCommand(NS::UInteger commandIndex)
+{
+    return Object::sendMessage<MTL::IndirectComputeCommand*>(this, _MTL_PRIVATE_SEL(indirectComputeCommandAtIndex_), commandIndex);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIndirectCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIndirectCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7464edb9afcae366cb0ae38c79beb4c3d15e295d
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIndirectCommandEncoder.hpp
@@ -0,0 +1,203 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLIndirectCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLRenderCommandEncoder.hpp"
+#include "MTLStageInputOutputDescriptor.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+class IndirectRenderCommand : public NS::Referencing<IndirectRenderCommand>
+{
+public:
+    void setRenderPipelineState(const class RenderPipelineState* pipelineState);
+
+    void setVertexBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void setFragmentBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void setVertexBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
+
+    void drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const class Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride);
+
+    void drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const class Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const class Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride);
+
+    void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance);
+
+    void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance);
+
+    void reset();
+};
+
+class IndirectComputeCommand : public NS::Referencing<IndirectComputeCommand>
+{
+public:
+    void setComputePipelineState(const class ComputePipelineState* pipelineState);
+
+    void setKernelBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void setKernelBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
+
+    void concurrentDispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup);
+
+    void concurrentDispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup);
+
+    void setBarrier();
+
+    void clearBarrier();
+
+    void setImageblockWidth(NS::UInteger width, NS::UInteger height);
+
+    void reset();
+
+    void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
+
+    void setStageInRegion(MTL::Region region);
+};
+
+}
+
+// method: setRenderPipelineState:
+_MTL_INLINE void MTL::IndirectRenderCommand::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState);
+}
+
+// method: setVertexBuffer:offset:atIndex:
+_MTL_INLINE void MTL::IndirectRenderCommand::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setFragmentBuffer:offset:atIndex:
+_MTL_INLINE void MTL::IndirectRenderCommand::setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setVertexBuffer:offset:attributeStride:atIndex:
+_MTL_INLINE void MTL::IndirectRenderCommand::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
+}
+
+// method: drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:
+_MTL_INLINE void MTL::IndirectRenderCommand::drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride);
+}
+
+// method: drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:
+_MTL_INLINE void MTL::IndirectRenderCommand::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride);
+}
+
+// method: drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:
+_MTL_INLINE void MTL::IndirectRenderCommand::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance);
+}
+
+// method: drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:
+_MTL_INLINE void MTL::IndirectRenderCommand::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance);
+}
+
+// method: reset
+_MTL_INLINE void MTL::IndirectRenderCommand::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
+
+// method: setComputePipelineState:
+_MTL_INLINE void MTL::IndirectComputeCommand::setComputePipelineState(const MTL::ComputePipelineState* pipelineState)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setComputePipelineState_), pipelineState);
+}
+
+// method: setKernelBuffer:offset:atIndex:
+_MTL_INLINE void MTL::IndirectComputeCommand::setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setKernelBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setKernelBuffer:offset:attributeStride:atIndex:
+_MTL_INLINE void MTL::IndirectComputeCommand::setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setKernelBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
+}
+
+// method: concurrentDispatchThreadgroups:threadsPerThreadgroup:
+_MTL_INLINE void MTL::IndirectComputeCommand::concurrentDispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(concurrentDispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup);
+}
+
+// method: concurrentDispatchThreads:threadsPerThreadgroup:
+_MTL_INLINE void MTL::IndirectComputeCommand::concurrentDispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(concurrentDispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup);
+}
+
+// method: setBarrier
+_MTL_INLINE void MTL::IndirectComputeCommand::setBarrier()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBarrier));
+}
+
+// method: clearBarrier
+_MTL_INLINE void MTL::IndirectComputeCommand::clearBarrier()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(clearBarrier));
+}
+
+// method: setImageblockWidth:height:
+_MTL_INLINE void MTL::IndirectComputeCommand::setImageblockWidth(NS::UInteger width, NS::UInteger height)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height);
+}
+
+// method: reset
+_MTL_INLINE void MTL::IndirectComputeCommand::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
+
+// method: setThreadgroupMemoryLength:atIndex:
+_MTL_INLINE void MTL::IndirectComputeCommand::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index);
+}
+
+// method: setStageInRegion:
+_MTL_INLINE void MTL::IndirectComputeCommand::setStageInRegion(MTL::Region region)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStageInRegion_), region);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIntersectionFunctionTable.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIntersectionFunctionTable.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e1c0911ef5bf5394c7ad3808e2edec3b7dae1d19
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLIntersectionFunctionTable.hpp
@@ -0,0 +1,181 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLIntersectionFunctionTable.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLIntersectionFunctionTable.hpp"
+#include "MTLResource.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_OPTIONS(NS::UInteger, IntersectionFunctionSignature) {
+    IntersectionFunctionSignatureNone = 0,
+    IntersectionFunctionSignatureInstancing = 1,
+    IntersectionFunctionSignatureTriangleData = 2,
+    IntersectionFunctionSignatureWorldSpaceData = 4,
+    IntersectionFunctionSignatureInstanceMotion = 8,
+    IntersectionFunctionSignaturePrimitiveMotion = 16,
+    IntersectionFunctionSignatureExtendedLimits = 32,
+    IntersectionFunctionSignatureMaxLevels = 64,
+    IntersectionFunctionSignatureCurveData = 128,
+};
+
+class IntersectionFunctionTableDescriptor : public NS::Copying<IntersectionFunctionTableDescriptor>
+{
+public:
+    static class IntersectionFunctionTableDescriptor* alloc();
+
+    class IntersectionFunctionTableDescriptor*        init();
+
+    static class IntersectionFunctionTableDescriptor* intersectionFunctionTableDescriptor();
+
+    NS::UInteger                                      functionCount() const;
+    void                                              setFunctionCount(NS::UInteger functionCount);
+};
+
+class IntersectionFunctionTable : public NS::Referencing<IntersectionFunctionTable, Resource>
+{
+public:
+    void            setBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void            setBuffers(const class Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
+
+    MTL::ResourceID gpuResourceID() const;
+
+    void            setFunction(const class FunctionHandle* function, NS::UInteger index);
+
+    void            setFunctions(const class FunctionHandle* const functions[], NS::Range range);
+
+    void            setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index);
+
+    void            setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range);
+
+    void            setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index);
+
+    void            setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range);
+
+    void            setVisibleFunctionTable(const class VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
+
+    void            setVisibleFunctionTables(const class VisibleFunctionTable* const functionTables[], NS::Range bufferRange);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::IntersectionFunctionTableDescriptor>(_MTL_PRIVATE_CLS(MTLIntersectionFunctionTableDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::init()
+{
+    return NS::Object::init<MTL::IntersectionFunctionTableDescriptor>();
+}
+
+// static method: intersectionFunctionTableDescriptor
+_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::intersectionFunctionTableDescriptor()
+{
+    return Object::sendMessage<MTL::IntersectionFunctionTableDescriptor*>(_MTL_PRIVATE_CLS(MTLIntersectionFunctionTableDescriptor), _MTL_PRIVATE_SEL(intersectionFunctionTableDescriptor));
+}
+
+// property: functionCount
+_MTL_INLINE NS::UInteger MTL::IntersectionFunctionTableDescriptor::functionCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(functionCount));
+}
+
+_MTL_INLINE void MTL::IntersectionFunctionTableDescriptor::setFunctionCount(NS::UInteger functionCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionCount_), functionCount);
+}
+
+// method: setBuffer:offset:atIndex:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setBuffers:offsets:withRange:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::IntersectionFunctionTable::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
+
+// method: setFunction:atIndex:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setFunction(const MTL::FunctionHandle* function, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunction_atIndex_), function, index);
+}
+
+// method: setFunctions:withRange:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctions_withRange_), functions, range);
+}
+
+// method: setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_), signature, index);
+}
+
+// method: setOpaqueTriangleIntersectionFunctionWithSignature:withRange:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_withRange_), signature, range);
+}
+
+// method: setOpaqueCurveIntersectionFunctionWithSignature:atIndex:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueCurveIntersectionFunctionWithSignature_atIndex_), signature, index);
+}
+
+// method: setOpaqueCurveIntersectionFunctionWithSignature:withRange:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaqueCurveIntersectionFunctionWithSignature_withRange_), signature, range);
+}
+
+// method: setVisibleFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
+}
+
+// method: setVisibleFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::IntersectionFunctionTable::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range bufferRange)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withBufferRange_), functionTables, bufferRange);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLLibrary.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLLibrary.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..234373d4bebe11d571a1d46cbc4c2fb95ea8edd0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLLibrary.hpp
@@ -0,0 +1,691 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLLibrary.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLArgument.hpp"
+#include "MTLFunctionDescriptor.hpp"
+#include "MTLLibrary.hpp"
+#include <functional>
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, PatchType) {
+    PatchTypeNone = 0,
+    PatchTypeTriangle = 1,
+    PatchTypeQuad = 2,
+};
+
+class VertexAttribute : public NS::Referencing<VertexAttribute>
+{
+public:
+    static class VertexAttribute* alloc();
+
+    class VertexAttribute*        init();
+
+    NS::String*                   name() const;
+
+    NS::UInteger                  attributeIndex() const;
+
+    MTL::DataType                 attributeType() const;
+
+    bool                          active() const;
+
+    bool                          patchData() const;
+
+    bool                          patchControlPointData() const;
+};
+
+class Attribute : public NS::Referencing<Attribute>
+{
+public:
+    static class Attribute* alloc();
+
+    class Attribute*        init();
+
+    NS::String*             name() const;
+
+    NS::UInteger            attributeIndex() const;
+
+    MTL::DataType           attributeType() const;
+
+    bool                    active() const;
+
+    bool                    patchData() const;
+
+    bool                    patchControlPointData() const;
+};
+
+_MTL_ENUM(NS::UInteger, FunctionType) {
+    FunctionTypeVertex = 1,
+    FunctionTypeFragment = 2,
+    FunctionTypeKernel = 3,
+    FunctionTypeVisible = 5,
+    FunctionTypeIntersection = 6,
+    FunctionTypeMesh = 7,
+    FunctionTypeObject = 8,
+};
+
+class FunctionConstant : public NS::Referencing<FunctionConstant>
+{
+public:
+    static class FunctionConstant* alloc();
+
+    class FunctionConstant*        init();
+
+    NS::String*                    name() const;
+
+    MTL::DataType                  type() const;
+
+    NS::UInteger                   index() const;
+
+    bool                           required() const;
+};
+
+using AutoreleasedArgument = class Argument*;
+
+class Function : public NS::Referencing<Function>
+{
+public:
+    NS::String*            label() const;
+    void                   setLabel(const NS::String* label);
+
+    class Device*          device() const;
+
+    MTL::FunctionType      functionType() const;
+
+    MTL::PatchType         patchType() const;
+
+    NS::Integer            patchControlPointCount() const;
+
+    NS::Array*             vertexAttributes() const;
+
+    NS::Array*             stageInputAttributes() const;
+
+    NS::String*            name() const;
+
+    NS::Dictionary*        functionConstantsDictionary() const;
+
+    class ArgumentEncoder* newArgumentEncoder(NS::UInteger bufferIndex);
+
+    class ArgumentEncoder* newArgumentEncoder(NS::UInteger bufferIndex, const MTL::AutoreleasedArgument* reflection);
+
+    MTL::FunctionOptions   options() const;
+};
+
+_MTL_ENUM(NS::UInteger, LanguageVersion) {
+    LanguageVersion1_0 = 65536,
+    LanguageVersion1_1 = 65537,
+    LanguageVersion1_2 = 65538,
+    LanguageVersion2_0 = 131072,
+    LanguageVersion2_1 = 131073,
+    LanguageVersion2_2 = 131074,
+    LanguageVersion2_3 = 131075,
+    LanguageVersion2_4 = 131076,
+    LanguageVersion3_0 = 196608,
+};
+
+_MTL_ENUM(NS::Integer, LibraryType) {
+    LibraryTypeExecutable = 0,
+    LibraryTypeDynamic = 1,
+};
+
+_MTL_ENUM(NS::Integer, LibraryOptimizationLevel) {
+    LibraryOptimizationLevelDefault = 0,
+    LibraryOptimizationLevelSize = 1,
+};
+
+_MTL_ENUM(NS::Integer, CompileSymbolVisibility) {
+    CompileSymbolVisibilityDefault = 0,
+    CompileSymbolVisibilityHidden = 1,
+};
+
+class CompileOptions : public NS::Copying<CompileOptions>
+{
+public:
+    static class CompileOptions*  alloc();
+
+    class CompileOptions*         init();
+
+    NS::Dictionary*               preprocessorMacros() const;
+    void                          setPreprocessorMacros(const NS::Dictionary* preprocessorMacros);
+
+    bool                          fastMathEnabled() const;
+    void                          setFastMathEnabled(bool fastMathEnabled);
+
+    MTL::LanguageVersion          languageVersion() const;
+    void                          setLanguageVersion(MTL::LanguageVersion languageVersion);
+
+    MTL::LibraryType              libraryType() const;
+    void                          setLibraryType(MTL::LibraryType libraryType);
+
+    NS::String*                   installName() const;
+    void                          setInstallName(const NS::String* installName);
+
+    NS::Array*                    libraries() const;
+    void                          setLibraries(const NS::Array* libraries);
+
+    bool                          preserveInvariance() const;
+    void                          setPreserveInvariance(bool preserveInvariance);
+
+    MTL::LibraryOptimizationLevel optimizationLevel() const;
+    void                          setOptimizationLevel(MTL::LibraryOptimizationLevel optimizationLevel);
+
+    MTL::CompileSymbolVisibility  compileSymbolVisibility() const;
+    void                          setCompileSymbolVisibility(MTL::CompileSymbolVisibility compileSymbolVisibility);
+
+    bool                          allowReferencingUndefinedSymbols() const;
+    void                          setAllowReferencingUndefinedSymbols(bool allowReferencingUndefinedSymbols);
+
+    NS::UInteger                  maxTotalThreadsPerThreadgroup() const;
+    void                          setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
+};
+
+_MTL_ENUM(NS::UInteger, LibraryError) {
+    LibraryErrorUnsupported = 1,
+    LibraryErrorInternal = 2,
+    LibraryErrorCompileFailure = 3,
+    LibraryErrorCompileWarning = 4,
+    LibraryErrorFunctionNotFound = 5,
+    LibraryErrorFileNotFound = 6,
+};
+
+class Library : public NS::Referencing<Library>
+{
+public:
+    void             newFunction(const NS::String* pFunctionName, const class FunctionConstantValues* pConstantValues, const std::function<void(Function* pFunction, NS::Error* pError)>& completionHandler);
+
+    void             newFunction(const class FunctionDescriptor* pDescriptor, const std::function<void(Function* pFunction, NS::Error* pError)>& completionHandler);
+
+    void             newIntersectionFunction(const class IntersectionFunctionDescriptor* pDescriptor, const std::function<void(Function* pFunction, NS::Error* pError)>& completionHandler);
+
+    NS::String*      label() const;
+    void             setLabel(const NS::String* label);
+
+    class Device*    device() const;
+
+    class Function*  newFunction(const NS::String* functionName);
+
+    class Function*  newFunction(const NS::String* name, const class FunctionConstantValues* constantValues, NS::Error** error);
+
+    void             newFunction(const NS::String* name, const class FunctionConstantValues* constantValues, void (^completionHandler)(MTL::Function*, NS::Error*));
+
+    void             newFunction(const class FunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*));
+
+    class Function*  newFunction(const class FunctionDescriptor* descriptor, NS::Error** error);
+
+    void             newIntersectionFunction(const class IntersectionFunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*));
+
+    class Function*  newIntersectionFunction(const class IntersectionFunctionDescriptor* descriptor, NS::Error** error);
+
+    NS::Array*       functionNames() const;
+
+    MTL::LibraryType type() const;
+
+    NS::String*      installName() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::VertexAttribute* MTL::VertexAttribute::alloc()
+{
+    return NS::Object::alloc<MTL::VertexAttribute>(_MTL_PRIVATE_CLS(MTLVertexAttribute));
+}
+
+// method: init
+_MTL_INLINE MTL::VertexAttribute* MTL::VertexAttribute::init()
+{
+    return NS::Object::init<MTL::VertexAttribute>();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::VertexAttribute::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: attributeIndex
+_MTL_INLINE NS::UInteger MTL::VertexAttribute::attributeIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(attributeIndex));
+}
+
+// property: attributeType
+_MTL_INLINE MTL::DataType MTL::VertexAttribute::attributeType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(attributeType));
+}
+
+// property: active
+_MTL_INLINE bool MTL::VertexAttribute::active() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
+}
+
+// property: patchData
+_MTL_INLINE bool MTL::VertexAttribute::patchData() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchData));
+}
+
+// property: patchControlPointData
+_MTL_INLINE bool MTL::VertexAttribute::patchControlPointData() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchControlPointData));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::Attribute* MTL::Attribute::alloc()
+{
+    return NS::Object::alloc<MTL::Attribute>(_MTL_PRIVATE_CLS(MTLAttribute));
+}
+
+// method: init
+_MTL_INLINE MTL::Attribute* MTL::Attribute::init()
+{
+    return NS::Object::init<MTL::Attribute>();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::Attribute::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: attributeIndex
+_MTL_INLINE NS::UInteger MTL::Attribute::attributeIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(attributeIndex));
+}
+
+// property: attributeType
+_MTL_INLINE MTL::DataType MTL::Attribute::attributeType() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(attributeType));
+}
+
+// property: active
+_MTL_INLINE bool MTL::Attribute::active() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isActive));
+}
+
+// property: patchData
+_MTL_INLINE bool MTL::Attribute::patchData() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchData));
+}
+
+// property: patchControlPointData
+_MTL_INLINE bool MTL::Attribute::patchControlPointData() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isPatchControlPointData));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::FunctionConstant* MTL::FunctionConstant::alloc()
+{
+    return NS::Object::alloc<MTL::FunctionConstant>(_MTL_PRIVATE_CLS(MTLFunctionConstant));
+}
+
+// method: init
+_MTL_INLINE MTL::FunctionConstant* MTL::FunctionConstant::init()
+{
+    return NS::Object::init<MTL::FunctionConstant>();
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::FunctionConstant::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: type
+_MTL_INLINE MTL::DataType MTL::FunctionConstant::type() const
+{
+    return Object::sendMessage<MTL::DataType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+// property: index
+_MTL_INLINE NS::UInteger MTL::FunctionConstant::index() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(index));
+}
+
+// property: required
+_MTL_INLINE bool MTL::FunctionConstant::required() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(required));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::Function::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::Function::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::Function::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: functionType
+_MTL_INLINE MTL::FunctionType MTL::Function::functionType() const
+{
+    return Object::sendMessage<MTL::FunctionType>(this, _MTL_PRIVATE_SEL(functionType));
+}
+
+// property: patchType
+_MTL_INLINE MTL::PatchType MTL::Function::patchType() const
+{
+    return Object::sendMessage<MTL::PatchType>(this, _MTL_PRIVATE_SEL(patchType));
+}
+
+// property: patchControlPointCount
+_MTL_INLINE NS::Integer MTL::Function::patchControlPointCount() const
+{
+    return Object::sendMessage<NS::Integer>(this, _MTL_PRIVATE_SEL(patchControlPointCount));
+}
+
+// property: vertexAttributes
+_MTL_INLINE NS::Array* MTL::Function::vertexAttributes() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexAttributes));
+}
+
+// property: stageInputAttributes
+_MTL_INLINE NS::Array* MTL::Function::stageInputAttributes() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(stageInputAttributes));
+}
+
+// property: name
+_MTL_INLINE NS::String* MTL::Function::name() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(name));
+}
+
+// property: functionConstantsDictionary
+_MTL_INLINE NS::Dictionary* MTL::Function::functionConstantsDictionary() const
+{
+    return Object::sendMessage<NS::Dictionary*>(this, _MTL_PRIVATE_SEL(functionConstantsDictionary));
+}
+
+// method: newArgumentEncoderWithBufferIndex:
+_MTL_INLINE MTL::ArgumentEncoder* MTL::Function::newArgumentEncoder(NS::UInteger bufferIndex)
+{
+    return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferIndex_), bufferIndex);
+}
+
+// method: newArgumentEncoderWithBufferIndex:reflection:
+_MTL_INLINE MTL::ArgumentEncoder* MTL::Function::newArgumentEncoder(NS::UInteger bufferIndex, const MTL::AutoreleasedArgument* reflection)
+{
+    return Object::sendMessage<MTL::ArgumentEncoder*>(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferIndex_reflection_), bufferIndex, reflection);
+}
+
+// property: options
+_MTL_INLINE MTL::FunctionOptions MTL::Function::options() const
+{
+    return Object::sendMessage<MTL::FunctionOptions>(this, _MTL_PRIVATE_SEL(options));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::CompileOptions* MTL::CompileOptions::alloc()
+{
+    return NS::Object::alloc<MTL::CompileOptions>(_MTL_PRIVATE_CLS(MTLCompileOptions));
+}
+
+// method: init
+_MTL_INLINE MTL::CompileOptions* MTL::CompileOptions::init()
+{
+    return NS::Object::init<MTL::CompileOptions>();
+}
+
+// property: preprocessorMacros
+_MTL_INLINE NS::Dictionary* MTL::CompileOptions::preprocessorMacros() const
+{
+    return Object::sendMessage<NS::Dictionary*>(this, _MTL_PRIVATE_SEL(preprocessorMacros));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setPreprocessorMacros(const NS::Dictionary* preprocessorMacros)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreprocessorMacros_), preprocessorMacros);
+}
+
+// property: fastMathEnabled
+_MTL_INLINE bool MTL::CompileOptions::fastMathEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(fastMathEnabled));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setFastMathEnabled(bool fastMathEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFastMathEnabled_), fastMathEnabled);
+}
+
+// property: languageVersion
+_MTL_INLINE MTL::LanguageVersion MTL::CompileOptions::languageVersion() const
+{
+    return Object::sendMessage<MTL::LanguageVersion>(this, _MTL_PRIVATE_SEL(languageVersion));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setLanguageVersion(MTL::LanguageVersion languageVersion)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLanguageVersion_), languageVersion);
+}
+
+// property: libraryType
+_MTL_INLINE MTL::LibraryType MTL::CompileOptions::libraryType() const
+{
+    return Object::sendMessage<MTL::LibraryType>(this, _MTL_PRIVATE_SEL(libraryType));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setLibraryType(MTL::LibraryType libraryType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLibraryType_), libraryType);
+}
+
+// property: installName
+_MTL_INLINE NS::String* MTL::CompileOptions::installName() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(installName));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setInstallName(const NS::String* installName)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstallName_), installName);
+}
+
+// property: libraries
+_MTL_INLINE NS::Array* MTL::CompileOptions::libraries() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(libraries));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setLibraries(const NS::Array* libraries)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLibraries_), libraries);
+}
+
+// property: preserveInvariance
+_MTL_INLINE bool MTL::CompileOptions::preserveInvariance() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(preserveInvariance));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setPreserveInvariance(bool preserveInvariance)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreserveInvariance_), preserveInvariance);
+}
+
+// property: optimizationLevel
+_MTL_INLINE MTL::LibraryOptimizationLevel MTL::CompileOptions::optimizationLevel() const
+{
+    return Object::sendMessage<MTL::LibraryOptimizationLevel>(this, _MTL_PRIVATE_SEL(optimizationLevel));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setOptimizationLevel(MTL::LibraryOptimizationLevel optimizationLevel)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOptimizationLevel_), optimizationLevel);
+}
+
+// property: compileSymbolVisibility
+_MTL_INLINE MTL::CompileSymbolVisibility MTL::CompileOptions::compileSymbolVisibility() const
+{
+    return Object::sendMessage<MTL::CompileSymbolVisibility>(this, _MTL_PRIVATE_SEL(compileSymbolVisibility));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setCompileSymbolVisibility(MTL::CompileSymbolVisibility compileSymbolVisibility)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCompileSymbolVisibility_), compileSymbolVisibility);
+}
+
+// property: allowReferencingUndefinedSymbols
+_MTL_INLINE bool MTL::CompileOptions::allowReferencingUndefinedSymbols() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(allowReferencingUndefinedSymbols));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setAllowReferencingUndefinedSymbols(bool allowReferencingUndefinedSymbols)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAllowReferencingUndefinedSymbols_), allowReferencingUndefinedSymbols);
+}
+
+// property: maxTotalThreadsPerThreadgroup
+_MTL_INLINE NS::UInteger MTL::CompileOptions::maxTotalThreadsPerThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
+}
+
+_MTL_INLINE void MTL::CompileOptions::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
+}
+
+_MTL_INLINE void MTL::Library::newFunction(const NS::String* pFunctionName, const FunctionConstantValues* pConstantValues, const std::function<void(Function* pFunction, NS::Error* pError)>& completionHandler)
+{
+    __block std::function<void(Function * pFunction, NS::Error * pError)> blockCompletionHandler = completionHandler;
+
+    newFunction(pFunctionName, pConstantValues, ^(Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); });
+}
+
+_MTL_INLINE void MTL::Library::newFunction(const FunctionDescriptor* pDescriptor, const std::function<void(Function* pFunction, NS::Error* pError)>& completionHandler)
+{
+    __block std::function<void(Function * pFunction, NS::Error * pError)> blockCompletionHandler = completionHandler;
+
+    newFunction(pDescriptor, ^(Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); });
+}
+
+_MTL_INLINE void MTL::Library::newIntersectionFunction(const IntersectionFunctionDescriptor* pDescriptor, const std::function<void(Function* pFunction, NS::Error* pError)>& completionHandler)
+{
+    __block std::function<void(Function * pFunction, NS::Error * pError)> blockCompletionHandler = completionHandler;
+
+    newIntersectionFunction(pDescriptor, ^(Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); });
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::Library::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::Library::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::Library::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// method: newFunctionWithName:
+_MTL_INLINE MTL::Function* MTL::Library::newFunction(const NS::String* functionName)
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newFunctionWithName_), functionName);
+}
+
+// method: newFunctionWithName:constantValues:error:
+_MTL_INLINE MTL::Function* MTL::Library::newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newFunctionWithName_constantValues_error_), name, constantValues, error);
+}
+
+// method: newFunctionWithName:constantValues:completionHandler:
+_MTL_INLINE void MTL::Library::newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, void (^completionHandler)(MTL::Function*, NS::Error*))
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newFunctionWithName_constantValues_completionHandler_), name, constantValues, completionHandler);
+}
+
+// method: newFunctionWithDescriptor:completionHandler:
+_MTL_INLINE void MTL::Library::newFunction(const MTL::FunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*))
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newFunctionWithDescriptor_completionHandler_), descriptor, completionHandler);
+}
+
+// method: newFunctionWithDescriptor:error:
+_MTL_INLINE MTL::Function* MTL::Library::newFunction(const MTL::FunctionDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newFunctionWithDescriptor_error_), descriptor, error);
+}
+
+// method: newIntersectionFunctionWithDescriptor:completionHandler:
+_MTL_INLINE void MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*))
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionWithDescriptor_completionHandler_), descriptor, completionHandler);
+}
+
+// method: newIntersectionFunctionWithDescriptor:error:
+_MTL_INLINE MTL::Function* MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, NS::Error** error)
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionWithDescriptor_error_), descriptor, error);
+}
+
+// property: functionNames
+_MTL_INLINE NS::Array* MTL::Library::functionNames() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functionNames));
+}
+
+// property: type
+_MTL_INLINE MTL::LibraryType MTL::Library::type() const
+{
+    return Object::sendMessage<MTL::LibraryType>(this, _MTL_PRIVATE_SEL(type));
+}
+
+// property: installName
+_MTL_INLINE NS::String* MTL::Library::installName() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(installName));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLLinkedFunctions.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLLinkedFunctions.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..89ee8759926735598087d43593c4b62849118c3c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLLinkedFunctions.hpp
@@ -0,0 +1,115 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLLinkedFunctions.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+class LinkedFunctions : public NS::Copying<LinkedFunctions>
+{
+public:
+    static class LinkedFunctions* alloc();
+
+    class LinkedFunctions*        init();
+
+    static class LinkedFunctions* linkedFunctions();
+
+    NS::Array*                    functions() const;
+    void                          setFunctions(const NS::Array* functions);
+
+    NS::Array*                    binaryFunctions() const;
+    void                          setBinaryFunctions(const NS::Array* binaryFunctions);
+
+    NS::Dictionary*               groups() const;
+    void                          setGroups(const NS::Dictionary* groups);
+
+    NS::Array*                    privateFunctions() const;
+    void                          setPrivateFunctions(const NS::Array* privateFunctions);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::alloc()
+{
+    return NS::Object::alloc<MTL::LinkedFunctions>(_MTL_PRIVATE_CLS(MTLLinkedFunctions));
+}
+
+// method: init
+_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::init()
+{
+    return NS::Object::init<MTL::LinkedFunctions>();
+}
+
+// static method: linkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::linkedFunctions()
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(_MTL_PRIVATE_CLS(MTLLinkedFunctions), _MTL_PRIVATE_SEL(linkedFunctions));
+}
+
+// property: functions
+_MTL_INLINE NS::Array* MTL::LinkedFunctions::functions() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(functions));
+}
+
+_MTL_INLINE void MTL::LinkedFunctions::setFunctions(const NS::Array* functions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctions_), functions);
+}
+
+// property: binaryFunctions
+_MTL_INLINE NS::Array* MTL::LinkedFunctions::binaryFunctions() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryFunctions));
+}
+
+_MTL_INLINE void MTL::LinkedFunctions::setBinaryFunctions(const NS::Array* binaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryFunctions_), binaryFunctions);
+}
+
+// property: groups
+_MTL_INLINE NS::Dictionary* MTL::LinkedFunctions::groups() const
+{
+    return Object::sendMessage<NS::Dictionary*>(this, _MTL_PRIVATE_SEL(groups));
+}
+
+_MTL_INLINE void MTL::LinkedFunctions::setGroups(const NS::Dictionary* groups)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setGroups_), groups);
+}
+
+// property: privateFunctions
+_MTL_INLINE NS::Array* MTL::LinkedFunctions::privateFunctions() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(privateFunctions));
+}
+
+_MTL_INLINE void MTL::LinkedFunctions::setPrivateFunctions(const NS::Array* privateFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrivateFunctions_), privateFunctions);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLParallelRenderCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLParallelRenderCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..d6d6ad8cfd2a951c254a860b1d7e3c334c00de64
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLParallelRenderCommandEncoder.hpp
@@ -0,0 +1,94 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLParallelRenderCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLCommandEncoder.hpp"
+#include "MTLRenderPass.hpp"
+
+namespace MTL
+{
+class ParallelRenderCommandEncoder : public NS::Referencing<ParallelRenderCommandEncoder, CommandEncoder>
+{
+public:
+    class RenderCommandEncoder* renderCommandEncoder();
+
+    void                        setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex);
+
+    void                        setDepthStoreAction(MTL::StoreAction storeAction);
+
+    void                        setStencilStoreAction(MTL::StoreAction storeAction);
+
+    void                        setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex);
+
+    void                        setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
+
+    void                        setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
+};
+
+}
+
+// method: renderCommandEncoder
+_MTL_INLINE MTL::RenderCommandEncoder* MTL::ParallelRenderCommandEncoder::renderCommandEncoder()
+{
+    return Object::sendMessage<MTL::RenderCommandEncoder*>(this, _MTL_PRIVATE_SEL(renderCommandEncoder));
+}
+
+// method: setColorStoreAction:atIndex:
+_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex);
+}
+
+// method: setDepthStoreAction:
+_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction);
+}
+
+// method: setStencilStoreAction:
+_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction);
+}
+
+// method: setColorStoreActionOptions:atIndex:
+_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreActionOptions_atIndex_), storeActionOptions, colorAttachmentIndex);
+}
+
+// method: setDepthStoreActionOptions:
+_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreActionOptions_), storeActionOptions);
+}
+
+// method: setStencilStoreActionOptions:
+_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreActionOptions_), storeActionOptions);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPipeline.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPipeline.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1b6859ca1de9ddf6976fa2208c2b7464a591653a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPipeline.hpp
@@ -0,0 +1,109 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLPipeline.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLPipeline.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, Mutability) {
+    MutabilityDefault = 0,
+    MutabilityMutable = 1,
+    MutabilityImmutable = 2,
+};
+
+class PipelineBufferDescriptor : public NS::Copying<PipelineBufferDescriptor>
+{
+public:
+    static class PipelineBufferDescriptor* alloc();
+
+    class PipelineBufferDescriptor*        init();
+
+    MTL::Mutability                        mutability() const;
+    void                                   setMutability(MTL::Mutability mutability);
+};
+
+class PipelineBufferDescriptorArray : public NS::Referencing<PipelineBufferDescriptorArray>
+{
+public:
+    static class PipelineBufferDescriptorArray* alloc();
+
+    class PipelineBufferDescriptorArray*        init();
+
+    class PipelineBufferDescriptor*             object(NS::UInteger bufferIndex);
+
+    void                                        setObject(const class PipelineBufferDescriptor* buffer, NS::UInteger bufferIndex);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::PipelineBufferDescriptor* MTL::PipelineBufferDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::PipelineBufferDescriptor>(_MTL_PRIVATE_CLS(MTLPipelineBufferDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::PipelineBufferDescriptor* MTL::PipelineBufferDescriptor::init()
+{
+    return NS::Object::init<MTL::PipelineBufferDescriptor>();
+}
+
+// property: mutability
+_MTL_INLINE MTL::Mutability MTL::PipelineBufferDescriptor::mutability() const
+{
+    return Object::sendMessage<MTL::Mutability>(this, _MTL_PRIVATE_SEL(mutability));
+}
+
+_MTL_INLINE void MTL::PipelineBufferDescriptor::setMutability(MTL::Mutability mutability)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMutability_), mutability);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::PipelineBufferDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::PipelineBufferDescriptorArray>(_MTL_PRIVATE_CLS(MTLPipelineBufferDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::PipelineBufferDescriptorArray::init()
+{
+    return NS::Object::init<MTL::PipelineBufferDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::PipelineBufferDescriptor* MTL::PipelineBufferDescriptorArray::object(NS::UInteger bufferIndex)
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), bufferIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::PipelineBufferDescriptorArray::setObject(const MTL::PipelineBufferDescriptor* buffer, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), buffer, bufferIndex);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPixelFormat.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPixelFormat.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7a0c3c09c69a836ec79beaca7a4180792830aebb
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPixelFormat.hpp
@@ -0,0 +1,173 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLPixelFormat.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, PixelFormat) {
+    PixelFormatInvalid = 0,
+    PixelFormatA8Unorm = 1,
+    PixelFormatR8Unorm = 10,
+    PixelFormatR8Unorm_sRGB = 11,
+    PixelFormatR8Snorm = 12,
+    PixelFormatR8Uint = 13,
+    PixelFormatR8Sint = 14,
+    PixelFormatR16Unorm = 20,
+    PixelFormatR16Snorm = 22,
+    PixelFormatR16Uint = 23,
+    PixelFormatR16Sint = 24,
+    PixelFormatR16Float = 25,
+    PixelFormatRG8Unorm = 30,
+    PixelFormatRG8Unorm_sRGB = 31,
+    PixelFormatRG8Snorm = 32,
+    PixelFormatRG8Uint = 33,
+    PixelFormatRG8Sint = 34,
+    PixelFormatB5G6R5Unorm = 40,
+    PixelFormatA1BGR5Unorm = 41,
+    PixelFormatABGR4Unorm = 42,
+    PixelFormatBGR5A1Unorm = 43,
+    PixelFormatR32Uint = 53,
+    PixelFormatR32Sint = 54,
+    PixelFormatR32Float = 55,
+    PixelFormatRG16Unorm = 60,
+    PixelFormatRG16Snorm = 62,
+    PixelFormatRG16Uint = 63,
+    PixelFormatRG16Sint = 64,
+    PixelFormatRG16Float = 65,
+    PixelFormatRGBA8Unorm = 70,
+    PixelFormatRGBA8Unorm_sRGB = 71,
+    PixelFormatRGBA8Snorm = 72,
+    PixelFormatRGBA8Uint = 73,
+    PixelFormatRGBA8Sint = 74,
+    PixelFormatBGRA8Unorm = 80,
+    PixelFormatBGRA8Unorm_sRGB = 81,
+    PixelFormatRGB10A2Unorm = 90,
+    PixelFormatRGB10A2Uint = 91,
+    PixelFormatRG11B10Float = 92,
+    PixelFormatRGB9E5Float = 93,
+    PixelFormatBGR10A2Unorm = 94,
+    PixelFormatRG32Uint = 103,
+    PixelFormatRG32Sint = 104,
+    PixelFormatRG32Float = 105,
+    PixelFormatRGBA16Unorm = 110,
+    PixelFormatRGBA16Snorm = 112,
+    PixelFormatRGBA16Uint = 113,
+    PixelFormatRGBA16Sint = 114,
+    PixelFormatRGBA16Float = 115,
+    PixelFormatRGBA32Uint = 123,
+    PixelFormatRGBA32Sint = 124,
+    PixelFormatRGBA32Float = 125,
+    PixelFormatBC1_RGBA = 130,
+    PixelFormatBC1_RGBA_sRGB = 131,
+    PixelFormatBC2_RGBA = 132,
+    PixelFormatBC2_RGBA_sRGB = 133,
+    PixelFormatBC3_RGBA = 134,
+    PixelFormatBC3_RGBA_sRGB = 135,
+    PixelFormatBC4_RUnorm = 140,
+    PixelFormatBC4_RSnorm = 141,
+    PixelFormatBC5_RGUnorm = 142,
+    PixelFormatBC5_RGSnorm = 143,
+    PixelFormatBC6H_RGBFloat = 150,
+    PixelFormatBC6H_RGBUfloat = 151,
+    PixelFormatBC7_RGBAUnorm = 152,
+    PixelFormatBC7_RGBAUnorm_sRGB = 153,
+    PixelFormatPVRTC_RGB_2BPP = 160,
+    PixelFormatPVRTC_RGB_2BPP_sRGB = 161,
+    PixelFormatPVRTC_RGB_4BPP = 162,
+    PixelFormatPVRTC_RGB_4BPP_sRGB = 163,
+    PixelFormatPVRTC_RGBA_2BPP = 164,
+    PixelFormatPVRTC_RGBA_2BPP_sRGB = 165,
+    PixelFormatPVRTC_RGBA_4BPP = 166,
+    PixelFormatPVRTC_RGBA_4BPP_sRGB = 167,
+    PixelFormatEAC_R11Unorm = 170,
+    PixelFormatEAC_R11Snorm = 172,
+    PixelFormatEAC_RG11Unorm = 174,
+    PixelFormatEAC_RG11Snorm = 176,
+    PixelFormatEAC_RGBA8 = 178,
+    PixelFormatEAC_RGBA8_sRGB = 179,
+    PixelFormatETC2_RGB8 = 180,
+    PixelFormatETC2_RGB8_sRGB = 181,
+    PixelFormatETC2_RGB8A1 = 182,
+    PixelFormatETC2_RGB8A1_sRGB = 183,
+    PixelFormatASTC_4x4_sRGB = 186,
+    PixelFormatASTC_5x4_sRGB = 187,
+    PixelFormatASTC_5x5_sRGB = 188,
+    PixelFormatASTC_6x5_sRGB = 189,
+    PixelFormatASTC_6x6_sRGB = 190,
+    PixelFormatASTC_8x5_sRGB = 192,
+    PixelFormatASTC_8x6_sRGB = 193,
+    PixelFormatASTC_8x8_sRGB = 194,
+    PixelFormatASTC_10x5_sRGB = 195,
+    PixelFormatASTC_10x6_sRGB = 196,
+    PixelFormatASTC_10x8_sRGB = 197,
+    PixelFormatASTC_10x10_sRGB = 198,
+    PixelFormatASTC_12x10_sRGB = 199,
+    PixelFormatASTC_12x12_sRGB = 200,
+    PixelFormatASTC_4x4_LDR = 204,
+    PixelFormatASTC_5x4_LDR = 205,
+    PixelFormatASTC_5x5_LDR = 206,
+    PixelFormatASTC_6x5_LDR = 207,
+    PixelFormatASTC_6x6_LDR = 208,
+    PixelFormatASTC_8x5_LDR = 210,
+    PixelFormatASTC_8x6_LDR = 211,
+    PixelFormatASTC_8x8_LDR = 212,
+    PixelFormatASTC_10x5_LDR = 213,
+    PixelFormatASTC_10x6_LDR = 214,
+    PixelFormatASTC_10x8_LDR = 215,
+    PixelFormatASTC_10x10_LDR = 216,
+    PixelFormatASTC_12x10_LDR = 217,
+    PixelFormatASTC_12x12_LDR = 218,
+    PixelFormatASTC_4x4_HDR = 222,
+    PixelFormatASTC_5x4_HDR = 223,
+    PixelFormatASTC_5x5_HDR = 224,
+    PixelFormatASTC_6x5_HDR = 225,
+    PixelFormatASTC_6x6_HDR = 226,
+    PixelFormatASTC_8x5_HDR = 228,
+    PixelFormatASTC_8x6_HDR = 229,
+    PixelFormatASTC_8x8_HDR = 230,
+    PixelFormatASTC_10x5_HDR = 231,
+    PixelFormatASTC_10x6_HDR = 232,
+    PixelFormatASTC_10x8_HDR = 233,
+    PixelFormatASTC_10x10_HDR = 234,
+    PixelFormatASTC_12x10_HDR = 235,
+    PixelFormatASTC_12x12_HDR = 236,
+    PixelFormatGBGR422 = 240,
+    PixelFormatBGRG422 = 241,
+    PixelFormatDepth16Unorm = 250,
+    PixelFormatDepth32Float = 252,
+    PixelFormatStencil8 = 253,
+    PixelFormatDepth24Unorm_Stencil8 = 255,
+    PixelFormatDepth32Float_Stencil8 = 260,
+    PixelFormatX32_Stencil8 = 261,
+    PixelFormatX24_Stencil8 = 262,
+    PixelFormatBGRA10_XR = 552,
+    PixelFormatBGRA10_XR_sRGB = 553,
+    PixelFormatBGR10_XR = 554,
+    PixelFormatBGR10_XR_sRGB = 555,
+};
+
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPrivate.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPrivate.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e72e635463bad72d1b9e640f60fdcd2391faef7b
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLPrivate.hpp
@@ -0,0 +1,156 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLPrivate.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLDefines.hpp"
+
+#include <objc/runtime.h>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _MTL_PRIVATE_CLS(symbol) (Private::Class::s_k##symbol)
+#define _MTL_PRIVATE_SEL(accessor) (Private::Selector::s_k##accessor)
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#if defined(MTL_PRIVATE_IMPLEMENTATION)
+
+#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN
+#define _MTL_PRIVATE_VISIBILITY __attribute__((visibility("hidden")))
+#else
+#define _MTL_PRIVATE_VISIBILITY __attribute__((visibility("default")))
+#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN
+
+#define _MTL_PRIVATE_IMPORT __attribute__((weak_import))
+
+#ifdef __OBJC__
+#define _MTL_PRIVATE_OBJC_LOOKUP_CLASS(symbol) ((__bridge void*)objc_lookUpClass(#symbol))
+#define _MTL_PRIVATE_OBJC_GET_PROTOCOL(symbol) ((__bridge void*)objc_getProtocol(#symbol))
+#else
+#define _MTL_PRIVATE_OBJC_LOOKUP_CLASS(symbol) objc_lookUpClass(#symbol)
+#define _MTL_PRIVATE_OBJC_GET_PROTOCOL(symbol) objc_getProtocol(#symbol)
+#endif // __OBJC__
+
+#define _MTL_PRIVATE_DEF_CLS(symbol) void* s_k##symbol _MTL_PRIVATE_VISIBILITY = _MTL_PRIVATE_OBJC_LOOKUP_CLASS(symbol)
+#define _MTL_PRIVATE_DEF_PRO(symbol) void* s_k##symbol _MTL_PRIVATE_VISIBILITY = _MTL_PRIVATE_OBJC_GET_PROTOCOL(symbol)
+#define _MTL_PRIVATE_DEF_SEL(accessor, symbol) SEL s_k##accessor _MTL_PRIVATE_VISIBILITY = sel_registerName(symbol)
+
+#include <dlfcn.h>
+#define MTL_DEF_FUNC( name, signature ) \
+    using Fn##name = signature; \
+    Fn##name name = reinterpret_cast< Fn##name >( dlsym( RTLD_DEFAULT, #name ) )
+
+namespace MTL::Private
+{
+    template <typename _Type>
+    inline _Type const LoadSymbol(const char* pSymbol)
+    {
+        const _Type* pAddress = static_cast<_Type*>(dlsym(RTLD_DEFAULT, pSymbol));
+
+        return pAddress ? *pAddress : nullptr;
+    }
+} // MTL::Private
+
+#if defined(__MAC_10_16) || defined(__MAC_11_0) || defined(__MAC_12_0) || defined(__MAC_13_0) || defined(__MAC_14_0) || defined(__IPHONE_14_0) || defined(__IPHONE_15_0) || defined(__IPHONE_16_0) || defined(__IPHONE_17_0) || defined(__TVOS_14_0) || defined(__TVOS_15_0) || defined(__TVOS_16_0) || defined(__TVOS_17_0)
+
+#define _MTL_PRIVATE_DEF_STR(type, symbol)                  \
+    _MTL_EXTERN type const MTL##symbol _MTL_PRIVATE_IMPORT; \
+    type const                         MTL::symbol = (nullptr != &MTL##symbol) ? MTL##symbol : nullptr
+
+#define _MTL_PRIVATE_DEF_CONST(type, symbol)              \
+    _MTL_EXTERN type const MTL##symbol _MTL_PRIVATE_IMPORT; \
+    type const                         MTL::symbol = (nullptr != &MTL##symbol) ? MTL##symbol : nullptr
+
+#define _MTL_PRIVATE_DEF_WEAK_CONST(type, symbol) \
+    _MTL_EXTERN type const MTL##symbol;    \
+    type const             MTL::symbol = Private::LoadSymbol<type>("MTL" #symbol)
+
+#else
+
+#define _MTL_PRIVATE_DEF_STR(type, symbol) \
+    _MTL_EXTERN type const MTL##symbol;    \
+    type const             MTL::symbol = Private::LoadSymbol<type>("MTL" #symbol)
+
+#define _MTL_PRIVATE_DEF_CONST(type, symbol) \
+    _MTL_EXTERN type const MTL##symbol;    \
+    type const             MTL::symbol = Private::LoadSymbol<type>("MTL" #symbol)
+
+#define _MTL_PRIVATE_DEF_WEAK_CONST(type, symbol) _MTL_PRIVATE_DEF_CONST(type, symbol)
+
+#endif // defined(__MAC_10_16) || defined(__MAC_11_0) || defined(__MAC_12_0) || defined(__MAC_13_0) || defined(__MAC_14_0) || defined(__IPHONE_14_0) || defined(__IPHONE_15_0) || defined(__IPHONE_16_0) || defined(__IPHONE_17_0) || defined(__TVOS_14_0) || defined(__TVOS_15_0) || defined(__TVOS_16_0) || defined(__TVOS_17_0)
+
+#else
+
+#define _MTL_PRIVATE_DEF_CLS(symbol) extern void* s_k##symbol
+#define _MTL_PRIVATE_DEF_PRO(symbol) extern void* s_k##symbol
+#define _MTL_PRIVATE_DEF_SEL(accessor, symbol) extern SEL s_k##accessor
+#define _MTL_PRIVATE_DEF_STR(type, symbol) extern type const MTL::symbol
+#define _MTL_PRIVATE_DEF_CONST(type, symbol) extern type const MTL::symbol
+#define _MTL_PRIVATE_DEF_WEAK_CONST(type, symbol) extern type const MTL::symbol
+
+#endif // MTL_PRIVATE_IMPLEMENTATION
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTL
+{
+namespace Private
+{
+    namespace Class
+    {
+
+    } // Class
+} // Private
+} // MTL
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTL
+{
+namespace Private
+{
+    namespace Protocol
+    {
+
+    } // Protocol
+} // Private
+} // MTL
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTL
+{
+namespace Private
+{
+    namespace Selector
+    {
+
+        _MTL_PRIVATE_DEF_SEL(beginScope,
+            "beginScope");
+        _MTL_PRIVATE_DEF_SEL(endScope,
+            "endScope");
+    } // Class
+} // Private
+} // MTL
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRasterizationRate.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRasterizationRate.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..cac233926bbbf6df5147d917682cf25cf7207509
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRasterizationRate.hpp
@@ -0,0 +1,386 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLRasterizationRate.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLDevice.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+class RasterizationRateSampleArray : public NS::Referencing<RasterizationRateSampleArray>
+{
+public:
+    static class RasterizationRateSampleArray* alloc();
+
+    class RasterizationRateSampleArray*        init();
+
+    NS::Number*                                object(NS::UInteger index);
+
+    void                                       setObject(const NS::Number* value, NS::UInteger index);
+};
+
+class RasterizationRateLayerDescriptor : public NS::Copying<RasterizationRateLayerDescriptor>
+{
+public:
+    static class RasterizationRateLayerDescriptor* alloc();
+
+    MTL::RasterizationRateLayerDescriptor*         init();
+
+    MTL::RasterizationRateLayerDescriptor*         init(MTL::Size sampleCount);
+
+    MTL::RasterizationRateLayerDescriptor*         init(MTL::Size sampleCount, const float* horizontal, const float* vertical);
+
+    MTL::Size                                      sampleCount() const;
+
+    MTL::Size                                      maxSampleCount() const;
+
+    float*                                         horizontalSampleStorage() const;
+
+    float*                                         verticalSampleStorage() const;
+
+    class RasterizationRateSampleArray*            horizontal() const;
+
+    class RasterizationRateSampleArray*            vertical() const;
+
+    void                                           setSampleCount(MTL::Size sampleCount);
+};
+
+class RasterizationRateLayerArray : public NS::Referencing<RasterizationRateLayerArray>
+{
+public:
+    static class RasterizationRateLayerArray* alloc();
+
+    class RasterizationRateLayerArray*        init();
+
+    class RasterizationRateLayerDescriptor*   object(NS::UInteger layerIndex);
+
+    void                                      setObject(const class RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex);
+};
+
+class RasterizationRateMapDescriptor : public NS::Copying<RasterizationRateMapDescriptor>
+{
+public:
+    static class RasterizationRateMapDescriptor* alloc();
+
+    class RasterizationRateMapDescriptor*        init();
+
+    static class RasterizationRateMapDescriptor* rasterizationRateMapDescriptor(MTL::Size screenSize);
+
+    static class RasterizationRateMapDescriptor* rasterizationRateMapDescriptor(MTL::Size screenSize, const class RasterizationRateLayerDescriptor* layer);
+
+    static class RasterizationRateMapDescriptor* rasterizationRateMapDescriptor(MTL::Size screenSize, NS::UInteger layerCount, const class RasterizationRateLayerDescriptor* const* layers);
+
+    class RasterizationRateLayerDescriptor*      layer(NS::UInteger layerIndex);
+
+    void                                         setLayer(const class RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex);
+
+    class RasterizationRateLayerArray*           layers() const;
+
+    MTL::Size                                    screenSize() const;
+    void                                         setScreenSize(MTL::Size screenSize);
+
+    NS::String*                                  label() const;
+    void                                         setLabel(const NS::String* label);
+
+    NS::UInteger                                 layerCount() const;
+};
+
+class RasterizationRateMap : public NS::Referencing<RasterizationRateMap>
+{
+public:
+    class Device*     device() const;
+
+    NS::String*       label() const;
+
+    MTL::Size         screenSize() const;
+
+    MTL::Size         physicalGranularity() const;
+
+    NS::UInteger      layerCount() const;
+
+    MTL::SizeAndAlign parameterBufferSizeAndAlign() const;
+
+    void              copyParameterDataToBuffer(const class Buffer* buffer, NS::UInteger offset);
+
+    MTL::Size         physicalSize(NS::UInteger layerIndex);
+
+    MTL::Coordinate2D mapScreenToPhysicalCoordinates(MTL::Coordinate2D screenCoordinates, NS::UInteger layerIndex);
+
+    MTL::Coordinate2D mapPhysicalToScreenCoordinates(MTL::Coordinate2D physicalCoordinates, NS::UInteger layerIndex);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateSampleArray::alloc()
+{
+    return NS::Object::alloc<MTL::RasterizationRateSampleArray>(_MTL_PRIVATE_CLS(MTLRasterizationRateSampleArray));
+}
+
+// method: init
+_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateSampleArray::init()
+{
+    return NS::Object::init<MTL::RasterizationRateSampleArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE NS::Number* MTL::RasterizationRateSampleArray::object(NS::UInteger index)
+{
+    return Object::sendMessage<NS::Number*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::RasterizationRateSampleArray::setObject(const NS::Number* value, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), value, index);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RasterizationRateLayerDescriptor>(_MTL_PRIVATE_CLS(MTLRasterizationRateLayerDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::init()
+{
+    return NS::Object::init<MTL::RasterizationRateLayerDescriptor>();
+}
+
+// method: initWithSampleCount:
+_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::init(MTL::Size sampleCount)
+{
+    return Object::sendMessage<MTL::RasterizationRateLayerDescriptor*>(this, _MTL_PRIVATE_SEL(initWithSampleCount_), sampleCount);
+}
+
+// method: initWithSampleCount:horizontal:vertical:
+_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::init(MTL::Size sampleCount, const float* horizontal, const float* vertical)
+{
+    return Object::sendMessage<MTL::RasterizationRateLayerDescriptor*>(this, _MTL_PRIVATE_SEL(initWithSampleCount_horizontal_vertical_), sampleCount, horizontal, vertical);
+}
+
+// property: sampleCount
+_MTL_INLINE MTL::Size MTL::RasterizationRateLayerDescriptor::sampleCount() const
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(sampleCount));
+}
+
+// property: maxSampleCount
+_MTL_INLINE MTL::Size MTL::RasterizationRateLayerDescriptor::maxSampleCount() const
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(maxSampleCount));
+}
+
+// property: horizontalSampleStorage
+_MTL_INLINE float* MTL::RasterizationRateLayerDescriptor::horizontalSampleStorage() const
+{
+    return Object::sendMessage<float*>(this, _MTL_PRIVATE_SEL(horizontalSampleStorage));
+}
+
+// property: verticalSampleStorage
+_MTL_INLINE float* MTL::RasterizationRateLayerDescriptor::verticalSampleStorage() const
+{
+    return Object::sendMessage<float*>(this, _MTL_PRIVATE_SEL(verticalSampleStorage));
+}
+
+// property: horizontal
+_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateLayerDescriptor::horizontal() const
+{
+    return Object::sendMessage<MTL::RasterizationRateSampleArray*>(this, _MTL_PRIVATE_SEL(horizontal));
+}
+
+// property: vertical
+_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateLayerDescriptor::vertical() const
+{
+    return Object::sendMessage<MTL::RasterizationRateSampleArray*>(this, _MTL_PRIVATE_SEL(vertical));
+}
+
+// method: setSampleCount:
+_MTL_INLINE void MTL::RasterizationRateLayerDescriptor::setSampleCount(MTL::Size sampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RasterizationRateLayerArray* MTL::RasterizationRateLayerArray::alloc()
+{
+    return NS::Object::alloc<MTL::RasterizationRateLayerArray>(_MTL_PRIVATE_CLS(MTLRasterizationRateLayerArray));
+}
+
+// method: init
+_MTL_INLINE MTL::RasterizationRateLayerArray* MTL::RasterizationRateLayerArray::init()
+{
+    return NS::Object::init<MTL::RasterizationRateLayerArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerArray::object(NS::UInteger layerIndex)
+{
+    return Object::sendMessage<MTL::RasterizationRateLayerDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), layerIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::RasterizationRateLayerArray::setObject(const MTL::RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), layer, layerIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RasterizationRateMapDescriptor>(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::init()
+{
+    return NS::Object::init<MTL::RasterizationRateMapDescriptor>();
+}
+
+// static method: rasterizationRateMapDescriptorWithScreenSize:
+_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::rasterizationRateMapDescriptor(MTL::Size screenSize)
+{
+    return Object::sendMessage<MTL::RasterizationRateMapDescriptor*>(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor), _MTL_PRIVATE_SEL(rasterizationRateMapDescriptorWithScreenSize_), screenSize);
+}
+
+// static method: rasterizationRateMapDescriptorWithScreenSize:layer:
+_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::rasterizationRateMapDescriptor(MTL::Size screenSize, const MTL::RasterizationRateLayerDescriptor* layer)
+{
+    return Object::sendMessage<MTL::RasterizationRateMapDescriptor*>(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor), _MTL_PRIVATE_SEL(rasterizationRateMapDescriptorWithScreenSize_layer_), screenSize, layer);
+}
+
+// static method: rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:
+_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::rasterizationRateMapDescriptor(MTL::Size screenSize, NS::UInteger layerCount, const MTL::RasterizationRateLayerDescriptor* const* layers)
+{
+    return Object::sendMessage<MTL::RasterizationRateMapDescriptor*>(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor), _MTL_PRIVATE_SEL(rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_), screenSize, layerCount, layers);
+}
+
+// method: layerAtIndex:
+_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateMapDescriptor::layer(NS::UInteger layerIndex)
+{
+    return Object::sendMessage<MTL::RasterizationRateLayerDescriptor*>(this, _MTL_PRIVATE_SEL(layerAtIndex_), layerIndex);
+}
+
+// method: setLayer:atIndex:
+_MTL_INLINE void MTL::RasterizationRateMapDescriptor::setLayer(const MTL::RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLayer_atIndex_), layer, layerIndex);
+}
+
+// property: layers
+_MTL_INLINE MTL::RasterizationRateLayerArray* MTL::RasterizationRateMapDescriptor::layers() const
+{
+    return Object::sendMessage<MTL::RasterizationRateLayerArray*>(this, _MTL_PRIVATE_SEL(layers));
+}
+
+// property: screenSize
+_MTL_INLINE MTL::Size MTL::RasterizationRateMapDescriptor::screenSize() const
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(screenSize));
+}
+
+_MTL_INLINE void MTL::RasterizationRateMapDescriptor::setScreenSize(MTL::Size screenSize)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScreenSize_), screenSize);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::RasterizationRateMapDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::RasterizationRateMapDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: layerCount
+_MTL_INLINE NS::UInteger MTL::RasterizationRateMapDescriptor::layerCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(layerCount));
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::RasterizationRateMap::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::RasterizationRateMap::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// property: screenSize
+_MTL_INLINE MTL::Size MTL::RasterizationRateMap::screenSize() const
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(screenSize));
+}
+
+// property: physicalGranularity
+_MTL_INLINE MTL::Size MTL::RasterizationRateMap::physicalGranularity() const
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(physicalGranularity));
+}
+
+// property: layerCount
+_MTL_INLINE NS::UInteger MTL::RasterizationRateMap::layerCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(layerCount));
+}
+
+// property: parameterBufferSizeAndAlign
+_MTL_INLINE MTL::SizeAndAlign MTL::RasterizationRateMap::parameterBufferSizeAndAlign() const
+{
+    return Object::sendMessage<MTL::SizeAndAlign>(this, _MTL_PRIVATE_SEL(parameterBufferSizeAndAlign));
+}
+
+// method: copyParameterDataToBuffer:offset:
+_MTL_INLINE void MTL::RasterizationRateMap::copyParameterDataToBuffer(const MTL::Buffer* buffer, NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(copyParameterDataToBuffer_offset_), buffer, offset);
+}
+
+// method: physicalSizeForLayer:
+_MTL_INLINE MTL::Size MTL::RasterizationRateMap::physicalSize(NS::UInteger layerIndex)
+{
+    return Object::sendMessage<MTL::Size>(this, _MTL_PRIVATE_SEL(physicalSizeForLayer_), layerIndex);
+}
+
+// method: mapScreenToPhysicalCoordinates:forLayer:
+_MTL_INLINE MTL::Coordinate2D MTL::RasterizationRateMap::mapScreenToPhysicalCoordinates(MTL::Coordinate2D screenCoordinates, NS::UInteger layerIndex)
+{
+    return Object::sendMessage<MTL::Coordinate2D>(this, _MTL_PRIVATE_SEL(mapScreenToPhysicalCoordinates_forLayer_), screenCoordinates, layerIndex);
+}
+
+// method: mapPhysicalToScreenCoordinates:forLayer:
+_MTL_INLINE MTL::Coordinate2D MTL::RasterizationRateMap::mapPhysicalToScreenCoordinates(MTL::Coordinate2D physicalCoordinates, NS::UInteger layerIndex)
+{
+    return Object::sendMessage<MTL::Coordinate2D>(this, _MTL_PRIVATE_SEL(mapPhysicalToScreenCoordinates_forLayer_), physicalCoordinates, layerIndex);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a3b0c42015b95fbde2252231c69b9ddf95b0956a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderCommandEncoder.hpp
@@ -0,0 +1,1177 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLRenderCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLCommandEncoder.hpp"
+#include "MTLRenderCommandEncoder.hpp"
+#include "MTLRenderPass.hpp"
+#include "MTLStageInputOutputDescriptor.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, PrimitiveType) {
+    PrimitiveTypePoint = 0,
+    PrimitiveTypeLine = 1,
+    PrimitiveTypeLineStrip = 2,
+    PrimitiveTypeTriangle = 3,
+    PrimitiveTypeTriangleStrip = 4,
+};
+
+_MTL_ENUM(NS::UInteger, VisibilityResultMode) {
+    VisibilityResultModeDisabled = 0,
+    VisibilityResultModeBoolean = 1,
+    VisibilityResultModeCounting = 2,
+};
+
+struct ScissorRect
+{
+    NS::UInteger x;
+    NS::UInteger y;
+    NS::UInteger width;
+    NS::UInteger height;
+} _MTL_PACKED;
+
+struct Viewport
+{
+    double originX;
+    double originY;
+    double width;
+    double height;
+    double znear;
+    double zfar;
+} _MTL_PACKED;
+
+_MTL_ENUM(NS::UInteger, CullMode) {
+    CullModeNone = 0,
+    CullModeFront = 1,
+    CullModeBack = 2,
+};
+
+_MTL_ENUM(NS::UInteger, Winding) {
+    WindingClockwise = 0,
+    WindingCounterClockwise = 1,
+};
+
+_MTL_ENUM(NS::UInteger, DepthClipMode) {
+    DepthClipModeClip = 0,
+    DepthClipModeClamp = 1,
+};
+
+_MTL_ENUM(NS::UInteger, TriangleFillMode) {
+    TriangleFillModeFill = 0,
+    TriangleFillModeLines = 1,
+};
+
+struct DrawPrimitivesIndirectArguments
+{
+    uint32_t vertexCount;
+    uint32_t instanceCount;
+    uint32_t vertexStart;
+    uint32_t baseInstance;
+} _MTL_PACKED;
+
+struct DrawIndexedPrimitivesIndirectArguments
+{
+    uint32_t indexCount;
+    uint32_t instanceCount;
+    uint32_t indexStart;
+    int32_t  baseVertex;
+    uint32_t baseInstance;
+} _MTL_PACKED;
+
+struct VertexAmplificationViewMapping
+{
+    uint32_t viewportArrayIndexOffset;
+    uint32_t renderTargetArrayIndexOffset;
+} _MTL_PACKED;
+
+struct DrawPatchIndirectArguments
+{
+    uint32_t patchCount;
+    uint32_t instanceCount;
+    uint32_t patchStart;
+    uint32_t baseInstance;
+} _MTL_PACKED;
+
+struct QuadTessellationFactorsHalf
+{
+    uint16_t edgeTessellationFactor[4];
+    uint16_t insideTessellationFactor[2];
+} _MTL_PACKED;
+
+struct TriangleTessellationFactorsHalf
+{
+    uint16_t edgeTessellationFactor[3];
+    uint16_t insideTessellationFactor;
+} _MTL_PACKED;
+
+_MTL_OPTIONS(NS::UInteger, RenderStages) {
+    RenderStageVertex = 1,
+    RenderStageFragment = 2,
+    RenderStageTile = 4,
+    RenderStageObject = 8,
+    RenderStageMesh = 16,
+};
+
+class RenderCommandEncoder : public NS::Referencing<RenderCommandEncoder, CommandEncoder>
+{
+public:
+    void         setRenderPipelineState(const class RenderPipelineState* pipelineState);
+
+    void         setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
+
+    void         setVertexBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void         setVertexBufferOffset(NS::UInteger offset, NS::UInteger index);
+
+    void         setVertexBuffers(const class Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
+
+    void         setVertexBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
+
+    void         setVertexBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range);
+
+    void         setVertexBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
+
+    void         setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index);
+
+    void         setVertexTexture(const class Texture* texture, NS::UInteger index);
+
+    void         setVertexTextures(const class Texture* const textures[], NS::Range range);
+
+    void         setVertexSamplerState(const class SamplerState* sampler, NS::UInteger index);
+
+    void         setVertexSamplerStates(const class SamplerState* const samplers[], NS::Range range);
+
+    void         setVertexSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
+
+    void         setVertexSamplerStates(const class SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
+
+    void         setVertexVisibleFunctionTable(const class VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
+
+    void         setVertexVisibleFunctionTables(const class VisibleFunctionTable* const functionTables[], NS::Range range);
+
+    void         setVertexIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
+
+    void         setVertexIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
+
+    void         setVertexAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
+
+    void         setViewport(MTL::Viewport viewport);
+
+    void         setViewports(const MTL::Viewport* viewports, NS::UInteger count);
+
+    void         setFrontFacingWinding(MTL::Winding frontFacingWinding);
+
+    void         setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings);
+
+    void         setCullMode(MTL::CullMode cullMode);
+
+    void         setDepthClipMode(MTL::DepthClipMode depthClipMode);
+
+    void         setDepthBias(float depthBias, float slopeScale, float clamp);
+
+    void         setScissorRect(MTL::ScissorRect rect);
+
+    void         setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count);
+
+    void         setTriangleFillMode(MTL::TriangleFillMode fillMode);
+
+    void         setFragmentBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
+
+    void         setFragmentBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void         setFragmentBufferOffset(NS::UInteger offset, NS::UInteger index);
+
+    void         setFragmentBuffers(const class Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
+
+    void         setFragmentTexture(const class Texture* texture, NS::UInteger index);
+
+    void         setFragmentTextures(const class Texture* const textures[], NS::Range range);
+
+    void         setFragmentSamplerState(const class SamplerState* sampler, NS::UInteger index);
+
+    void         setFragmentSamplerStates(const class SamplerState* const samplers[], NS::Range range);
+
+    void         setFragmentSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
+
+    void         setFragmentSamplerStates(const class SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
+
+    void         setFragmentVisibleFunctionTable(const class VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
+
+    void         setFragmentVisibleFunctionTables(const class VisibleFunctionTable* const functionTables[], NS::Range range);
+
+    void         setFragmentIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
+
+    void         setFragmentIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
+
+    void         setFragmentAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
+
+    void         setBlendColor(float red, float green, float blue, float alpha);
+
+    void         setDepthStencilState(const class DepthStencilState* depthStencilState);
+
+    void         setStencilReferenceValue(uint32_t referenceValue);
+
+    void         setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue);
+
+    void         setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset);
+
+    void         setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex);
+
+    void         setDepthStoreAction(MTL::StoreAction storeAction);
+
+    void         setStencilStoreAction(MTL::StoreAction storeAction);
+
+    void         setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex);
+
+    void         setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
+
+    void         setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
+
+    void         setObjectBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
+
+    void         setObjectBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void         setObjectBufferOffset(NS::UInteger offset, NS::UInteger index);
+
+    void         setObjectBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range);
+
+    void         setObjectTexture(const class Texture* texture, NS::UInteger index);
+
+    void         setObjectTextures(const class Texture* const textures[], NS::Range range);
+
+    void         setObjectSamplerState(const class SamplerState* sampler, NS::UInteger index);
+
+    void         setObjectSamplerStates(const class SamplerState* const samplers[], NS::Range range);
+
+    void         setObjectSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
+
+    void         setObjectSamplerStates(const class SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range);
+
+    void         setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
+
+    void         setMeshBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
+
+    void         setMeshBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void         setMeshBufferOffset(NS::UInteger offset, NS::UInteger index);
+
+    void         setMeshBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range);
+
+    void         setMeshTexture(const class Texture* texture, NS::UInteger index);
+
+    void         setMeshTextures(const class Texture* const textures[], NS::Range range);
+
+    void         setMeshSamplerState(const class SamplerState* sampler, NS::UInteger index);
+
+    void         setMeshSamplerStates(const class SamplerState* const samplers[], NS::Range range);
+
+    void         setMeshSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
+
+    void         setMeshSamplerStates(const class SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range);
+
+    void         drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
+
+    void         drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
+
+    void         drawMeshThreadgroups(const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
+
+    void         drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount);
+
+    void         drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount);
+
+    void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount);
+
+    void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset);
+
+    void         drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance);
+
+    void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance);
+
+    void         drawPrimitives(MTL::PrimitiveType primitiveType, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
+
+    void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
+
+    void         textureBarrier();
+
+    void         updateFence(const class Fence* fence, MTL::RenderStages stages);
+
+    void         waitForFence(const class Fence* fence, MTL::RenderStages stages);
+
+    void         setTessellationFactorBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride);
+
+    void         setTessellationFactorScale(float scale);
+
+    void         drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance);
+
+    void         drawPatches(NS::UInteger numberOfPatchControlPoints, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
+
+    void         drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const class Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance);
+
+    void         drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const class Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
+
+    NS::UInteger tileWidth() const;
+
+    NS::UInteger tileHeight() const;
+
+    void         setTileBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
+
+    void         setTileBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
+
+    void         setTileBufferOffset(NS::UInteger offset, NS::UInteger index);
+
+    void         setTileBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range);
+
+    void         setTileTexture(const class Texture* texture, NS::UInteger index);
+
+    void         setTileTextures(const class Texture* const textures[], NS::Range range);
+
+    void         setTileSamplerState(const class SamplerState* sampler, NS::UInteger index);
+
+    void         setTileSamplerStates(const class SamplerState* const samplers[], NS::Range range);
+
+    void         setTileSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
+
+    void         setTileSamplerStates(const class SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
+
+    void         setTileVisibleFunctionTable(const class VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
+
+    void         setTileVisibleFunctionTables(const class VisibleFunctionTable* const functionTables[], NS::Range range);
+
+    void         setTileIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
+
+    void         setTileIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
+
+    void         setTileAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
+
+    void         dispatchThreadsPerTile(MTL::Size threadsPerTile);
+
+    void         setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index);
+
+    void         useResource(const class Resource* resource, MTL::ResourceUsage usage);
+
+    void         useResources(const class Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage);
+
+    void         useResource(const class Resource* resource, MTL::ResourceUsage usage, MTL::RenderStages stages);
+
+    void         useResources(const class Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage, MTL::RenderStages stages);
+
+    void         useHeap(const class Heap* heap);
+
+    void         useHeaps(const class Heap* const heaps[], NS::UInteger count);
+
+    void         useHeap(const class Heap* heap, MTL::RenderStages stages);
+
+    void         useHeaps(const class Heap* const heaps[], NS::UInteger count, MTL::RenderStages stages);
+
+    void         executeCommandsInBuffer(const class IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange);
+
+    void         executeCommandsInBuffer(const class IndirectCommandBuffer* indirectCommandbuffer, const class Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset);
+
+    void         memoryBarrier(MTL::BarrierScope scope, MTL::RenderStages after, MTL::RenderStages before);
+
+    void         memoryBarrier(const class Resource* const resources[], NS::UInteger count, MTL::RenderStages after, MTL::RenderStages before);
+
+    void         sampleCountersInBuffer(const class CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
+};
+
+}
+
+// method: setRenderPipelineState:
+_MTL_INLINE void MTL::RenderCommandEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState);
+}
+
+// method: setVertexBytes:length:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBytes_length_atIndex_), bytes, length, index);
+}
+
+// method: setVertexBuffer:offset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setVertexBufferOffset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBufferOffset(NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_atIndex_), offset, index);
+}
+
+// method: setVertexBuffers:offsets:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// method: setVertexBuffer:offset:attributeStride:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
+}
+
+// method: setVertexBuffers:offsets:attributeStrides:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffers_offsets_attributeStrides_withRange_), buffers, offsets, strides, range);
+}
+
+// method: setVertexBufferOffset:attributeStride:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_attributeStride_atIndex_), offset, stride, index);
+}
+
+// method: setVertexBytes:length:attributeStride:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBytes_length_attributeStride_atIndex_), bytes, length, stride, index);
+}
+
+// method: setVertexTexture:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexTexture(const MTL::Texture* texture, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexTexture_atIndex_), texture, index);
+}
+
+// method: setVertexTextures:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexTextures(const MTL::Texture* const textures[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexTextures_withRange_), textures, range);
+}
+
+// method: setVertexSamplerState:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerState_atIndex_), sampler, index);
+}
+
+// method: setVertexSamplerStates:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerStates_withRange_), samplers, range);
+}
+
+// method: setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
+}
+
+// method: setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
+}
+
+// method: setVertexVisibleFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
+}
+
+// method: setVertexVisibleFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexVisibleFunctionTables_withBufferRange_), functionTables, range);
+}
+
+// method: setVertexIntersectionFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
+}
+
+// method: setVertexIntersectionFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
+}
+
+// method: setVertexAccelerationStructure:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
+}
+
+// method: setViewport:
+_MTL_INLINE void MTL::RenderCommandEncoder::setViewport(MTL::Viewport viewport)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setViewport_), viewport);
+}
+
+// method: setViewports:count:
+_MTL_INLINE void MTL::RenderCommandEncoder::setViewports(const MTL::Viewport* viewports, NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setViewports_count_), viewports, count);
+}
+
+// method: setFrontFacingWinding:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFrontFacingWinding(MTL::Winding frontFacingWinding)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFrontFacingWinding_), frontFacingWinding);
+}
+
+// method: setVertexAmplificationCount:viewMappings:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAmplificationCount_viewMappings_), count, viewMappings);
+}
+
+// method: setCullMode:
+_MTL_INLINE void MTL::RenderCommandEncoder::setCullMode(MTL::CullMode cullMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCullMode_), cullMode);
+}
+
+// method: setDepthClipMode:
+_MTL_INLINE void MTL::RenderCommandEncoder::setDepthClipMode(MTL::DepthClipMode depthClipMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthClipMode_), depthClipMode);
+}
+
+// method: setDepthBias:slopeScale:clamp:
+_MTL_INLINE void MTL::RenderCommandEncoder::setDepthBias(float depthBias, float slopeScale, float clamp)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthBias_slopeScale_clamp_), depthBias, slopeScale, clamp);
+}
+
+// method: setScissorRect:
+_MTL_INLINE void MTL::RenderCommandEncoder::setScissorRect(MTL::ScissorRect rect)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScissorRect_), rect);
+}
+
+// method: setScissorRects:count:
+_MTL_INLINE void MTL::RenderCommandEncoder::setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScissorRects_count_), scissorRects, count);
+}
+
+// method: setTriangleFillMode:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTriangleFillMode(MTL::TriangleFillMode fillMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleFillMode_), fillMode);
+}
+
+// method: setFragmentBytes:length:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBytes_length_atIndex_), bytes, length, index);
+}
+
+// method: setFragmentBuffer:offset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setFragmentBufferOffset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBufferOffset(NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBufferOffset_atIndex_), offset, index);
+}
+
+// method: setFragmentBuffers:offsets:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// method: setFragmentTexture:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentTexture(const MTL::Texture* texture, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentTexture_atIndex_), texture, index);
+}
+
+// method: setFragmentTextures:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentTextures(const MTL::Texture* const textures[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentTextures_withRange_), textures, range);
+}
+
+// method: setFragmentSamplerState:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerState_atIndex_), sampler, index);
+}
+
+// method: setFragmentSamplerStates:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerStates_withRange_), samplers, range);
+}
+
+// method: setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
+}
+
+// method: setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
+}
+
+// method: setFragmentVisibleFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
+}
+
+// method: setFragmentVisibleFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentVisibleFunctionTables_withBufferRange_), functionTables, range);
+}
+
+// method: setFragmentIntersectionFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
+}
+
+// method: setFragmentIntersectionFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
+}
+
+// method: setFragmentAccelerationStructure:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
+}
+
+// method: setBlendColorRed:green:blue:alpha:
+_MTL_INLINE void MTL::RenderCommandEncoder::setBlendColor(float red, float green, float blue, float alpha)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBlendColorRed_green_blue_alpha_), red, green, blue, alpha);
+}
+
+// method: setDepthStencilState:
+_MTL_INLINE void MTL::RenderCommandEncoder::setDepthStencilState(const MTL::DepthStencilState* depthStencilState)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilState_), depthStencilState);
+}
+
+// method: setStencilReferenceValue:
+_MTL_INLINE void MTL::RenderCommandEncoder::setStencilReferenceValue(uint32_t referenceValue)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilReferenceValue_), referenceValue);
+}
+
+// method: setStencilFrontReferenceValue:backReferenceValue:
+_MTL_INLINE void MTL::RenderCommandEncoder::setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilFrontReferenceValue_backReferenceValue_), frontReferenceValue, backReferenceValue);
+}
+
+// method: setVisibilityResultMode:offset:
+_MTL_INLINE void MTL::RenderCommandEncoder::setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibilityResultMode_offset_), mode, offset);
+}
+
+// method: setColorStoreAction:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex);
+}
+
+// method: setDepthStoreAction:
+_MTL_INLINE void MTL::RenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction);
+}
+
+// method: setStencilStoreAction:
+_MTL_INLINE void MTL::RenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction);
+}
+
+// method: setColorStoreActionOptions:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreActionOptions_atIndex_), storeActionOptions, colorAttachmentIndex);
+}
+
+// method: setDepthStoreActionOptions:
+_MTL_INLINE void MTL::RenderCommandEncoder::setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreActionOptions_), storeActionOptions);
+}
+
+// method: setStencilStoreActionOptions:
+_MTL_INLINE void MTL::RenderCommandEncoder::setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreActionOptions_), storeActionOptions);
+}
+
+// method: setObjectBytes:length:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBytes_length_atIndex_), bytes, length, index);
+}
+
+// method: setObjectBuffer:offset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setObjectBufferOffset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBufferOffset(NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBufferOffset_atIndex_), offset, index);
+}
+
+// method: setObjectBuffers:offsets:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// method: setObjectTexture:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectTexture(const MTL::Texture* texture, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectTexture_atIndex_), texture, index);
+}
+
+// method: setObjectTextures:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectTextures(const MTL::Texture* const textures[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectTextures_withRange_), textures, range);
+}
+
+// method: setObjectSamplerState:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerState_atIndex_), sampler, index);
+}
+
+// method: setObjectSamplerStates:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerStates_withRange_), samplers, range);
+}
+
+// method: setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
+}
+
+// method: setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
+}
+
+// method: setObjectThreadgroupMemoryLength:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectThreadgroupMemoryLength_atIndex_), length, index);
+}
+
+// method: setMeshBytes:length:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBytes_length_atIndex_), bytes, length, index);
+}
+
+// method: setMeshBuffer:offset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setMeshBufferOffset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBufferOffset(NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBufferOffset_atIndex_), offset, index);
+}
+
+// method: setMeshBuffers:offsets:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// method: setMeshTexture:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshTexture(const MTL::Texture* texture, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshTexture_atIndex_), texture, index);
+}
+
+// method: setMeshTextures:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshTextures(const MTL::Texture* const textures[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshTextures_withRange_), textures, range);
+}
+
+// method: setMeshSamplerState:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerState_atIndex_), sampler, index);
+}
+
+// method: setMeshSamplerStates:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerStates_withRange_), samplers, range);
+}
+
+// method: setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
+}
+
+// method: setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
+}
+
+// method: drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadgroupsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
+}
+
+// method: drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
+}
+
+// method: drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), indirectBuffer, indirectBufferOffset, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
+}
+
+// method: drawPrimitives:vertexStart:vertexCount:instanceCount:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_), primitiveType, vertexStart, vertexCount, instanceCount);
+}
+
+// method: drawPrimitives:vertexStart:vertexCount:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_), primitiveType, vertexStart, vertexCount);
+}
+
+// method: drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount);
+}
+
+// method: drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset);
+}
+
+// method: drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance);
+}
+
+// method: drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance);
+}
+
+// method: drawPrimitives:indirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_indirectBuffer_indirectBufferOffset_), primitiveType, indirectBuffer, indirectBufferOffset);
+}
+
+// method: drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_), primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset);
+}
+
+// method: textureBarrier
+_MTL_INLINE void MTL::RenderCommandEncoder::textureBarrier()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(textureBarrier));
+}
+
+// method: updateFence:afterStages:
+_MTL_INLINE void MTL::RenderCommandEncoder::updateFence(const MTL::Fence* fence, MTL::RenderStages stages)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_afterStages_), fence, stages);
+}
+
+// method: waitForFence:beforeStages:
+_MTL_INLINE void MTL::RenderCommandEncoder::waitForFence(const MTL::Fence* fence, MTL::RenderStages stages)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_beforeStages_), fence, stages);
+}
+
+// method: setTessellationFactorBuffer:offset:instanceStride:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTessellationFactorBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorBuffer_offset_instanceStride_), buffer, offset, instanceStride);
+}
+
+// method: setTessellationFactorScale:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTessellationFactorScale(float scale)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorScale_), scale);
+}
+
+// method: drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance);
+}
+
+// method: drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_), numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset);
+}
+
+// method: drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance);
+}
+
+// method: drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_), numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset);
+}
+
+// property: tileWidth
+_MTL_INLINE NS::UInteger MTL::RenderCommandEncoder::tileWidth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileWidth));
+}
+
+// property: tileHeight
+_MTL_INLINE NS::UInteger MTL::RenderCommandEncoder::tileHeight() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileHeight));
+}
+
+// method: setTileBytes:length:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBytes_length_atIndex_), bytes, length, index);
+}
+
+// method: setTileBuffer:offset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBuffer_offset_atIndex_), buffer, offset, index);
+}
+
+// method: setTileBufferOffset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileBufferOffset(NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBufferOffset_atIndex_), offset, index);
+}
+
+// method: setTileBuffers:offsets:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBuffers_offsets_withRange_), buffers, offsets, range);
+}
+
+// method: setTileTexture:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileTexture(const MTL::Texture* texture, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileTexture_atIndex_), texture, index);
+}
+
+// method: setTileTextures:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileTextures(const MTL::Texture* const textures[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileTextures_withRange_), textures, range);
+}
+
+// method: setTileSamplerState:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerState_atIndex_), sampler, index);
+}
+
+// method: setTileSamplerStates:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerStates_withRange_), samplers, range);
+}
+
+// method: setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
+}
+
+// method: setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
+}
+
+// method: setTileVisibleFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
+}
+
+// method: setTileVisibleFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileVisibleFunctionTables_withBufferRange_), functionTables, range);
+}
+
+// method: setTileIntersectionFunctionTable:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
+}
+
+// method: setTileIntersectionFunctionTables:withBufferRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
+}
+
+// method: setTileAccelerationStructure:atBufferIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setTileAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
+}
+
+// method: dispatchThreadsPerTile:
+_MTL_INLINE void MTL::RenderCommandEncoder::dispatchThreadsPerTile(MTL::Size threadsPerTile)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadsPerTile_), threadsPerTile);
+}
+
+// method: setThreadgroupMemoryLength:offset:atIndex:
+_MTL_INLINE void MTL::RenderCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_offset_atIndex_), length, offset, index);
+}
+
+// method: useResource:usage:
+_MTL_INLINE void MTL::RenderCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage);
+}
+
+// method: useResources:count:usage:
+_MTL_INLINE void MTL::RenderCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage);
+}
+
+// method: useResource:usage:stages:
+_MTL_INLINE void MTL::RenderCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage, MTL::RenderStages stages)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_stages_), resource, usage, stages);
+}
+
+// method: useResources:count:usage:stages:
+_MTL_INLINE void MTL::RenderCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage, MTL::RenderStages stages)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_stages_), resources, count, usage, stages);
+}
+
+// method: useHeap:
+_MTL_INLINE void MTL::RenderCommandEncoder::useHeap(const MTL::Heap* heap)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_), heap);
+}
+
+// method: useHeaps:count:
+_MTL_INLINE void MTL::RenderCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count);
+}
+
+// method: useHeap:stages:
+_MTL_INLINE void MTL::RenderCommandEncoder::useHeap(const MTL::Heap* heap, MTL::RenderStages stages)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_stages_), heap, stages);
+}
+
+// method: useHeaps:count:stages:
+_MTL_INLINE void MTL::RenderCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count, MTL::RenderStages stages)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_stages_), heaps, count, stages);
+}
+
+// method: executeCommandsInBuffer:withRange:
+_MTL_INLINE void MTL::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange);
+}
+
+// method: executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_), indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset);
+}
+
+// method: memoryBarrierWithScope:afterStages:beforeStages:
+_MTL_INLINE void MTL::RenderCommandEncoder::memoryBarrier(MTL::BarrierScope scope, MTL::RenderStages after, MTL::RenderStages before)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithScope_afterStages_beforeStages_), scope, after, before);
+}
+
+// method: memoryBarrierWithResources:count:afterStages:beforeStages:
+_MTL_INLINE void MTL::RenderCommandEncoder::memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count, MTL::RenderStages after, MTL::RenderStages before)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithResources_count_afterStages_beforeStages_), resources, count, after, before);
+}
+
+// method: sampleCountersInBuffer:atSampleIndex:withBarrier:
+_MTL_INLINE void MTL::RenderCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderPass.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderPass.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..087b4467cfad319688dec38e9e448421f4cb3ec7
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderPass.hpp
@@ -0,0 +1,786 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLRenderPass.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLRenderPass.hpp"
+
+namespace MTL
+{
+struct ClearColor
+{
+    static ClearColor Make(double red, double green, double blue, double alpha);
+
+    ClearColor() = default;
+
+    ClearColor(double red, double green, double blue, double alpha);
+
+    double red;
+    double green;
+    double blue;
+    double alpha;
+} _MTL_PACKED;
+
+_MTL_ENUM(NS::UInteger, LoadAction) {
+    LoadActionDontCare = 0,
+    LoadActionLoad = 1,
+    LoadActionClear = 2,
+};
+
+_MTL_ENUM(NS::UInteger, StoreAction) {
+    StoreActionDontCare = 0,
+    StoreActionStore = 1,
+    StoreActionMultisampleResolve = 2,
+    StoreActionStoreAndMultisampleResolve = 3,
+    StoreActionUnknown = 4,
+    StoreActionCustomSampleDepthStore = 5,
+};
+
+_MTL_OPTIONS(NS::UInteger, StoreActionOptions) {
+    StoreActionOptionNone = 0,
+    StoreActionOptionValidMask = 1,
+    StoreActionOptionCustomSamplePositions = 1,
+};
+
+class RenderPassAttachmentDescriptor : public NS::Copying<RenderPassAttachmentDescriptor>
+{
+public:
+    static class RenderPassAttachmentDescriptor* alloc();
+
+    class RenderPassAttachmentDescriptor*        init();
+
+    class Texture*                               texture() const;
+    void                                         setTexture(const class Texture* texture);
+
+    NS::UInteger                                 level() const;
+    void                                         setLevel(NS::UInteger level);
+
+    NS::UInteger                                 slice() const;
+    void                                         setSlice(NS::UInteger slice);
+
+    NS::UInteger                                 depthPlane() const;
+    void                                         setDepthPlane(NS::UInteger depthPlane);
+
+    class Texture*                               resolveTexture() const;
+    void                                         setResolveTexture(const class Texture* resolveTexture);
+
+    NS::UInteger                                 resolveLevel() const;
+    void                                         setResolveLevel(NS::UInteger resolveLevel);
+
+    NS::UInteger                                 resolveSlice() const;
+    void                                         setResolveSlice(NS::UInteger resolveSlice);
+
+    NS::UInteger                                 resolveDepthPlane() const;
+    void                                         setResolveDepthPlane(NS::UInteger resolveDepthPlane);
+
+    MTL::LoadAction                              loadAction() const;
+    void                                         setLoadAction(MTL::LoadAction loadAction);
+
+    MTL::StoreAction                             storeAction() const;
+    void                                         setStoreAction(MTL::StoreAction storeAction);
+
+    MTL::StoreActionOptions                      storeActionOptions() const;
+    void                                         setStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
+};
+
+class RenderPassColorAttachmentDescriptor : public NS::Copying<RenderPassColorAttachmentDescriptor, MTL::RenderPassAttachmentDescriptor>
+{
+public:
+    static class RenderPassColorAttachmentDescriptor* alloc();
+
+    class RenderPassColorAttachmentDescriptor*        init();
+
+    MTL::ClearColor                                   clearColor() const;
+    void                                              setClearColor(MTL::ClearColor clearColor);
+};
+
+_MTL_ENUM(NS::UInteger, MultisampleDepthResolveFilter) {
+    MultisampleDepthResolveFilterSample0 = 0,
+    MultisampleDepthResolveFilterMin = 1,
+    MultisampleDepthResolveFilterMax = 2,
+};
+
+class RenderPassDepthAttachmentDescriptor : public NS::Copying<RenderPassDepthAttachmentDescriptor, MTL::RenderPassAttachmentDescriptor>
+{
+public:
+    static class RenderPassDepthAttachmentDescriptor* alloc();
+
+    class RenderPassDepthAttachmentDescriptor*        init();
+
+    double                                            clearDepth() const;
+    void                                              setClearDepth(double clearDepth);
+
+    MTL::MultisampleDepthResolveFilter                depthResolveFilter() const;
+    void                                              setDepthResolveFilter(MTL::MultisampleDepthResolveFilter depthResolveFilter);
+};
+
+_MTL_ENUM(NS::UInteger, MultisampleStencilResolveFilter) {
+    MultisampleStencilResolveFilterSample0 = 0,
+    MultisampleStencilResolveFilterDepthResolvedSample = 1,
+};
+
+class RenderPassStencilAttachmentDescriptor : public NS::Copying<RenderPassStencilAttachmentDescriptor, MTL::RenderPassAttachmentDescriptor>
+{
+public:
+    static class RenderPassStencilAttachmentDescriptor* alloc();
+
+    class RenderPassStencilAttachmentDescriptor*        init();
+
+    uint32_t                                            clearStencil() const;
+    void                                                setClearStencil(uint32_t clearStencil);
+
+    MTL::MultisampleStencilResolveFilter                stencilResolveFilter() const;
+    void                                                setStencilResolveFilter(MTL::MultisampleStencilResolveFilter stencilResolveFilter);
+};
+
+class RenderPassColorAttachmentDescriptorArray : public NS::Referencing<RenderPassColorAttachmentDescriptorArray>
+{
+public:
+    static class RenderPassColorAttachmentDescriptorArray* alloc();
+
+    class RenderPassColorAttachmentDescriptorArray*        init();
+
+    class RenderPassColorAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                   setObject(const class RenderPassColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class RenderPassSampleBufferAttachmentDescriptor : public NS::Copying<RenderPassSampleBufferAttachmentDescriptor>
+{
+public:
+    static class RenderPassSampleBufferAttachmentDescriptor* alloc();
+
+    class RenderPassSampleBufferAttachmentDescriptor*        init();
+
+    class CounterSampleBuffer*                               sampleBuffer() const;
+    void                                                     setSampleBuffer(const class CounterSampleBuffer* sampleBuffer);
+
+    NS::UInteger                                             startOfVertexSampleIndex() const;
+    void                                                     setStartOfVertexSampleIndex(NS::UInteger startOfVertexSampleIndex);
+
+    NS::UInteger                                             endOfVertexSampleIndex() const;
+    void                                                     setEndOfVertexSampleIndex(NS::UInteger endOfVertexSampleIndex);
+
+    NS::UInteger                                             startOfFragmentSampleIndex() const;
+    void                                                     setStartOfFragmentSampleIndex(NS::UInteger startOfFragmentSampleIndex);
+
+    NS::UInteger                                             endOfFragmentSampleIndex() const;
+    void                                                     setEndOfFragmentSampleIndex(NS::UInteger endOfFragmentSampleIndex);
+};
+
+class RenderPassSampleBufferAttachmentDescriptorArray : public NS::Referencing<RenderPassSampleBufferAttachmentDescriptorArray>
+{
+public:
+    static class RenderPassSampleBufferAttachmentDescriptorArray* alloc();
+
+    class RenderPassSampleBufferAttachmentDescriptorArray*        init();
+
+    class RenderPassSampleBufferAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                          setObject(const class RenderPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class RenderPassDescriptor : public NS::Copying<RenderPassDescriptor>
+{
+public:
+    static class RenderPassDescriptor*                     alloc();
+
+    class RenderPassDescriptor*                            init();
+
+    static class RenderPassDescriptor*                     renderPassDescriptor();
+
+    class RenderPassColorAttachmentDescriptorArray*        colorAttachments() const;
+
+    class RenderPassDepthAttachmentDescriptor*             depthAttachment() const;
+    void                                                   setDepthAttachment(const class RenderPassDepthAttachmentDescriptor* depthAttachment);
+
+    class RenderPassStencilAttachmentDescriptor*           stencilAttachment() const;
+    void                                                   setStencilAttachment(const class RenderPassStencilAttachmentDescriptor* stencilAttachment);
+
+    class Buffer*                                          visibilityResultBuffer() const;
+    void                                                   setVisibilityResultBuffer(const class Buffer* visibilityResultBuffer);
+
+    NS::UInteger                                           renderTargetArrayLength() const;
+    void                                                   setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength);
+
+    NS::UInteger                                           imageblockSampleLength() const;
+    void                                                   setImageblockSampleLength(NS::UInteger imageblockSampleLength);
+
+    NS::UInteger                                           threadgroupMemoryLength() const;
+    void                                                   setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength);
+
+    NS::UInteger                                           tileWidth() const;
+    void                                                   setTileWidth(NS::UInteger tileWidth);
+
+    NS::UInteger                                           tileHeight() const;
+    void                                                   setTileHeight(NS::UInteger tileHeight);
+
+    NS::UInteger                                           defaultRasterSampleCount() const;
+    void                                                   setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount);
+
+    NS::UInteger                                           renderTargetWidth() const;
+    void                                                   setRenderTargetWidth(NS::UInteger renderTargetWidth);
+
+    NS::UInteger                                           renderTargetHeight() const;
+    void                                                   setRenderTargetHeight(NS::UInteger renderTargetHeight);
+
+    void                                                   setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count);
+
+    NS::UInteger                                           getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count);
+
+    class RasterizationRateMap*                            rasterizationRateMap() const;
+    void                                                   setRasterizationRateMap(const class RasterizationRateMap* rasterizationRateMap);
+
+    class RenderPassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
+};
+
+}
+
+_MTL_INLINE MTL::ClearColor MTL::ClearColor::Make(double red, double green, double blue, double alpha)
+{
+    return ClearColor(red, green, blue, alpha);
+}
+
+_MTL_INLINE MTL::ClearColor::ClearColor(double _red, double _green, double _blue, double _alpha)
+    : red(_red)
+    , green(_green)
+    , blue(_blue)
+    , alpha(_alpha)
+{
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassAttachmentDescriptor* MTL::RenderPassAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassAttachmentDescriptor* MTL::RenderPassAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPassAttachmentDescriptor>();
+}
+
+// property: texture
+_MTL_INLINE MTL::Texture* MTL::RenderPassAttachmentDescriptor::texture() const
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(texture));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setTexture(const MTL::Texture* texture)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTexture_), texture);
+}
+
+// property: level
+_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::level() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(level));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setLevel(NS::UInteger level)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLevel_), level);
+}
+
+// property: slice
+_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::slice() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(slice));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setSlice(NS::UInteger slice)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSlice_), slice);
+}
+
+// property: depthPlane
+_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::depthPlane() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(depthPlane));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setDepthPlane(NS::UInteger depthPlane)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthPlane_), depthPlane);
+}
+
+// property: resolveTexture
+_MTL_INLINE MTL::Texture* MTL::RenderPassAttachmentDescriptor::resolveTexture() const
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(resolveTexture));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveTexture(const MTL::Texture* resolveTexture)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveTexture_), resolveTexture);
+}
+
+// property: resolveLevel
+_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveLevel() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(resolveLevel));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveLevel(NS::UInteger resolveLevel)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveLevel_), resolveLevel);
+}
+
+// property: resolveSlice
+_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveSlice() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(resolveSlice));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveSlice(NS::UInteger resolveSlice)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveSlice_), resolveSlice);
+}
+
+// property: resolveDepthPlane
+_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveDepthPlane() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(resolveDepthPlane));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveDepthPlane(NS::UInteger resolveDepthPlane)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveDepthPlane_), resolveDepthPlane);
+}
+
+// property: loadAction
+_MTL_INLINE MTL::LoadAction MTL::RenderPassAttachmentDescriptor::loadAction() const
+{
+    return Object::sendMessage<MTL::LoadAction>(this, _MTL_PRIVATE_SEL(loadAction));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setLoadAction(MTL::LoadAction loadAction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLoadAction_), loadAction);
+}
+
+// property: storeAction
+_MTL_INLINE MTL::StoreAction MTL::RenderPassAttachmentDescriptor::storeAction() const
+{
+    return Object::sendMessage<MTL::StoreAction>(this, _MTL_PRIVATE_SEL(storeAction));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setStoreAction(MTL::StoreAction storeAction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStoreAction_), storeAction);
+}
+
+// property: storeActionOptions
+_MTL_INLINE MTL::StoreActionOptions MTL::RenderPassAttachmentDescriptor::storeActionOptions() const
+{
+    return Object::sendMessage<MTL::StoreActionOptions>(this, _MTL_PRIVATE_SEL(storeActionOptions));
+}
+
+_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStoreActionOptions_), storeActionOptions);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassColorAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassColorAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPassColorAttachmentDescriptor>();
+}
+
+// property: clearColor
+_MTL_INLINE MTL::ClearColor MTL::RenderPassColorAttachmentDescriptor::clearColor() const
+{
+    return Object::sendMessage<MTL::ClearColor>(this, _MTL_PRIVATE_SEL(clearColor));
+}
+
+_MTL_INLINE void MTL::RenderPassColorAttachmentDescriptor::setClearColor(MTL::ClearColor clearColor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setClearColor_), clearColor);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDepthAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassDepthAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassDepthAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDepthAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPassDepthAttachmentDescriptor>();
+}
+
+// property: clearDepth
+_MTL_INLINE double MTL::RenderPassDepthAttachmentDescriptor::clearDepth() const
+{
+    return Object::sendMessage<double>(this, _MTL_PRIVATE_SEL(clearDepth));
+}
+
+_MTL_INLINE void MTL::RenderPassDepthAttachmentDescriptor::setClearDepth(double clearDepth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setClearDepth_), clearDepth);
+}
+
+// property: depthResolveFilter
+_MTL_INLINE MTL::MultisampleDepthResolveFilter MTL::RenderPassDepthAttachmentDescriptor::depthResolveFilter() const
+{
+    return Object::sendMessage<MTL::MultisampleDepthResolveFilter>(this, _MTL_PRIVATE_SEL(depthResolveFilter));
+}
+
+_MTL_INLINE void MTL::RenderPassDepthAttachmentDescriptor::setDepthResolveFilter(MTL::MultisampleDepthResolveFilter depthResolveFilter)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthResolveFilter_), depthResolveFilter);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassStencilAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassStencilAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassStencilAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassStencilAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPassStencilAttachmentDescriptor>();
+}
+
+// property: clearStencil
+_MTL_INLINE uint32_t MTL::RenderPassStencilAttachmentDescriptor::clearStencil() const
+{
+    return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(clearStencil));
+}
+
+_MTL_INLINE void MTL::RenderPassStencilAttachmentDescriptor::setClearStencil(uint32_t clearStencil)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setClearStencil_), clearStencil);
+}
+
+// property: stencilResolveFilter
+_MTL_INLINE MTL::MultisampleStencilResolveFilter MTL::RenderPassStencilAttachmentDescriptor::stencilResolveFilter() const
+{
+    return Object::sendMessage<MTL::MultisampleStencilResolveFilter>(this, _MTL_PRIVATE_SEL(stencilResolveFilter));
+}
+
+_MTL_INLINE void MTL::RenderPassStencilAttachmentDescriptor::setStencilResolveFilter(MTL::MultisampleStencilResolveFilter stencilResolveFilter)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilResolveFilter_), stencilResolveFilter);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassColorAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassColorAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLRenderPassColorAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassColorAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::RenderPassColorAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::RenderPassColorAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::RenderPassColorAttachmentDescriptorArray::setObject(const MTL::RenderPassColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassSampleBufferAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPassSampleBufferAttachmentDescriptor>();
+}
+
+// property: sampleBuffer
+_MTL_INLINE MTL::CounterSampleBuffer* MTL::RenderPassSampleBufferAttachmentDescriptor::sampleBuffer() const
+{
+    return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
+}
+
+_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
+}
+
+// property: startOfVertexSampleIndex
+_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::startOfVertexSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfVertexSampleIndex));
+}
+
+_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setStartOfVertexSampleIndex(NS::UInteger startOfVertexSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfVertexSampleIndex_), startOfVertexSampleIndex);
+}
+
+// property: endOfVertexSampleIndex
+_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::endOfVertexSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfVertexSampleIndex));
+}
+
+_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setEndOfVertexSampleIndex(NS::UInteger endOfVertexSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfVertexSampleIndex_), endOfVertexSampleIndex);
+}
+
+// property: startOfFragmentSampleIndex
+_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::startOfFragmentSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfFragmentSampleIndex));
+}
+
+_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setStartOfFragmentSampleIndex(NS::UInteger startOfFragmentSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfFragmentSampleIndex_), startOfFragmentSampleIndex);
+}
+
+// property: endOfFragmentSampleIndex
+_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::endOfFragmentSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfFragmentSampleIndex));
+}
+
+_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setEndOfFragmentSampleIndex(NS::UInteger endOfFragmentSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfFragmentSampleIndex_), endOfFragmentSampleIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassSampleBufferAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLRenderPassSampleBufferAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassSampleBufferAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::RenderPassSampleBufferAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::RenderPassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptorArray::setObject(const MTL::RenderPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPassDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPassDescriptor>();
+}
+
+// static method: renderPassDescriptor
+_MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::renderPassDescriptor()
+{
+    return Object::sendMessage<MTL::RenderPassDescriptor*>(_MTL_PRIVATE_CLS(MTLRenderPassDescriptor), _MTL_PRIVATE_SEL(renderPassDescriptor));
+}
+
+// property: colorAttachments
+_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassDescriptor::colorAttachments() const
+{
+    return Object::sendMessage<MTL::RenderPassColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
+}
+
+// property: depthAttachment
+_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDescriptor::depthAttachment() const
+{
+    return Object::sendMessage<MTL::RenderPassDepthAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(depthAttachment));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthAttachment_), depthAttachment);
+}
+
+// property: stencilAttachment
+_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassDescriptor::stencilAttachment() const
+{
+    return Object::sendMessage<MTL::RenderPassStencilAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(stencilAttachment));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilAttachment_), stencilAttachment);
+}
+
+// property: visibilityResultBuffer
+_MTL_INLINE MTL::Buffer* MTL::RenderPassDescriptor::visibilityResultBuffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(visibilityResultBuffer));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibilityResultBuffer_), visibilityResultBuffer);
+}
+
+// property: renderTargetArrayLength
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetArrayLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetArrayLength));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetArrayLength_), renderTargetArrayLength);
+}
+
+// property: imageblockSampleLength
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::imageblockSampleLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockSampleLength));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setImageblockSampleLength(NS::UInteger imageblockSampleLength)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockSampleLength_), imageblockSampleLength);
+}
+
+// property: threadgroupMemoryLength
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::threadgroupMemoryLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryLength));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_), threadgroupMemoryLength);
+}
+
+// property: tileWidth
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::tileWidth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileWidth));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setTileWidth(NS::UInteger tileWidth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileWidth_), tileWidth);
+}
+
+// property: tileHeight
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::tileHeight() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileHeight));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setTileHeight(NS::UInteger tileHeight)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileHeight_), tileHeight);
+}
+
+// property: defaultRasterSampleCount
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::defaultRasterSampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(defaultRasterSampleCount));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDefaultRasterSampleCount_), defaultRasterSampleCount);
+}
+
+// property: renderTargetWidth
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetWidth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetWidth));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetWidth(NS::UInteger renderTargetWidth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetWidth_), renderTargetWidth);
+}
+
+// property: renderTargetHeight
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetHeight() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetHeight));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetHeight(NS::UInteger renderTargetHeight)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetHeight_), renderTargetHeight);
+}
+
+// method: setSamplePositions:count:
+_MTL_INLINE void MTL::RenderPassDescriptor::setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplePositions_count_), positions, count);
+}
+
+// method: getSamplePositions:count:
+_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count)
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(getSamplePositions_count_), positions, count);
+}
+
+// property: rasterizationRateMap
+_MTL_INLINE MTL::RasterizationRateMap* MTL::RenderPassDescriptor::rasterizationRateMap() const
+{
+    return Object::sendMessage<MTL::RasterizationRateMap*>(this, _MTL_PRIVATE_SEL(rasterizationRateMap));
+}
+
+_MTL_INLINE void MTL::RenderPassDescriptor::setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationRateMap_), rasterizationRateMap);
+}
+
+// property: sampleBufferAttachments
+_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassDescriptor::sampleBufferAttachments() const
+{
+    return Object::sendMessage<MTL::RenderPassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderPipeline.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderPipeline.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1a3c08eec1f1632509465bd13136b4f9fea82dc3
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLRenderPipeline.hpp
@@ -0,0 +1,1640 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLRenderPipeline.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLPixelFormat.hpp"
+#include "MTLRenderCommandEncoder.hpp"
+#include "MTLRenderPipeline.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, BlendFactor) {
+    BlendFactorZero = 0,
+    BlendFactorOne = 1,
+    BlendFactorSourceColor = 2,
+    BlendFactorOneMinusSourceColor = 3,
+    BlendFactorSourceAlpha = 4,
+    BlendFactorOneMinusSourceAlpha = 5,
+    BlendFactorDestinationColor = 6,
+    BlendFactorOneMinusDestinationColor = 7,
+    BlendFactorDestinationAlpha = 8,
+    BlendFactorOneMinusDestinationAlpha = 9,
+    BlendFactorSourceAlphaSaturated = 10,
+    BlendFactorBlendColor = 11,
+    BlendFactorOneMinusBlendColor = 12,
+    BlendFactorBlendAlpha = 13,
+    BlendFactorOneMinusBlendAlpha = 14,
+    BlendFactorSource1Color = 15,
+    BlendFactorOneMinusSource1Color = 16,
+    BlendFactorSource1Alpha = 17,
+    BlendFactorOneMinusSource1Alpha = 18,
+};
+
+_MTL_ENUM(NS::UInteger, BlendOperation) {
+    BlendOperationAdd = 0,
+    BlendOperationSubtract = 1,
+    BlendOperationReverseSubtract = 2,
+    BlendOperationMin = 3,
+    BlendOperationMax = 4,
+};
+
+_MTL_OPTIONS(NS::UInteger, ColorWriteMask) {
+    ColorWriteMaskNone = 0,
+    ColorWriteMaskAlpha = 1,
+    ColorWriteMaskBlue = 2,
+    ColorWriteMaskGreen = 4,
+    ColorWriteMaskRed = 8,
+    ColorWriteMaskAll = 15,
+};
+
+_MTL_ENUM(NS::UInteger, PrimitiveTopologyClass) {
+    PrimitiveTopologyClassUnspecified = 0,
+    PrimitiveTopologyClassPoint = 1,
+    PrimitiveTopologyClassLine = 2,
+    PrimitiveTopologyClassTriangle = 3,
+};
+
+_MTL_ENUM(NS::UInteger, TessellationPartitionMode) {
+    TessellationPartitionModePow2 = 0,
+    TessellationPartitionModeInteger = 1,
+    TessellationPartitionModeFractionalOdd = 2,
+    TessellationPartitionModeFractionalEven = 3,
+};
+
+_MTL_ENUM(NS::UInteger, TessellationFactorStepFunction) {
+    TessellationFactorStepFunctionConstant = 0,
+    TessellationFactorStepFunctionPerPatch = 1,
+    TessellationFactorStepFunctionPerInstance = 2,
+    TessellationFactorStepFunctionPerPatchAndPerInstance = 3,
+};
+
+_MTL_ENUM(NS::UInteger, TessellationFactorFormat) {
+    TessellationFactorFormatHalf = 0,
+};
+
+_MTL_ENUM(NS::UInteger, TessellationControlPointIndexType) {
+    TessellationControlPointIndexTypeNone = 0,
+    TessellationControlPointIndexTypeUInt16 = 1,
+    TessellationControlPointIndexTypeUInt32 = 2,
+};
+
+class RenderPipelineColorAttachmentDescriptor : public NS::Copying<RenderPipelineColorAttachmentDescriptor>
+{
+public:
+    static class RenderPipelineColorAttachmentDescriptor* alloc();
+
+    class RenderPipelineColorAttachmentDescriptor*        init();
+
+    MTL::PixelFormat                                      pixelFormat() const;
+    void                                                  setPixelFormat(MTL::PixelFormat pixelFormat);
+
+    bool                                                  blendingEnabled() const;
+    void                                                  setBlendingEnabled(bool blendingEnabled);
+
+    MTL::BlendFactor                                      sourceRGBBlendFactor() const;
+    void                                                  setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor);
+
+    MTL::BlendFactor                                      destinationRGBBlendFactor() const;
+    void                                                  setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor);
+
+    MTL::BlendOperation                                   rgbBlendOperation() const;
+    void                                                  setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation);
+
+    MTL::BlendFactor                                      sourceAlphaBlendFactor() const;
+    void                                                  setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor);
+
+    MTL::BlendFactor                                      destinationAlphaBlendFactor() const;
+    void                                                  setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor);
+
+    MTL::BlendOperation                                   alphaBlendOperation() const;
+    void                                                  setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation);
+
+    MTL::ColorWriteMask                                   writeMask() const;
+    void                                                  setWriteMask(MTL::ColorWriteMask writeMask);
+};
+
+class RenderPipelineReflection : public NS::Referencing<RenderPipelineReflection>
+{
+public:
+    static class RenderPipelineReflection* alloc();
+
+    class RenderPipelineReflection*        init();
+
+    NS::Array*                             vertexBindings() const;
+
+    NS::Array*                             fragmentBindings() const;
+
+    NS::Array*                             tileBindings() const;
+
+    NS::Array*                             objectBindings() const;
+
+    NS::Array*                             meshBindings() const;
+
+    NS::Array*                             vertexArguments() const;
+
+    NS::Array*                             fragmentArguments() const;
+
+    NS::Array*                             tileArguments() const;
+};
+
+class RenderPipelineDescriptor : public NS::Copying<RenderPipelineDescriptor>
+{
+public:
+    static class RenderPipelineDescriptor*              alloc();
+
+    class RenderPipelineDescriptor*                     init();
+
+    NS::String*                                         label() const;
+    void                                                setLabel(const NS::String* label);
+
+    class Function*                                     vertexFunction() const;
+    void                                                setVertexFunction(const class Function* vertexFunction);
+
+    class Function*                                     fragmentFunction() const;
+    void                                                setFragmentFunction(const class Function* fragmentFunction);
+
+    class VertexDescriptor*                             vertexDescriptor() const;
+    void                                                setVertexDescriptor(const class VertexDescriptor* vertexDescriptor);
+
+    NS::UInteger                                        sampleCount() const;
+    void                                                setSampleCount(NS::UInteger sampleCount);
+
+    NS::UInteger                                        rasterSampleCount() const;
+    void                                                setRasterSampleCount(NS::UInteger rasterSampleCount);
+
+    bool                                                alphaToCoverageEnabled() const;
+    void                                                setAlphaToCoverageEnabled(bool alphaToCoverageEnabled);
+
+    bool                                                alphaToOneEnabled() const;
+    void                                                setAlphaToOneEnabled(bool alphaToOneEnabled);
+
+    bool                                                rasterizationEnabled() const;
+    void                                                setRasterizationEnabled(bool rasterizationEnabled);
+
+    NS::UInteger                                        maxVertexAmplificationCount() const;
+    void                                                setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount);
+
+    class RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
+
+    MTL::PixelFormat                                    depthAttachmentPixelFormat() const;
+    void                                                setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat);
+
+    MTL::PixelFormat                                    stencilAttachmentPixelFormat() const;
+    void                                                setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat);
+
+    MTL::PrimitiveTopologyClass                         inputPrimitiveTopology() const;
+    void                                                setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology);
+
+    MTL::TessellationPartitionMode                      tessellationPartitionMode() const;
+    void                                                setTessellationPartitionMode(MTL::TessellationPartitionMode tessellationPartitionMode);
+
+    NS::UInteger                                        maxTessellationFactor() const;
+    void                                                setMaxTessellationFactor(NS::UInteger maxTessellationFactor);
+
+    bool                                                tessellationFactorScaleEnabled() const;
+    void                                                setTessellationFactorScaleEnabled(bool tessellationFactorScaleEnabled);
+
+    MTL::TessellationFactorFormat                       tessellationFactorFormat() const;
+    void                                                setTessellationFactorFormat(MTL::TessellationFactorFormat tessellationFactorFormat);
+
+    MTL::TessellationControlPointIndexType              tessellationControlPointIndexType() const;
+    void                                                setTessellationControlPointIndexType(MTL::TessellationControlPointIndexType tessellationControlPointIndexType);
+
+    MTL::TessellationFactorStepFunction                 tessellationFactorStepFunction() const;
+    void                                                setTessellationFactorStepFunction(MTL::TessellationFactorStepFunction tessellationFactorStepFunction);
+
+    MTL::Winding                                        tessellationOutputWindingOrder() const;
+    void                                                setTessellationOutputWindingOrder(MTL::Winding tessellationOutputWindingOrder);
+
+    class PipelineBufferDescriptorArray*                vertexBuffers() const;
+
+    class PipelineBufferDescriptorArray*                fragmentBuffers() const;
+
+    bool                                                supportIndirectCommandBuffers() const;
+    void                                                setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers);
+
+    NS::Array*                                          binaryArchives() const;
+    void                                                setBinaryArchives(const NS::Array* binaryArchives);
+
+    NS::Array*                                          vertexPreloadedLibraries() const;
+    void                                                setVertexPreloadedLibraries(const NS::Array* vertexPreloadedLibraries);
+
+    NS::Array*                                          fragmentPreloadedLibraries() const;
+    void                                                setFragmentPreloadedLibraries(const NS::Array* fragmentPreloadedLibraries);
+
+    class LinkedFunctions*                              vertexLinkedFunctions() const;
+    void                                                setVertexLinkedFunctions(const class LinkedFunctions* vertexLinkedFunctions);
+
+    class LinkedFunctions*                              fragmentLinkedFunctions() const;
+    void                                                setFragmentLinkedFunctions(const class LinkedFunctions* fragmentLinkedFunctions);
+
+    bool                                                supportAddingVertexBinaryFunctions() const;
+    void                                                setSupportAddingVertexBinaryFunctions(bool supportAddingVertexBinaryFunctions);
+
+    bool                                                supportAddingFragmentBinaryFunctions() const;
+    void                                                setSupportAddingFragmentBinaryFunctions(bool supportAddingFragmentBinaryFunctions);
+
+    NS::UInteger                                        maxVertexCallStackDepth() const;
+    void                                                setMaxVertexCallStackDepth(NS::UInteger maxVertexCallStackDepth);
+
+    NS::UInteger                                        maxFragmentCallStackDepth() const;
+    void                                                setMaxFragmentCallStackDepth(NS::UInteger maxFragmentCallStackDepth);
+
+    void                                                reset();
+};
+
+class RenderPipelineFunctionsDescriptor : public NS::Copying<RenderPipelineFunctionsDescriptor>
+{
+public:
+    static class RenderPipelineFunctionsDescriptor* alloc();
+
+    class RenderPipelineFunctionsDescriptor*        init();
+
+    NS::Array*                                      vertexAdditionalBinaryFunctions() const;
+    void                                            setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions);
+
+    NS::Array*                                      fragmentAdditionalBinaryFunctions() const;
+    void                                            setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions);
+
+    NS::Array*                                      tileAdditionalBinaryFunctions() const;
+    void                                            setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions);
+};
+
+class RenderPipelineState : public NS::Referencing<RenderPipelineState>
+{
+public:
+    NS::String*                      label() const;
+
+    class Device*                    device() const;
+
+    NS::UInteger                     maxTotalThreadsPerThreadgroup() const;
+
+    bool                             threadgroupSizeMatchesTileSize() const;
+
+    NS::UInteger                     imageblockSampleLength() const;
+
+    NS::UInteger                     imageblockMemoryLength(MTL::Size imageblockDimensions);
+
+    bool                             supportIndirectCommandBuffers() const;
+
+    NS::UInteger                     maxTotalThreadsPerObjectThreadgroup() const;
+
+    NS::UInteger                     maxTotalThreadsPerMeshThreadgroup() const;
+
+    NS::UInteger                     objectThreadExecutionWidth() const;
+
+    NS::UInteger                     meshThreadExecutionWidth() const;
+
+    NS::UInteger                     maxTotalThreadgroupsPerMeshGrid() const;
+
+    MTL::ResourceID                  gpuResourceID() const;
+
+    class FunctionHandle*            functionHandle(const class Function* function, MTL::RenderStages stage);
+
+    class VisibleFunctionTable*      newVisibleFunctionTable(const class VisibleFunctionTableDescriptor* descriptor, MTL::RenderStages stage);
+
+    class IntersectionFunctionTable* newIntersectionFunctionTable(const class IntersectionFunctionTableDescriptor* descriptor, MTL::RenderStages stage);
+
+    class RenderPipelineState*       newRenderPipelineState(const class RenderPipelineFunctionsDescriptor* additionalBinaryFunctions, NS::Error** error);
+};
+
+class RenderPipelineColorAttachmentDescriptorArray : public NS::Referencing<RenderPipelineColorAttachmentDescriptorArray>
+{
+public:
+    static class RenderPipelineColorAttachmentDescriptorArray* alloc();
+
+    class RenderPipelineColorAttachmentDescriptorArray*        init();
+
+    class RenderPipelineColorAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                       setObject(const class RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class TileRenderPipelineColorAttachmentDescriptor : public NS::Copying<TileRenderPipelineColorAttachmentDescriptor>
+{
+public:
+    static class TileRenderPipelineColorAttachmentDescriptor* alloc();
+
+    class TileRenderPipelineColorAttachmentDescriptor*        init();
+
+    MTL::PixelFormat                                          pixelFormat() const;
+    void                                                      setPixelFormat(MTL::PixelFormat pixelFormat);
+};
+
+class TileRenderPipelineColorAttachmentDescriptorArray : public NS::Referencing<TileRenderPipelineColorAttachmentDescriptorArray>
+{
+public:
+    static class TileRenderPipelineColorAttachmentDescriptorArray* alloc();
+
+    class TileRenderPipelineColorAttachmentDescriptorArray*        init();
+
+    class TileRenderPipelineColorAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                           setObject(const class TileRenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class TileRenderPipelineDescriptor : public NS::Copying<TileRenderPipelineDescriptor>
+{
+public:
+    static class TileRenderPipelineDescriptor*              alloc();
+
+    class TileRenderPipelineDescriptor*                     init();
+
+    NS::String*                                             label() const;
+    void                                                    setLabel(const NS::String* label);
+
+    class Function*                                         tileFunction() const;
+    void                                                    setTileFunction(const class Function* tileFunction);
+
+    NS::UInteger                                            rasterSampleCount() const;
+    void                                                    setRasterSampleCount(NS::UInteger rasterSampleCount);
+
+    class TileRenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
+
+    bool                                                    threadgroupSizeMatchesTileSize() const;
+    void                                                    setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize);
+
+    class PipelineBufferDescriptorArray*                    tileBuffers() const;
+
+    NS::UInteger                                            maxTotalThreadsPerThreadgroup() const;
+    void                                                    setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
+
+    NS::Array*                                              binaryArchives() const;
+    void                                                    setBinaryArchives(const NS::Array* binaryArchives);
+
+    NS::Array*                                              preloadedLibraries() const;
+    void                                                    setPreloadedLibraries(const NS::Array* preloadedLibraries);
+
+    class LinkedFunctions*                                  linkedFunctions() const;
+    void                                                    setLinkedFunctions(const class LinkedFunctions* linkedFunctions);
+
+    bool                                                    supportAddingBinaryFunctions() const;
+    void                                                    setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions);
+
+    NS::UInteger                                            maxCallStackDepth() const;
+    void                                                    setMaxCallStackDepth(NS::UInteger maxCallStackDepth);
+
+    void                                                    reset();
+};
+
+class MeshRenderPipelineDescriptor : public NS::Copying<MeshRenderPipelineDescriptor>
+{
+public:
+    static class MeshRenderPipelineDescriptor*          alloc();
+
+    class MeshRenderPipelineDescriptor*                 init();
+
+    NS::String*                                         label() const;
+    void                                                setLabel(const NS::String* label);
+
+    class Function*                                     objectFunction() const;
+    void                                                setObjectFunction(const class Function* objectFunction);
+
+    class Function*                                     meshFunction() const;
+    void                                                setMeshFunction(const class Function* meshFunction);
+
+    class Function*                                     fragmentFunction() const;
+    void                                                setFragmentFunction(const class Function* fragmentFunction);
+
+    NS::UInteger                                        maxTotalThreadsPerObjectThreadgroup() const;
+    void                                                setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup);
+
+    NS::UInteger                                        maxTotalThreadsPerMeshThreadgroup() const;
+    void                                                setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup);
+
+    bool                                                objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const;
+    void                                                setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth);
+
+    bool                                                meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const;
+    void                                                setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth);
+
+    NS::UInteger                                        payloadMemoryLength() const;
+    void                                                setPayloadMemoryLength(NS::UInteger payloadMemoryLength);
+
+    NS::UInteger                                        maxTotalThreadgroupsPerMeshGrid() const;
+    void                                                setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid);
+
+    class PipelineBufferDescriptorArray*                objectBuffers() const;
+
+    class PipelineBufferDescriptorArray*                meshBuffers() const;
+
+    class PipelineBufferDescriptorArray*                fragmentBuffers() const;
+
+    NS::UInteger                                        rasterSampleCount() const;
+    void                                                setRasterSampleCount(NS::UInteger rasterSampleCount);
+
+    bool                                                alphaToCoverageEnabled() const;
+    void                                                setAlphaToCoverageEnabled(bool alphaToCoverageEnabled);
+
+    bool                                                alphaToOneEnabled() const;
+    void                                                setAlphaToOneEnabled(bool alphaToOneEnabled);
+
+    bool                                                rasterizationEnabled() const;
+    void                                                setRasterizationEnabled(bool rasterizationEnabled);
+
+    NS::UInteger                                        maxVertexAmplificationCount() const;
+    void                                                setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount);
+
+    class RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
+
+    MTL::PixelFormat                                    depthAttachmentPixelFormat() const;
+    void                                                setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat);
+
+    MTL::PixelFormat                                    stencilAttachmentPixelFormat() const;
+    void                                                setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat);
+
+    class LinkedFunctions*                              objectLinkedFunctions() const;
+    void                                                setObjectLinkedFunctions(const class LinkedFunctions* objectLinkedFunctions);
+
+    class LinkedFunctions*                              meshLinkedFunctions() const;
+    void                                                setMeshLinkedFunctions(const class LinkedFunctions* meshLinkedFunctions);
+
+    class LinkedFunctions*                              fragmentLinkedFunctions() const;
+    void                                                setFragmentLinkedFunctions(const class LinkedFunctions* fragmentLinkedFunctions);
+
+    void                                                reset();
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPipelineColorAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPipelineColorAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPipelineColorAttachmentDescriptor>();
+}
+
+// property: pixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineColorAttachmentDescriptor::pixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(pixelFormat));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat);
+}
+
+// property: blendingEnabled
+_MTL_INLINE bool MTL::RenderPipelineColorAttachmentDescriptor::blendingEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isBlendingEnabled));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setBlendingEnabled(bool blendingEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBlendingEnabled_), blendingEnabled);
+}
+
+// property: sourceRGBBlendFactor
+_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::sourceRGBBlendFactor() const
+{
+    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(sourceRGBBlendFactor));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSourceRGBBlendFactor_), sourceRGBBlendFactor);
+}
+
+// property: destinationRGBBlendFactor
+_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::destinationRGBBlendFactor() const
+{
+    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(destinationRGBBlendFactor));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestinationRGBBlendFactor_), destinationRGBBlendFactor);
+}
+
+// property: rgbBlendOperation
+_MTL_INLINE MTL::BlendOperation MTL::RenderPipelineColorAttachmentDescriptor::rgbBlendOperation() const
+{
+    return Object::sendMessage<MTL::BlendOperation>(this, _MTL_PRIVATE_SEL(rgbBlendOperation));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRgbBlendOperation_), rgbBlendOperation);
+}
+
+// property: sourceAlphaBlendFactor
+_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::sourceAlphaBlendFactor() const
+{
+    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(sourceAlphaBlendFactor));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSourceAlphaBlendFactor_), sourceAlphaBlendFactor);
+}
+
+// property: destinationAlphaBlendFactor
+_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::destinationAlphaBlendFactor() const
+{
+    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(destinationAlphaBlendFactor));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestinationAlphaBlendFactor_), destinationAlphaBlendFactor);
+}
+
+// property: alphaBlendOperation
+_MTL_INLINE MTL::BlendOperation MTL::RenderPipelineColorAttachmentDescriptor::alphaBlendOperation() const
+{
+    return Object::sendMessage<MTL::BlendOperation>(this, _MTL_PRIVATE_SEL(alphaBlendOperation));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaBlendOperation_), alphaBlendOperation);
+}
+
+// property: writeMask
+_MTL_INLINE MTL::ColorWriteMask MTL::RenderPipelineColorAttachmentDescriptor::writeMask() const
+{
+    return Object::sendMessage<MTL::ColorWriteMask>(this, _MTL_PRIVATE_SEL(writeMask));
+}
+
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setWriteMask(MTL::ColorWriteMask writeMask)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPipelineReflection* MTL::RenderPipelineReflection::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPipelineReflection>(_MTL_PRIVATE_CLS(MTLRenderPipelineReflection));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPipelineReflection* MTL::RenderPipelineReflection::init()
+{
+    return NS::Object::init<MTL::RenderPipelineReflection>();
+}
+
+// property: vertexBindings
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::vertexBindings() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexBindings));
+}
+
+// property: fragmentBindings
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::fragmentBindings() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentBindings));
+}
+
+// property: tileBindings
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::tileBindings() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(tileBindings));
+}
+
+// property: objectBindings
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::objectBindings() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(objectBindings));
+}
+
+// property: meshBindings
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::meshBindings() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(meshBindings));
+}
+
+// property: vertexArguments
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::vertexArguments() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexArguments));
+}
+
+// property: fragmentArguments
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::fragmentArguments() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentArguments));
+}
+
+// property: tileArguments
+_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::tileArguments() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(tileArguments));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPipelineDescriptor* MTL::RenderPipelineDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPipelineDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPipelineDescriptor* MTL::RenderPipelineDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPipelineDescriptor>();
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::RenderPipelineDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: vertexFunction
+_MTL_INLINE MTL::Function* MTL::RenderPipelineDescriptor::vertexFunction() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(vertexFunction));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexFunction(const MTL::Function* vertexFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFunction_), vertexFunction);
+}
+
+// property: fragmentFunction
+_MTL_INLINE MTL::Function* MTL::RenderPipelineDescriptor::fragmentFunction() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(fragmentFunction));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentFunction(const MTL::Function* fragmentFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentFunction_), fragmentFunction);
+}
+
+// property: vertexDescriptor
+_MTL_INLINE MTL::VertexDescriptor* MTL::RenderPipelineDescriptor::vertexDescriptor() const
+{
+    return Object::sendMessage<MTL::VertexDescriptor*>(this, _MTL_PRIVATE_SEL(vertexDescriptor));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexDescriptor_), vertexDescriptor);
+}
+
+// property: sampleCount
+_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::sampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setSampleCount(NS::UInteger sampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount);
+}
+
+// property: rasterSampleCount
+_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::rasterSampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
+}
+
+// property: alphaToCoverageEnabled
+_MTL_INLINE bool MTL::RenderPipelineDescriptor::alphaToCoverageEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isAlphaToCoverageEnabled));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setAlphaToCoverageEnabled(bool alphaToCoverageEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToCoverageEnabled_), alphaToCoverageEnabled);
+}
+
+// property: alphaToOneEnabled
+_MTL_INLINE bool MTL::RenderPipelineDescriptor::alphaToOneEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isAlphaToOneEnabled));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setAlphaToOneEnabled(bool alphaToOneEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToOneEnabled_), alphaToOneEnabled);
+}
+
+// property: rasterizationEnabled
+_MTL_INLINE bool MTL::RenderPipelineDescriptor::rasterizationEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRasterizationEnabled));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled);
+}
+
+// property: maxVertexAmplificationCount
+_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxVertexAmplificationCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount);
+}
+
+// property: colorAttachments
+_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineDescriptor::colorAttachments() const
+{
+    return Object::sendMessage<MTL::RenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
+}
+
+// property: depthAttachmentPixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineDescriptor::depthAttachmentPixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(depthAttachmentPixelFormat));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthAttachmentPixelFormat_), depthAttachmentPixelFormat);
+}
+
+// property: stencilAttachmentPixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineDescriptor::stencilAttachmentPixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(stencilAttachmentPixelFormat));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilAttachmentPixelFormat_), stencilAttachmentPixelFormat);
+}
+
+// property: inputPrimitiveTopology
+_MTL_INLINE MTL::PrimitiveTopologyClass MTL::RenderPipelineDescriptor::inputPrimitiveTopology() const
+{
+    return Object::sendMessage<MTL::PrimitiveTopologyClass>(this, _MTL_PRIVATE_SEL(inputPrimitiveTopology));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInputPrimitiveTopology_), inputPrimitiveTopology);
+}
+
+// property: tessellationPartitionMode
+_MTL_INLINE MTL::TessellationPartitionMode MTL::RenderPipelineDescriptor::tessellationPartitionMode() const
+{
+    return Object::sendMessage<MTL::TessellationPartitionMode>(this, _MTL_PRIVATE_SEL(tessellationPartitionMode));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationPartitionMode(MTL::TessellationPartitionMode tessellationPartitionMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationPartitionMode_), tessellationPartitionMode);
+}
+
+// property: maxTessellationFactor
+_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxTessellationFactor() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTessellationFactor));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxTessellationFactor(NS::UInteger maxTessellationFactor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTessellationFactor_), maxTessellationFactor);
+}
+
+// property: tessellationFactorScaleEnabled
+_MTL_INLINE bool MTL::RenderPipelineDescriptor::tessellationFactorScaleEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isTessellationFactorScaleEnabled));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorScaleEnabled(bool tessellationFactorScaleEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorScaleEnabled_), tessellationFactorScaleEnabled);
+}
+
+// property: tessellationFactorFormat
+_MTL_INLINE MTL::TessellationFactorFormat MTL::RenderPipelineDescriptor::tessellationFactorFormat() const
+{
+    return Object::sendMessage<MTL::TessellationFactorFormat>(this, _MTL_PRIVATE_SEL(tessellationFactorFormat));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorFormat(MTL::TessellationFactorFormat tessellationFactorFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorFormat_), tessellationFactorFormat);
+}
+
+// property: tessellationControlPointIndexType
+_MTL_INLINE MTL::TessellationControlPointIndexType MTL::RenderPipelineDescriptor::tessellationControlPointIndexType() const
+{
+    return Object::sendMessage<MTL::TessellationControlPointIndexType>(this, _MTL_PRIVATE_SEL(tessellationControlPointIndexType));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationControlPointIndexType(MTL::TessellationControlPointIndexType tessellationControlPointIndexType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationControlPointIndexType_), tessellationControlPointIndexType);
+}
+
+// property: tessellationFactorStepFunction
+_MTL_INLINE MTL::TessellationFactorStepFunction MTL::RenderPipelineDescriptor::tessellationFactorStepFunction() const
+{
+    return Object::sendMessage<MTL::TessellationFactorStepFunction>(this, _MTL_PRIVATE_SEL(tessellationFactorStepFunction));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorStepFunction(MTL::TessellationFactorStepFunction tessellationFactorStepFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorStepFunction_), tessellationFactorStepFunction);
+}
+
+// property: tessellationOutputWindingOrder
+_MTL_INLINE MTL::Winding MTL::RenderPipelineDescriptor::tessellationOutputWindingOrder() const
+{
+    return Object::sendMessage<MTL::Winding>(this, _MTL_PRIVATE_SEL(tessellationOutputWindingOrder));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationOutputWindingOrder(MTL::Winding tessellationOutputWindingOrder)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationOutputWindingOrder_), tessellationOutputWindingOrder);
+}
+
+// property: vertexBuffers
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::RenderPipelineDescriptor::vertexBuffers() const
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(vertexBuffers));
+}
+
+// property: fragmentBuffers
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::RenderPipelineDescriptor::fragmentBuffers() const
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(fragmentBuffers));
+}
+
+// property: supportIndirectCommandBuffers
+_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportIndirectCommandBuffers() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers);
+}
+
+// property: binaryArchives
+_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::binaryArchives() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
+}
+
+// property: vertexPreloadedLibraries
+_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::vertexPreloadedLibraries() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexPreloadedLibraries));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexPreloadedLibraries(const NS::Array* vertexPreloadedLibraries)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexPreloadedLibraries_), vertexPreloadedLibraries);
+}
+
+// property: fragmentPreloadedLibraries
+_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::fragmentPreloadedLibraries() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentPreloadedLibraries));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentPreloadedLibraries(const NS::Array* fragmentPreloadedLibraries)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentPreloadedLibraries_), fragmentPreloadedLibraries);
+}
+
+// property: vertexLinkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::RenderPipelineDescriptor::vertexLinkedFunctions() const
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(vertexLinkedFunctions));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexLinkedFunctions(const MTL::LinkedFunctions* vertexLinkedFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexLinkedFunctions_), vertexLinkedFunctions);
+}
+
+// property: fragmentLinkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::RenderPipelineDescriptor::fragmentLinkedFunctions() const
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(fragmentLinkedFunctions));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentLinkedFunctions(const MTL::LinkedFunctions* fragmentLinkedFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentLinkedFunctions_), fragmentLinkedFunctions);
+}
+
+// property: supportAddingVertexBinaryFunctions
+_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportAddingVertexBinaryFunctions() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingVertexBinaryFunctions));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportAddingVertexBinaryFunctions(bool supportAddingVertexBinaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingVertexBinaryFunctions_), supportAddingVertexBinaryFunctions);
+}
+
+// property: supportAddingFragmentBinaryFunctions
+_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportAddingFragmentBinaryFunctions() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingFragmentBinaryFunctions));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportAddingFragmentBinaryFunctions(bool supportAddingFragmentBinaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingFragmentBinaryFunctions_), supportAddingFragmentBinaryFunctions);
+}
+
+// property: maxVertexCallStackDepth
+_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxVertexCallStackDepth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexCallStackDepth));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxVertexCallStackDepth(NS::UInteger maxVertexCallStackDepth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexCallStackDepth_), maxVertexCallStackDepth);
+}
+
+// property: maxFragmentCallStackDepth
+_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxFragmentCallStackDepth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxFragmentCallStackDepth));
+}
+
+_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxFragmentCallStackDepth(NS::UInteger maxFragmentCallStackDepth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxFragmentCallStackDepth_), maxFragmentCallStackDepth);
+}
+
+// method: reset
+_MTL_INLINE void MTL::RenderPipelineDescriptor::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPipelineFunctionsDescriptor* MTL::RenderPipelineFunctionsDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPipelineFunctionsDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPipelineFunctionsDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPipelineFunctionsDescriptor* MTL::RenderPipelineFunctionsDescriptor::init()
+{
+    return NS::Object::init<MTL::RenderPipelineFunctionsDescriptor>();
+}
+
+// property: vertexAdditionalBinaryFunctions
+_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::vertexAdditionalBinaryFunctions() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexAdditionalBinaryFunctions));
+}
+
+_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAdditionalBinaryFunctions_), vertexAdditionalBinaryFunctions);
+}
+
+// property: fragmentAdditionalBinaryFunctions
+_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::fragmentAdditionalBinaryFunctions() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentAdditionalBinaryFunctions));
+}
+
+_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentAdditionalBinaryFunctions_), fragmentAdditionalBinaryFunctions);
+}
+
+// property: tileAdditionalBinaryFunctions
+_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::tileAdditionalBinaryFunctions() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(tileAdditionalBinaryFunctions));
+}
+
+_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileAdditionalBinaryFunctions_), tileAdditionalBinaryFunctions);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::RenderPipelineState::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::RenderPipelineState::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: maxTotalThreadsPerThreadgroup
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadsPerThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
+}
+
+// property: threadgroupSizeMatchesTileSize
+_MTL_INLINE bool MTL::RenderPipelineState::threadgroupSizeMatchesTileSize() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize));
+}
+
+// property: imageblockSampleLength
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::imageblockSampleLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockSampleLength));
+}
+
+// method: imageblockMemoryLengthForDimensions:
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::imageblockMemoryLength(MTL::Size imageblockDimensions)
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockMemoryLengthForDimensions_), imageblockDimensions);
+}
+
+// property: supportIndirectCommandBuffers
+_MTL_INLINE bool MTL::RenderPipelineState::supportIndirectCommandBuffers() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
+}
+
+// property: maxTotalThreadsPerObjectThreadgroup
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadsPerObjectThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerObjectThreadgroup));
+}
+
+// property: maxTotalThreadsPerMeshThreadgroup
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadsPerMeshThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerMeshThreadgroup));
+}
+
+// property: objectThreadExecutionWidth
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::objectThreadExecutionWidth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(objectThreadExecutionWidth));
+}
+
+// property: meshThreadExecutionWidth
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::meshThreadExecutionWidth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(meshThreadExecutionWidth));
+}
+
+// property: maxTotalThreadgroupsPerMeshGrid
+_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadgroupsPerMeshGrid() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadgroupsPerMeshGrid));
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::RenderPipelineState::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
+
+// method: functionHandleWithFunction:stage:
+_MTL_INLINE MTL::FunctionHandle* MTL::RenderPipelineState::functionHandle(const MTL::Function* function, MTL::RenderStages stage)
+{
+    return Object::sendMessage<MTL::FunctionHandle*>(this, _MTL_PRIVATE_SEL(functionHandleWithFunction_stage_), function, stage);
+}
+
+// method: newVisibleFunctionTableWithDescriptor:stage:
+_MTL_INLINE MTL::VisibleFunctionTable* MTL::RenderPipelineState::newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor, MTL::RenderStages stage)
+{
+    return Object::sendMessage<MTL::VisibleFunctionTable*>(this, _MTL_PRIVATE_SEL(newVisibleFunctionTableWithDescriptor_stage_), descriptor, stage);
+}
+
+// method: newIntersectionFunctionTableWithDescriptor:stage:
+_MTL_INLINE MTL::IntersectionFunctionTable* MTL::RenderPipelineState::newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor, MTL::RenderStages stage)
+{
+    return Object::sendMessage<MTL::IntersectionFunctionTable*>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionTableWithDescriptor_stage_), descriptor, stage);
+}
+
+// method: newRenderPipelineStateWithAdditionalBinaryFunctions:error:
+_MTL_INLINE MTL::RenderPipelineState* MTL::RenderPipelineState::newRenderPipelineState(const MTL::RenderPipelineFunctionsDescriptor* additionalBinaryFunctions, NS::Error** error)
+{
+    return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithAdditionalBinaryFunctions_error_), additionalBinaryFunctions, error);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineColorAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::RenderPipelineColorAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLRenderPipelineColorAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineColorAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::RenderPipelineColorAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::RenderPipelineColorAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptorArray::setObject(const MTL::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::TileRenderPipelineColorAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLTileRenderPipelineColorAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::TileRenderPipelineColorAttachmentDescriptor>();
+}
+
+// property: pixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::TileRenderPipelineColorAttachmentDescriptor::pixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(pixelFormat));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineColorAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::TileRenderPipelineColorAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLTileRenderPipelineColorAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineColorAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::TileRenderPipelineColorAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::TileRenderPipelineColorAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::TileRenderPipelineColorAttachmentDescriptorArray::setObject(const MTL::TileRenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::TileRenderPipelineDescriptor* MTL::TileRenderPipelineDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::TileRenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTLTileRenderPipelineDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::TileRenderPipelineDescriptor* MTL::TileRenderPipelineDescriptor::init()
+{
+    return NS::Object::init<MTL::TileRenderPipelineDescriptor>();
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::TileRenderPipelineDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: tileFunction
+_MTL_INLINE MTL::Function* MTL::TileRenderPipelineDescriptor::tileFunction() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(tileFunction));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setTileFunction(const MTL::Function* tileFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileFunction_), tileFunction);
+}
+
+// property: rasterSampleCount
+_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::rasterSampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
+}
+
+// property: colorAttachments
+_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineDescriptor::colorAttachments() const
+{
+    return Object::sendMessage<MTL::TileRenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
+}
+
+// property: threadgroupSizeMatchesTileSize
+_MTL_INLINE bool MTL::TileRenderPipelineDescriptor::threadgroupSizeMatchesTileSize() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupSizeMatchesTileSize_), threadgroupSizeMatchesTileSize);
+}
+
+// property: tileBuffers
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::TileRenderPipelineDescriptor::tileBuffers() const
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(tileBuffers));
+}
+
+// property: maxTotalThreadsPerThreadgroup
+_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::maxTotalThreadsPerThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
+}
+
+// property: binaryArchives
+_MTL_INLINE NS::Array* MTL::TileRenderPipelineDescriptor::binaryArchives() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
+}
+
+// property: preloadedLibraries
+_MTL_INLINE NS::Array* MTL::TileRenderPipelineDescriptor::preloadedLibraries() const
+{
+    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(preloadedLibraries));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries);
+}
+
+// property: linkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::TileRenderPipelineDescriptor::linkedFunctions() const
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(linkedFunctions));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLinkedFunctions_), linkedFunctions);
+}
+
+// property: supportAddingBinaryFunctions
+_MTL_INLINE bool MTL::TileRenderPipelineDescriptor::supportAddingBinaryFunctions() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingBinaryFunctions));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingBinaryFunctions_), supportAddingBinaryFunctions);
+}
+
+// property: maxCallStackDepth
+_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::maxCallStackDepth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCallStackDepth));
+}
+
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth);
+}
+
+// method: reset
+_MTL_INLINE void MTL::TileRenderPipelineDescriptor::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::MeshRenderPipelineDescriptor* MTL::MeshRenderPipelineDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::MeshRenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTLMeshRenderPipelineDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::MeshRenderPipelineDescriptor* MTL::MeshRenderPipelineDescriptor::init()
+{
+    return NS::Object::init<MTL::MeshRenderPipelineDescriptor>();
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::MeshRenderPipelineDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: objectFunction
+_MTL_INLINE MTL::Function* MTL::MeshRenderPipelineDescriptor::objectFunction() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(objectFunction));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setObjectFunction(const MTL::Function* objectFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectFunction_), objectFunction);
+}
+
+// property: meshFunction
+_MTL_INLINE MTL::Function* MTL::MeshRenderPipelineDescriptor::meshFunction() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(meshFunction));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMeshFunction(const MTL::Function* meshFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshFunction_), meshFunction);
+}
+
+// property: fragmentFunction
+_MTL_INLINE MTL::Function* MTL::MeshRenderPipelineDescriptor::fragmentFunction() const
+{
+    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(fragmentFunction));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setFragmentFunction(const MTL::Function* fragmentFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentFunction_), fragmentFunction);
+}
+
+// property: maxTotalThreadsPerObjectThreadgroup
+_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxTotalThreadsPerObjectThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerObjectThreadgroup));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerObjectThreadgroup_), maxTotalThreadsPerObjectThreadgroup);
+}
+
+// property: maxTotalThreadsPerMeshThreadgroup
+_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxTotalThreadsPerMeshThreadgroup() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerMeshThreadgroup));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerMeshThreadgroup_), maxTotalThreadsPerMeshThreadgroup);
+}
+
+// property: objectThreadgroupSizeIsMultipleOfThreadExecutionWidth
+_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(objectThreadgroupSizeIsMultipleOfThreadExecutionWidth));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth_), objectThreadgroupSizeIsMultipleOfThreadExecutionWidth);
+}
+
+// property: meshThreadgroupSizeIsMultipleOfThreadExecutionWidth
+_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(meshThreadgroupSizeIsMultipleOfThreadExecutionWidth));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth_), meshThreadgroupSizeIsMultipleOfThreadExecutionWidth);
+}
+
+// property: payloadMemoryLength
+_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::payloadMemoryLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(payloadMemoryLength));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setPayloadMemoryLength(NS::UInteger payloadMemoryLength)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPayloadMemoryLength_), payloadMemoryLength);
+}
+
+// property: maxTotalThreadgroupsPerMeshGrid
+_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxTotalThreadgroupsPerMeshGrid() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadgroupsPerMeshGrid));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadgroupsPerMeshGrid_), maxTotalThreadgroupsPerMeshGrid);
+}
+
+// property: objectBuffers
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::MeshRenderPipelineDescriptor::objectBuffers() const
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(objectBuffers));
+}
+
+// property: meshBuffers
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::MeshRenderPipelineDescriptor::meshBuffers() const
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(meshBuffers));
+}
+
+// property: fragmentBuffers
+_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::MeshRenderPipelineDescriptor::fragmentBuffers() const
+{
+    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(fragmentBuffers));
+}
+
+// property: rasterSampleCount
+_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::rasterSampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
+}
+
+// property: alphaToCoverageEnabled
+_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::alphaToCoverageEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isAlphaToCoverageEnabled));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setAlphaToCoverageEnabled(bool alphaToCoverageEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToCoverageEnabled_), alphaToCoverageEnabled);
+}
+
+// property: alphaToOneEnabled
+_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::alphaToOneEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isAlphaToOneEnabled));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setAlphaToOneEnabled(bool alphaToOneEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToOneEnabled_), alphaToOneEnabled);
+}
+
+// property: rasterizationEnabled
+_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::rasterizationEnabled() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRasterizationEnabled));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled);
+}
+
+// property: maxVertexAmplificationCount
+_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxVertexAmplificationCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount);
+}
+
+// property: colorAttachments
+_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::MeshRenderPipelineDescriptor::colorAttachments() const
+{
+    return Object::sendMessage<MTL::RenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
+}
+
+// property: depthAttachmentPixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::MeshRenderPipelineDescriptor::depthAttachmentPixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(depthAttachmentPixelFormat));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthAttachmentPixelFormat_), depthAttachmentPixelFormat);
+}
+
+// property: stencilAttachmentPixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::MeshRenderPipelineDescriptor::stencilAttachmentPixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(stencilAttachmentPixelFormat));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilAttachmentPixelFormat_), stencilAttachmentPixelFormat);
+}
+
+// property: objectLinkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::MeshRenderPipelineDescriptor::objectLinkedFunctions() const
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(objectLinkedFunctions));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setObjectLinkedFunctions(const MTL::LinkedFunctions* objectLinkedFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectLinkedFunctions_), objectLinkedFunctions);
+}
+
+// property: meshLinkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::MeshRenderPipelineDescriptor::meshLinkedFunctions() const
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(meshLinkedFunctions));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMeshLinkedFunctions(const MTL::LinkedFunctions* meshLinkedFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshLinkedFunctions_), meshLinkedFunctions);
+}
+
+// property: fragmentLinkedFunctions
+_MTL_INLINE MTL::LinkedFunctions* MTL::MeshRenderPipelineDescriptor::fragmentLinkedFunctions() const
+{
+    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(fragmentLinkedFunctions));
+}
+
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setFragmentLinkedFunctions(const MTL::LinkedFunctions* fragmentLinkedFunctions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentLinkedFunctions_), fragmentLinkedFunctions);
+}
+
+// method: reset
+_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResource.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResource.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..69c57d38dd1067efb6e22347abca9a18dc02b469
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResource.hpp
@@ -0,0 +1,178 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLResource.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLResource.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, PurgeableState) {
+    PurgeableStateKeepCurrent = 1,
+    PurgeableStateNonVolatile = 2,
+    PurgeableStateVolatile = 3,
+    PurgeableStateEmpty = 4,
+};
+
+_MTL_ENUM(NS::UInteger, CPUCacheMode) {
+    CPUCacheModeDefaultCache = 0,
+    CPUCacheModeWriteCombined = 1,
+};
+
+_MTL_ENUM(NS::UInteger, StorageMode) {
+    StorageModeShared = 0,
+    StorageModeManaged = 1,
+    StorageModePrivate = 2,
+    StorageModeMemoryless = 3,
+};
+
+_MTL_ENUM(NS::UInteger, HazardTrackingMode) {
+    HazardTrackingModeDefault = 0,
+    HazardTrackingModeUntracked = 1,
+    HazardTrackingModeTracked = 2,
+};
+
+_MTL_OPTIONS(NS::UInteger, ResourceOptions) {
+    ResourceStorageModeShared = 0,
+    ResourceHazardTrackingModeDefault = 0,
+    ResourceCPUCacheModeDefaultCache = 0,
+    ResourceOptionCPUCacheModeDefault = 0,
+    ResourceCPUCacheModeWriteCombined = 1,
+    ResourceOptionCPUCacheModeWriteCombined = 1,
+    ResourceStorageModeManaged = 16,
+    ResourceStorageModePrivate = 32,
+    ResourceStorageModeMemoryless = 48,
+    ResourceHazardTrackingModeUntracked = 256,
+    ResourceHazardTrackingModeTracked = 512,
+};
+
+class Resource : public NS::Referencing<Resource>
+{
+public:
+    NS::String*             label() const;
+    void                    setLabel(const NS::String* label);
+
+    class Device*           device() const;
+
+    MTL::CPUCacheMode       cpuCacheMode() const;
+
+    MTL::StorageMode        storageMode() const;
+
+    MTL::HazardTrackingMode hazardTrackingMode() const;
+
+    MTL::ResourceOptions    resourceOptions() const;
+
+    MTL::PurgeableState     setPurgeableState(MTL::PurgeableState state);
+
+    class Heap*             heap() const;
+
+    NS::UInteger            heapOffset() const;
+
+    NS::UInteger            allocatedSize() const;
+
+    void                    makeAliasable();
+
+    bool                    isAliasable();
+};
+
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::Resource::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::Resource::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::Resource::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: cpuCacheMode
+_MTL_INLINE MTL::CPUCacheMode MTL::Resource::cpuCacheMode() const
+{
+    return Object::sendMessage<MTL::CPUCacheMode>(this, _MTL_PRIVATE_SEL(cpuCacheMode));
+}
+
+// property: storageMode
+_MTL_INLINE MTL::StorageMode MTL::Resource::storageMode() const
+{
+    return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
+}
+
+// property: hazardTrackingMode
+_MTL_INLINE MTL::HazardTrackingMode MTL::Resource::hazardTrackingMode() const
+{
+    return Object::sendMessage<MTL::HazardTrackingMode>(this, _MTL_PRIVATE_SEL(hazardTrackingMode));
+}
+
+// property: resourceOptions
+_MTL_INLINE MTL::ResourceOptions MTL::Resource::resourceOptions() const
+{
+    return Object::sendMessage<MTL::ResourceOptions>(this, _MTL_PRIVATE_SEL(resourceOptions));
+}
+
+// method: setPurgeableState:
+_MTL_INLINE MTL::PurgeableState MTL::Resource::setPurgeableState(MTL::PurgeableState state)
+{
+    return Object::sendMessage<MTL::PurgeableState>(this, _MTL_PRIVATE_SEL(setPurgeableState_), state);
+}
+
+// property: heap
+_MTL_INLINE MTL::Heap* MTL::Resource::heap() const
+{
+    return Object::sendMessage<MTL::Heap*>(this, _MTL_PRIVATE_SEL(heap));
+}
+
+// property: heapOffset
+_MTL_INLINE NS::UInteger MTL::Resource::heapOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(heapOffset));
+}
+
+// property: allocatedSize
+_MTL_INLINE NS::UInteger MTL::Resource::allocatedSize() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(allocatedSize));
+}
+
+// method: makeAliasable
+_MTL_INLINE void MTL::Resource::makeAliasable()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(makeAliasable));
+}
+
+// method: isAliasable
+_MTL_INLINE bool MTL::Resource::isAliasable()
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isAliasable));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResourceStateCommandEncoder.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResourceStateCommandEncoder.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf54f387d09f4b19fe1c7e5de3dc75fe732dfded
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResourceStateCommandEncoder.hpp
@@ -0,0 +1,103 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLResourceStateCommandEncoder.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLCommandEncoder.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, SparseTextureMappingMode) {
+    SparseTextureMappingModeMap = 0,
+    SparseTextureMappingModeUnmap = 1,
+};
+
+struct MapIndirectArguments
+{
+    uint32_t regionOriginX;
+    uint32_t regionOriginY;
+    uint32_t regionOriginZ;
+    uint32_t regionSizeWidth;
+    uint32_t regionSizeHeight;
+    uint32_t regionSizeDepth;
+    uint32_t mipMapLevel;
+    uint32_t sliceId;
+} _MTL_PACKED;
+
+class ResourceStateCommandEncoder : public NS::Referencing<ResourceStateCommandEncoder, CommandEncoder>
+{
+public:
+    void updateTextureMappings(const class Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region* regions, const NS::UInteger* mipLevels, const NS::UInteger* slices, NS::UInteger numRegions);
+
+    void updateTextureMapping(const class Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region region, const NS::UInteger mipLevel, const NS::UInteger slice);
+
+    void updateTextureMapping(const class Texture* texture, const MTL::SparseTextureMappingMode mode, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
+
+    void updateFence(const class Fence* fence);
+
+    void waitForFence(const class Fence* fence);
+
+    void moveTextureMappingsFromTexture(const class Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const class Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin);
+};
+
+}
+
+// method: updateTextureMappings:mode:regions:mipLevels:slices:numRegions:
+_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateTextureMappings(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region* regions, const NS::UInteger* mipLevels, const NS::UInteger* slices, NS::UInteger numRegions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateTextureMappings_mode_regions_mipLevels_slices_numRegions_), texture, mode, regions, mipLevels, slices, numRegions);
+}
+
+// method: updateTextureMapping:mode:region:mipLevel:slice:
+_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateTextureMapping(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region region, const NS::UInteger mipLevel, const NS::UInteger slice)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateTextureMapping_mode_region_mipLevel_slice_), texture, mode, region, mipLevel, slice);
+}
+
+// method: updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:
+_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateTextureMapping(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_), texture, mode, indirectBuffer, indirectBufferOffset);
+}
+
+// method: updateFence:
+_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_), fence);
+}
+
+// method: waitForFence:
+_MTL_INLINE void MTL::ResourceStateCommandEncoder::waitForFence(const MTL::Fence* fence)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_), fence);
+}
+
+// method: moveTextureMappingsFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:
+_MTL_INLINE void MTL::ResourceStateCommandEncoder::moveTextureMappingsFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(moveTextureMappingsFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResourceStatePass.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResourceStatePass.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3c759b1a5ef8590c2fb78f9bf8d5d3fd602f2608
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLResourceStatePass.hpp
@@ -0,0 +1,165 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLResourceStatePass.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+namespace MTL
+{
+class ResourceStatePassSampleBufferAttachmentDescriptor : public NS::Copying<ResourceStatePassSampleBufferAttachmentDescriptor>
+{
+public:
+    static class ResourceStatePassSampleBufferAttachmentDescriptor* alloc();
+
+    class ResourceStatePassSampleBufferAttachmentDescriptor*        init();
+
+    class CounterSampleBuffer*                                      sampleBuffer() const;
+    void                                                            setSampleBuffer(const class CounterSampleBuffer* sampleBuffer);
+
+    NS::UInteger                                                    startOfEncoderSampleIndex() const;
+    void                                                            setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex);
+
+    NS::UInteger                                                    endOfEncoderSampleIndex() const;
+    void                                                            setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex);
+};
+
+class ResourceStatePassSampleBufferAttachmentDescriptorArray : public NS::Referencing<ResourceStatePassSampleBufferAttachmentDescriptorArray>
+{
+public:
+    static class ResourceStatePassSampleBufferAttachmentDescriptorArray* alloc();
+
+    class ResourceStatePassSampleBufferAttachmentDescriptorArray*        init();
+
+    class ResourceStatePassSampleBufferAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
+
+    void                                                                 setObject(const class ResourceStatePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
+};
+
+class ResourceStatePassDescriptor : public NS::Copying<ResourceStatePassDescriptor>
+{
+public:
+    static class ResourceStatePassDescriptor*                     alloc();
+
+    class ResourceStatePassDescriptor*                            init();
+
+    static class ResourceStatePassDescriptor*                     resourceStatePassDescriptor();
+
+    class ResourceStatePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptor* MTL::ResourceStatePassSampleBufferAttachmentDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::ResourceStatePassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptor* MTL::ResourceStatePassSampleBufferAttachmentDescriptor::init()
+{
+    return NS::Object::init<MTL::ResourceStatePassSampleBufferAttachmentDescriptor>();
+}
+
+// property: sampleBuffer
+_MTL_INLINE MTL::CounterSampleBuffer* MTL::ResourceStatePassSampleBufferAttachmentDescriptor::sampleBuffer() const
+{
+    return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
+}
+
+_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
+}
+
+// property: startOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::ResourceStatePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex);
+}
+
+// property: endOfEncoderSampleIndex
+_MTL_INLINE NS::UInteger MTL::ResourceStatePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex));
+}
+
+_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray* MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray* MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::init()
+{
+    return NS::Object::init<MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptor* MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
+{
+    return Object::sendMessage<MTL::ResourceStatePassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::ResourceStatePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::ResourceStatePassDescriptor* MTL::ResourceStatePassDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::ResourceStatePassDescriptor>(_MTL_PRIVATE_CLS(MTLResourceStatePassDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::ResourceStatePassDescriptor* MTL::ResourceStatePassDescriptor::init()
+{
+    return NS::Object::init<MTL::ResourceStatePassDescriptor>();
+}
+
+// static method: resourceStatePassDescriptor
+_MTL_INLINE MTL::ResourceStatePassDescriptor* MTL::ResourceStatePassDescriptor::resourceStatePassDescriptor()
+{
+    return Object::sendMessage<MTL::ResourceStatePassDescriptor*>(_MTL_PRIVATE_CLS(MTLResourceStatePassDescriptor), _MTL_PRIVATE_SEL(resourceStatePassDescriptor));
+}
+
+// property: sampleBufferAttachments
+_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray* MTL::ResourceStatePassDescriptor::sampleBufferAttachments() const
+{
+    return Object::sendMessage<MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLSampler.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLSampler.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b086744a629bc1dfcc43cfa883e1dc10a2c239d3
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLSampler.hpp
@@ -0,0 +1,319 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLSampler.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLDepthStencil.hpp"
+#include "MTLSampler.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, SamplerMinMagFilter) {
+    SamplerMinMagFilterNearest = 0,
+    SamplerMinMagFilterLinear = 1,
+};
+
+_MTL_ENUM(NS::UInteger, SamplerMipFilter) {
+    SamplerMipFilterNotMipmapped = 0,
+    SamplerMipFilterNearest = 1,
+    SamplerMipFilterLinear = 2,
+};
+
+_MTL_ENUM(NS::UInteger, SamplerAddressMode) {
+    SamplerAddressModeClampToEdge = 0,
+    SamplerAddressModeMirrorClampToEdge = 1,
+    SamplerAddressModeRepeat = 2,
+    SamplerAddressModeMirrorRepeat = 3,
+    SamplerAddressModeClampToZero = 4,
+    SamplerAddressModeClampToBorderColor = 5,
+};
+
+_MTL_ENUM(NS::UInteger, SamplerBorderColor) {
+    SamplerBorderColorTransparentBlack = 0,
+    SamplerBorderColorOpaqueBlack = 1,
+    SamplerBorderColorOpaqueWhite = 2,
+};
+
+class SamplerDescriptor : public NS::Copying<SamplerDescriptor>
+{
+public:
+    static class SamplerDescriptor* alloc();
+
+    class SamplerDescriptor*        init();
+
+    MTL::SamplerMinMagFilter        minFilter() const;
+    void                            setMinFilter(MTL::SamplerMinMagFilter minFilter);
+
+    MTL::SamplerMinMagFilter        magFilter() const;
+    void                            setMagFilter(MTL::SamplerMinMagFilter magFilter);
+
+    MTL::SamplerMipFilter           mipFilter() const;
+    void                            setMipFilter(MTL::SamplerMipFilter mipFilter);
+
+    NS::UInteger                    maxAnisotropy() const;
+    void                            setMaxAnisotropy(NS::UInteger maxAnisotropy);
+
+    MTL::SamplerAddressMode         sAddressMode() const;
+    void                            setSAddressMode(MTL::SamplerAddressMode sAddressMode);
+
+    MTL::SamplerAddressMode         tAddressMode() const;
+    void                            setTAddressMode(MTL::SamplerAddressMode tAddressMode);
+
+    MTL::SamplerAddressMode         rAddressMode() const;
+    void                            setRAddressMode(MTL::SamplerAddressMode rAddressMode);
+
+    MTL::SamplerBorderColor         borderColor() const;
+    void                            setBorderColor(MTL::SamplerBorderColor borderColor);
+
+    bool                            normalizedCoordinates() const;
+    void                            setNormalizedCoordinates(bool normalizedCoordinates);
+
+    float                           lodMinClamp() const;
+    void                            setLodMinClamp(float lodMinClamp);
+
+    float                           lodMaxClamp() const;
+    void                            setLodMaxClamp(float lodMaxClamp);
+
+    bool                            lodAverage() const;
+    void                            setLodAverage(bool lodAverage);
+
+    MTL::CompareFunction            compareFunction() const;
+    void                            setCompareFunction(MTL::CompareFunction compareFunction);
+
+    bool                            supportArgumentBuffers() const;
+    void                            setSupportArgumentBuffers(bool supportArgumentBuffers);
+
+    NS::String*                     label() const;
+    void                            setLabel(const NS::String* label);
+};
+
+class SamplerState : public NS::Referencing<SamplerState>
+{
+public:
+    NS::String*     label() const;
+
+    class Device*   device() const;
+
+    MTL::ResourceID gpuResourceID() const;
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::SamplerDescriptor* MTL::SamplerDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::SamplerDescriptor>(_MTL_PRIVATE_CLS(MTLSamplerDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::SamplerDescriptor* MTL::SamplerDescriptor::init()
+{
+    return NS::Object::init<MTL::SamplerDescriptor>();
+}
+
+// property: minFilter
+_MTL_INLINE MTL::SamplerMinMagFilter MTL::SamplerDescriptor::minFilter() const
+{
+    return Object::sendMessage<MTL::SamplerMinMagFilter>(this, _MTL_PRIVATE_SEL(minFilter));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setMinFilter(MTL::SamplerMinMagFilter minFilter)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMinFilter_), minFilter);
+}
+
+// property: magFilter
+_MTL_INLINE MTL::SamplerMinMagFilter MTL::SamplerDescriptor::magFilter() const
+{
+    return Object::sendMessage<MTL::SamplerMinMagFilter>(this, _MTL_PRIVATE_SEL(magFilter));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setMagFilter(MTL::SamplerMinMagFilter magFilter)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMagFilter_), magFilter);
+}
+
+// property: mipFilter
+_MTL_INLINE MTL::SamplerMipFilter MTL::SamplerDescriptor::mipFilter() const
+{
+    return Object::sendMessage<MTL::SamplerMipFilter>(this, _MTL_PRIVATE_SEL(mipFilter));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setMipFilter(MTL::SamplerMipFilter mipFilter)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMipFilter_), mipFilter);
+}
+
+// property: maxAnisotropy
+_MTL_INLINE NS::UInteger MTL::SamplerDescriptor::maxAnisotropy() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxAnisotropy));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setMaxAnisotropy(NS::UInteger maxAnisotropy)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxAnisotropy_), maxAnisotropy);
+}
+
+// property: sAddressMode
+_MTL_INLINE MTL::SamplerAddressMode MTL::SamplerDescriptor::sAddressMode() const
+{
+    return Object::sendMessage<MTL::SamplerAddressMode>(this, _MTL_PRIVATE_SEL(sAddressMode));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setSAddressMode(MTL::SamplerAddressMode sAddressMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSAddressMode_), sAddressMode);
+}
+
+// property: tAddressMode
+_MTL_INLINE MTL::SamplerAddressMode MTL::SamplerDescriptor::tAddressMode() const
+{
+    return Object::sendMessage<MTL::SamplerAddressMode>(this, _MTL_PRIVATE_SEL(tAddressMode));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setTAddressMode(MTL::SamplerAddressMode tAddressMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTAddressMode_), tAddressMode);
+}
+
+// property: rAddressMode
+_MTL_INLINE MTL::SamplerAddressMode MTL::SamplerDescriptor::rAddressMode() const
+{
+    return Object::sendMessage<MTL::SamplerAddressMode>(this, _MTL_PRIVATE_SEL(rAddressMode));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setRAddressMode(MTL::SamplerAddressMode rAddressMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRAddressMode_), rAddressMode);
+}
+
+// property: borderColor
+_MTL_INLINE MTL::SamplerBorderColor MTL::SamplerDescriptor::borderColor() const
+{
+    return Object::sendMessage<MTL::SamplerBorderColor>(this, _MTL_PRIVATE_SEL(borderColor));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setBorderColor(MTL::SamplerBorderColor borderColor)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBorderColor_), borderColor);
+}
+
+// property: normalizedCoordinates
+_MTL_INLINE bool MTL::SamplerDescriptor::normalizedCoordinates() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(normalizedCoordinates));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setNormalizedCoordinates(bool normalizedCoordinates)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setNormalizedCoordinates_), normalizedCoordinates);
+}
+
+// property: lodMinClamp
+_MTL_INLINE float MTL::SamplerDescriptor::lodMinClamp() const
+{
+    return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(lodMinClamp));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setLodMinClamp(float lodMinClamp)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLodMinClamp_), lodMinClamp);
+}
+
+// property: lodMaxClamp
+_MTL_INLINE float MTL::SamplerDescriptor::lodMaxClamp() const
+{
+    return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(lodMaxClamp));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setLodMaxClamp(float lodMaxClamp)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLodMaxClamp_), lodMaxClamp);
+}
+
+// property: lodAverage
+_MTL_INLINE bool MTL::SamplerDescriptor::lodAverage() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(lodAverage));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setLodAverage(bool lodAverage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLodAverage_), lodAverage);
+}
+
+// property: compareFunction
+_MTL_INLINE MTL::CompareFunction MTL::SamplerDescriptor::compareFunction() const
+{
+    return Object::sendMessage<MTL::CompareFunction>(this, _MTL_PRIVATE_SEL(compareFunction));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setCompareFunction(MTL::CompareFunction compareFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCompareFunction_), compareFunction);
+}
+
+// property: supportArgumentBuffers
+_MTL_INLINE bool MTL::SamplerDescriptor::supportArgumentBuffers() const
+{
+    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportArgumentBuffers));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setSupportArgumentBuffers(bool supportArgumentBuffers)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportArgumentBuffers_), supportArgumentBuffers);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::SamplerDescriptor::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE void MTL::SamplerDescriptor::setLabel(const NS::String* label)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::SamplerState::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::SamplerState::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::SamplerState::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLStageInputOutputDescriptor.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLStageInputOutputDescriptor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..dbc3746718a6b4caecfcbb044a1b24049c6deb76
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLStageInputOutputDescriptor.hpp
@@ -0,0 +1,383 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLStageInputOutputDescriptor.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLStageInputOutputDescriptor.hpp"
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, AttributeFormat) {
+    AttributeFormatInvalid = 0,
+    AttributeFormatUChar2 = 1,
+    AttributeFormatUChar3 = 2,
+    AttributeFormatUChar4 = 3,
+    AttributeFormatChar2 = 4,
+    AttributeFormatChar3 = 5,
+    AttributeFormatChar4 = 6,
+    AttributeFormatUChar2Normalized = 7,
+    AttributeFormatUChar3Normalized = 8,
+    AttributeFormatUChar4Normalized = 9,
+    AttributeFormatChar2Normalized = 10,
+    AttributeFormatChar3Normalized = 11,
+    AttributeFormatChar4Normalized = 12,
+    AttributeFormatUShort2 = 13,
+    AttributeFormatUShort3 = 14,
+    AttributeFormatUShort4 = 15,
+    AttributeFormatShort2 = 16,
+    AttributeFormatShort3 = 17,
+    AttributeFormatShort4 = 18,
+    AttributeFormatUShort2Normalized = 19,
+    AttributeFormatUShort3Normalized = 20,
+    AttributeFormatUShort4Normalized = 21,
+    AttributeFormatShort2Normalized = 22,
+    AttributeFormatShort3Normalized = 23,
+    AttributeFormatShort4Normalized = 24,
+    AttributeFormatHalf2 = 25,
+    AttributeFormatHalf3 = 26,
+    AttributeFormatHalf4 = 27,
+    AttributeFormatFloat = 28,
+    AttributeFormatFloat2 = 29,
+    AttributeFormatFloat3 = 30,
+    AttributeFormatFloat4 = 31,
+    AttributeFormatInt = 32,
+    AttributeFormatInt2 = 33,
+    AttributeFormatInt3 = 34,
+    AttributeFormatInt4 = 35,
+    AttributeFormatUInt = 36,
+    AttributeFormatUInt2 = 37,
+    AttributeFormatUInt3 = 38,
+    AttributeFormatUInt4 = 39,
+    AttributeFormatInt1010102Normalized = 40,
+    AttributeFormatUInt1010102Normalized = 41,
+    AttributeFormatUChar4Normalized_BGRA = 42,
+    AttributeFormatUChar = 45,
+    AttributeFormatChar = 46,
+    AttributeFormatUCharNormalized = 47,
+    AttributeFormatCharNormalized = 48,
+    AttributeFormatUShort = 49,
+    AttributeFormatShort = 50,
+    AttributeFormatUShortNormalized = 51,
+    AttributeFormatShortNormalized = 52,
+    AttributeFormatHalf = 53,
+    AttributeFormatFloatRG11B10 = 54,
+    AttributeFormatFloatRGB9E5 = 55,
+};
+
+_MTL_ENUM(NS::UInteger, IndexType) {
+    IndexTypeUInt16 = 0,
+    IndexTypeUInt32 = 1,
+};
+
+_MTL_ENUM(NS::UInteger, StepFunction) {
+    StepFunctionConstant = 0,
+    StepFunctionPerVertex = 1,
+    StepFunctionPerInstance = 2,
+    StepFunctionPerPatch = 3,
+    StepFunctionPerPatchControlPoint = 4,
+    StepFunctionThreadPositionInGridX = 5,
+    StepFunctionThreadPositionInGridY = 6,
+    StepFunctionThreadPositionInGridXIndexed = 7,
+    StepFunctionThreadPositionInGridYIndexed = 8,
+};
+
+class BufferLayoutDescriptor : public NS::Copying<BufferLayoutDescriptor>
+{
+public:
+    static class BufferLayoutDescriptor* alloc();
+
+    class BufferLayoutDescriptor*        init();
+
+    NS::UInteger                         stride() const;
+    void                                 setStride(NS::UInteger stride);
+
+    MTL::StepFunction                    stepFunction() const;
+    void                                 setStepFunction(MTL::StepFunction stepFunction);
+
+    NS::UInteger                         stepRate() const;
+    void                                 setStepRate(NS::UInteger stepRate);
+};
+
+class BufferLayoutDescriptorArray : public NS::Referencing<BufferLayoutDescriptorArray>
+{
+public:
+    static class BufferLayoutDescriptorArray* alloc();
+
+    class BufferLayoutDescriptorArray*        init();
+
+    class BufferLayoutDescriptor*             object(NS::UInteger index);
+
+    void                                      setObject(const class BufferLayoutDescriptor* bufferDesc, NS::UInteger index);
+};
+
+class AttributeDescriptor : public NS::Copying<AttributeDescriptor>
+{
+public:
+    static class AttributeDescriptor* alloc();
+
+    class AttributeDescriptor*        init();
+
+    MTL::AttributeFormat              format() const;
+    void                              setFormat(MTL::AttributeFormat format);
+
+    NS::UInteger                      offset() const;
+    void                              setOffset(NS::UInteger offset);
+
+    NS::UInteger                      bufferIndex() const;
+    void                              setBufferIndex(NS::UInteger bufferIndex);
+};
+
+class AttributeDescriptorArray : public NS::Referencing<AttributeDescriptorArray>
+{
+public:
+    static class AttributeDescriptorArray* alloc();
+
+    class AttributeDescriptorArray*        init();
+
+    class AttributeDescriptor*             object(NS::UInteger index);
+
+    void                                   setObject(const class AttributeDescriptor* attributeDesc, NS::UInteger index);
+};
+
+class StageInputOutputDescriptor : public NS::Copying<StageInputOutputDescriptor>
+{
+public:
+    static class StageInputOutputDescriptor* alloc();
+
+    class StageInputOutputDescriptor*        init();
+
+    static class StageInputOutputDescriptor* stageInputOutputDescriptor();
+
+    class BufferLayoutDescriptorArray*       layouts() const;
+
+    class AttributeDescriptorArray*          attributes() const;
+
+    MTL::IndexType                           indexType() const;
+    void                                     setIndexType(MTL::IndexType indexType);
+
+    NS::UInteger                             indexBufferIndex() const;
+    void                                     setIndexBufferIndex(NS::UInteger indexBufferIndex);
+
+    void                                     reset();
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::BufferLayoutDescriptor* MTL::BufferLayoutDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::BufferLayoutDescriptor>(_MTL_PRIVATE_CLS(MTLBufferLayoutDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::BufferLayoutDescriptor* MTL::BufferLayoutDescriptor::init()
+{
+    return NS::Object::init<MTL::BufferLayoutDescriptor>();
+}
+
+// property: stride
+_MTL_INLINE NS::UInteger MTL::BufferLayoutDescriptor::stride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(stride));
+}
+
+_MTL_INLINE void MTL::BufferLayoutDescriptor::setStride(NS::UInteger stride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStride_), stride);
+}
+
+// property: stepFunction
+_MTL_INLINE MTL::StepFunction MTL::BufferLayoutDescriptor::stepFunction() const
+{
+    return Object::sendMessage<MTL::StepFunction>(this, _MTL_PRIVATE_SEL(stepFunction));
+}
+
+_MTL_INLINE void MTL::BufferLayoutDescriptor::setStepFunction(MTL::StepFunction stepFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStepFunction_), stepFunction);
+}
+
+// property: stepRate
+_MTL_INLINE NS::UInteger MTL::BufferLayoutDescriptor::stepRate() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(stepRate));
+}
+
+_MTL_INLINE void MTL::BufferLayoutDescriptor::setStepRate(NS::UInteger stepRate)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStepRate_), stepRate);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::BufferLayoutDescriptorArray* MTL::BufferLayoutDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::BufferLayoutDescriptorArray>(_MTL_PRIVATE_CLS(MTLBufferLayoutDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::BufferLayoutDescriptorArray* MTL::BufferLayoutDescriptorArray::init()
+{
+    return NS::Object::init<MTL::BufferLayoutDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::BufferLayoutDescriptor* MTL::BufferLayoutDescriptorArray::object(NS::UInteger index)
+{
+    return Object::sendMessage<MTL::BufferLayoutDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::BufferLayoutDescriptorArray::setObject(const MTL::BufferLayoutDescriptor* bufferDesc, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), bufferDesc, index);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AttributeDescriptor* MTL::AttributeDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::AttributeDescriptor>(_MTL_PRIVATE_CLS(MTLAttributeDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::AttributeDescriptor* MTL::AttributeDescriptor::init()
+{
+    return NS::Object::init<MTL::AttributeDescriptor>();
+}
+
+// property: format
+_MTL_INLINE MTL::AttributeFormat MTL::AttributeDescriptor::format() const
+{
+    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(format));
+}
+
+_MTL_INLINE void MTL::AttributeDescriptor::setFormat(MTL::AttributeFormat format)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFormat_), format);
+}
+
+// property: offset
+_MTL_INLINE NS::UInteger MTL::AttributeDescriptor::offset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(offset));
+}
+
+_MTL_INLINE void MTL::AttributeDescriptor::setOffset(NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOffset_), offset);
+}
+
+// property: bufferIndex
+_MTL_INLINE NS::UInteger MTL::AttributeDescriptor::bufferIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferIndex));
+}
+
+_MTL_INLINE void MTL::AttributeDescriptor::setBufferIndex(NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBufferIndex_), bufferIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::AttributeDescriptorArray* MTL::AttributeDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::AttributeDescriptorArray>(_MTL_PRIVATE_CLS(MTLAttributeDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::AttributeDescriptorArray* MTL::AttributeDescriptorArray::init()
+{
+    return NS::Object::init<MTL::AttributeDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::AttributeDescriptor* MTL::AttributeDescriptorArray::object(NS::UInteger index)
+{
+    return Object::sendMessage<MTL::AttributeDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::AttributeDescriptorArray::setObject(const MTL::AttributeDescriptor* attributeDesc, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attributeDesc, index);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::StageInputOutputDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::StageInputOutputDescriptor>(_MTL_PRIVATE_CLS(MTLStageInputOutputDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::StageInputOutputDescriptor::init()
+{
+    return NS::Object::init<MTL::StageInputOutputDescriptor>();
+}
+
+// static method: stageInputOutputDescriptor
+_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::StageInputOutputDescriptor::stageInputOutputDescriptor()
+{
+    return Object::sendMessage<MTL::StageInputOutputDescriptor*>(_MTL_PRIVATE_CLS(MTLStageInputOutputDescriptor), _MTL_PRIVATE_SEL(stageInputOutputDescriptor));
+}
+
+// property: layouts
+_MTL_INLINE MTL::BufferLayoutDescriptorArray* MTL::StageInputOutputDescriptor::layouts() const
+{
+    return Object::sendMessage<MTL::BufferLayoutDescriptorArray*>(this, _MTL_PRIVATE_SEL(layouts));
+}
+
+// property: attributes
+_MTL_INLINE MTL::AttributeDescriptorArray* MTL::StageInputOutputDescriptor::attributes() const
+{
+    return Object::sendMessage<MTL::AttributeDescriptorArray*>(this, _MTL_PRIVATE_SEL(attributes));
+}
+
+// property: indexType
+_MTL_INLINE MTL::IndexType MTL::StageInputOutputDescriptor::indexType() const
+{
+    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
+}
+
+_MTL_INLINE void MTL::StageInputOutputDescriptor::setIndexType(MTL::IndexType indexType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
+}
+
+// property: indexBufferIndex
+_MTL_INLINE NS::UInteger MTL::StageInputOutputDescriptor::indexBufferIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferIndex));
+}
+
+_MTL_INLINE void MTL::StageInputOutputDescriptor::setIndexBufferIndex(NS::UInteger indexBufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferIndex_), indexBufferIndex);
+}
+
+// method: reset
+_MTL_INLINE void MTL::StageInputOutputDescriptor::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLTexture.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLTexture.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..15898f40464d32ba7ea9e1f0b7ebaae364f41cf5
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLTexture.hpp
@@ -0,0 +1,685 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLTexture.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLPixelFormat.hpp"
+#include "MTLResource.hpp"
+#include "MTLTexture.hpp"
+#include "MTLTypes.hpp"
+#include <IOSurface/IOSurfaceRef.h>
+
+namespace MTL
+{
+_MTL_ENUM(NS::UInteger, TextureType) {
+    TextureType1D = 0,
+    TextureType1DArray = 1,
+    TextureType2D = 2,
+    TextureType2DArray = 3,
+    TextureType2DMultisample = 4,
+    TextureTypeCube = 5,
+    TextureTypeCubeArray = 6,
+    TextureType3D = 7,
+    TextureType2DMultisampleArray = 8,
+    TextureTypeTextureBuffer = 9,
+};
+
+_MTL_ENUM(uint8_t, TextureSwizzle) {
+    TextureSwizzleZero = 0,
+    TextureSwizzleOne = 1,
+    TextureSwizzleRed = 2,
+    TextureSwizzleGreen = 3,
+    TextureSwizzleBlue = 4,
+    TextureSwizzleAlpha = 5,
+};
+
+struct TextureSwizzleChannels
+{
+    MTL::TextureSwizzle red;
+    MTL::TextureSwizzle green;
+    MTL::TextureSwizzle blue;
+    MTL::TextureSwizzle alpha;
+} _MTL_PACKED;
+
+class SharedTextureHandle : public NS::SecureCoding<SharedTextureHandle>
+{
+public:
+    static class SharedTextureHandle* alloc();
+
+    class SharedTextureHandle*        init();
+
+    class Device*                     device() const;
+
+    NS::String*                       label() const;
+};
+
+_MTL_OPTIONS(NS::UInteger, TextureUsage) {
+    TextureUsageUnknown = 0,
+    TextureUsageShaderRead = 1,
+    TextureUsageShaderWrite = 2,
+    TextureUsageRenderTarget = 4,
+    TextureUsagePixelFormatView = 16,
+    TextureUsageShaderAtomic = 32,
+};
+
+_MTL_ENUM(NS::Integer, TextureCompressionType) {
+    TextureCompressionTypeLossless = 0,
+    TextureCompressionTypeLossy = 1,
+};
+
+class TextureDescriptor : public NS::Copying<TextureDescriptor>
+{
+public:
+    static class TextureDescriptor* alloc();
+
+    class TextureDescriptor*        init();
+
+    static class TextureDescriptor* texture2DDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, NS::UInteger height, bool mipmapped);
+
+    static class TextureDescriptor* textureCubeDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger size, bool mipmapped);
+
+    static class TextureDescriptor* textureBufferDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, MTL::ResourceOptions resourceOptions, MTL::TextureUsage usage);
+
+    MTL::TextureType                textureType() const;
+    void                            setTextureType(MTL::TextureType textureType);
+
+    MTL::PixelFormat                pixelFormat() const;
+    void                            setPixelFormat(MTL::PixelFormat pixelFormat);
+
+    NS::UInteger                    width() const;
+    void                            setWidth(NS::UInteger width);
+
+    NS::UInteger                    height() const;
+    void                            setHeight(NS::UInteger height);
+
+    NS::UInteger                    depth() const;
+    void                            setDepth(NS::UInteger depth);
+
+    NS::UInteger                    mipmapLevelCount() const;
+    void                            setMipmapLevelCount(NS::UInteger mipmapLevelCount);
+
+    NS::UInteger                    sampleCount() const;
+    void                            setSampleCount(NS::UInteger sampleCount);
+
+    NS::UInteger                    arrayLength() const;
+    void                            setArrayLength(NS::UInteger arrayLength);
+
+    MTL::ResourceOptions            resourceOptions() const;
+    void                            setResourceOptions(MTL::ResourceOptions resourceOptions);
+
+    MTL::CPUCacheMode               cpuCacheMode() const;
+    void                            setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode);
+
+    MTL::StorageMode                storageMode() const;
+    void                            setStorageMode(MTL::StorageMode storageMode);
+
+    MTL::HazardTrackingMode         hazardTrackingMode() const;
+    void                            setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode);
+
+    MTL::TextureUsage               usage() const;
+    void                            setUsage(MTL::TextureUsage usage);
+
+    bool                            allowGPUOptimizedContents() const;
+    void                            setAllowGPUOptimizedContents(bool allowGPUOptimizedContents);
+
+    MTL::TextureCompressionType     compressionType() const;
+    void                            setCompressionType(MTL::TextureCompressionType compressionType);
+
+    MTL::TextureSwizzleChannels     swizzle() const;
+    void                            setSwizzle(MTL::TextureSwizzleChannels swizzle);
+};
+
+class Texture : public NS::Referencing<Texture, Resource>
+{
+public:
+    class Resource*             rootResource() const;
+
+    class Texture*              parentTexture() const;
+
+    NS::UInteger                parentRelativeLevel() const;
+
+    NS::UInteger                parentRelativeSlice() const;
+
+    class Buffer*               buffer() const;
+
+    NS::UInteger                bufferOffset() const;
+
+    NS::UInteger                bufferBytesPerRow() const;
+
+    IOSurfaceRef                iosurface() const;
+
+    NS::UInteger                iosurfacePlane() const;
+
+    MTL::TextureType            textureType() const;
+
+    MTL::PixelFormat            pixelFormat() const;
+
+    NS::UInteger                width() const;
+
+    NS::UInteger                height() const;
+
+    NS::UInteger                depth() const;
+
+    NS::UInteger                mipmapLevelCount() const;
+
+    NS::UInteger                sampleCount() const;
+
+    NS::UInteger                arrayLength() const;
+
+    MTL::TextureUsage           usage() const;
+
+    bool                        shareable() const;
+
+    bool                        framebufferOnly() const;
+
+    NS::UInteger                firstMipmapInTail() const;
+
+    NS::UInteger                tailSizeInBytes() const;
+
+    bool                        isSparse() const;
+
+    bool                        allowGPUOptimizedContents() const;
+
+    MTL::TextureCompressionType compressionType() const;
+
+    MTL::ResourceID             gpuResourceID() const;
+
+    void                        getBytes(const void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage, MTL::Region region, NS::UInteger level, NS::UInteger slice);
+
+    void                        replaceRegion(MTL::Region region, NS::UInteger level, NS::UInteger slice, const void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage);
+
+    void                        getBytes(const void* pixelBytes, NS::UInteger bytesPerRow, MTL::Region region, NS::UInteger level);
+
+    void                        replaceRegion(MTL::Region region, NS::UInteger level, const void* pixelBytes, NS::UInteger bytesPerRow);
+
+    class Texture*              newTextureView(MTL::PixelFormat pixelFormat);
+
+    class Texture*              newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange);
+
+    class SharedTextureHandle*  newSharedTextureHandle();
+
+    class Texture*              remoteStorageTexture() const;
+
+    class Texture*              newRemoteTextureViewForDevice(const class Device* device);
+
+    MTL::TextureSwizzleChannels swizzle() const;
+
+    class Texture*              newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange, MTL::TextureSwizzleChannels swizzle);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::SharedTextureHandle* MTL::SharedTextureHandle::alloc()
+{
+    return NS::Object::alloc<MTL::SharedTextureHandle>(_MTL_PRIVATE_CLS(MTLSharedTextureHandle));
+}
+
+// method: init
+_MTL_INLINE MTL::SharedTextureHandle* MTL::SharedTextureHandle::init()
+{
+    return NS::Object::init<MTL::SharedTextureHandle>();
+}
+
+// property: device
+_MTL_INLINE MTL::Device* MTL::SharedTextureHandle::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
+}
+
+// property: label
+_MTL_INLINE NS::String* MTL::SharedTextureHandle::label() const
+{
+    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
+}
+
+// static method: alloc
+_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::TextureDescriptor>(_MTL_PRIVATE_CLS(MTLTextureDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::init()
+{
+    return NS::Object::init<MTL::TextureDescriptor>();
+}
+
+// static method: texture2DDescriptorWithPixelFormat:width:height:mipmapped:
+_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::texture2DDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, NS::UInteger height, bool mipmapped)
+{
+    return Object::sendMessage<MTL::TextureDescriptor*>(_MTL_PRIVATE_CLS(MTLTextureDescriptor), _MTL_PRIVATE_SEL(texture2DDescriptorWithPixelFormat_width_height_mipmapped_), pixelFormat, width, height, mipmapped);
+}
+
+// static method: textureCubeDescriptorWithPixelFormat:size:mipmapped:
+_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::textureCubeDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger size, bool mipmapped)
+{
+    return Object::sendMessage<MTL::TextureDescriptor*>(_MTL_PRIVATE_CLS(MTLTextureDescriptor), _MTL_PRIVATE_SEL(textureCubeDescriptorWithPixelFormat_size_mipmapped_), pixelFormat, size, mipmapped);
+}
+
+// static method: textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:
+_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::textureBufferDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, MTL::ResourceOptions resourceOptions, MTL::TextureUsage usage)
+{
+    return Object::sendMessage<MTL::TextureDescriptor*>(_MTL_PRIVATE_CLS(MTLTextureDescriptor), _MTL_PRIVATE_SEL(textureBufferDescriptorWithPixelFormat_width_resourceOptions_usage_), pixelFormat, width, resourceOptions, usage);
+}
+
+// property: textureType
+_MTL_INLINE MTL::TextureType MTL::TextureDescriptor::textureType() const
+{
+    return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setTextureType(MTL::TextureType textureType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTextureType_), textureType);
+}
+
+// property: pixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::TextureDescriptor::pixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(pixelFormat));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat);
+}
+
+// property: width
+_MTL_INLINE NS::UInteger MTL::TextureDescriptor::width() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(width));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setWidth(NS::UInteger width)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setWidth_), width);
+}
+
+// property: height
+_MTL_INLINE NS::UInteger MTL::TextureDescriptor::height() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(height));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setHeight(NS::UInteger height)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setHeight_), height);
+}
+
+// property: depth
+_MTL_INLINE NS::UInteger MTL::TextureDescriptor::depth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(depth));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setDepth(NS::UInteger depth)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepth_), depth);
+}
+
+// property: mipmapLevelCount
+_MTL_INLINE NS::UInteger MTL::TextureDescriptor::mipmapLevelCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(mipmapLevelCount));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setMipmapLevelCount(NS::UInteger mipmapLevelCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMipmapLevelCount_), mipmapLevelCount);
+}
+
+// property: sampleCount
+_MTL_INLINE NS::UInteger MTL::TextureDescriptor::sampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setSampleCount(NS::UInteger sampleCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount);
+}
+
+// property: arrayLength
+_MTL_INLINE NS::UInteger MTL::TextureDescriptor::arrayLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setArrayLength(NS::UInteger arrayLength)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setArrayLength_), arrayLength);
+}
+
+// property: resourceOptions
+_MTL_INLINE MTL::ResourceOptions MTL::TextureDescriptor::resourceOptions() const
+{
+    return Object::sendMessage<MTL::ResourceOptions>(this, _MTL_PRIVATE_SEL(resourceOptions));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setResourceOptions(MTL::ResourceOptions resourceOptions)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResourceOptions_), resourceOptions);
+}
+
+// property: cpuCacheMode
+_MTL_INLINE MTL::CPUCacheMode MTL::TextureDescriptor::cpuCacheMode() const
+{
+    return Object::sendMessage<MTL::CPUCacheMode>(this, _MTL_PRIVATE_SEL(cpuCacheMode));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCpuCacheMode_), cpuCacheMode);
+}
+
+// property: storageMode
+_MTL_INLINE MTL::StorageMode MTL::TextureDescriptor::storageMode() const
+{
+    return Object::sendMessage<MTL::StorageMode>(this, _MTL_PRIVATE_SEL(storageMode));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setStorageMode(MTL::StorageMode storageMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode);
+}
+
+// property: hazardTrackingMode
+_MTL_INLINE MTL::HazardTrackingMode MTL::TextureDescriptor::hazardTrackingMode() const
+{
+    return Object::sendMessage<MTL::HazardTrackingMode>(this, _MTL_PRIVATE_SEL(hazardTrackingMode));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setHazardTrackingMode_), hazardTrackingMode);
+}
+
+// property: usage
+_MTL_INLINE MTL::TextureUsage MTL::TextureDescriptor::usage() const
+{
+    return Object::sendMessage<MTL::TextureUsage>(this, _MTL_PRIVATE_SEL(usage));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setUsage(MTL::TextureUsage usage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setUsage_), usage);
+}
+
+// property: allowGPUOptimizedContents
+_MTL_INLINE bool MTL::TextureDescriptor::allowGPUOptimizedContents() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(allowGPUOptimizedContents));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setAllowGPUOptimizedContents(bool allowGPUOptimizedContents)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAllowGPUOptimizedContents_), allowGPUOptimizedContents);
+}
+
+// property: compressionType
+_MTL_INLINE MTL::TextureCompressionType MTL::TextureDescriptor::compressionType() const
+{
+    return Object::sendMessage<MTL::TextureCompressionType>(this, _MTL_PRIVATE_SEL(compressionType));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setCompressionType(MTL::TextureCompressionType compressionType)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCompressionType_), compressionType);
+}
+
+// property: swizzle
+_MTL_INLINE MTL::TextureSwizzleChannels MTL::TextureDescriptor::swizzle() const
+{
+    return Object::sendMessage<MTL::TextureSwizzleChannels>(this, _MTL_PRIVATE_SEL(swizzle));
+}
+
+_MTL_INLINE void MTL::TextureDescriptor::setSwizzle(MTL::TextureSwizzleChannels swizzle)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSwizzle_), swizzle);
+}
+
+// property: rootResource
+_MTL_INLINE MTL::Resource* MTL::Texture::rootResource() const
+{
+    return Object::sendMessage<MTL::Resource*>(this, _MTL_PRIVATE_SEL(rootResource));
+}
+
+// property: parentTexture
+_MTL_INLINE MTL::Texture* MTL::Texture::parentTexture() const
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(parentTexture));
+}
+
+// property: parentRelativeLevel
+_MTL_INLINE NS::UInteger MTL::Texture::parentRelativeLevel() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(parentRelativeLevel));
+}
+
+// property: parentRelativeSlice
+_MTL_INLINE NS::UInteger MTL::Texture::parentRelativeSlice() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(parentRelativeSlice));
+}
+
+// property: buffer
+_MTL_INLINE MTL::Buffer* MTL::Texture::buffer() const
+{
+    return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(buffer));
+}
+
+// property: bufferOffset
+_MTL_INLINE NS::UInteger MTL::Texture::bufferOffset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferOffset));
+}
+
+// property: bufferBytesPerRow
+_MTL_INLINE NS::UInteger MTL::Texture::bufferBytesPerRow() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferBytesPerRow));
+}
+
+// property: iosurface
+_MTL_INLINE IOSurfaceRef MTL::Texture::iosurface() const
+{
+    return Object::sendMessage<IOSurfaceRef>(this, _MTL_PRIVATE_SEL(iosurface));
+}
+
+// property: iosurfacePlane
+_MTL_INLINE NS::UInteger MTL::Texture::iosurfacePlane() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(iosurfacePlane));
+}
+
+// property: textureType
+_MTL_INLINE MTL::TextureType MTL::Texture::textureType() const
+{
+    return Object::sendMessage<MTL::TextureType>(this, _MTL_PRIVATE_SEL(textureType));
+}
+
+// property: pixelFormat
+_MTL_INLINE MTL::PixelFormat MTL::Texture::pixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(pixelFormat));
+}
+
+// property: width
+_MTL_INLINE NS::UInteger MTL::Texture::width() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(width));
+}
+
+// property: height
+_MTL_INLINE NS::UInteger MTL::Texture::height() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(height));
+}
+
+// property: depth
+_MTL_INLINE NS::UInteger MTL::Texture::depth() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(depth));
+}
+
+// property: mipmapLevelCount
+_MTL_INLINE NS::UInteger MTL::Texture::mipmapLevelCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(mipmapLevelCount));
+}
+
+// property: sampleCount
+_MTL_INLINE NS::UInteger MTL::Texture::sampleCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
+}
+
+// property: arrayLength
+_MTL_INLINE NS::UInteger MTL::Texture::arrayLength() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(arrayLength));
+}
+
+// property: usage
+_MTL_INLINE MTL::TextureUsage MTL::Texture::usage() const
+{
+    return Object::sendMessage<MTL::TextureUsage>(this, _MTL_PRIVATE_SEL(usage));
+}
+
+// property: shareable
+_MTL_INLINE bool MTL::Texture::shareable() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isShareable));
+}
+
+// property: framebufferOnly
+_MTL_INLINE bool MTL::Texture::framebufferOnly() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isFramebufferOnly));
+}
+
+// property: firstMipmapInTail
+_MTL_INLINE NS::UInteger MTL::Texture::firstMipmapInTail() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(firstMipmapInTail));
+}
+
+// property: tailSizeInBytes
+_MTL_INLINE NS::UInteger MTL::Texture::tailSizeInBytes() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tailSizeInBytes));
+}
+
+// property: isSparse
+_MTL_INLINE bool MTL::Texture::isSparse() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isSparse));
+}
+
+// property: allowGPUOptimizedContents
+_MTL_INLINE bool MTL::Texture::allowGPUOptimizedContents() const
+{
+    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(allowGPUOptimizedContents));
+}
+
+// property: compressionType
+_MTL_INLINE MTL::TextureCompressionType MTL::Texture::compressionType() const
+{
+    return Object::sendMessage<MTL::TextureCompressionType>(this, _MTL_PRIVATE_SEL(compressionType));
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::Texture::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
+
+// method: getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:
+_MTL_INLINE void MTL::Texture::getBytes(const void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage, MTL::Region region, NS::UInteger level, NS::UInteger slice)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_), pixelBytes, bytesPerRow, bytesPerImage, region, level, slice);
+}
+
+// method: replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:
+_MTL_INLINE void MTL::Texture::replaceRegion(MTL::Region region, NS::UInteger level, NS::UInteger slice, const void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_), region, level, slice, pixelBytes, bytesPerRow, bytesPerImage);
+}
+
+// method: getBytes:bytesPerRow:fromRegion:mipmapLevel:
+_MTL_INLINE void MTL::Texture::getBytes(const void* pixelBytes, NS::UInteger bytesPerRow, MTL::Region region, NS::UInteger level)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(getBytes_bytesPerRow_fromRegion_mipmapLevel_), pixelBytes, bytesPerRow, region, level);
+}
+
+// method: replaceRegion:mipmapLevel:withBytes:bytesPerRow:
+_MTL_INLINE void MTL::Texture::replaceRegion(MTL::Region region, NS::UInteger level, const void* pixelBytes, NS::UInteger bytesPerRow)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(replaceRegion_mipmapLevel_withBytes_bytesPerRow_), region, level, pixelBytes, bytesPerRow);
+}
+
+// method: newTextureViewWithPixelFormat:
+_MTL_INLINE MTL::Texture* MTL::Texture::newTextureView(MTL::PixelFormat pixelFormat)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureViewWithPixelFormat_), pixelFormat);
+}
+
+// method: newTextureViewWithPixelFormat:textureType:levels:slices:
+_MTL_INLINE MTL::Texture* MTL::Texture::newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_), pixelFormat, textureType, levelRange, sliceRange);
+}
+
+// method: newSharedTextureHandle
+_MTL_INLINE MTL::SharedTextureHandle* MTL::Texture::newSharedTextureHandle()
+{
+    return Object::sendMessage<MTL::SharedTextureHandle*>(this, _MTL_PRIVATE_SEL(newSharedTextureHandle));
+}
+
+// property: remoteStorageTexture
+_MTL_INLINE MTL::Texture* MTL::Texture::remoteStorageTexture() const
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(remoteStorageTexture));
+}
+
+// method: newRemoteTextureViewForDevice:
+_MTL_INLINE MTL::Texture* MTL::Texture::newRemoteTextureViewForDevice(const MTL::Device* device)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newRemoteTextureViewForDevice_), device);
+}
+
+// property: swizzle
+_MTL_INLINE MTL::TextureSwizzleChannels MTL::Texture::swizzle() const
+{
+    return Object::sendMessage<MTL::TextureSwizzleChannels>(this, _MTL_PRIVATE_SEL(swizzle));
+}
+
+// method: newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:
+_MTL_INLINE MTL::Texture* MTL::Texture::newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange, MTL::TextureSwizzleChannels swizzle)
+{
+    return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_), pixelFormat, textureType, levelRange, sliceRange, swizzle);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLTypes.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLTypes.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..09a81840c296ce97d41669e8356695aa7111ef77
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLTypes.hpp
@@ -0,0 +1,168 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLTypes.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+struct Origin
+{
+    Origin() = default;
+
+    Origin(NS::UInteger x, NS::UInteger y, NS::UInteger z);
+
+    static Origin Make(NS::UInteger x, NS::UInteger y, NS::UInteger z);
+
+    NS::UInteger  x;
+    NS::UInteger  y;
+    NS::UInteger  z;
+} _MTL_PACKED;
+
+struct Size
+{
+    Size() = default;
+
+    Size(NS::UInteger width, NS::UInteger height, NS::UInteger depth);
+
+    static Size  Make(NS::UInteger width, NS::UInteger height, NS::UInteger depth);
+
+    NS::UInteger width;
+    NS::UInteger height;
+    NS::UInteger depth;
+} _MTL_PACKED;
+
+struct Region
+{
+    Region() = default;
+
+    Region(NS::UInteger x, NS::UInteger width);
+
+    Region(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height);
+
+    Region(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth);
+
+    static Region Make1D(NS::UInteger x, NS::UInteger width);
+
+    static Region Make2D(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height);
+
+    static Region Make3D(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth);
+
+    MTL::Origin   origin;
+    MTL::Size     size;
+} _MTL_PACKED;
+
+struct SamplePosition;
+
+using Coordinate2D = SamplePosition;
+
+struct SamplePosition
+{
+    SamplePosition() = default;
+
+    SamplePosition(float _x, float _y);
+
+    static SamplePosition Make(float x, float y);
+
+    float                 x;
+    float                 y;
+} _MTL_PACKED;
+
+struct ResourceID
+{
+    uint64_t _impl;
+} _MTL_PACKED;
+
+}
+
+_MTL_INLINE MTL::Origin::Origin(NS::UInteger _x, NS::UInteger _y, NS::UInteger _z)
+    : x(_x)
+    , y(_y)
+    , z(_z)
+{
+}
+
+_MTL_INLINE MTL::Origin MTL::Origin::Make(NS::UInteger x, NS::UInteger y, NS::UInteger z)
+{
+    return Origin(x, y, z);
+}
+
+_MTL_INLINE MTL::Size::Size(NS::UInteger _width, NS::UInteger _height, NS::UInteger _depth)
+    : width(_width)
+    , height(_height)
+    , depth(_depth)
+{
+}
+
+_MTL_INLINE MTL::Size MTL::Size::Make(NS::UInteger width, NS::UInteger height, NS::UInteger depth)
+{
+    return Size(width, height, depth);
+}
+
+_MTL_INLINE MTL::Region::Region(NS::UInteger x, NS::UInteger width)
+    : origin(x, 0, 0)
+    , size(width, 1, 1)
+{
+}
+
+_MTL_INLINE MTL::Region::Region(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height)
+    : origin(x, y, 0)
+    , size(width, height, 1)
+{
+}
+
+_MTL_INLINE MTL::Region::Region(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth)
+    : origin(x, y, z)
+    , size(width, height, depth)
+{
+}
+
+_MTL_INLINE MTL::Region MTL::Region::Make1D(NS::UInteger x, NS::UInteger width)
+{
+    return Region(x, width);
+}
+
+_MTL_INLINE MTL::Region MTL::Region::Make2D(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height)
+{
+    return Region(x, y, width, height);
+}
+
+_MTL_INLINE MTL::Region MTL::Region::Make3D(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth)
+{
+    return Region(x, y, z, width, height, depth);
+}
+
+_MTL_INLINE MTL::SamplePosition::SamplePosition(float _x, float _y)
+    : x(_x)
+    , y(_y)
+{
+}
+
+_MTL_INLINE MTL::SamplePosition MTL::SamplePosition::Make(float x, float y)
+{
+    return SamplePosition(x, y);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVersion.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVersion.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5926b6b551c65c5cd016bdd3cea458109de49945
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVersion.hpp
@@ -0,0 +1,32 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLVersion.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define METALCPP_VERSION_MAJOR 341
+#define METALCPP_VERSION_MINOR 0
+#define METALCPP_VERSION_PATCH 0
+
+#define METALCPP_SUPPORTS_VERSION(major, minor, patch) \
+    ((major < METALCPP_VERSION_MAJOR) || \
+    (major == METALCPP_VERSION_MAJOR && minor < METALCPP_VERSION_MINOR) || \
+    (major == METALCPP_VERSION_MAJOR && minor == METALCPP_VERSION_MINOR && patch <= METALCPP_VERSION_PATCH))
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVertexDescriptor.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVertexDescriptor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e92b55117beff9f15fa180497c5bb39a408863f
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVertexDescriptor.hpp
@@ -0,0 +1,349 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLVertexDescriptor.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLVertexDescriptor.hpp"
+
+namespace MTL
+{
+
+static const NS::UInteger BufferLayoutStrideDynamic = NS::UIntegerMax;
+
+_MTL_ENUM(NS::UInteger, VertexFormat) {
+    VertexFormatInvalid = 0,
+    VertexFormatUChar2 = 1,
+    VertexFormatUChar3 = 2,
+    VertexFormatUChar4 = 3,
+    VertexFormatChar2 = 4,
+    VertexFormatChar3 = 5,
+    VertexFormatChar4 = 6,
+    VertexFormatUChar2Normalized = 7,
+    VertexFormatUChar3Normalized = 8,
+    VertexFormatUChar4Normalized = 9,
+    VertexFormatChar2Normalized = 10,
+    VertexFormatChar3Normalized = 11,
+    VertexFormatChar4Normalized = 12,
+    VertexFormatUShort2 = 13,
+    VertexFormatUShort3 = 14,
+    VertexFormatUShort4 = 15,
+    VertexFormatShort2 = 16,
+    VertexFormatShort3 = 17,
+    VertexFormatShort4 = 18,
+    VertexFormatUShort2Normalized = 19,
+    VertexFormatUShort3Normalized = 20,
+    VertexFormatUShort4Normalized = 21,
+    VertexFormatShort2Normalized = 22,
+    VertexFormatShort3Normalized = 23,
+    VertexFormatShort4Normalized = 24,
+    VertexFormatHalf2 = 25,
+    VertexFormatHalf3 = 26,
+    VertexFormatHalf4 = 27,
+    VertexFormatFloat = 28,
+    VertexFormatFloat2 = 29,
+    VertexFormatFloat3 = 30,
+    VertexFormatFloat4 = 31,
+    VertexFormatInt = 32,
+    VertexFormatInt2 = 33,
+    VertexFormatInt3 = 34,
+    VertexFormatInt4 = 35,
+    VertexFormatUInt = 36,
+    VertexFormatUInt2 = 37,
+    VertexFormatUInt3 = 38,
+    VertexFormatUInt4 = 39,
+    VertexFormatInt1010102Normalized = 40,
+    VertexFormatUInt1010102Normalized = 41,
+    VertexFormatUChar4Normalized_BGRA = 42,
+    VertexFormatUChar = 45,
+    VertexFormatChar = 46,
+    VertexFormatUCharNormalized = 47,
+    VertexFormatCharNormalized = 48,
+    VertexFormatUShort = 49,
+    VertexFormatShort = 50,
+    VertexFormatUShortNormalized = 51,
+    VertexFormatShortNormalized = 52,
+    VertexFormatHalf = 53,
+    VertexFormatFloatRG11B10 = 54,
+    VertexFormatFloatRGB9E5 = 55,
+};
+
+_MTL_ENUM(NS::UInteger, VertexStepFunction) {
+    VertexStepFunctionConstant = 0,
+    VertexStepFunctionPerVertex = 1,
+    VertexStepFunctionPerInstance = 2,
+    VertexStepFunctionPerPatch = 3,
+    VertexStepFunctionPerPatchControlPoint = 4,
+};
+
+class VertexBufferLayoutDescriptor : public NS::Copying<VertexBufferLayoutDescriptor>
+{
+public:
+    static class VertexBufferLayoutDescriptor* alloc();
+
+    class VertexBufferLayoutDescriptor*        init();
+
+    NS::UInteger                               stride() const;
+    void                                       setStride(NS::UInteger stride);
+
+    MTL::VertexStepFunction                    stepFunction() const;
+    void                                       setStepFunction(MTL::VertexStepFunction stepFunction);
+
+    NS::UInteger                               stepRate() const;
+    void                                       setStepRate(NS::UInteger stepRate);
+};
+
+class VertexBufferLayoutDescriptorArray : public NS::Referencing<VertexBufferLayoutDescriptorArray>
+{
+public:
+    static class VertexBufferLayoutDescriptorArray* alloc();
+
+    class VertexBufferLayoutDescriptorArray*        init();
+
+    class VertexBufferLayoutDescriptor*             object(NS::UInteger index);
+
+    void                                            setObject(const class VertexBufferLayoutDescriptor* bufferDesc, NS::UInteger index);
+};
+
+class VertexAttributeDescriptor : public NS::Copying<VertexAttributeDescriptor>
+{
+public:
+    static class VertexAttributeDescriptor* alloc();
+
+    class VertexAttributeDescriptor*        init();
+
+    MTL::VertexFormat                       format() const;
+    void                                    setFormat(MTL::VertexFormat format);
+
+    NS::UInteger                            offset() const;
+    void                                    setOffset(NS::UInteger offset);
+
+    NS::UInteger                            bufferIndex() const;
+    void                                    setBufferIndex(NS::UInteger bufferIndex);
+};
+
+class VertexAttributeDescriptorArray : public NS::Referencing<VertexAttributeDescriptorArray>
+{
+public:
+    static class VertexAttributeDescriptorArray* alloc();
+
+    class VertexAttributeDescriptorArray*        init();
+
+    class VertexAttributeDescriptor*             object(NS::UInteger index);
+
+    void                                         setObject(const class VertexAttributeDescriptor* attributeDesc, NS::UInteger index);
+};
+
+class VertexDescriptor : public NS::Copying<VertexDescriptor>
+{
+public:
+    static class VertexDescriptor*           alloc();
+
+    class VertexDescriptor*                  init();
+
+    static class VertexDescriptor*           vertexDescriptor();
+
+    class VertexBufferLayoutDescriptorArray* layouts() const;
+
+    class VertexAttributeDescriptorArray*    attributes() const;
+
+    void                                     reset();
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::VertexBufferLayoutDescriptor* MTL::VertexBufferLayoutDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::VertexBufferLayoutDescriptor>(_MTL_PRIVATE_CLS(MTLVertexBufferLayoutDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::VertexBufferLayoutDescriptor* MTL::VertexBufferLayoutDescriptor::init()
+{
+    return NS::Object::init<MTL::VertexBufferLayoutDescriptor>();
+}
+
+// property: stride
+_MTL_INLINE NS::UInteger MTL::VertexBufferLayoutDescriptor::stride() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(stride));
+}
+
+_MTL_INLINE void MTL::VertexBufferLayoutDescriptor::setStride(NS::UInteger stride)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStride_), stride);
+}
+
+// property: stepFunction
+_MTL_INLINE MTL::VertexStepFunction MTL::VertexBufferLayoutDescriptor::stepFunction() const
+{
+    return Object::sendMessage<MTL::VertexStepFunction>(this, _MTL_PRIVATE_SEL(stepFunction));
+}
+
+_MTL_INLINE void MTL::VertexBufferLayoutDescriptor::setStepFunction(MTL::VertexStepFunction stepFunction)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStepFunction_), stepFunction);
+}
+
+// property: stepRate
+_MTL_INLINE NS::UInteger MTL::VertexBufferLayoutDescriptor::stepRate() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(stepRate));
+}
+
+_MTL_INLINE void MTL::VertexBufferLayoutDescriptor::setStepRate(NS::UInteger stepRate)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStepRate_), stepRate);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::VertexBufferLayoutDescriptorArray* MTL::VertexBufferLayoutDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::VertexBufferLayoutDescriptorArray>(_MTL_PRIVATE_CLS(MTLVertexBufferLayoutDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::VertexBufferLayoutDescriptorArray* MTL::VertexBufferLayoutDescriptorArray::init()
+{
+    return NS::Object::init<MTL::VertexBufferLayoutDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::VertexBufferLayoutDescriptor* MTL::VertexBufferLayoutDescriptorArray::object(NS::UInteger index)
+{
+    return Object::sendMessage<MTL::VertexBufferLayoutDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::VertexBufferLayoutDescriptorArray::setObject(const MTL::VertexBufferLayoutDescriptor* bufferDesc, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), bufferDesc, index);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::VertexAttributeDescriptor* MTL::VertexAttributeDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::VertexAttributeDescriptor>(_MTL_PRIVATE_CLS(MTLVertexAttributeDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::VertexAttributeDescriptor* MTL::VertexAttributeDescriptor::init()
+{
+    return NS::Object::init<MTL::VertexAttributeDescriptor>();
+}
+
+// property: format
+_MTL_INLINE MTL::VertexFormat MTL::VertexAttributeDescriptor::format() const
+{
+    return Object::sendMessage<MTL::VertexFormat>(this, _MTL_PRIVATE_SEL(format));
+}
+
+_MTL_INLINE void MTL::VertexAttributeDescriptor::setFormat(MTL::VertexFormat format)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFormat_), format);
+}
+
+// property: offset
+_MTL_INLINE NS::UInteger MTL::VertexAttributeDescriptor::offset() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(offset));
+}
+
+_MTL_INLINE void MTL::VertexAttributeDescriptor::setOffset(NS::UInteger offset)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOffset_), offset);
+}
+
+// property: bufferIndex
+_MTL_INLINE NS::UInteger MTL::VertexAttributeDescriptor::bufferIndex() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(bufferIndex));
+}
+
+_MTL_INLINE void MTL::VertexAttributeDescriptor::setBufferIndex(NS::UInteger bufferIndex)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBufferIndex_), bufferIndex);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::VertexAttributeDescriptorArray* MTL::VertexAttributeDescriptorArray::alloc()
+{
+    return NS::Object::alloc<MTL::VertexAttributeDescriptorArray>(_MTL_PRIVATE_CLS(MTLVertexAttributeDescriptorArray));
+}
+
+// method: init
+_MTL_INLINE MTL::VertexAttributeDescriptorArray* MTL::VertexAttributeDescriptorArray::init()
+{
+    return NS::Object::init<MTL::VertexAttributeDescriptorArray>();
+}
+
+// method: objectAtIndexedSubscript:
+_MTL_INLINE MTL::VertexAttributeDescriptor* MTL::VertexAttributeDescriptorArray::object(NS::UInteger index)
+{
+    return Object::sendMessage<MTL::VertexAttributeDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index);
+}
+
+// method: setObject:atIndexedSubscript:
+_MTL_INLINE void MTL::VertexAttributeDescriptorArray::setObject(const MTL::VertexAttributeDescriptor* attributeDesc, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attributeDesc, index);
+}
+
+// static method: alloc
+_MTL_INLINE MTL::VertexDescriptor* MTL::VertexDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::VertexDescriptor>(_MTL_PRIVATE_CLS(MTLVertexDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::VertexDescriptor* MTL::VertexDescriptor::init()
+{
+    return NS::Object::init<MTL::VertexDescriptor>();
+}
+
+// static method: vertexDescriptor
+_MTL_INLINE MTL::VertexDescriptor* MTL::VertexDescriptor::vertexDescriptor()
+{
+    return Object::sendMessage<MTL::VertexDescriptor*>(_MTL_PRIVATE_CLS(MTLVertexDescriptor), _MTL_PRIVATE_SEL(vertexDescriptor));
+}
+
+// property: layouts
+_MTL_INLINE MTL::VertexBufferLayoutDescriptorArray* MTL::VertexDescriptor::layouts() const
+{
+    return Object::sendMessage<MTL::VertexBufferLayoutDescriptorArray*>(this, _MTL_PRIVATE_SEL(layouts));
+}
+
+// property: attributes
+_MTL_INLINE MTL::VertexAttributeDescriptorArray* MTL::VertexDescriptor::attributes() const
+{
+    return Object::sendMessage<MTL::VertexAttributeDescriptorArray*>(this, _MTL_PRIVATE_SEL(attributes));
+}
+
+// method: reset
+_MTL_INLINE void MTL::VertexDescriptor::reset()
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVisibleFunctionTable.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVisibleFunctionTable.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..88e8fb1e902214b1bc06e2a541656ff7036841bd
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/MTLVisibleFunctionTable.hpp
@@ -0,0 +1,104 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/MTLVisibleFunctionTable.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MTLDefines.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLPrivate.hpp"
+
+#include <Foundation/Foundation.hpp>
+
+#include "MTLResource.hpp"
+#include "MTLTypes.hpp"
+
+namespace MTL
+{
+class VisibleFunctionTableDescriptor : public NS::Copying<VisibleFunctionTableDescriptor>
+{
+public:
+    static class VisibleFunctionTableDescriptor* alloc();
+
+    class VisibleFunctionTableDescriptor*        init();
+
+    static class VisibleFunctionTableDescriptor* visibleFunctionTableDescriptor();
+
+    NS::UInteger                                 functionCount() const;
+    void                                         setFunctionCount(NS::UInteger functionCount);
+};
+
+class VisibleFunctionTable : public NS::Referencing<VisibleFunctionTable, Resource>
+{
+public:
+    MTL::ResourceID gpuResourceID() const;
+
+    void            setFunction(const class FunctionHandle* function, NS::UInteger index);
+
+    void            setFunctions(const class FunctionHandle* const functions[], NS::Range range);
+};
+
+}
+
+// static method: alloc
+_MTL_INLINE MTL::VisibleFunctionTableDescriptor* MTL::VisibleFunctionTableDescriptor::alloc()
+{
+    return NS::Object::alloc<MTL::VisibleFunctionTableDescriptor>(_MTL_PRIVATE_CLS(MTLVisibleFunctionTableDescriptor));
+}
+
+// method: init
+_MTL_INLINE MTL::VisibleFunctionTableDescriptor* MTL::VisibleFunctionTableDescriptor::init()
+{
+    return NS::Object::init<MTL::VisibleFunctionTableDescriptor>();
+}
+
+// static method: visibleFunctionTableDescriptor
+_MTL_INLINE MTL::VisibleFunctionTableDescriptor* MTL::VisibleFunctionTableDescriptor::visibleFunctionTableDescriptor()
+{
+    return Object::sendMessage<MTL::VisibleFunctionTableDescriptor*>(_MTL_PRIVATE_CLS(MTLVisibleFunctionTableDescriptor), _MTL_PRIVATE_SEL(visibleFunctionTableDescriptor));
+}
+
+// property: functionCount
+_MTL_INLINE NS::UInteger MTL::VisibleFunctionTableDescriptor::functionCount() const
+{
+    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(functionCount));
+}
+
+_MTL_INLINE void MTL::VisibleFunctionTableDescriptor::setFunctionCount(NS::UInteger functionCount)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctionCount_), functionCount);
+}
+
+// property: gpuResourceID
+_MTL_INLINE MTL::ResourceID MTL::VisibleFunctionTable::gpuResourceID() const
+{
+    return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
+}
+
+// method: setFunction:atIndex:
+_MTL_INLINE void MTL::VisibleFunctionTable::setFunction(const MTL::FunctionHandle* function, NS::UInteger index)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunction_atIndex_), function, index);
+}
+
+// method: setFunctions:withRange:
+_MTL_INLINE void MTL::VisibleFunctionTable::setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range)
+{
+    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFunctions_withRange_), functions, range);
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/Metal.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/Metal.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ea7adf3a354d37a59e2ff4dfe8eca3c7faea7da
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/Metal/Metal.hpp
@@ -0,0 +1,84 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// Metal/Metal.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLAccelerationStructure.hpp"
+#include "MTLAccelerationStructureCommandEncoder.hpp"
+#include "MTLAccelerationStructureTypes.hpp"
+#include "MTLArgument.hpp"
+#include "MTLArgumentEncoder.hpp"
+#include "MTLBinaryArchive.hpp"
+#include "MTLBlitCommandEncoder.hpp"
+#include "MTLBlitPass.hpp"
+#include "MTLBuffer.hpp"
+#include "MTLCaptureManager.hpp"
+#include "MTLCaptureScope.hpp"
+#include "MTLCommandBuffer.hpp"
+#include "MTLCommandEncoder.hpp"
+#include "MTLCommandQueue.hpp"
+#include "MTLComputeCommandEncoder.hpp"
+#include "MTLComputePass.hpp"
+#include "MTLComputePipeline.hpp"
+#include "MTLCounters.hpp"
+#include "MTLDefines.hpp"
+#include "MTLDepthStencil.hpp"
+#include "MTLDevice.hpp"
+#include "MTLDrawable.hpp"
+#include "MTLDynamicLibrary.hpp"
+#include "MTLEvent.hpp"
+#include "MTLFence.hpp"
+#include "MTLFunctionConstantValues.hpp"
+#include "MTLFunctionDescriptor.hpp"
+#include "MTLFunctionHandle.hpp"
+#include "MTLFunctionLog.hpp"
+#include "MTLFunctionStitching.hpp"
+#include "MTLHeaderBridge.hpp"
+#include "MTLHeap.hpp"
+#include "MTLIndirectCommandBuffer.hpp"
+#include "MTLIndirectCommandEncoder.hpp"
+#include "MTLIntersectionFunctionTable.hpp"
+#include "MTLIOCommandBuffer.hpp"
+#include "MTLIOCommandQueue.hpp"
+#include "MTLIOCompressor.hpp"
+#include "MTLLibrary.hpp"
+#include "MTLLinkedFunctions.hpp"
+#include "MTLParallelRenderCommandEncoder.hpp"
+#include "MTLPipeline.hpp"
+#include "MTLPixelFormat.hpp"
+#include "MTLPrivate.hpp"
+#include "MTLRasterizationRate.hpp"
+#include "MTLRenderCommandEncoder.hpp"
+#include "MTLRenderPass.hpp"
+#include "MTLRenderPipeline.hpp"
+#include "MTLResource.hpp"
+#include "MTLResourceStateCommandEncoder.hpp"
+#include "MTLResourceStatePass.hpp"
+#include "MTLSampler.hpp"
+#include "MTLStageInputOutputDescriptor.hpp"
+#include "MTLTexture.hpp"
+#include "MTLTypes.hpp"
+#include "MTLVertexDescriptor.hpp"
+#include "MTLVisibleFunctionTable.hpp"
+#include "MTLVersion.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXDefines.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXDefines.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8b4521687931b4662ca296d39dc2fb77dfa4750c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXDefines.hpp
@@ -0,0 +1,41 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// MetalFX/MTLFXDefines.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "../Foundation/NSDefines.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _MTLFX_EXPORT                           _NS_EXPORT
+#define _MTLFX_EXTERN                           _NS_EXTERN
+#define _MTLFX_INLINE                           _NS_INLINE
+#define _MTLFX_PACKED                           _NS_PACKED
+
+#define _MTLFX_CONST( type, name )              _NS_CONST( type, name )
+#define _MTLFX_ENUM( type, name )               _NS_ENUM( type, name )
+#define _MTLFX_OPTIONS( type, name )            _NS_OPTIONS( type, name )
+
+#define _MTLFX_VALIDATE_SIZE( mtlfx, name )     _NS_VALIDATE_SIZE( mtlfx, name )
+#define _MTLFX_VALIDATE_ENUM( mtlfx, name )     _NS_VALIDATE_ENUM( mtlfx, name )
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXPrivate.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXPrivate.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e46455378c05bf7e4fd0fecb76276ea759c2513d
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXPrivate.hpp
@@ -0,0 +1,281 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// MetalFX/MTLFXPrivate.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLFXDefines.hpp"
+
+#include <objc/runtime.h>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _MTLFX_PRIVATE_CLS( symbol )                    ( Private::Class::s_k##symbol )
+#define _MTLFX_PRIVATE_SEL( accessor )                  ( Private::Selector::s_k##accessor )
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#if defined( MTLFX_PRIVATE_IMPLEMENTATION )
+
+#if defined( METALCPP_SYMBOL_VISIBILITY_HIDDEN )
+#define _MTLFX_PRIVATE_VISIBILITY                       __attribute__( ( visibility("hidden" ) ) )
+#else
+#define _MTLFX_PRIVATE_VISIBILITY                       __attribute__( ( visibility("default" ) ) )
+#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN
+
+#define _MTLFX_PRIVATE_IMPORT                           __attribute__( ( weak_import ) )
+
+#ifdef __OBJC__
+#define _MTLFX_PRIVATE_OBJC_LOOKUP_CLASS( symbol )      ( ( __bridge void* ) objc_lookUpClass( #symbol ) )
+#define _MTLFX_PRIVATE_OBJC_GET_PROTOCOL( symbol )      ( ( __bridge void* ) objc_getProtocol( #symbol ) )
+#else
+#define _MTLFX_PRIVATE_OBJC_LOOKUP_CLASS( symbol )      objc_lookUpClass(#symbol)
+#define _MTLFX_PRIVATE_OBJC_GET_PROTOCOL( symbol )      objc_getProtocol(#symbol)
+#endif // __OBJC__
+
+#define _MTLFX_PRIVATE_DEF_CLS( symbol )                void* s_k##symbol _MTLFX_PRIVATE_VISIBILITY = _MTLFX_PRIVATE_OBJC_LOOKUP_CLASS( symbol )
+#define _MTLFX_PRIVATE_DEF_PRO( symbol )                void* s_k##symbol _MTLFX_PRIVATE_VISIBILITY = _MTLFX_PRIVATE_OBJC_GET_PROTOCOL( symbol )
+#define _MTLFX_PRIVATE_DEF_SEL( accessor, symbol )       SEL s_k##accessor _MTLFX_PRIVATE_VISIBILITY = sel_registerName( symbol )
+
+#include <dlfcn.h>
+#define MTLFX_DEF_FUNC( name, signature )               using Fn##name = signature; \
+                                                        Fn##name name = reinterpret_cast< Fn##name >( dlsym( RTLD_DEFAULT, #name ) )
+
+namespace MTLFX::Private
+{
+    template <typename _Type>
+
+    inline _Type const LoadSymbol(const char* pSymbol)
+    {
+        const _Type* pAddress = static_cast<_Type*>(dlsym(RTLD_DEFAULT, pSymbol));
+
+        return pAddress ? *pAddress : nullptr;
+    }
+} // MTLFX::Private
+
+#if defined( __MAC_13_0 ) || defined( __MAC_14_0 ) || defined( __IPHONE_16_0 ) || defined( __IPHONE_17_0 ) || defined( __TVOS_16_0 ) || defined( __TVOS_17_0 )
+
+#define _MTLFX_PRIVATE_DEF_STR( type, symbol )                                                                                  \
+    _MTLFX_EXTERN type const                            MTLFX##symbol _MTLFX_PRIVATE_IMPORT;                                    \
+    type const                                          MTLFX::symbol = ( nullptr != &MTLFX##symbol ) ? MTLFX##ssymbol : nullptr
+
+#define _MTLFX_PRIVATE_DEF_CONST( type, symbol )                                                                                \
+    _MTLFX_EXTERN type const                            MTLFX##ssymbol _MTLFX_PRIVATE_IMPORT;                                   \
+    type const                                          MTLFX::symbol = (nullptr != &MTLFX##ssymbol) ? MTLFX##ssymbol : nullptr
+
+#define _MTLFX_PRIVATE_DEF_WEAK_CONST( type, symbol )                                                                           \
+    _MTLFX_EXTERN type const                            MTLFX##ssymbol;                                                         \
+    type const                                          MTLFX::symbol = Private::LoadSymbol< type >( "MTLFX" #symbol )
+
+#else
+
+#define _MTLFX_PRIVATE_DEF_STR( type, symbol )                                                                                  \
+    _MTLFX_EXTERN type const                            MTLFX##ssymbol;                                                         \
+    type const                                          MTLFX::symbol = Private::LoadSymbol< type >( "MTLFX" #symbol )
+
+#define _MTLFX_PRIVATE_DEF_CONST( type, symbol )                                                                                \
+    _MTLFX_EXTERN type const                            MTLFX##ssymbol;                                                         \
+    type const                                          MTLFX::symbol = Private::LoadSymbol< type >( "MTLFX" #symbol )
+
+#define _MTLFX_PRIVATE_DEF_WEAK_CONST( type, symbol )   _MTLFX_PRIVATE_DEF_CONST( type, symbol )
+
+#endif // defined( __MAC_13_0 ) || defined( __MAC_14_0 ) || defined( __IPHONE_16_0 ) || defined( __IPHONE_17_0 ) || defined( __TVOS_16_0 ) || defined( __TVOS_17_0 )
+
+#else
+
+#define _MTLFX_PRIVATE_DEF_CLS( symbol )                extern void* s_k##symbol
+#define _MTLFX_PRIVATE_DEF_PRO( symbol )                extern void* s_k##symbol
+#define _MTLFX_PRIVATE_DEF_SEL( accessor, symbol )      extern SEL s_k##accessor
+#define _MTLFX_PRIVATE_DEF_STR( type, symbol )          extern type const MTLFX::symbol
+#define _MTLFX_PRIVATE_DEF_CONST( type, symbol )        extern type const MTLFX::symbol
+#define _MTLFX_PRIVATE_DEF_WEAK_CONST( type, symbol )   extern type const MTLFX::symbol
+
+#endif // MTLFX_PRIVATE_IMPLEMENTATION
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTLFX
+{
+    namespace Private
+    {
+        namespace Class
+        {
+            _MTLFX_PRIVATE_DEF_CLS( MTLFXSpatialScalerDescriptor );
+            _MTLFX_PRIVATE_DEF_CLS( MTLFXTemporalScalerDescriptor );
+        } // Class
+    } // Private
+} // MTLFX
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTLFX
+{
+    namespace Private
+    {
+        namespace Protocol
+        {
+            _MTLFX_PRIVATE_DEF_PRO( MTLFXSpatialScaler );
+            _MTLFX_PRIVATE_DEF_PRO( MTLFXTemporalScaler );
+        } // Protocol
+    } // Private
+} // MTLFX
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTLFX
+{
+    namespace Private
+    {
+        namespace Selector
+        {
+            _MTLFX_PRIVATE_DEF_SEL( colorProcessingMode,
+                                    "colorProcessingMode" );
+            _MTLFX_PRIVATE_DEF_SEL( colorTexture,
+                                    "colorTexture" );
+            _MTLFX_PRIVATE_DEF_SEL( colorTextureFormat,
+                                    "colorTextureFormat" );
+            _MTLFX_PRIVATE_DEF_SEL( colorTextureUsage,
+                                    "colorTextureUsage" );
+            _MTLFX_PRIVATE_DEF_SEL( depthTexture,
+                                    "depthTexture" );
+            _MTLFX_PRIVATE_DEF_SEL( depthTextureFormat,
+                                    "depthTextureFormat" );
+            _MTLFX_PRIVATE_DEF_SEL( depthTextureUsage,
+                                    "depthTextureUsage" );                                    
+            _MTLFX_PRIVATE_DEF_SEL( encodeToCommandBuffer_,
+                                    "encodeToCommandBuffer:" );
+            _MTLFX_PRIVATE_DEF_SEL( exposureTexture,
+                                    "exposureTexture" );                                    
+            _MTLFX_PRIVATE_DEF_SEL( fence,
+                                    "fence" );
+            _MTLFX_PRIVATE_DEF_SEL( inputContentHeight,
+                                    "inputContentHeight" );
+            _MTLFX_PRIVATE_DEF_SEL( inputContentMaxScale,
+                                    "inputContentMaxScale" );
+            _MTLFX_PRIVATE_DEF_SEL( inputContentMinScale,
+                                    "inputContentMinScale" );
+            _MTLFX_PRIVATE_DEF_SEL( inputContentWidth,
+                                    "inputContentWidth" );
+            _MTLFX_PRIVATE_DEF_SEL( inputHeight,
+                                    "inputHeight" );
+            _MTLFX_PRIVATE_DEF_SEL( inputWidth,
+                                    "inputWidth" );
+            _MTLFX_PRIVATE_DEF_SEL( isAutoExposureEnabled,
+                                    "isAutoExposureEnabled" );
+            _MTLFX_PRIVATE_DEF_SEL( isDepthReversed,
+                                    "isDepthReversed" );
+            _MTLFX_PRIVATE_DEF_SEL( isInputContentPropertiesEnabled,
+                                    "isInputContentPropertiesEnabled" );
+            _MTLFX_PRIVATE_DEF_SEL( jitterOffsetX,
+                                    "jitterOffsetX" );
+            _MTLFX_PRIVATE_DEF_SEL( jitterOffsetY,
+                                    "jitterOffsetY" );
+            _MTLFX_PRIVATE_DEF_SEL( motionTexture,
+                                    "motionTexture" );
+            _MTLFX_PRIVATE_DEF_SEL( motionTextureFormat,
+                                    "motionTextureFormat" );
+            _MTLFX_PRIVATE_DEF_SEL( motionTextureUsage,
+                                    "motionTextureUsage" );
+            _MTLFX_PRIVATE_DEF_SEL( motionVectorScaleX,
+                                    "motionVectorScaleX" );
+            _MTLFX_PRIVATE_DEF_SEL( motionVectorScaleY,
+                                    "motionVectorScaleY" );
+            _MTLFX_PRIVATE_DEF_SEL( newSpatialScalerWithDevice_,
+                                    "newSpatialScalerWithDevice:" );
+            _MTLFX_PRIVATE_DEF_SEL( newTemporalScalerWithDevice_,
+                                    "newTemporalScalerWithDevice:" );
+            _MTLFX_PRIVATE_DEF_SEL( outputHeight,
+                                    "outputHeight" );
+            _MTLFX_PRIVATE_DEF_SEL( outputTexture,
+                                    "outputTexture" );
+            _MTLFX_PRIVATE_DEF_SEL( outputTextureFormat,
+                                    "outputTextureFormat" );
+            _MTLFX_PRIVATE_DEF_SEL( outputTextureUsage,
+                                    "outputTextureUsage" );
+            _MTLFX_PRIVATE_DEF_SEL( outputWidth,
+                                    "outputWidth" );
+            _MTLFX_PRIVATE_DEF_SEL( preExposure,
+                                    "preExposure" );
+            _MTLFX_PRIVATE_DEF_SEL( reset,
+                                    "reset" );
+            _MTLFX_PRIVATE_DEF_SEL( setAutoExposureEnabled_,
+                                    "setAutoExposureEnabled:" );
+            _MTLFX_PRIVATE_DEF_SEL( setColorProcessingMode_,
+                                    "setColorProcessingMode:" );
+            _MTLFX_PRIVATE_DEF_SEL( setColorTexture_,
+                                    "setColorTexture:" );
+            _MTLFX_PRIVATE_DEF_SEL( setColorTextureFormat_,
+                                    "setColorTextureFormat:" );
+            _MTLFX_PRIVATE_DEF_SEL( setDepthReversed_,
+                                    "setDepthReversed:" );
+            _MTLFX_PRIVATE_DEF_SEL( setDepthTexture_,
+                                    "setDepthTexture:" );
+            _MTLFX_PRIVATE_DEF_SEL( setDepthTextureFormat_,
+                                    "setDepthTextureFormat:" );
+            _MTLFX_PRIVATE_DEF_SEL( setExposureTexture_,
+                                    "setExposureTexture:" );                                    
+            _MTLFX_PRIVATE_DEF_SEL( setFence_,
+                                    "setFence:" );
+            _MTLFX_PRIVATE_DEF_SEL( setInputContentHeight_,
+                                    "setInputContentHeight:" );
+            _MTLFX_PRIVATE_DEF_SEL( setInputContentMaxScale_,
+                                    "setInputContentMaxScale:" );
+            _MTLFX_PRIVATE_DEF_SEL( setInputContentMinScale_,
+                                    "setInputContentMinScale:" );
+            _MTLFX_PRIVATE_DEF_SEL( setInputContentPropertiesEnabled_,
+                                    "setInputContentPropertiesEnabled:" );
+            _MTLFX_PRIVATE_DEF_SEL( setInputContentWidth_,
+                                    "setInputContentWidth_:" );
+            _MTLFX_PRIVATE_DEF_SEL( setInputHeight_,
+                                    "setInputHeight:" );
+            _MTLFX_PRIVATE_DEF_SEL( setInputWidth_,
+                                    "setInputWidth:" );
+            _MTLFX_PRIVATE_DEF_SEL( setJitterOffsetX_,
+                                    "setJitterOffsetX:" );
+            _MTLFX_PRIVATE_DEF_SEL( setJitterOffsetY_,
+                                    "setJitterOffsetY:" );
+            _MTLFX_PRIVATE_DEF_SEL( setMotionTexture_,
+                                    "setMotionTexture:" );
+            _MTLFX_PRIVATE_DEF_SEL( setMotionTextureFormat_,
+                                    "setMotionTextureFormat:" );
+            _MTLFX_PRIVATE_DEF_SEL( setMotionVectorScaleX_,
+                                    "setMotionVectorScaleX:" );
+            _MTLFX_PRIVATE_DEF_SEL( setMotionVectorScaleY_,
+                                    "setMotionVectorScaleY:" );
+            _MTLFX_PRIVATE_DEF_SEL( setOutputHeight_,
+                                    "setOutputHeight:" );
+            _MTLFX_PRIVATE_DEF_SEL( setOutputTexture_,
+                                    "setOutputTexture:" );
+            _MTLFX_PRIVATE_DEF_SEL( setOutputTextureFormat_,
+                                    "setOutputTextureFormat:" );
+            _MTLFX_PRIVATE_DEF_SEL( setOutputWidth_,
+                                    "setOutputWidth:" );
+            _MTLFX_PRIVATE_DEF_SEL( setPreExposure_,
+                                    "setPreExposure:" );
+            _MTLFX_PRIVATE_DEF_SEL( setReset_,
+                                    "setReset:" );
+            _MTLFX_PRIVATE_DEF_SEL( supportsDevice_,
+                                    "supportsDevice:" );
+        } // Selector
+    } // Private
+} // MTLFX
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXSpatialScaler.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXSpatialScaler.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..841898d464b91c15fef025153210eb1cff2f13c7
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXSpatialScaler.hpp
@@ -0,0 +1,372 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// MetalFX/MTLFXSpatialScaler.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLFXDefines.hpp"
+#include "MTLFXPrivate.hpp"
+
+#include "../Metal/Metal.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTLFX
+{
+    _MTLFX_ENUM( NS::Integer, SpatialScalerColorProcessingMode )
+    {
+        SpatialScalerColorProcessingModePerceptual  = 0,
+        SpatialScalerColorProcessingModeLinear      = 1,
+        SpatialScalerColorProcessingModeHDR         = 2
+    };
+
+    class SpatialScalerDescriptor : public NS::Copying< SpatialScalerDescriptor >
+    {
+    public:
+        static class SpatialScalerDescriptor*       alloc();
+        class SpatialScalerDescriptor*              init();
+
+        MTL::PixelFormat                            colorTextureFormat() const;
+        void                                        setColorTextureFormat( MTL::PixelFormat format );
+
+        MTL::PixelFormat                            outputTextureFormat() const;
+        void                                        setOutputTextureFormat( MTL::PixelFormat format );
+
+        NS::UInteger                                inputWidth() const;
+        void                                        setInputWidth( NS::UInteger width );
+
+        NS::UInteger                                inputHeight() const;
+        void                                        setInputHeight( NS::UInteger height );
+
+        NS::UInteger                                outputWidth() const;
+        void                                        setOutputWidth( NS::UInteger width );
+
+        NS::UInteger                                outputHeight() const;
+        void                                        setOutputHeight( NS::UInteger height );
+
+        SpatialScalerColorProcessingMode            colorProcessingMode() const;
+        void                                        setColorProcessingMode( SpatialScalerColorProcessingMode mode );
+
+        class SpatialScaler*                        newSpatialScaler( const MTL::Device* pDevice );
+
+        static bool                                 supportsDevice( const MTL::Device* );
+    };
+
+    class SpatialScaler : public NS::Referencing< SpatialScaler >
+    {
+    public:
+        MTL::TextureUsage                           colorTextureUsage() const;
+        MTL::TextureUsage                           outputTextureUsage() const;
+
+        NS::UInteger                                inputContentWidth() const;
+        void                                        setInputContentWidth( NS::UInteger width );
+
+        NS::UInteger                                inputContentHeight() const;
+        void                                        setInputContentHeight( NS::UInteger height );
+
+        MTL::Texture*                               colorTexture() const;
+        void                                        setColorTexture( MTL::Texture* pTexture );
+
+        MTL::Texture*                               outputTexture() const;
+        void                                        setOutputTexture( MTL::Texture* pTexture );
+
+        MTL::PixelFormat                            colorTextureFormat() const;
+        MTL::PixelFormat                            outputTextureFormat() const;
+        NS::UInteger                                inputWidth() const;
+        NS::UInteger                                inputHeight() const;
+        NS::UInteger                                outputWidth() const;
+        NS::UInteger                                outputHeight() const;
+        SpatialScalerColorProcessingMode            colorProcessingMode() const;
+
+        MTL::Fence*                                 fence() const;
+        void                                        setFence( MTL::Fence* pFence );
+
+        void                                        encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer );
+    };
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::SpatialScalerDescriptor* MTLFX::SpatialScalerDescriptor::alloc()
+{
+    return NS::Object::alloc< SpatialScalerDescriptor >( _MTLFX_PRIVATE_CLS( MTLFXSpatialScalerDescriptor ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::SpatialScalerDescriptor* MTLFX::SpatialScalerDescriptor::init()
+{
+    return NS::Object::init< SpatialScalerDescriptor >();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScalerDescriptor::colorTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setColorTextureFormat( MTL::PixelFormat format )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setColorTextureFormat_ ), format );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScalerDescriptor::outputTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setOutputTextureFormat( MTL::PixelFormat format )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputTextureFormat_ ), format );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::inputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setInputWidth( NS::UInteger width )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputWidth_ ), width );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::inputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setInputHeight( NS::UInteger height )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputHeight_ ), height );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::outputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setOutputWidth( NS::UInteger width )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputWidth_ ), width );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::outputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setOutputHeight( NS::UInteger height )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputHeight_ ), height );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::SpatialScalerColorProcessingMode MTLFX::SpatialScalerDescriptor::colorProcessingMode() const
+{
+    return Object::sendMessage< SpatialScalerColorProcessingMode >( this, _MTLFX_PRIVATE_SEL( colorProcessingMode ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setColorProcessingMode( SpatialScalerColorProcessingMode mode )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setColorProcessingMode_ ), mode );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::SpatialScaler* MTLFX::SpatialScalerDescriptor::newSpatialScaler( const MTL::Device* pDevice )
+{
+    return Object::sendMessage< SpatialScaler* >( this, _MTLFX_PRIVATE_SEL( newSpatialScalerWithDevice_ ), pDevice );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE bool MTLFX::SpatialScalerDescriptor::supportsDevice( const MTL::Device* pDevice )
+{
+    return Object::sendMessageSafe< bool >( _NS_PRIVATE_CLS( MTLFXSpatialScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportsDevice_ ), pDevice );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::TextureUsage MTLFX::SpatialScaler::colorTextureUsage() const
+{
+    return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( colorTextureUsage ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::TextureUsage MTLFX::SpatialScaler::outputTextureUsage() const
+{
+    return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( outputTextureUsage ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScaler::inputContentWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScaler::setInputContentWidth( NS::UInteger width )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputContentWidth_ ), width );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScaler::inputContentHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScaler::setInputContentHeight( NS::UInteger height )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputContentHeight_ ), height );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Texture* MTLFX::SpatialScaler::colorTexture() const
+{
+    return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( colorTexture ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScaler::setColorTexture( MTL::Texture* pTexture )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setColorTexture_ ), pTexture );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Texture* MTLFX::SpatialScaler::outputTexture() const
+{
+    return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( outputTexture ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScaler::setOutputTexture( MTL::Texture* pTexture )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputTexture_ ), pTexture );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScaler::colorTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScaler::outputTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScaler::inputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScaler::inputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScaler::outputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::SpatialScaler::outputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::SpatialScalerColorProcessingMode MTLFX::SpatialScaler::colorProcessingMode() const
+{
+    return Object::sendMessage< SpatialScalerColorProcessingMode >( this, _MTLFX_PRIVATE_SEL( colorProcessingMode ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Fence* MTLFX::SpatialScaler::fence() const
+{
+    return Object::sendMessage< MTL::Fence* >( this, _MTLFX_PRIVATE_SEL( fence ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScaler::setFence( MTL::Fence* pFence )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setFence_ ), pFence );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::SpatialScaler::encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( encodeToCommandBuffer_ ), pCommandBuffer );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXTemporalScaler.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXTemporalScaler.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..97e189afba6f614126db8ae4ffb512c157e5e18b
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MTLFXTemporalScaler.hpp
@@ -0,0 +1,660 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// MetalFX/MTLFXTemporalScaler.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLFXDefines.hpp"
+#include "MTLFXPrivate.hpp"
+
+#include "../Metal/Metal.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace MTLFX
+{
+    class TemporalScalerDescriptor : public NS::Copying< TemporalScalerDescriptor >
+    {
+    public:
+        static class TemporalScalerDescriptor*      alloc();
+        class TemporalScalerDescriptor*             init();
+
+        MTL::PixelFormat                            colorTextureFormat() const;
+        void                                        setColorTextureFormat( MTL::PixelFormat format );
+
+        MTL::PixelFormat                            depthTextureFormat() const;
+        void                                        setDepthTextureFormat( MTL::PixelFormat format );
+
+        MTL::PixelFormat                            motionTextureFormat() const;
+        void                                        setMotionTextureFormat( MTL::PixelFormat format );
+
+        MTL::PixelFormat                            outputTextureFormat() const;
+        void                                        setOutputTextureFormat( MTL::PixelFormat format );
+
+        NS::UInteger                                inputWidth() const;
+        void                                        setInputWidth( NS::UInteger width );
+
+        NS::UInteger                                inputHeight() const;
+        void                                        setInputHeight( NS::UInteger height );
+
+        NS::UInteger                                outputWidth() const;
+        void                                        setOutputWidth( NS::UInteger width );
+
+        NS::UInteger                                outputHeight() const;
+        void                                        setOutputHeight( NS::UInteger height );
+
+        bool                                        isAutoExposureEnabled() const;
+        void                                        setAutoExposureEnabled( bool enabled );
+
+        bool                                        isInputContentPropertiesEnabled() const;
+        void                                        setInputContentPropertiesEnabled( bool enabled );
+
+        float                                       inputContentMinScale() const;
+        void                                        setInputContentMinScale( float scale );
+
+        float                                       inputContentMaxScale() const;
+        void                                        setInputContentMaxScale( float scale );
+
+        class TemporalScaler*                       newTemporalScaler( const MTL::Device* pDevice ) const;
+
+        static bool                                 supportsDevice( const MTL::Device* pDevice );
+    };
+
+    class TemporalScaler : public NS::Referencing< TemporalScaler >
+    {
+    public:
+        MTL::TextureUsage                           colorTextureUsage() const;
+        MTL::TextureUsage                           depthTextureUsage() const;
+        MTL::TextureUsage                           motionTextureUsage() const;
+        MTL::TextureUsage                           outputTextureUsage() const;
+
+        NS::UInteger                                inputContentWidth() const;
+        void                                        setInputContentWidth( NS::UInteger width );
+
+        NS::UInteger                                inputContentHeight() const;
+        void                                        setInputContentHeight( NS::UInteger height );
+
+        MTL::Texture*                               colorTexture() const;
+        void                                        setColorTexture( MTL::Texture* pTexture );
+
+        MTL::Texture*                               depthTexture() const;
+        void                                        setDepthTexture( MTL::Texture* pTexture );
+
+        MTL::Texture*                               motionTexture() const;
+        void                                        setMotionTexture( MTL::Texture* pTexture );
+
+        MTL::Texture*                               outputTexture() const;
+        void                                        setOutputTexture( MTL::Texture* pTexture );
+
+        MTL::Texture*                               exposureTexture() const;
+        void                                        setExposureTexture( MTL::Texture* pTexture );
+
+        float                                       preExposure() const;
+        void                                        setPreExposure( float preExposure );
+        
+        float                                       jitterOffsetX() const;
+        void                                        setJitterOffsetX( float offset );
+
+        float                                       jitterOffsetY() const;
+        void                                        setJitterOffsetY( float offset );
+
+        float                                       motionVectorScaleX() const;
+        void                                        setMotionVectorScaleX( float scale );
+
+        float                                       motionVectorScaleY() const;
+        void                                        setMotionVectorScaleY( float scale );
+
+        bool                                        reset() const;
+        void                                        setReset( bool reset );
+
+        bool                                        isDepthReversed() const;
+        void                                        setDepthReversed( bool depthReversed );
+
+        MTL::PixelFormat                            colorTextureFormat() const;
+        MTL::PixelFormat                            depthTextureFormat() const;
+        MTL::PixelFormat                            motionTextureFormat() const;
+        MTL::PixelFormat                            outputTextureFormat() const;
+        NS::UInteger                                inputWidth() const;
+        NS::UInteger                                inputHeight() const;
+        NS::UInteger                                outputWidth() const;
+        NS::UInteger                                outputHeight() const;
+        float                                       inputContentMinScale() const;
+        float                                       inputContentMaxScale() const;
+
+        MTL::Fence*                                 fence() const;
+        void                                        setFence( MTL::Fence* pFence );
+
+        void                                        encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer );
+    };
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::TemporalScalerDescriptor* MTLFX::TemporalScalerDescriptor::alloc()
+{
+    return NS::Object::alloc< TemporalScalerDescriptor >( _MTLFX_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::TemporalScalerDescriptor* MTLFX::TemporalScalerDescriptor::init()
+{
+    return NS::Object::init< TemporalScalerDescriptor >();
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::colorTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setColorTextureFormat( MTL::PixelFormat format )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setColorTextureFormat_ ), format );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::depthTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setDepthTextureFormat( MTL::PixelFormat format )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setDepthTextureFormat_ ), format );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::motionTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setMotionTextureFormat( MTL::PixelFormat format )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setMotionTextureFormat_ ), format );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::outputTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setOutputTextureFormat( MTL::PixelFormat format )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputTextureFormat_ ), format );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::inputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputWidth( NS::UInteger width )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputWidth_ ), width );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::inputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputHeight( NS::UInteger height )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputHeight_ ), height );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::outputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setOutputWidth( NS::UInteger width )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputWidth_ ), width );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::outputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setOutputHeight( NS::UInteger height )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputHeight_ ), height );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::isAutoExposureEnabled() const
+{
+    return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isAutoExposureEnabled ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setAutoExposureEnabled( bool enabled )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setAutoExposureEnabled_ ), enabled );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::isInputContentPropertiesEnabled() const
+{
+    return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isInputContentPropertiesEnabled ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputContentPropertiesEnabled( bool enabled )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputContentPropertiesEnabled_ ), enabled );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScalerDescriptor::inputContentMinScale() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMinScale ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputContentMinScale( float scale )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputContentMinScale_ ), scale );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScalerDescriptor::inputContentMaxScale() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMaxScale ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputContentMaxScale( float scale )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputContentMaxScale_ ), scale );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTLFX::TemporalScaler* MTLFX::TemporalScalerDescriptor::newTemporalScaler( const MTL::Device* pDevice ) const
+{
+    return Object::sendMessage< TemporalScaler* >( this, _MTLFX_PRIVATE_SEL( newTemporalScalerWithDevice_ ), pDevice );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::supportsDevice( const MTL::Device* pDevice )
+{
+    return Object::sendMessageSafe< bool >( _NS_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportsDevice_ ), pDevice );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScaler::colorTextureUsage() const
+{
+    return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( colorTextureUsage ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScaler::depthTextureUsage() const
+{
+    return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( depthTextureUsage ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScaler::motionTextureUsage() const
+{
+    return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( motionTextureUsage ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScaler::outputTextureUsage() const
+{
+    return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( outputTextureUsage ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScaler::inputContentWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setInputContentWidth( NS::UInteger width )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputContentWidth_ ), width );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScaler::inputContentHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setInputContentHeight( NS::UInteger height )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setInputContentHeight_ ), height );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScaler::colorTexture() const
+{
+    return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( colorTexture ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setColorTexture( MTL::Texture* pTexture )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setColorTexture_ ), pTexture );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScaler::depthTexture() const
+{
+    return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( depthTexture ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setDepthTexture( MTL::Texture* pTexture )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setDepthTexture_ ), pTexture );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScaler::motionTexture() const
+{
+    return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( motionTexture ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setMotionTexture( MTL::Texture* pTexture )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setMotionTexture_ ), pTexture );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScaler::outputTexture() const
+{
+    return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( outputTexture ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setOutputTexture( MTL::Texture* pTexture )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setOutputTexture_ ), pTexture );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScaler::exposureTexture() const
+{
+    return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( exposureTexture ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setExposureTexture( MTL::Texture* pTexture )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setExposureTexture_ ), pTexture );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScaler::preExposure() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( preExposure ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setPreExposure( float preExposure )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setPreExposure_ ), preExposure );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScaler::jitterOffsetX() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetX ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setJitterOffsetX( float offset )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setJitterOffsetX_ ), offset );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScaler::jitterOffsetY() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetY ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setJitterOffsetY( float offset )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setJitterOffsetY_ ), offset );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScaler::motionVectorScaleX() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleX ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setMotionVectorScaleX( float scale )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setMotionVectorScaleX_ ), scale );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScaler::motionVectorScaleY() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleY ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setMotionVectorScaleY( float scale )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setMotionVectorScaleY_ ), scale );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE bool MTLFX::TemporalScaler::reset() const
+{
+    return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( reset ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setReset( bool reset )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setReset_ ), reset );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE bool MTLFX::TemporalScaler::isDepthReversed() const
+{
+    return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isDepthReversed ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setDepthReversed( bool depthReversed )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setDepthReversed_ ), depthReversed );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScaler::colorTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScaler::depthTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScaler::motionTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScaler::outputTextureFormat() const
+{
+    return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScaler::inputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScaler::inputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScaler::outputWidth() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE NS::UInteger MTLFX::TemporalScaler::outputHeight() const
+{
+    return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScaler::inputContentMinScale() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMinScale ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE float MTLFX::TemporalScaler::inputContentMaxScale() const
+{
+    return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMaxScale ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE MTL::Fence* MTLFX::TemporalScaler::fence() const
+{
+    return Object::sendMessage< MTL::Fence* >( this, _MTLFX_PRIVATE_SEL( fence ) );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::setFence( MTL::Fence* pFence )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( setFence_ ), pFence );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_MTLFX_INLINE void MTLFX::TemporalScaler::encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer )
+{
+    Object::sendMessage< void >( this, _MTL_PRIVATE_SEL( encodeToCommandBuffer_ ), pCommandBuffer );
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MetalFX.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MetalFX.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..40405cd3d633fa597660ce11805644db4aa148f0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/MetalFX/MetalFX.hpp
@@ -0,0 +1,28 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// MetalFX/MetalFX.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "MTLFXSpatialScaler.hpp"
+#include "MTLFXTemporalScaler.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CADefines.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CADefines.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..83f3d8fc076ea0bf5059c036842220a86f863700
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CADefines.hpp
@@ -0,0 +1,41 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// QuartzCore/CADefines.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "../Foundation/NSDefines.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _CA_EXPORT _NS_EXPORT
+#define _CA_EXTERN _NS_EXTERN
+#define _CA_INLINE _NS_INLINE
+#define _CA_PACKED _NS_PACKED
+
+#define _CA_CONST(type, name) _NS_CONST(type, name)
+#define _CA_ENUM(type, name) _NS_ENUM(type, name)
+#define _CA_OPTIONS(type, name) _NS_OPTIONS(type, name)
+
+#define _CA_VALIDATE_SIZE(ns, name) _NS_VALIDATE_SIZE(ns, name)
+#define _CA_VALIDATE_ENUM(ns, name) _NS_VALIDATE_ENUM(ns, name)
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAMetalDrawable.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAMetalDrawable.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..99a3872a4f3dc1769b97b25775d691c4184992a0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAMetalDrawable.hpp
@@ -0,0 +1,57 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// QuartzCore/CAMetalDrawable.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "../Metal/MTLDrawable.hpp"
+#include "../Metal/MTLTexture.hpp"
+
+#include "CADefines.hpp"
+#include "CAPrivate.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace CA
+{
+class MetalDrawable : public NS::Referencing<MetalDrawable, MTL::Drawable>
+{
+public:
+    class MetalLayer* layer() const;
+    MTL::Texture*     texture() const;
+};
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE CA::MetalLayer* CA::MetalDrawable::layer() const
+{
+    return Object::sendMessage<MetalLayer*>(this, _CA_PRIVATE_SEL(layer));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE MTL::Texture* CA::MetalDrawable::texture() const
+{
+    return Object::sendMessage<MTL::Texture*>(this, _CA_PRIVATE_SEL(texture));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAMetalLayer.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAMetalLayer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..904e218880f366a4b2c187ffc147f33eb5612ad2
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAMetalLayer.hpp
@@ -0,0 +1,131 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// QuartzCore/CAMetalDrawable.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "../Metal/MTLPixelFormat.hpp"
+#include "../Metal/MTLTexture.hpp"
+#include <CoreGraphics/CGGeometry.h>
+
+#include "CADefines.hpp"
+#include "CAMetalDrawable.hpp"
+#include "CAPrivate.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace CA
+{
+
+class MetalLayer : public NS::Referencing<MetalLayer>
+{
+public:
+    static class MetalLayer* layer();
+
+    MTL::Device*             device() const;
+    void                     setDevice(MTL::Device* device);
+
+    MTL::PixelFormat         pixelFormat() const;
+    void                     setPixelFormat(MTL::PixelFormat pixelFormat);
+
+    bool                     framebufferOnly() const;
+    void                     setFramebufferOnly(bool framebufferOnly);
+
+    CGSize                   drawableSize() const;
+    void                     setDrawableSize(CGSize drawableSize);
+
+    class MetalDrawable*     nextDrawable();
+};
+} // namespace CA
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+_CA_INLINE CA::MetalLayer* CA::MetalLayer::layer()
+{
+    return Object::sendMessage<CA::MetalLayer*>(_CA_PRIVATE_CLS(CAMetalLayer), _CA_PRIVATE_SEL(layer));
+}
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE MTL::Device* CA::MetalLayer::device() const
+{
+    return Object::sendMessage<MTL::Device*>(this, _CA_PRIVATE_SEL(device));
+}
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE void CA::MetalLayer::setDevice(MTL::Device* device)
+{
+    return Object::sendMessage<void>(this, _CA_PRIVATE_SEL(setDevice_), device);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE MTL::PixelFormat CA::MetalLayer::pixelFormat() const
+{
+    return Object::sendMessage<MTL::PixelFormat>(this,
+        _CA_PRIVATE_SEL(pixelFormat));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE void CA::MetalLayer::setPixelFormat(MTL::PixelFormat pixelFormat)
+{
+    return Object::sendMessage<void>(this, _CA_PRIVATE_SEL(setPixelFormat_),
+        pixelFormat);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE bool CA::MetalLayer::framebufferOnly() const
+{
+    return Object::sendMessage<bool>(this, _CA_PRIVATE_SEL(framebufferOnly));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE void CA::MetalLayer::setFramebufferOnly(bool framebufferOnly)
+{
+    return Object::sendMessage<void>(this, _CA_PRIVATE_SEL(setFramebufferOnly_),
+        framebufferOnly);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE CGSize CA::MetalLayer::drawableSize() const
+{
+    return Object::sendMessage<CGSize>(this, _CA_PRIVATE_SEL(drawableSize));
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE void CA::MetalLayer::setDrawableSize(CGSize drawableSize)
+{
+    return Object::sendMessage<void>(this, _CA_PRIVATE_SEL(setDrawableSize_),
+        drawableSize);
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+_CA_INLINE CA::MetalDrawable* CA::MetalLayer::nextDrawable()
+{
+    return Object::sendMessage<MetalDrawable*>(this,
+        _CA_PRIVATE_SEL(nextDrawable));
+}
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAPrivate.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAPrivate.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..701ee08207b07e3c1b9500c0e32d6530a66569f0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/CAPrivate.hpp
@@ -0,0 +1,132 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// QuartzCore/CAPrivate.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "CADefines.hpp"
+
+#include <objc/runtime.h>
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#define _CA_PRIVATE_CLS(symbol) (Private::Class::s_k##symbol)
+#define _CA_PRIVATE_SEL(accessor) (Private::Selector::s_k##accessor)
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#if defined(CA_PRIVATE_IMPLEMENTATION)
+
+#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN
+#define _CA_PRIVATE_VISIBILITY __attribute__((visibility("hidden")))
+#else
+#define _CA_PRIVATE_VISIBILITY __attribute__((visibility("default")))
+#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN
+
+#define _CA_PRIVATE_IMPORT __attribute__((weak_import))
+
+#ifdef __OBJC__
+#define _CA_PRIVATE_OBJC_LOOKUP_CLASS(symbol) ((__bridge void*)objc_lookUpClass(#symbol))
+#define _CA_PRIVATE_OBJC_GET_PROTOCOL(symbol) ((__bridge void*)objc_getProtocol(#symbol))
+#else
+#define _CA_PRIVATE_OBJC_LOOKUP_CLASS(symbol) objc_lookUpClass(#symbol)
+#define _CA_PRIVATE_OBJC_GET_PROTOCOL(symbol) objc_getProtocol(#symbol)
+#endif // __OBJC__
+
+#define _CA_PRIVATE_DEF_CLS(symbol) void* s_k##symbol _CA_PRIVATE_VISIBILITY = _CA_PRIVATE_OBJC_LOOKUP_CLASS(symbol)
+#define _CA_PRIVATE_DEF_PRO(symbol) void* s_k##symbol _CA_PRIVATE_VISIBILITY = _CA_PRIVATE_OBJC_GET_PROTOCOL(symbol)
+#define _CA_PRIVATE_DEF_SEL(accessor, symbol) SEL s_k##accessor _CA_PRIVATE_VISIBILITY = sel_registerName(symbol)
+#define _CA_PRIVATE_DEF_STR(type, symbol)                \
+    _CA_EXTERN type const CA##symbol _CA_PRIVATE_IMPORT; \
+    type const                       CA::symbol = (nullptr != &CA##symbol) ? CA##symbol : nullptr
+
+#else
+
+#define _CA_PRIVATE_DEF_CLS(symbol) extern void* s_k##symbol
+#define _CA_PRIVATE_DEF_PRO(symbol) extern void* s_k##symbol
+#define _CA_PRIVATE_DEF_SEL(accessor, symbol) extern SEL s_k##accessor
+#define _CA_PRIVATE_DEF_STR(type, symbol) extern type const CA::symbol
+
+#endif // CA_PRIVATE_IMPLEMENTATION
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace CA
+{
+namespace Private
+{
+    namespace Class
+    {
+        _CA_PRIVATE_DEF_CLS(CAMetalLayer);
+    } // Class
+} // Private
+} // CA
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace CA
+{
+namespace Private
+{
+    namespace Protocol
+    {
+
+        _CA_PRIVATE_DEF_PRO(CAMetalDrawable);
+
+    } // Protocol
+} // Private
+} // CA
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+namespace CA
+{
+namespace Private
+{
+    namespace Selector
+    {
+        _CA_PRIVATE_DEF_SEL(device,
+            "device");
+        _CA_PRIVATE_DEF_SEL(drawableSize,
+            "drawableSize");
+        _CA_PRIVATE_DEF_SEL(framebufferOnly,
+            "framebufferOnly");
+        _CA_PRIVATE_DEF_SEL(layer,
+            "layer");
+        _CA_PRIVATE_DEF_SEL(nextDrawable,
+            "nextDrawable");
+        _CA_PRIVATE_DEF_SEL(pixelFormat,
+            "pixelFormat");
+        _CA_PRIVATE_DEF_SEL(setDevice_,
+            "setDevice:");
+        _CA_PRIVATE_DEF_SEL(setDrawableSize_,
+            "setDrawableSize:");
+        _CA_PRIVATE_DEF_SEL(setFramebufferOnly_,
+            "setFramebufferOnly:");
+        _CA_PRIVATE_DEF_SEL(setPixelFormat_,
+            "setPixelFormat:");
+        _CA_PRIVATE_DEF_SEL(texture,
+            "texture");
+    } // Class
+} // Private
+} // CA
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/QuartzCore.hpp b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/QuartzCore.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..beb57b615a5c0aeee700e23322f6aaab1a47ec75
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/QuartzCore/QuartzCore.hpp
@@ -0,0 +1,28 @@
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+//
+// QuartzCore/QuartzCore.hpp
+//
+// Copyright 2020-2023 Apple Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+#include "CAMetalDrawable.hpp"
+#include "CAMetalLayer.hpp"
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/README.md b/lib/python3.11/site-packages/mlx/include/metal_cpp/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..52e1938cff9b1db634d62ab4ac860966f72e76f0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/README.md
@@ -0,0 +1,311 @@
+## About
+
+**metal-cpp** is a low overhead and header only C++ interface for Metal that helps developers add Metal functionality to graphics applications that are written in C++ (such as game engines). **metal-cpp** removes the need to create a shim and allows developers to call Metal functions directly from anywhere in their existing C++ code.
+
+
+## Highlights
+
+- Drop in C++ alternative interface to the Metal Objective-C headers.
+- Direct mapping of all Metal Objective-C classes, constants and enums to C++ in the MTL C++ namespace.
+- No measurable overhead compared to calling Metal Objective-C headers, due to inlining of C++ function calls.
+- No usage of wrapper containers that require additional allocations.
+- Requires C++17 due to the usage of `constexpr` in `NS::Object`.
+- Identical header files and function/constant/enum availability for iOS, macOS and tvOS.
+- Backwards compatibility: All `bool MTL::Device::supports...()` functions check if their required selectors exist and automatically return `false` if not.
+- String (`ErrorDomain`) constants are weak linked and automatically set to `nullptr` if not available.
+
+## Changelog
+
+| Version | Changes |
+|-|-|
+| macOS 14, iOS 17 | Add support for the **MetalFX** framework. <br/>Add all the APIs in macOS 14 and iOS 17. |
+| macOS 13.3, iOS 16.4 | Add all the APIs in macOS 13.3 and iOS 16.4. |
+| macOS 13, iOS 16| Add all the APIs in macOS 13 and iOS 16.<br />New optional `NS::SharedPtr<T>` type to assist with memory management.<br/>New convenience function to create a `CA::MetalLayer`.<br/>New `MTLSTR(str)` macro allows faster string creation from literals.<br/>Fix a problem with the signature of functions that take an array of pointers as input.<br/>Fix a problem with the signature of the `setGroups()` function in `MTL::LinkedFunctions`.|
+| macOS 12, iOS 15 | Initial release. |
+
+## Memory Allocation Policy
+
+**metal-cpp** follows the object allocation policies of Cocoa, Cocoa Touch, and CoreFoundation. Understanding these rules is especially important when using metal-cpp, as C++ objects are not eligible for automatic reference counting (ARC).
+
+**metal-cpp** objects are reference counted. To help convey and manage object lifecycles, the following conventions are observed:
+
+1. *You own any object returned by methods whose name begins with* `alloc` *,* `new` *,* `copy` *,* `mutableCopy` *, or* `Create`. The method returns these objects with `retainCount` equals to `1`.
+2. *You can take ownership of an object by calling its* ```retain()``` *method*. A received object is normally guaranteed to remain valid within the method it was received in. You use `retain` in two situations: (1) In the implementation of an accessor method (a setter) or to take ownership of an object; and (2) To prevent an object from being deallocated as a side-effect of some other operation.
+3. *When you no longer need it, you must relinquish ownership of an object you own*. You relinquish ownership by calling its `release()` or `autorelease()` method.
+4. *You must not relinquish ownership of an object you do not own*.
+
+When an object's `retainCount` reaches `0`, the object is immediately deallocated. It is illegal to call methods on a deallocated object and it may lead to an application crash.
+
+### AutoreleasePools and Objects
+
+Several methods that create temporary objects in **metal-cpp** add them to an `AutoreleasePool` to help manage their lifetimes. In these situations, after **metal-cpp** creates the object, it adds it to an `AutoreleasePool`, which will release its objects when you release (or drain) it.
+
+By adding temporary objects to an AutoreleasePool, you do not need to explicitly call `release()` to deallocate them. Instead, you can rely on the `AutoreleasePool` to implicitly manage those lifetimes.
+
+If you create an object with a method that does not begin with `alloc`, `new`, `copy`, `mutableCopy`, or `Create`, the creating method adds the object to an autorelease pool.
+
+The typical scope of an `AutoreleasePool` is one frame of rendering for the main thread of the program. When the thread returns control to the RunLoop (an object responsible for receiving input and events from the windowing system), the pool is *drained*, releasing its objects.
+
+You can create and manage additional `AutoreleasePool`s at smaller scopes to reduce your program's working set, and you are required to do so for any additional threads your program creates.
+
+If an object's lifecycle needs to be extended beyond the scope of an `AutoreleasePool` instance, you can claim ownership of it by calling its `retain()` method before the pool is drained. In these cases, you are responsible for making the appropriate `release()` call on the object after you no longer need it.
+
+You can find a more-detailed introduction to the memory management rules here: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmRules.html, and here: https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFMemoryMgmt/Concepts/Ownership.html
+
+For more details about the application's RunLoop, please find its documentation here: https://developer.apple.com/documentation/foundation/nsrunloop
+
+### Use and debug AutoreleasePools
+
+When you create an autoreleased object and there is no enclosing `AutoreleasePool`, the object is leaked.
+
+To prevent this, you normally create an `AutoreleasePool` in your program's `main` function, and in the entry function for every thread you create. You may also create additional `AutoreleasePool`s to avoid growing your program's high memory watermark when you create several autoreleased objects, such as when rendering.
+
+Use the Environment Variable `OBJC_DEBUG_MISSING_POOLS=YES` to print a runtime warning when an autoreleased object is leaked because no enclosing `AutoreleasePool` is available for its thread.
+
+You can also run `leaks --autoreleasePools` on a memgraph file or a process ID (macOS only) to view a listing of your program's `AutoreleasePool`s and all objects they contain.
+
+### NS::SharedPtr
+
+The **metal-cpp** headers include an optional `NS::SharedPtr<>` (shared pointer) template that can help you manually manage memory in your apps.
+
+Shared pointers in **metal-cpp** are different from `std::shared_ptr<>` in that they implement specific optimizations for its memory model. For example, **metal-cpp**'s shared pointers avoid the overhead of the standard library's version by leveraging the reference counting implementation of the `NS::Object` type.
+
+#### Note
+
+The **metal-cpp** shared pointer’s destructor method always calls the `release()` method of the pointer that it wraps.
+
+You can create an `NS::SharedPtr<>` by calling the metal-cpp's factory method that's appropriate for your application's intent:
+
+* You can **transfer** ownership of a pointer to a new shared pointer instance by calling the  `NS::TransferPtr()` factory function, which is the correct function for Resource Acquisition is Initialization (RAII) implementations because it doesn't increase the pointee's retain count.
+
+* You can **share** ownership of a pointer with another entity by calling the `NS::RetainPtr()` factory function. This function can also extend an object's lifecycle beyond an `AutoreleasePool` instance's scope because it creates a strong reference to the pointee and increases its retain count.
+
+Usage of `NS::SharedPtr<>` is optional.
+
+### nullptr
+
+Similar to Objective-C, it is legal to call any method, including `retain()` and `release()`, on `nullptr` "objects". While calling methods on `nullptr` still does incur in function call overhead, the effective result is equivalent of a NOP.
+
+Conversely, do not assume that because calling a method on a pointer did not result in a crash, that the pointed-to object is valid.
+
+## Adding metal-cpp to a Project
+
+Simply include `Metal/Metal.hpp`. To ensure that the selector and class symbols are linked, add to one of your cpp files:
+
+```cpp
+#define NS_PRIVATE_IMPLEMENTATION
+#define MTL_PRIVATE_IMPLEMENTATION
+
+#include "Metal/Metal.hpp"
+```
+
+If you want to use the QuartzCore wrapper, add:
+
+```cpp
+#define CA_PRIVATE_IMPLEMENTATION
+
+#include "QuartzCore/QuartzCore.hpp"
+```
+
+## Generating a Single Header File
+
+Purely optional: You can generate a single header file that contains all **metal-cpp** headers via:
+
+```shell
+./SingleHeader/MakeSingleHeader.py Foundation/Foundation.hpp QuartzCore/QuartzCore.hpp Metal/Metal.hpp MetalFX/MetalFX.hpp
+```
+
+By default the generator script writes its output to `./SingleHeader/Metal.hpp`. Use the `-o` option to customize output filename.
+
+## Global Symbol Visibility
+
+metal-cpp marks all its symbols with `default` visibility. Define the macro: `METALCPP_SYMBOL_VISIBILITY_HIDDEN` to override this behavior and hide its symbols.
+
+## Examples
+
+#### Creating the device
+
+###### Objective-C (with automatic reference counting)
+
+```objc
+id< MTLDevice > device = MTLCreateSystemDefaultDevice();
+
+// ...
+```
+
+###### Objective-C
+
+```objc
+id< MTLDevice > device = MTLCreateSystemDefaultDevice();
+
+// ...
+
+[device release];
+```
+
+###### C++
+
+```cpp
+MTL::Device* pDevice = MTL::CreateSystemDefaultDevice();
+
+// ...
+
+pDevice->release();
+```
+
+###### C++ (using NS::SharedPtr)
+
+```cpp
+NS::SharedPtr< MTL::Device > pDevice = NS::TransferPtr( MTL::CreateSystemDefaultDevice() );
+
+// ...
+```
+
+#### Metal function calls map directly to C++
+
+###### Objective-C (with automatic reference counting)
+
+```objc
+MTLSamplerDescriptor* samplerDescriptor = [[MTLSamplerDescriptor alloc] init];
+
+[samplerDescriptor setSAddressMode: MTLSamplerAddressModeRepeat];
+[samplerDescriptor setTAddressMode: MTLSamplerAddressModeRepeat];
+[samplerDescriptor setRAddressMode: MTLSamplerAddressModeRepeat];
+[samplerDescriptor setMagFilter: MTLSamplerMinMagFilterLinear];
+[samplerDescriptor setMinFilter: MTLSamplerMinMagFilterLinear];
+[samplerDescriptor setMipFilter: MTLSamplerMipFilterLinear];
+[samplerDescriptor setSupportArgumentBuffers: YES];
+
+id< MTLSamplerState > samplerState = [device newSamplerStateWithDescriptor:samplerDescriptor];
+```
+
+###### Objective-C
+
+```objc
+MTLSamplerDescriptor* samplerDescriptor = [[MTLSamplerDescriptor alloc] init];
+
+[samplerDescriptor setSAddressMode: MTLSamplerAddressModeRepeat];
+[samplerDescriptor setTAddressMode: MTLSamplerAddressModeRepeat];
+[samplerDescriptor setRAddressMode: MTLSamplerAddressModeRepeat];
+[samplerDescriptor setMagFilter: MTLSamplerMinMagFilterLinear];
+[samplerDescriptor setMinFilter: MTLSamplerMinMagFilterLinear];
+[samplerDescriptor setMipFilter: MTLSamplerMipFilterLinear];
+[samplerDescriptor setSupportArgumentBuffers: YES];
+
+id< MTLSamplerState > samplerState = [device newSamplerStateWithDescriptor:samplerDescriptor];
+
+[samplerDescriptor release];
+
+// ...
+
+[samplerState release];
+```
+
+###### C++
+
+```cpp
+MTL::SamplerDescriptor* pSamplerDescriptor = MTL::SamplerDescriptor::alloc()->init();
+
+pSamplerDescriptor->setSAddressMode( MTL::SamplerAddressModeRepeat );
+pSamplerDescriptor->setTAddressMode( MTL::SamplerAddressModeRepeat );
+pSamplerDescriptor->setRAddressMode( MTL::SamplerAddressModeRepeat );
+pSamplerDescriptor->setMagFilter( MTL::SamplerMinMagFilterLinear );
+pSamplerDescriptor->setMinFilter( MTL::SamplerMinMagFilterLinear );
+pSamplerDescriptor->setMipFilter( MTL::SamplerMipFilterLinear );
+pSamplerDescriptor->setSupportArgumentBuffers( true );
+
+MTL::SamplerState* pSamplerState = pDevice->newSamplerState( pSamplerDescriptor );
+
+pSamplerDescriptor->release();
+
+// ...
+
+pSamplerState->release();
+```
+
+###### C++ (using NS::SharedPtr)
+
+```cpp
+NS::SharedPtr< MTL::SamplerDescriptor > pSamplerDescriptor = NS::TransferPtr( MTL::SamplerDescriptor::alloc()->init() );
+
+pSamplerDescriptor->setSAddressMode( MTL::SamplerAddressModeRepeat );
+pSamplerDescriptor->setTAddressMode( MTL::SamplerAddressModeRepeat );
+pSamplerDescriptor->setRAddressMode( MTL::SamplerAddressModeRepeat );
+pSamplerDescriptor->setMagFilter( MTL::SamplerMinMagFilterLinear );
+pSamplerDescriptor->setMinFilter( MTL::SamplerMinMagFilterLinear );
+pSamplerDescriptor->setMipFilter( MTL::SamplerMipFilterLinear );
+pSamplerDescriptor->setSupportArgumentBuffers( true );
+
+NS::SharedPtr< MTL::SamplerState > pSamplerState( pDevice->newSamplerState( pSamplerDescriptor ) );
+```
+
+#### A subset of bindings for Foundation classes is provided for seamless integration
+
+###### Objective-C (with automatic reference counting)
+
+```objc
+NSAutoreleasePool*  pool   = [[NSAutoreleasePool alloc] init];
+NSString*           string = [NSString stringWithCString: "Hello World" encoding: NSASCIIStringEncoding];
+
+printf( "string = \"%s\"\n", [string cStringUsingEncoding: NSASCIIStringEncoding] );
+```
+
+###### Objective-C
+
+```objc
+NSAutoreleasePool* pool   = [[NSAutoreleasePool alloc] init];
+NSString*          string = [NSString stringWithCString: "Hello World" encoding: NSASCIIStringEncoding];
+								
+printf( "string = \"%s\"\n", [string cStringUsingEncoding: NSASCIIStringEncoding] );
+
+[pool release];
+```
+
+###### C++
+
+```cpp
+NS::AutoreleasePool* pPool   = NS::AutoreleasePool::alloc()->init();
+NS::String*          pString = NS::String::string( "Hello World", NS::ASCIIStringEncoding );
+
+printf( "pString = \"%s\"\n", pString->cString( NS::ASCIIStringEncoding ) );
+
+pPool->release();
+```
+
+###### C++ (using NS::SharedPtr)
+
+```cpp
+NS::SharedPtr< NS::AutoreleasePool > pPool   = NS::TransferPtr( NS::AutoreleasePool::alloc()->init() );
+NS::String*                          pString = NS::String::string( "Hello World", NS::ASCIIStringEncoding );
+
+printf( "pString = \"%s\"\n", pString->cString( NS::ASCIIStringEncoding ) );
+```
+
+####  Containers
+
+Use the CoreFoundation framework to create `NS::Array` and `NS::Dictionary` instances.
+
+```cpp
+MTL::AccelerationStructureTriangleGeometryDescriptor* pGeoDescriptor  = MTL::AccelerationStructureTriangleGeometryDescriptor::alloc()->init();
+CFTypeRef                                             descriptors[]   = { ( CFTypeRef )( pGeoDescriptor ) };
+NS::Array*                                            pGeoDescriptors = ( NS::Array* )( CFArrayCreate( kCFAllocatorDefault, descriptors, SIZEOF_ARRAY( descriptors), &kCFTypeArrayCallBacks ) );
+
+// ...
+
+pGeoDescriptors->release();
+```
+
+Containers, such as `NS::Array` and `NS::Dictionary`, retain the objects they hold and release them when the container is deallocated.
+
+#### Accessing the Metal Drawable
+
+```cpp
+#import <QuartzCore/QuartzCore.hpp>
+
+// ...
+
+CA::MetalLayer*    pMetalLayer    = /* layer associated with the view */;
+CA::MetalDrawable* pMetalDrawable = pMetalLayer->nextDrawable();
+
+// ...
+```
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/SingleHeader/MakeSingleHeader.py b/lib/python3.11/site-packages/mlx/include/metal_cpp/SingleHeader/MakeSingleHeader.py
new file mode 100644
index 0000000000000000000000000000000000000000..520cb88985078e3864cdbc7fd73c2e7a0432a9e1
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/metal_cpp/SingleHeader/MakeSingleHeader.py
@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+#
+# SingleHeader/MakeSingleHeader.py
+#
+# Copyright 2020-2023 Apple Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+import argparse
+import datetime
+import logging
+import os
+import re
+import subprocess
+import sys
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+class HeaderPrefix( object ):
+	__template 			= ( '//\n'
+							'// {file}\n'
+							'//\n'
+							'// {meta_data}\n'
+							'//\n'
+							'// Copyright 2020-2023 Apple Inc.\n'
+							'//\n'
+							'// Licensed under the Apache License, Version 2.0 (the "License");\n'
+							'// you may not use this file except in compliance with the License.\n'
+							'// You may obtain a copy of the License at\n'
+							'//\n'
+							'//     http://www.apache.org/licenses/LICENSE-2.0\n'
+							'//\n'
+							'// Unless required by applicable law or agreed to in writing, software\n'
+							'// distributed under the License is distributed on an "AS IS" BASIS,\n'
+							'// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n'
+							'// See the License for the specific language governing permissions and\n'
+							'// limitations under the License.\n'
+							'//\n'
+							'\n' )
+
+	__template_commit	=	'Autogenerated from commit {commit}.'
+	__template_date		=	'Autogenerated on %B %d, %Y.'
+
+	def __init__( self, file ):
+		self.__file = file
+
+	def __str__( self ):
+		return self.__template.format( file = self.__file, meta_data = self.__meta_data_string() )
+
+	def __get_commit_hash( self ):
+		git_commit_hash = None
+
+		try:
+			git_dir			= os.path.dirname( os.path.realpath( __file__ ) )
+			proc 			= subprocess.Popen( [ 'git', 'rev-parse', 'HEAD' ], cwd = git_dir, stdout = subprocess.PIPE, stderr = subprocess.PIPE )
+			git_commit_hash = proc.stdout.read().decode( 'utf-8', 'replace' ).strip()
+		except:
+			logging.error( 'Failed to determine git commit hash!' )
+			pass
+
+		return git_commit_hash
+
+	def __get_commit_string( self ):
+		meta_data		= None
+		git_commit_hash	= self.__get_commit_hash()
+
+		if git_commit_hash:
+			meta_data = self.__template_commit.format( commit = git_commit_hash )
+
+		return meta_data
+
+	def __get_date_string( self ):
+		today = datetime.date.today()
+ 
+		return today.strftime( self.__template_date )
+
+	def __meta_data_string( self ):
+		meta_data = self.__get_commit_string()
+
+		if not meta_data:
+			meta_data = self.__get_date_string()
+
+		return meta_data
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+class SingleHeader( object ):
+	__pragma_once = '#pragma once\n\n'
+
+	def __init__( self ):
+		self.__header_paths = list()
+
+	def __str__( self ):
+		return self.process()
+
+	def append( self, header_path ):
+		self.__header_paths.append( header_path )
+
+	def process( self ):
+		out_header 				= self.__pragma_once
+
+		self.__included_headers	= set()
+		self.__base_path 		= list()
+
+		for header_path in self.__header_paths:
+			out_header += self.__process_header( header_path )
+
+		return self.__strip_empty_lines( out_header )
+
+	def __read_header( self, path ):
+		path = os.path.realpath( path )
+
+		try:
+			f = open( path, 'r' )
+		except:
+			raise RuntimeError( 'Failed to open file \"' + path + '\" for read!' )
+
+		return f.read()
+
+	def __strip_pragma_once( self, header ):
+		return re.sub( '\\s*#pragma once\s*\\/\\/-*\\n', '', header )
+
+	def __strip_comments( self, header ):
+		return re.sub( '^//.*\\n', '', header, flags = re.MULTILINE )
+
+	def __strip_empty_lines( self, header ):
+		return re.sub( '\\n\\n+', '\\n\\n', header, flags = re.MULTILINE )
+
+	def __substitute_include_directive( self, match ):
+		header_path = match.group( 'HEADER_PATH' )
+
+		logging.info( '\tSubstituting \"' + header_path + '\"...' )
+
+		return self.__process_header( os.path.join( self.__base_path[-1], header_path ) )
+
+	def __process_include_directives( self, header ):
+		return re.sub( '^\\s*#include\\s\\"(?P<HEADER_PATH>\\S*)\\"', self.__substitute_include_directive, header, flags = re.MULTILINE )
+
+	def __process_foundation_directives( self, header ):
+		if header.find("#include <Foundation/Foundation.hpp>") != -1:
+			logging.info( '\tSubstituting <Foundation/Foundation.hpp>...' )
+			return header.replace("#include <Foundation/Foundation.hpp>", self.__process_header( os.path.join( self.__base_path[-1], "../Foundation/Foundation.hpp" ) ) )
+		return header
+
+
+	def __process_header( self, header_path ):
+		out_header = ''		
+
+		header_path = os.path.realpath( header_path )
+
+		if not header_path in self.__included_headers:
+			logging.info( 'Processing \"' + header_path + '\"...' )
+
+			self.__base_path.append( os.path.dirname( header_path ) )
+			self.__included_headers.add( header_path )
+			
+			out_header = self.__read_header( header_path )
+			out_header = self.__strip_pragma_once( out_header )
+			out_header = self.__strip_comments( out_header )
+			out_header = self.__process_include_directives( out_header )
+			out_header = self.__process_foundation_directives( out_header )
+
+			self.__base_path.pop()
+		else:
+			logging.info( '\tSkipping \"' + header_path + '\"...' )
+
+		return out_header
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+def create_argument_parser():
+	parser 			= argparse.ArgumentParser()
+	base_path 		= os.path.dirname( os.path.realpath( __file__ ) )
+	output_path		= os.path.join( base_path, 'Metal.hpp' )
+
+	parser.add_argument( '-o', '--output',  dest = 'output_path', metavar = 'PATH', default = output_path, help = 'Output path for the single header file.' )
+	parser.add_argument( '-v', '--verbose', action = 'store_true',  help = 'Show verbose output.' )
+	parser.add_argument( dest = 'header_paths', metavar = 'HEADER_FILE', nargs='+', help = 'Input header file.' )
+
+	return parser
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+def parse_arguments():
+	parser	= create_argument_parser()
+	args	= parser.parse_args()
+
+	if args.verbose:
+		logging.getLogger().setLevel( logging.INFO )
+	else:
+		logging.getLogger().setLevel( logging.ERROR )
+
+	return args
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+def make_header( args ):
+	prefix = HeaderPrefix( os.path.basename( args.output_path ) )
+	header = SingleHeader()
+	
+	for header_path in args.header_paths:
+		header.append( header_path )
+
+	return str( prefix ) + str( header )
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+def make_dir( path ):
+	try:
+		if not os.path.exists( path ):
+			os.makedirs( path )
+	except os.error:
+		pass
+	except:
+		raise
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+def write_header( args, content ):
+	path = os.path.realpath( args.output_path )
+
+	logging.info( 'Writing \"' + path + '\"...' )
+
+	make_dir( os.path.dirname( path ) )
+
+	try:
+		f = open( path, 'w' )
+	except:
+		raise RuntimeError( 'Failed to open file \"' + path + '\" for write!' )
+
+	f.write( content )
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+if __name__ == '__main__':
+	result = -1
+	
+	try:
+		if sys.getdefaultencoding().lower() == 'ascii':
+			reload( sys )
+			sys.setdefaultencoding( 'utf-8' )
+
+		args 	= parse_arguments()
+		header 	= make_header( args )
+
+		write_header( args, header )
+
+		result = 0
+
+	except ( KeyboardInterrupt, SystemExit ):
+	 	pass
+	except:
+	 	raise
+
+	sys.exit( result )
+
+#--------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/lib/python3.11/site-packages/mlx/include/metal_cpp/SingleHeader/__pycache__/MakeSingleHeader.cpython-311.pyc b/lib/python3.11/site-packages/mlx/include/metal_cpp/SingleHeader/__pycache__/MakeSingleHeader.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30b7dc0f438011b8c615ccb74febecd7cd63d5cc
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/include/metal_cpp/SingleHeader/__pycache__/MakeSingleHeader.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/3rdparty/pocketfft.h b/lib/python3.11/site-packages/mlx/include/mlx/3rdparty/pocketfft.h
new file mode 100644
index 0000000000000000000000000000000000000000..03a45897a0f0cd664167380a4739f46fab68755d
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/3rdparty/pocketfft.h
@@ -0,0 +1,3581 @@
+/*
+This file is part of pocketfft.
+
+Copyright (C) 2010-2022 Max-Planck-Society
+Copyright (C) 2019-2020 Peter Bell
+
+For the odd-sized DCT-IV transforms:
+  Copyright (C) 2003, 2007-14 Matteo Frigo
+  Copyright (C) 2003, 2007-14 Massachusetts Institute of Technology
+
+Authors: Martin Reinecke, Peter Bell
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name of the copyright holder nor the names of its contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef POCKETFFT_HDRONLY_H
+#define POCKETFFT_HDRONLY_H
+
+#ifndef __cplusplus
+#error This file is C++ and requires a C++ compiler.
+#endif
+
+#if !(__cplusplus >= 201103L || _MSVC_LANG+0L >= 201103L)
+#error This file requires at least C++11 support.
+#endif
+
+#ifndef POCKETFFT_CACHE_SIZE
+#define POCKETFFT_CACHE_SIZE 0
+#endif
+
+#include <cmath>
+#include <cstdlib>
+#include <stdexcept>
+#include <memory>
+#include <vector>
+#include <complex>
+#include <algorithm>
+#if POCKETFFT_CACHE_SIZE!=0
+#include <array>
+#include <mutex>
+#endif
+
+#ifndef POCKETFFT_NO_MULTITHREADING
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+#include <queue>
+#include <atomic>
+#include <functional>
+#include <new>
+
+#ifdef POCKETFFT_PTHREADS
+#  include <pthread.h>
+#endif
+#endif
+
+#if defined(__GNUC__)
+#define POCKETFFT_NOINLINE __attribute__((noinline))
+#define POCKETFFT_RESTRICT __restrict__
+#elif defined(_MSC_VER)
+#define POCKETFFT_NOINLINE __declspec(noinline)
+#define POCKETFFT_RESTRICT __restrict
+#else
+#define POCKETFFT_NOINLINE
+#define POCKETFFT_RESTRICT
+#endif
+
+namespace pocketfft {
+
+namespace detail {
+using std::size_t;
+using std::ptrdiff_t;
+
+// Always use std:: for <cmath> functions
+template <typename T> T cos(T) = delete;
+template <typename T> T sin(T) = delete;
+template <typename T> T sqrt(T) = delete;
+
+using shape_t = std::vector<size_t>;
+using stride_t = std::vector<ptrdiff_t>;
+
+constexpr bool FORWARD  = true,
+               BACKWARD = false;
+
+// only enable vector support for gcc>=5.0 and clang>=5.0
+#ifndef POCKETFFT_NO_VECTORS
+#define POCKETFFT_NO_VECTORS
+#if defined(__INTEL_COMPILER)
+// do nothing. This is necessary because this compiler also sets __GNUC__.
+#elif defined(__clang__)
+// AppleClang has their own version numbering
+#ifdef __apple_build_version__
+#  if (__clang_major__ > 9) || (__clang_major__ == 9 && __clang_minor__ >= 1)
+#     undef POCKETFFT_NO_VECTORS
+#  endif
+#elif __clang_major__ >= 5
+#  undef POCKETFFT_NO_VECTORS
+#endif
+#elif defined(__GNUC__)
+#if __GNUC__>=5
+#undef POCKETFFT_NO_VECTORS
+#endif
+#endif
+#endif
+
+template<typename T> struct VLEN { static constexpr size_t val=1; };
+
+#ifndef POCKETFFT_NO_VECTORS
+#if (defined(__AVX512F__))
+template<> struct VLEN<float> { static constexpr size_t val=16; };
+template<> struct VLEN<double> { static constexpr size_t val=8; };
+#elif (defined(__AVX__))
+template<> struct VLEN<float> { static constexpr size_t val=8; };
+template<> struct VLEN<double> { static constexpr size_t val=4; };
+#elif (defined(__SSE2__))
+template<> struct VLEN<float> { static constexpr size_t val=4; };
+template<> struct VLEN<double> { static constexpr size_t val=2; };
+#elif (defined(__VSX__))
+template<> struct VLEN<float> { static constexpr size_t val=4; };
+template<> struct VLEN<double> { static constexpr size_t val=2; };
+#elif (defined(__ARM_NEON__) || defined(__ARM_NEON))
+template<> struct VLEN<float> { static constexpr size_t val=4; };
+template<> struct VLEN<double> { static constexpr size_t val=2; };
+#else
+#define POCKETFFT_NO_VECTORS
+#endif
+#endif
+
+// the __MINGW32__ part in the conditional below works around the problem that
+// the standard C++ library on Windows does not provide aligned_alloc() even
+// though the MinGW compiler and MSVC may advertise C++17 compliance.
+#if (__cplusplus >= 201703L) && (!defined(__MINGW32__)) && (!defined(_MSC_VER))
+inline void *aligned_alloc(size_t align, size_t size)
+  {
+  // aligned_alloc() requires that the requested size is a multiple of "align"
+  void *ptr = ::aligned_alloc(align,(size+align-1)&(~(align-1)));
+  if (!ptr) throw std::bad_alloc();
+  return ptr;
+  }
+inline void aligned_dealloc(void *ptr)
+    { free(ptr); }
+#else // portable emulation
+inline void *aligned_alloc(size_t align, size_t size)
+  {
+  align = std::max(align, alignof(max_align_t));
+  void *ptr = malloc(size+align);
+  if (!ptr) throw std::bad_alloc();
+  void *res = reinterpret_cast<void *>
+    ((reinterpret_cast<uintptr_t>(ptr) & ~(uintptr_t(align-1))) + uintptr_t(align));
+  (reinterpret_cast<void**>(res))[-1] = ptr;
+  return res;
+  }
+inline void aligned_dealloc(void *ptr)
+  { if (ptr) free((reinterpret_cast<void**>(ptr))[-1]); }
+#endif
+
+template<typename T> class arr
+  {
+  private:
+    T *p;
+    size_t sz;
+
+#if defined(POCKETFFT_NO_VECTORS)
+    static T *ralloc(size_t num)
+      {
+      if (num==0) return nullptr;
+      void *res = malloc(num*sizeof(T));
+      if (!res) throw std::bad_alloc();
+      return reinterpret_cast<T *>(res);
+      }
+    static void dealloc(T *ptr)
+      { free(ptr); }
+#else
+    static T *ralloc(size_t num)
+      {
+      if (num==0) return nullptr;
+      void *ptr = aligned_alloc(64, num*sizeof(T));
+      return static_cast<T*>(ptr);
+      }
+    static void dealloc(T *ptr)
+      { aligned_dealloc(ptr); }
+#endif
+
+  public:
+    arr() : p(0), sz(0) {}
+    arr(size_t n) : p(ralloc(n)), sz(n) {}
+    arr(arr &&other)
+      : p(other.p), sz(other.sz)
+      { other.p=nullptr; other.sz=0; }
+    ~arr() { dealloc(p); }
+
+    void resize(size_t n)
+      {
+      if (n==sz) return;
+      dealloc(p);
+      p = ralloc(n);
+      sz = n;
+      }
+
+    T &operator[](size_t idx) { return p[idx]; }
+    const T &operator[](size_t idx) const { return p[idx]; }
+
+    T *data() { return p; }
+    const T *data() const { return p; }
+
+    size_t size() const { return sz; }
+  };
+
+template<typename T> struct cmplx {
+  T r, i;
+  cmplx() {}
+  cmplx(T r_, T i_) : r(r_), i(i_) {}
+  void Set(T r_, T i_) { r=r_; i=i_; }
+  void Set(T r_) { r=r_; i=T(0); }
+  cmplx &operator+= (const cmplx &other)
+    { r+=other.r; i+=other.i; return *this; }
+  template<typename T2>cmplx &operator*= (T2 other)
+    { r*=other; i*=other; return *this; }
+  template<typename T2>cmplx &operator*= (const cmplx<T2> &other)
+    {
+    T tmp = r*other.r - i*other.i;
+    i = r*other.i + i*other.r;
+    r = tmp;
+    return *this;
+    }
+  template<typename T2>cmplx &operator+= (const cmplx<T2> &other)
+    { r+=other.r; i+=other.i; return *this; }
+  template<typename T2>cmplx &operator-= (const cmplx<T2> &other)
+    { r-=other.r; i-=other.i; return *this; }
+  template<typename T2> auto operator* (const T2 &other) const
+    -> cmplx<decltype(r*other)>
+    { return {r*other, i*other}; }
+  template<typename T2> auto operator+ (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    { return {r+other.r, i+other.i}; }
+  template<typename T2> auto operator- (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    { return {r-other.r, i-other.i}; }
+  template<typename T2> auto operator* (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    { return {r*other.r-i*other.i, r*other.i + i*other.r}; }
+  template<bool fwd, typename T2> auto special_mul (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    {
+    using Tres = cmplx<decltype(r+other.r)>;
+    return fwd ? Tres(r*other.r+i*other.i, i*other.r-r*other.i)
+               : Tres(r*other.r-i*other.i, r*other.i+i*other.r);
+    }
+};
+template<typename T> inline void PM(T &a, T &b, T c, T d)
+  { a=c+d; b=c-d; }
+template<typename T> inline void PMINPLACE(T &a, T &b)
+  { T t = a; a+=b; b=t-b; }
+template<typename T> inline void MPINPLACE(T &a, T &b)
+  { T t = a; a-=b; b=t+b; }
+template<typename T> cmplx<T> conj(const cmplx<T> &a)
+  { return {a.r, -a.i}; }
+template<bool fwd, typename T, typename T2> void special_mul (const cmplx<T> &v1, const cmplx<T2> &v2, cmplx<T> &res)
+  {
+  res = fwd ? cmplx<T>(v1.r*v2.r+v1.i*v2.i, v1.i*v2.r-v1.r*v2.i)
+            : cmplx<T>(v1.r*v2.r-v1.i*v2.i, v1.r*v2.i+v1.i*v2.r);
+  }
+
+template<typename T> void ROT90(cmplx<T> &a)
+  { auto tmp_=a.r; a.r=-a.i; a.i=tmp_; }
+template<bool fwd, typename T> void ROTX90(cmplx<T> &a)
+  { auto tmp_= fwd ? -a.r : a.r; a.r = fwd ? a.i : -a.i; a.i=tmp_; }
+
+//
+// twiddle factor section
+//
+template<typename T> class sincos_2pibyn
+  {
+  private:
+    using Thigh = typename std::conditional<(sizeof(T)>sizeof(double)), T, double>::type;
+    size_t N, mask, shift;
+    arr<cmplx<Thigh>> v1, v2;
+
+    static cmplx<Thigh> calc(size_t x, size_t n, Thigh ang)
+      {
+      x<<=3;
+      if (x<4*n) // first half
+        {
+        if (x<2*n) // first quadrant
+          {
+          if (x<n) return cmplx<Thigh>(std::cos(Thigh(x)*ang), std::sin(Thigh(x)*ang));
+          return cmplx<Thigh>(std::sin(Thigh(2*n-x)*ang), std::cos(Thigh(2*n-x)*ang));
+          }
+        else // second quadrant
+          {
+          x-=2*n;
+          if (x<n) return cmplx<Thigh>(-std::sin(Thigh(x)*ang), std::cos(Thigh(x)*ang));
+          return cmplx<Thigh>(-std::cos(Thigh(2*n-x)*ang), std::sin(Thigh(2*n-x)*ang));
+          }
+        }
+      else
+        {
+        x=8*n-x;
+        if (x<2*n) // third quadrant
+          {
+          if (x<n) return cmplx<Thigh>(std::cos(Thigh(x)*ang), -std::sin(Thigh(x)*ang));
+          return cmplx<Thigh>(std::sin(Thigh(2*n-x)*ang), -std::cos(Thigh(2*n-x)*ang));
+          }
+        else // fourth quadrant
+          {
+          x-=2*n;
+          if (x<n) return cmplx<Thigh>(-std::sin(Thigh(x)*ang), -std::cos(Thigh(x)*ang));
+          return cmplx<Thigh>(-std::cos(Thigh(2*n-x)*ang), -std::sin(Thigh(2*n-x)*ang));
+          }
+        }
+      }
+
+  public:
+    POCKETFFT_NOINLINE sincos_2pibyn(size_t n)
+      : N(n)
+      {
+      constexpr auto pi = 3.141592653589793238462643383279502884197L;
+      Thigh ang = Thigh(0.25L*pi/n);
+      size_t nval = (n+2)/2;
+      shift = 1;
+      while((size_t(1)<<shift)*(size_t(1)<<shift) < nval) ++shift;
+      mask = (size_t(1)<<shift)-1;
+      v1.resize(mask+1);
+      v1[0].Set(Thigh(1), Thigh(0));
+      for (size_t i=1; i<v1.size(); ++i)
+        v1[i]=calc(i,n,ang);
+      v2.resize((nval+mask)/(mask+1));
+      v2[0].Set(Thigh(1), Thigh(0));
+      for (size_t i=1; i<v2.size(); ++i)
+        v2[i]=calc(i*(mask+1),n,ang);
+      }
+
+    cmplx<T> operator[](size_t idx) const
+      {
+      if (2*idx<=N)
+        {
+        auto x1=v1[idx&mask], x2=v2[idx>>shift];
+        return cmplx<T>(T(x1.r*x2.r-x1.i*x2.i), T(x1.r*x2.i+x1.i*x2.r));
+        }
+      idx = N-idx;
+      auto x1=v1[idx&mask], x2=v2[idx>>shift];
+      return cmplx<T>(T(x1.r*x2.r-x1.i*x2.i), -T(x1.r*x2.i+x1.i*x2.r));
+      }
+  };
+
+struct util // hack to avoid duplicate symbols
+  {
+  static POCKETFFT_NOINLINE size_t largest_prime_factor (size_t n)
+    {
+    size_t res=1;
+    while ((n&1)==0)
+      { res=2; n>>=1; }
+    for (size_t x=3; x*x<=n; x+=2)
+      while ((n%x)==0)
+        { res=x; n/=x; }
+    if (n>1) res=n;
+    return res;
+    }
+
+  static POCKETFFT_NOINLINE double cost_guess (size_t n)
+    {
+    constexpr double lfp=1.1; // penalty for non-hardcoded larger factors
+    size_t ni=n;
+    double result=0.;
+    while ((n&1)==0)
+      { result+=2; n>>=1; }
+    for (size_t x=3; x*x<=n; x+=2)
+      while ((n%x)==0)
+        {
+        result+= (x<=5) ? double(x) : lfp*double(x); // penalize larger prime factors
+        n/=x;
+        }
+    if (n>1) result+=(n<=5) ? double(n) : lfp*double(n);
+    return result*double(ni);
+    }
+
+  /* returns the smallest composite of 2, 3, 5, 7 and 11 which is >= n */
+  static POCKETFFT_NOINLINE size_t good_size_cmplx(size_t n)
+    {
+    if (n<=12) return n;
+
+    size_t bestfac=2*n;
+    for (size_t f11=1; f11<bestfac; f11*=11)
+      for (size_t f117=f11; f117<bestfac; f117*=7)
+        for (size_t f1175=f117; f1175<bestfac; f1175*=5)
+          {
+          size_t x=f1175;
+          while (x<n) x*=2;
+          for (;;)
+            {
+            if (x<n)
+              x*=3;
+            else if (x>n)
+              {
+              if (x<bestfac) bestfac=x;
+              if (x&1) break;
+              x>>=1;
+              }
+            else
+              return n;
+            }
+          }
+    return bestfac;
+    }
+
+  /* returns the smallest composite of 2, 3, 5 which is >= n */
+  static POCKETFFT_NOINLINE size_t good_size_real(size_t n)
+    {
+    if (n<=6) return n;
+
+    size_t bestfac=2*n;
+    for (size_t f5=1; f5<bestfac; f5*=5)
+      {
+      size_t x = f5;
+      while (x<n) x *= 2;
+      for (;;)
+        {
+        if (x<n)
+          x*=3;
+        else if (x>n)
+          {
+          if (x<bestfac) bestfac=x;
+          if (x&1) break;
+          x>>=1;
+          }
+        else
+          return n;
+        }
+      }
+    return bestfac;
+    }
+
+  static size_t prod(const shape_t &shape)
+    {
+    size_t res=1;
+    for (auto sz: shape)
+      res*=sz;
+    return res;
+    }
+
+  static POCKETFFT_NOINLINE void sanity_check(const shape_t &shape,
+    const stride_t &stride_in, const stride_t &stride_out, bool inplace)
+    {
+    auto ndim = shape.size();
+    if (ndim<1) throw std::runtime_error("ndim must be >= 1");
+    if ((stride_in.size()!=ndim) || (stride_out.size()!=ndim))
+      throw std::runtime_error("stride dimension mismatch");
+    if (inplace && (stride_in!=stride_out))
+      throw std::runtime_error("stride mismatch");
+    }
+
+  static POCKETFFT_NOINLINE void sanity_check(const shape_t &shape,
+    const stride_t &stride_in, const stride_t &stride_out, bool inplace,
+    const shape_t &axes)
+    {
+    sanity_check(shape, stride_in, stride_out, inplace);
+    auto ndim = shape.size();
+    shape_t tmp(ndim,0);
+    for (auto ax : axes)
+      {
+      if (ax>=ndim) throw std::invalid_argument("bad axis number");
+      if (++tmp[ax]>1) throw std::invalid_argument("axis specified repeatedly");
+      }
+    }
+
+  static POCKETFFT_NOINLINE void sanity_check(const shape_t &shape,
+    const stride_t &stride_in, const stride_t &stride_out, bool inplace,
+    size_t axis)
+    {
+    sanity_check(shape, stride_in, stride_out, inplace);
+    if (axis>=shape.size()) throw std::invalid_argument("bad axis number");
+    }
+
+#ifdef POCKETFFT_NO_MULTITHREADING
+  static size_t thread_count (size_t /*nthreads*/, const shape_t &/*shape*/,
+    size_t /*axis*/, size_t /*vlen*/)
+    { return 1; }
+#else
+  static size_t thread_count (size_t nthreads, const shape_t &shape,
+    size_t axis, size_t vlen)
+    {
+    if (nthreads==1) return 1;
+    size_t size = prod(shape);
+    size_t parallel = size / (shape[axis] * vlen);
+    if (shape[axis] < 1000)
+      parallel /= 4;
+    size_t max_threads = nthreads == 0 ?
+      std::thread::hardware_concurrency() : nthreads;
+    return std::max(size_t(1), std::min(parallel, max_threads));
+    }
+#endif
+  };
+
+namespace threading {
+
+#ifdef POCKETFFT_NO_MULTITHREADING
+
+constexpr inline size_t thread_id() { return 0; }
+constexpr inline size_t num_threads() { return 1; }
+
+template <typename Func>
+void thread_map(size_t /* nthreads */, Func f)
+  { f(); }
+
+#else
+
+inline size_t &thread_id()
+  {
+  static thread_local size_t thread_id_=0;
+  return thread_id_;
+  }
+inline size_t &num_threads()
+  {
+  static thread_local size_t num_threads_=1;
+  return num_threads_;
+  }
+static const size_t max_threads = std::max(1u, std::thread::hardware_concurrency());
+
+class latch
+  {
+    std::atomic<size_t> num_left_;
+    std::mutex mut_;
+    std::condition_variable completed_;
+    using lock_t = std::unique_lock<std::mutex>;
+
+  public:
+    latch(size_t n): num_left_(n) {}
+
+    void count_down()
+      {
+      lock_t lock(mut_);
+      if (--num_left_)
+        return;
+      completed_.notify_all();
+      }
+
+    void wait()
+      {
+      lock_t lock(mut_);
+      completed_.wait(lock, [this]{ return is_ready(); });
+      }
+    bool is_ready() { return num_left_ == 0; }
+  };
+
+template <typename T> class concurrent_queue
+  {
+    std::queue<T> q_;
+    std::mutex mut_;
+    std::atomic<size_t> size_;
+    using lock_t = std::lock_guard<std::mutex>;
+
+  public:
+
+    void push(T val)
+      {
+      lock_t lock(mut_);
+      ++size_;
+      q_.push(std::move(val));
+      }
+
+    bool try_pop(T &val)
+      {
+      if (size_ == 0) return false;
+      lock_t lock(mut_);
+      // Queue might have been emptied while we acquired the lock
+      if (q_.empty()) return false;
+
+      val = std::move(q_.front());
+      --size_;
+      q_.pop();
+      return true;
+      }
+
+    bool empty() const { return size_==0; }
+  };
+
+// C++ allocator with support for over-aligned types
+template <typename T> struct aligned_allocator
+  {
+  using value_type = T;
+  template <class U>
+  aligned_allocator(const aligned_allocator<U>&) {}
+  aligned_allocator() = default;
+
+  T *allocate(size_t n)
+    {
+    void* mem = aligned_alloc(alignof(T), n*sizeof(T));
+    return static_cast<T*>(mem);
+    }
+
+  void deallocate(T *p, size_t /*n*/)
+    { aligned_dealloc(p); }
+  };
+
+class thread_pool
+  {
+    // A reasonable guess, probably close enough for most hardware
+    static constexpr size_t cache_line_size = 64;
+    struct alignas(cache_line_size) worker
+      {
+      std::thread thread;
+      std::condition_variable work_ready;
+      std::mutex mut;
+      std::atomic_flag busy_flag = ATOMIC_FLAG_INIT;
+      std::function<void()> work;
+
+      void worker_main(
+        std::atomic<bool> &shutdown_flag,
+        std::atomic<size_t> &unscheduled_tasks,
+        concurrent_queue<std::function<void()>> &overflow_work)
+        {
+        using lock_t = std::unique_lock<std::mutex>;
+        bool expect_work = true;
+        while (!shutdown_flag || expect_work)
+          {
+          std::function<void()> local_work;
+          if (expect_work || unscheduled_tasks == 0)
+            {
+            lock_t lock(mut);
+            // Wait until there is work to be executed
+            work_ready.wait(lock, [&]{ return (work || shutdown_flag); });
+            local_work.swap(work);
+            expect_work = false;
+            }
+
+          bool marked_busy = false;
+          if (local_work)
+            {
+            marked_busy = true;
+            local_work();
+            }
+
+          if (!overflow_work.empty())
+            {
+            if (!marked_busy && busy_flag.test_and_set())
+              {
+              expect_work = true;
+              continue;
+              }
+            marked_busy = true;
+
+            while (overflow_work.try_pop(local_work))
+              {
+              --unscheduled_tasks;
+              local_work();
+              }
+            }
+
+          if (marked_busy) busy_flag.clear();
+          }
+        }
+      };
+
+    concurrent_queue<std::function<void()>> overflow_work_;
+    std::mutex mut_;
+    std::vector<worker, aligned_allocator<worker>> workers_;
+    std::atomic<bool> shutdown_;
+    std::atomic<size_t> unscheduled_tasks_;
+    using lock_t = std::lock_guard<std::mutex>;
+
+    void create_threads()
+      {
+      lock_t lock(mut_);
+      size_t nthreads=workers_.size();
+      for (size_t i=0; i<nthreads; ++i)
+        {
+        try
+          {
+          auto *worker = &workers_[i];
+          worker->busy_flag.clear();
+          worker->work = nullptr;
+          worker->thread = std::thread([worker, this]
+            {
+            worker->worker_main(shutdown_, unscheduled_tasks_, overflow_work_);
+            });
+          }
+        catch (...)
+          {
+          shutdown_locked();
+          throw;
+          }
+        }
+      }
+
+    void shutdown_locked()
+      {
+      shutdown_ = true;
+      for (auto &worker : workers_)
+        worker.work_ready.notify_all();
+
+      for (auto &worker : workers_)
+        if (worker.thread.joinable())
+          worker.thread.join();
+      }
+
+  public:
+    explicit thread_pool(size_t nthreads):
+      workers_(nthreads)
+      { create_threads(); }
+
+    thread_pool(): thread_pool(max_threads) {}
+
+    ~thread_pool() { shutdown(); }
+
+    void submit(std::function<void()> work)
+      {
+      lock_t lock(mut_);
+      if (shutdown_)
+        throw std::runtime_error("Work item submitted after shutdown");
+
+      ++unscheduled_tasks_;
+
+      // First check for any idle workers and wake those
+      for (auto &worker : workers_)
+        if (!worker.busy_flag.test_and_set())
+          {
+          --unscheduled_tasks_;
+          {
+          lock_t lock(worker.mut);
+          worker.work = std::move(work);
+          }
+          worker.work_ready.notify_one();
+          return;
+          }
+
+      // If no workers were idle, push onto the overflow queue for later
+      overflow_work_.push(std::move(work));
+      }
+
+    void shutdown()
+      {
+      lock_t lock(mut_);
+      shutdown_locked();
+      }
+
+    void restart()
+      {
+      shutdown_ = false;
+      create_threads();
+      }
+  };
+
+inline thread_pool & get_pool()
+  {
+  static thread_pool pool;
+#ifdef POCKETFFT_PTHREADS
+  static std::once_flag f;
+  std::call_once(f,
+    []{
+    pthread_atfork(
+      +[]{ get_pool().shutdown(); },  // prepare
+      +[]{ get_pool().restart(); },   // parent
+      +[]{ get_pool().restart(); }    // child
+      );
+    });
+#endif
+
+  return pool;
+  }
+
+/** Map a function f over nthreads */
+template <typename Func>
+void thread_map(size_t nthreads, Func f)
+  {
+  if (nthreads == 0)
+    nthreads = max_threads;
+
+  if (nthreads == 1)
+    { f(); return; }
+
+  auto & pool = get_pool();
+  latch counter(nthreads);
+  std::exception_ptr ex;
+  std::mutex ex_mut;
+  for (size_t i=0; i<nthreads; ++i)
+    {
+    pool.submit(
+      [&f, &counter, &ex, &ex_mut, i, nthreads] {
+      thread_id() = i;
+      num_threads() = nthreads;
+      try { f(); }
+      catch (...)
+        {
+        std::lock_guard<std::mutex> lock(ex_mut);
+        ex = std::current_exception();
+        }
+      counter.count_down();
+      });
+    }
+  counter.wait();
+  if (ex)
+    std::rethrow_exception(ex);
+  }
+
+#endif
+
+}
+
+//
+// complex FFTPACK transforms
+//
+
+template<typename T0> class cfftp
+  {
+  private:
+    struct fctdata
+      {
+      size_t fct;
+      cmplx<T0> *tw, *tws;
+      };
+
+    size_t length;
+    arr<cmplx<T0>> mem;
+    std::vector<fctdata> fact;
+
+    void add_factor(size_t factor)
+      { fact.push_back({factor, nullptr, nullptr}); }
+
+template<bool fwd, typename T> void pass2 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+2*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      CH(0,k,0) = CC(0,0,k)+CC(0,1,k);
+      CH(0,k,1) = CC(0,0,k)-CC(0,1,k);
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      CH(0,k,0) = CC(0,0,k)+CC(0,1,k);
+      CH(0,k,1) = CC(0,0,k)-CC(0,1,k);
+      for (size_t i=1; i<ido; ++i)
+        {
+        CH(i,k,0) = CC(i,0,k)+CC(i,1,k);
+        special_mul<fwd>(CC(i,0,k)-CC(i,1,k),WA(0,i),CH(i,k,1));
+        }
+      }
+  }
+
+#define POCKETFFT_PREP3(idx) \
+        T t0 = CC(idx,0,k), t1, t2; \
+        PM (t1,t2,CC(idx,1,k),CC(idx,2,k)); \
+        CH(idx,k,0)=t0+t1;
+#define POCKETFFT_PARTSTEP3a(u1,u2,twr,twi) \
+        { \
+        T ca=t0+t1*twr; \
+        T cb{-t2.i*twi, t2.r*twi}; \
+        PM(CH(0,k,u1),CH(0,k,u2),ca,cb) ;\
+        }
+#define POCKETFFT_PARTSTEP3b(u1,u2,twr,twi) \
+        { \
+        T ca=t0+t1*twr; \
+        T cb{-t2.i*twi, t2.r*twi}; \
+        special_mul<fwd>(ca+cb,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(ca-cb,WA(u2-1,i),CH(i,k,u2)); \
+        }
+template<bool fwd, typename T> void pass3 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r=-0.5,
+               tw1i= (fwd ? -1: 1) * T0(0.8660254037844386467637231707529362L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+3*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP3(0)
+      POCKETFFT_PARTSTEP3a(1,2,tw1r,tw1i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP3(0)
+      POCKETFFT_PARTSTEP3a(1,2,tw1r,tw1i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP3(i)
+        POCKETFFT_PARTSTEP3b(1,2,tw1r,tw1i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP3b
+#undef POCKETFFT_PARTSTEP3a
+#undef POCKETFFT_PREP3
+
+template<bool fwd, typename T> void pass4 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+4*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      T t1, t2, t3, t4;
+      PM(t2,t1,CC(0,0,k),CC(0,2,k));
+      PM(t3,t4,CC(0,1,k),CC(0,3,k));
+      ROTX90<fwd>(t4);
+      PM(CH(0,k,0),CH(0,k,2),t2,t3);
+      PM(CH(0,k,1),CH(0,k,3),t1,t4);
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      T t1, t2, t3, t4;
+      PM(t2,t1,CC(0,0,k),CC(0,2,k));
+      PM(t3,t4,CC(0,1,k),CC(0,3,k));
+      ROTX90<fwd>(t4);
+      PM(CH(0,k,0),CH(0,k,2),t2,t3);
+      PM(CH(0,k,1),CH(0,k,3),t1,t4);
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        T t1, t2, t3, t4;
+        T cc0=CC(i,0,k), cc1=CC(i,1,k),cc2=CC(i,2,k),cc3=CC(i,3,k);
+        PM(t2,t1,cc0,cc2);
+        PM(t3,t4,cc1,cc3);
+        ROTX90<fwd>(t4);
+        CH(i,k,0) = t2+t3;
+        special_mul<fwd>(t1+t4,WA(0,i),CH(i,k,1));
+        special_mul<fwd>(t2-t3,WA(1,i),CH(i,k,2));
+        special_mul<fwd>(t1-t4,WA(2,i),CH(i,k,3));
+        }
+      }
+  }
+
+#define POCKETFFT_PREP5(idx) \
+        T t0 = CC(idx,0,k), t1, t2, t3, t4; \
+        PM (t1,t4,CC(idx,1,k),CC(idx,4,k)); \
+        PM (t2,t3,CC(idx,2,k),CC(idx,3,k)); \
+        CH(idx,k,0).r=t0.r+t1.r+t2.r; \
+        CH(idx,k,0).i=t0.i+t1.i+t2.i;
+
+#define POCKETFFT_PARTSTEP5a(u1,u2,twar,twbr,twai,twbi) \
+        { \
+        T ca,cb; \
+        ca.r=t0.r+twar*t1.r+twbr*t2.r; \
+        ca.i=t0.i+twar*t1.i+twbr*t2.i; \
+        cb.i=twai*t4.r twbi*t3.r; \
+        cb.r=-(twai*t4.i twbi*t3.i); \
+        PM(CH(0,k,u1),CH(0,k,u2),ca,cb); \
+        }
+
+#define POCKETFFT_PARTSTEP5b(u1,u2,twar,twbr,twai,twbi) \
+        { \
+        T ca,cb,da,db; \
+        ca.r=t0.r+twar*t1.r+twbr*t2.r; \
+        ca.i=t0.i+twar*t1.i+twbr*t2.i; \
+        cb.i=twai*t4.r twbi*t3.r; \
+        cb.r=-(twai*t4.i twbi*t3.i); \
+        special_mul<fwd>(ca+cb,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(ca-cb,WA(u2-1,i),CH(i,k,u2)); \
+        }
+template<bool fwd, typename T> void pass5 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r= T0(0.3090169943749474241022934171828191L),
+               tw1i= (fwd ? -1: 1) * T0(0.9510565162951535721164393333793821L),
+               tw2r= T0(-0.8090169943749474241022934171828191L),
+               tw2i= (fwd ? -1: 1) * T0(0.5877852522924731291687059546390728L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+5*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP5(0)
+      POCKETFFT_PARTSTEP5a(1,4,tw1r,tw2r,+tw1i,+tw2i)
+      POCKETFFT_PARTSTEP5a(2,3,tw2r,tw1r,+tw2i,-tw1i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP5(0)
+      POCKETFFT_PARTSTEP5a(1,4,tw1r,tw2r,+tw1i,+tw2i)
+      POCKETFFT_PARTSTEP5a(2,3,tw2r,tw1r,+tw2i,-tw1i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP5(i)
+        POCKETFFT_PARTSTEP5b(1,4,tw1r,tw2r,+tw1i,+tw2i)
+        POCKETFFT_PARTSTEP5b(2,3,tw2r,tw1r,+tw2i,-tw1i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP5b
+#undef POCKETFFT_PARTSTEP5a
+#undef POCKETFFT_PREP5
+
+#define POCKETFFT_PREP7(idx) \
+        T t1 = CC(idx,0,k), t2, t3, t4, t5, t6, t7; \
+        PM (t2,t7,CC(idx,1,k),CC(idx,6,k)); \
+        PM (t3,t6,CC(idx,2,k),CC(idx,5,k)); \
+        PM (t4,t5,CC(idx,3,k),CC(idx,4,k)); \
+        CH(idx,k,0).r=t1.r+t2.r+t3.r+t4.r; \
+        CH(idx,k,0).i=t1.i+t2.i+t3.i+t4.i;
+
+#define POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,out1,out2) \
+        { \
+        T ca,cb; \
+        ca.r=t1.r+x1*t2.r+x2*t3.r+x3*t4.r; \
+        ca.i=t1.i+x1*t2.i+x2*t3.i+x3*t4.i; \
+        cb.i=y1*t7.r y2*t6.r y3*t5.r; \
+        cb.r=-(y1*t7.i y2*t6.i y3*t5.i); \
+        PM(out1,out2,ca,cb); \
+        }
+#define POCKETFFT_PARTSTEP7a(u1,u2,x1,x2,x3,y1,y2,y3) \
+        POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,CH(0,k,u1),CH(0,k,u2))
+#define POCKETFFT_PARTSTEP7(u1,u2,x1,x2,x3,y1,y2,y3) \
+        { \
+        T da,db; \
+        POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,da,db) \
+        special_mul<fwd>(da,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(db,WA(u2-1,i),CH(i,k,u2)); \
+        }
+
+template<bool fwd, typename T> void pass7(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r= T0(0.6234898018587335305250048840042398L),
+               tw1i= (fwd ? -1 : 1) * T0(0.7818314824680298087084445266740578L),
+               tw2r= T0(-0.2225209339563144042889025644967948L),
+               tw2i= (fwd ? -1 : 1) * T0(0.9749279121818236070181316829939312L),
+               tw3r= T0(-0.9009688679024191262361023195074451L),
+               tw3i= (fwd ? -1 : 1) * T0(0.433883739117558120475768332848359L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+7*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP7(0)
+      POCKETFFT_PARTSTEP7a(1,6,tw1r,tw2r,tw3r,+tw1i,+tw2i,+tw3i)
+      POCKETFFT_PARTSTEP7a(2,5,tw2r,tw3r,tw1r,+tw2i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP7a(3,4,tw3r,tw1r,tw2r,+tw3i,-tw1i,+tw2i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP7(0)
+      POCKETFFT_PARTSTEP7a(1,6,tw1r,tw2r,tw3r,+tw1i,+tw2i,+tw3i)
+      POCKETFFT_PARTSTEP7a(2,5,tw2r,tw3r,tw1r,+tw2i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP7a(3,4,tw3r,tw1r,tw2r,+tw3i,-tw1i,+tw2i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP7(i)
+        POCKETFFT_PARTSTEP7(1,6,tw1r,tw2r,tw3r,+tw1i,+tw2i,+tw3i)
+        POCKETFFT_PARTSTEP7(2,5,tw2r,tw3r,tw1r,+tw2i,-tw3i,-tw1i)
+        POCKETFFT_PARTSTEP7(3,4,tw3r,tw1r,tw2r,+tw3i,-tw1i,+tw2i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP7
+#undef POCKETFFT_PARTSTEP7a0
+#undef POCKETFFT_PARTSTEP7a
+#undef POCKETFFT_PREP7
+
+template <bool fwd, typename T> void ROTX45(T &a) const
+  {
+  constexpr T0 hsqt2=T0(0.707106781186547524400844362104849L);
+  if (fwd)
+    { auto tmp_=a.r; a.r=hsqt2*(a.r+a.i); a.i=hsqt2*(a.i-tmp_); }
+  else
+    { auto tmp_=a.r; a.r=hsqt2*(a.r-a.i); a.i=hsqt2*(a.i+tmp_); }
+  }
+template <bool fwd, typename T> void ROTX135(T &a) const
+  {
+  constexpr T0 hsqt2=T0(0.707106781186547524400844362104849L);
+  if (fwd)
+    { auto tmp_=a.r; a.r=hsqt2*(a.i-a.r); a.i=hsqt2*(-tmp_-a.i); }
+  else
+    { auto tmp_=a.r; a.r=hsqt2*(-a.r-a.i); a.i=hsqt2*(tmp_-a.i); }
+  }
+
+template<bool fwd, typename T> void pass8 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+8*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      T a0, a1, a2, a3, a4, a5, a6, a7;
+      PM(a1,a5,CC(0,1,k),CC(0,5,k));
+      PM(a3,a7,CC(0,3,k),CC(0,7,k));
+      PMINPLACE(a1,a3);
+      ROTX90<fwd>(a3);
+
+      ROTX90<fwd>(a7);
+      PMINPLACE(a5,a7);
+      ROTX45<fwd>(a5);
+      ROTX135<fwd>(a7);
+
+      PM(a0,a4,CC(0,0,k),CC(0,4,k));
+      PM(a2,a6,CC(0,2,k),CC(0,6,k));
+      PM(CH(0,k,0),CH(0,k,4),a0+a2,a1);
+      PM(CH(0,k,2),CH(0,k,6),a0-a2,a3);
+      ROTX90<fwd>(a6);
+      PM(CH(0,k,1),CH(0,k,5),a4+a6,a5);
+      PM(CH(0,k,3),CH(0,k,7),a4-a6,a7);
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      T a0, a1, a2, a3, a4, a5, a6, a7;
+      PM(a1,a5,CC(0,1,k),CC(0,5,k));
+      PM(a3,a7,CC(0,3,k),CC(0,7,k));
+      PMINPLACE(a1,a3);
+      ROTX90<fwd>(a3);
+
+      ROTX90<fwd>(a7);
+      PMINPLACE(a5,a7);
+      ROTX45<fwd>(a5);
+      ROTX135<fwd>(a7);
+
+      PM(a0,a4,CC(0,0,k),CC(0,4,k));
+      PM(a2,a6,CC(0,2,k),CC(0,6,k));
+      PM(CH(0,k,0),CH(0,k,4),a0+a2,a1);
+      PM(CH(0,k,2),CH(0,k,6),a0-a2,a3);
+      ROTX90<fwd>(a6);
+      PM(CH(0,k,1),CH(0,k,5),a4+a6,a5);
+      PM(CH(0,k,3),CH(0,k,7),a4-a6,a7);
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        T a0, a1, a2, a3, a4, a5, a6, a7;
+        PM(a1,a5,CC(i,1,k),CC(i,5,k));
+        PM(a3,a7,CC(i,3,k),CC(i,7,k));
+        ROTX90<fwd>(a7);
+        PMINPLACE(a1,a3);
+        ROTX90<fwd>(a3);
+        PMINPLACE(a5,a7);
+        ROTX45<fwd>(a5);
+        ROTX135<fwd>(a7);
+        PM(a0,a4,CC(i,0,k),CC(i,4,k));
+        PM(a2,a6,CC(i,2,k),CC(i,6,k));
+        PMINPLACE(a0,a2);
+        CH(i,k,0) = a0+a1;
+        special_mul<fwd>(a0-a1,WA(3,i),CH(i,k,4));
+        special_mul<fwd>(a2+a3,WA(1,i),CH(i,k,2));
+        special_mul<fwd>(a2-a3,WA(5,i),CH(i,k,6));
+        ROTX90<fwd>(a6);
+        PMINPLACE(a4,a6);
+        special_mul<fwd>(a4+a5,WA(0,i),CH(i,k,1));
+        special_mul<fwd>(a4-a5,WA(4,i),CH(i,k,5));
+        special_mul<fwd>(a6+a7,WA(2,i),CH(i,k,3));
+        special_mul<fwd>(a6-a7,WA(6,i),CH(i,k,7));
+        }
+      }
+   }
+
+
+#define POCKETFFT_PREP11(idx) \
+        T t1 = CC(idx,0,k), t2, t3, t4, t5, t6, t7, t8, t9, t10, t11; \
+        PM (t2,t11,CC(idx,1,k),CC(idx,10,k)); \
+        PM (t3,t10,CC(idx,2,k),CC(idx, 9,k)); \
+        PM (t4,t9 ,CC(idx,3,k),CC(idx, 8,k)); \
+        PM (t5,t8 ,CC(idx,4,k),CC(idx, 7,k)); \
+        PM (t6,t7 ,CC(idx,5,k),CC(idx, 6,k)); \
+        CH(idx,k,0).r=t1.r+t2.r+t3.r+t4.r+t5.r+t6.r; \
+        CH(idx,k,0).i=t1.i+t2.i+t3.i+t4.i+t5.i+t6.i;
+
+#define POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,out1,out2) \
+        { \
+        T ca = t1 + t2*x1 + t3*x2 + t4*x3 + t5*x4 +t6*x5, \
+          cb; \
+        cb.i=y1*t11.r y2*t10.r y3*t9.r y4*t8.r y5*t7.r; \
+        cb.r=-(y1*t11.i y2*t10.i y3*t9.i y4*t8.i y5*t7.i ); \
+        PM(out1,out2,ca,cb); \
+        }
+#define POCKETFFT_PARTSTEP11a(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5) \
+        POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,CH(0,k,u1),CH(0,k,u2))
+#define POCKETFFT_PARTSTEP11(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5) \
+        { \
+        T da,db; \
+        POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,da,db) \
+        special_mul<fwd>(da,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(db,WA(u2-1,i),CH(i,k,u2)); \
+        }
+
+template<bool fwd, typename T> void pass11 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r= T0(0.8412535328311811688618116489193677L),
+               tw1i= (fwd ? -1 : 1) * T0(0.5406408174555975821076359543186917L),
+               tw2r= T0(0.4154150130018864255292741492296232L),
+               tw2i= (fwd ? -1 : 1) * T0(0.9096319953545183714117153830790285L),
+               tw3r= T0(-0.1423148382732851404437926686163697L),
+               tw3i= (fwd ? -1 : 1) * T0(0.9898214418809327323760920377767188L),
+               tw4r= T0(-0.6548607339452850640569250724662936L),
+               tw4i= (fwd ? -1 : 1) * T0(0.7557495743542582837740358439723444L),
+               tw5r= T0(-0.9594929736144973898903680570663277L),
+               tw5i= (fwd ? -1 : 1) * T0(0.2817325568414296977114179153466169L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+11*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP11(0)
+      POCKETFFT_PARTSTEP11a(1,10,tw1r,tw2r,tw3r,tw4r,tw5r,+tw1i,+tw2i,+tw3i,+tw4i,+tw5i)
+      POCKETFFT_PARTSTEP11a(2, 9,tw2r,tw4r,tw5r,tw3r,tw1r,+tw2i,+tw4i,-tw5i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP11a(3, 8,tw3r,tw5r,tw2r,tw1r,tw4r,+tw3i,-tw5i,-tw2i,+tw1i,+tw4i)
+      POCKETFFT_PARTSTEP11a(4, 7,tw4r,tw3r,tw1r,tw5r,tw2r,+tw4i,-tw3i,+tw1i,+tw5i,-tw2i)
+      POCKETFFT_PARTSTEP11a(5, 6,tw5r,tw1r,tw4r,tw2r,tw3r,+tw5i,-tw1i,+tw4i,-tw2i,+tw3i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP11(0)
+      POCKETFFT_PARTSTEP11a(1,10,tw1r,tw2r,tw3r,tw4r,tw5r,+tw1i,+tw2i,+tw3i,+tw4i,+tw5i)
+      POCKETFFT_PARTSTEP11a(2, 9,tw2r,tw4r,tw5r,tw3r,tw1r,+tw2i,+tw4i,-tw5i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP11a(3, 8,tw3r,tw5r,tw2r,tw1r,tw4r,+tw3i,-tw5i,-tw2i,+tw1i,+tw4i)
+      POCKETFFT_PARTSTEP11a(4, 7,tw4r,tw3r,tw1r,tw5r,tw2r,+tw4i,-tw3i,+tw1i,+tw5i,-tw2i)
+      POCKETFFT_PARTSTEP11a(5, 6,tw5r,tw1r,tw4r,tw2r,tw3r,+tw5i,-tw1i,+tw4i,-tw2i,+tw3i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP11(i)
+        POCKETFFT_PARTSTEP11(1,10,tw1r,tw2r,tw3r,tw4r,tw5r,+tw1i,+tw2i,+tw3i,+tw4i,+tw5i)
+        POCKETFFT_PARTSTEP11(2, 9,tw2r,tw4r,tw5r,tw3r,tw1r,+tw2i,+tw4i,-tw5i,-tw3i,-tw1i)
+        POCKETFFT_PARTSTEP11(3, 8,tw3r,tw5r,tw2r,tw1r,tw4r,+tw3i,-tw5i,-tw2i,+tw1i,+tw4i)
+        POCKETFFT_PARTSTEP11(4, 7,tw4r,tw3r,tw1r,tw5r,tw2r,+tw4i,-tw3i,+tw1i,+tw5i,-tw2i)
+        POCKETFFT_PARTSTEP11(5, 6,tw5r,tw1r,tw4r,tw2r,tw3r,+tw5i,-tw1i,+tw4i,-tw2i,+tw3i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP11
+#undef POCKETFFT_PARTSTEP11a0
+#undef POCKETFFT_PARTSTEP11a
+#undef POCKETFFT_PREP11
+
+template<bool fwd, typename T> void passg (size_t ido, size_t ip,
+  size_t l1, T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa,
+  const cmplx<T0> * POCKETFFT_RESTRICT csarr) const
+  {
+  const size_t cdim=ip;
+  size_t ipph = (ip+1)/2;
+  size_t idl1 = ido*l1;
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido,cdim](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+cdim*c)]; };
+  auto CX = [cc, ido, l1](size_t a, size_t b, size_t c) -> T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CX2 = [cc, idl1](size_t a, size_t b) -> T&
+    { return cc[a+idl1*b]; };
+  auto CH2 = [ch, idl1](size_t a, size_t b) -> const T&
+    { return ch[a+idl1*b]; };
+
+  arr<cmplx<T0>> wal(ip);
+  wal[0] = cmplx<T0>(1., 0.);
+  for (size_t i=1; i<ip; ++i)
+    wal[i]=cmplx<T0>(csarr[i].r,fwd ? -csarr[i].i : csarr[i].i);
+
+  for (size_t k=0; k<l1; ++k)
+    for (size_t i=0; i<ido; ++i)
+      CH(i,k,0) = CC(i,0,k);
+  for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)
+    for (size_t k=0; k<l1; ++k)
+      for (size_t i=0; i<ido; ++i)
+        PM(CH(i,k,j),CH(i,k,jc),CC(i,j,k),CC(i,jc,k));
+  for (size_t k=0; k<l1; ++k)
+    for (size_t i=0; i<ido; ++i)
+      {
+      T tmp = CH(i,k,0);
+      for (size_t j=1; j<ipph; ++j)
+        tmp+=CH(i,k,j);
+      CX(i,k,0) = tmp;
+      }
+  for (size_t l=1, lc=ip-1; l<ipph; ++l, --lc)
+    {
+    // j=0
+    for (size_t ik=0; ik<idl1; ++ik)
+      {
+      CX2(ik,l).r = CH2(ik,0).r+wal[l].r*CH2(ik,1).r+wal[2*l].r*CH2(ik,2).r;
+      CX2(ik,l).i = CH2(ik,0).i+wal[l].r*CH2(ik,1).i+wal[2*l].r*CH2(ik,2).i;
+      CX2(ik,lc).r=-wal[l].i*CH2(ik,ip-1).i-wal[2*l].i*CH2(ik,ip-2).i;
+      CX2(ik,lc).i=wal[l].i*CH2(ik,ip-1).r+wal[2*l].i*CH2(ik,ip-2).r;
+      }
+
+    size_t iwal=2*l;
+    size_t j=3, jc=ip-3;
+    for (; j<ipph-1; j+=2, jc-=2)
+      {
+      iwal+=l; if (iwal>ip) iwal-=ip;
+      cmplx<T0> xwal=wal[iwal];
+      iwal+=l; if (iwal>ip) iwal-=ip;
+      cmplx<T0> xwal2=wal[iwal];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        CX2(ik,l).r += CH2(ik,j).r*xwal.r+CH2(ik,j+1).r*xwal2.r;
+        CX2(ik,l).i += CH2(ik,j).i*xwal.r+CH2(ik,j+1).i*xwal2.r;
+        CX2(ik,lc).r -= CH2(ik,jc).i*xwal.i+CH2(ik,jc-1).i*xwal2.i;
+        CX2(ik,lc).i += CH2(ik,jc).r*xwal.i+CH2(ik,jc-1).r*xwal2.i;
+        }
+      }
+    for (; j<ipph; ++j, --jc)
+      {
+      iwal+=l; if (iwal>ip) iwal-=ip;
+      cmplx<T0> xwal=wal[iwal];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        CX2(ik,l).r += CH2(ik,j).r*xwal.r;
+        CX2(ik,l).i += CH2(ik,j).i*xwal.r;
+        CX2(ik,lc).r -= CH2(ik,jc).i*xwal.i;
+        CX2(ik,lc).i += CH2(ik,jc).r*xwal.i;
+        }
+      }
+    }
+
+  // shuffling and twiddling
+  if (ido==1)
+    for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        T t1=CX2(ik,j), t2=CX2(ik,jc);
+        PM(CX2(ik,j),CX2(ik,jc),t1,t2);
+        }
+  else
+    {
+    for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)
+      for (size_t k=0; k<l1; ++k)
+        {
+        T t1=CX(0,k,j), t2=CX(0,k,jc);
+        PM(CX(0,k,j),CX(0,k,jc),t1,t2);
+        for (size_t i=1; i<ido; ++i)
+          {
+          T x1, x2;
+          PM(x1,x2,CX(i,k,j),CX(i,k,jc));
+          size_t idij=(j-1)*(ido-1)+i-1;
+          special_mul<fwd>(x1,wa[idij],CX(i,k,j));
+          idij=(jc-1)*(ido-1)+i-1;
+          special_mul<fwd>(x2,wa[idij],CX(i,k,jc));
+          }
+        }
+    }
+  }
+
+template<bool fwd, typename T> void pass_all(T c[], T0 fct) const
+  {
+  if (length==1) { c[0]*=fct; return; }
+  size_t l1=1;
+  arr<T> ch(length);
+  T *p1=c, *p2=ch.data();
+
+  for(size_t k1=0; k1<fact.size(); k1++)
+    {
+    size_t ip=fact[k1].fct;
+    size_t l2=ip*l1;
+    size_t ido = length/l2;
+    if     (ip==4)
+      pass4<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==8)
+      pass8<fwd>(ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==2)
+      pass2<fwd>(ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==3)
+      pass3<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==5)
+      pass5<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==7)
+      pass7<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==11)
+      pass11<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else
+      {
+      passg<fwd>(ido, ip, l1, p1, p2, fact[k1].tw, fact[k1].tws);
+      std::swap(p1,p2);
+      }
+    std::swap(p1,p2);
+    l1=l2;
+    }
+  if (p1!=c)
+    {
+    if (fct!=1.)
+      for (size_t i=0; i<length; ++i)
+        c[i] = ch[i]*fct;
+    else
+      std::copy_n (p1, length, c);
+    }
+  else
+    if (fct!=1.)
+      for (size_t i=0; i<length; ++i)
+        c[i] *= fct;
+  }
+
+  public:
+    template<typename T> void exec(T c[], T0 fct, bool fwd) const
+      { fwd ? pass_all<true>(c, fct) : pass_all<false>(c, fct); }
+
+  private:
+    POCKETFFT_NOINLINE void factorize()
+      {
+      size_t len=length;
+      while ((len&7)==0)
+        { add_factor(8); len>>=3; }
+      while ((len&3)==0)
+        { add_factor(4); len>>=2; }
+      if ((len&1)==0)
+        {
+        len>>=1;
+        // factor 2 should be at the front of the factor list
+        add_factor(2);
+        std::swap(fact[0].fct, fact.back().fct);
+        }
+      for (size_t divisor=3; divisor*divisor<=len; divisor+=2)
+        while ((len%divisor)==0)
+          {
+          add_factor(divisor);
+          len/=divisor;
+          }
+      if (len>1) add_factor(len);
+      }
+
+    size_t twsize() const
+      {
+      size_t twsize=0, l1=1;
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido= length/(l1*ip);
+        twsize+=(ip-1)*(ido-1);
+        if (ip>11)
+          twsize+=ip;
+        l1*=ip;
+        }
+      return twsize;
+      }
+
+    void comp_twiddle()
+      {
+      sincos_2pibyn<T0> twiddle(length);
+      size_t l1=1;
+      size_t memofs=0;
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido=length/(l1*ip);
+        fact[k].tw=mem.data()+memofs;
+        memofs+=(ip-1)*(ido-1);
+        for (size_t j=1; j<ip; ++j)
+          for (size_t i=1; i<ido; ++i)
+            fact[k].tw[(j-1)*(ido-1)+i-1] = twiddle[j*l1*i];
+        if (ip>11)
+          {
+          fact[k].tws=mem.data()+memofs;
+          memofs+=ip;
+          for (size_t j=0; j<ip; ++j)
+            fact[k].tws[j] = twiddle[j*l1*ido];
+          }
+        l1*=ip;
+        }
+      }
+
+  public:
+    POCKETFFT_NOINLINE cfftp(size_t length_)
+      : length(length_)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      if (length==1) return;
+      factorize();
+      mem.resize(twsize());
+      comp_twiddle();
+      }
+  };
+
+//
+// real-valued FFTPACK transforms
+//
+
+template<typename T0> class rfftp
+  {
+  private:
+    struct fctdata
+      {
+      size_t fct;
+      T0 *tw, *tws;
+      };
+
+    size_t length;
+    arr<T0> mem;
+    std::vector<fctdata> fact;
+
+    void add_factor(size_t factor)
+      { fact.push_back({factor, nullptr, nullptr}); }
+
+/* (a+ib) = conj(c+id) * (e+if) */
+template<typename T1, typename T2, typename T3> inline void MULPM
+  (T1 &a, T1 &b, T2 c, T2 d, T3 e, T3 f) const
+  {  a=c*e+d*f; b=c*f-d*e; }
+
+template<typename T> void radf2 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+2*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    PM (CH(0,0,k),CH(ido-1,1,k),CC(0,k,0),CC(0,k,1));
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      CH(    0,1,k) = -CC(ido-1,k,1);
+      CH(ido-1,0,k) =  CC(ido-1,k,0);
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T tr2, ti2;
+      MULPM (tr2,ti2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1));
+      PM (CH(i-1,0,k),CH(ic-1,1,k),CC(i-1,k,0),tr2);
+      PM (CH(i  ,0,k),CH(ic  ,1,k),ti2,CC(i  ,k,0));
+      }
+  }
+
+// a2=a+b; b2=i*(b-a);
+#define POCKETFFT_REARRANGE(rx, ix, ry, iy) \
+  {\
+  auto t1=rx+ry, t2=ry-rx, t3=ix+iy, t4=ix-iy; \
+  rx=t1; ix=t3; ry=t4; iy=t2; \
+  }
+
+template<typename T> void radf3(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 taur=-0.5, taui=T0(0.8660254037844386467637231707529362L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+3*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T cr2=CC(0,k,1)+CC(0,k,2);
+    CH(0,0,k) = CC(0,k,0)+cr2;
+    CH(0,2,k) = taui*(CC(0,k,2)-CC(0,k,1));
+    CH(ido-1,1,k) = CC(0,k,0)+taur*cr2;
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T di2, di3, dr2, dr3;
+      MULPM (dr2,di2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1)); // d2=conj(WA0)*CC1
+      MULPM (dr3,di3,WA(1,i-2),WA(1,i-1),CC(i-1,k,2),CC(i,k,2)); // d3=conj(WA1)*CC2
+      POCKETFFT_REARRANGE(dr2, di2, dr3, di3);
+      CH(i-1,0,k) = CC(i-1,k,0)+dr2; // c add
+      CH(i  ,0,k) = CC(i  ,k,0)+di2;
+      T tr2 = CC(i-1,k,0)+taur*dr2; // c add
+      T ti2 = CC(i  ,k,0)+taur*di2;
+      T tr3 = taui*dr3;  // t3 = taui*i*(d3-d2)?
+      T ti3 = taui*di3;
+      PM(CH(i-1,2,k),CH(ic-1,1,k),tr2,tr3); // PM(i) = t2+t3
+      PM(CH(i  ,2,k),CH(ic  ,1,k),ti3,ti2); // PM(ic) = conj(t2-t3)
+      }
+  }
+
+template<typename T> void radf4(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 hsqt2=T0(0.707106781186547524400844362104849L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+4*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T tr1,tr2;
+    PM (tr1,CH(0,2,k),CC(0,k,3),CC(0,k,1));
+    PM (tr2,CH(ido-1,1,k),CC(0,k,0),CC(0,k,2));
+    PM (CH(0,0,k),CH(ido-1,3,k),tr2,tr1);
+    }
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      T ti1=-hsqt2*(CC(ido-1,k,1)+CC(ido-1,k,3));
+      T tr1= hsqt2*(CC(ido-1,k,1)-CC(ido-1,k,3));
+      PM (CH(ido-1,0,k),CH(ido-1,2,k),CC(ido-1,k,0),tr1);
+      PM (CH(    0,3,k),CH(    0,1,k),ti1,CC(ido-1,k,2));
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
+      MULPM(cr2,ci2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1));
+      MULPM(cr3,ci3,WA(1,i-2),WA(1,i-1),CC(i-1,k,2),CC(i,k,2));
+      MULPM(cr4,ci4,WA(2,i-2),WA(2,i-1),CC(i-1,k,3),CC(i,k,3));
+      PM(tr1,tr4,cr4,cr2);
+      PM(ti1,ti4,ci2,ci4);
+      PM(tr2,tr3,CC(i-1,k,0),cr3);
+      PM(ti2,ti3,CC(i  ,k,0),ci3);
+      PM(CH(i-1,0,k),CH(ic-1,3,k),tr2,tr1);
+      PM(CH(i  ,0,k),CH(ic  ,3,k),ti1,ti2);
+      PM(CH(i-1,2,k),CH(ic-1,1,k),tr3,ti4);
+      PM(CH(i  ,2,k),CH(ic  ,1,k),tr4,ti3);
+      }
+  }
+
+template<typename T> void radf5(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tr11= T0(0.3090169943749474241022934171828191L),
+               ti11= T0(0.9510565162951535721164393333793821L),
+               tr12= T0(-0.8090169943749474241022934171828191L),
+               ti12= T0(0.5877852522924731291687059546390728L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+5*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T cr2, cr3, ci4, ci5;
+    PM (cr2,ci5,CC(0,k,4),CC(0,k,1));
+    PM (cr3,ci4,CC(0,k,3),CC(0,k,2));
+    CH(0,0,k)=CC(0,k,0)+cr2+cr3;
+    CH(ido-1,1,k)=CC(0,k,0)+tr11*cr2+tr12*cr3;
+    CH(0,2,k)=ti11*ci5+ti12*ci4;
+    CH(ido-1,3,k)=CC(0,k,0)+tr12*cr2+tr11*cr3;
+    CH(0,4,k)=ti12*ci5-ti11*ci4;
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2, ic=ido-2; i<ido; i+=2, ic-=2)
+      {
+      T di2, di3, di4, di5, dr2, dr3, dr4, dr5;
+      MULPM (dr2,di2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1));
+      MULPM (dr3,di3,WA(1,i-2),WA(1,i-1),CC(i-1,k,2),CC(i,k,2));
+      MULPM (dr4,di4,WA(2,i-2),WA(2,i-1),CC(i-1,k,3),CC(i,k,3));
+      MULPM (dr5,di5,WA(3,i-2),WA(3,i-1),CC(i-1,k,4),CC(i,k,4));
+      POCKETFFT_REARRANGE(dr2, di2, dr5, di5);
+      POCKETFFT_REARRANGE(dr3, di3, dr4, di4);
+      CH(i-1,0,k)=CC(i-1,k,0)+dr2+dr3;
+      CH(i  ,0,k)=CC(i  ,k,0)+di2+di3;
+      T tr2=CC(i-1,k,0)+tr11*dr2+tr12*dr3;
+      T ti2=CC(i  ,k,0)+tr11*di2+tr12*di3;
+      T tr3=CC(i-1,k,0)+tr12*dr2+tr11*dr3;
+      T ti3=CC(i  ,k,0)+tr12*di2+tr11*di3;
+      T tr5 = ti11*dr5 + ti12*dr4;
+      T ti5 = ti11*di5 + ti12*di4;
+      T tr4 = ti12*dr5 - ti11*dr4;
+      T ti4 = ti12*di5 - ti11*di4;
+      PM(CH(i-1,2,k),CH(ic-1,1,k),tr2,tr5);
+      PM(CH(i  ,2,k),CH(ic  ,1,k),ti5,ti2);
+      PM(CH(i-1,4,k),CH(ic-1,3,k),tr3,tr4);
+      PM(CH(i  ,4,k),CH(ic  ,3,k),ti4,ti3);
+      }
+  }
+
+#undef POCKETFFT_REARRANGE
+
+template<typename T> void radfg(size_t ido, size_t ip, size_t l1,
+  T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa, const T0 * POCKETFFT_RESTRICT csarr) const
+  {
+  const size_t cdim=ip;
+  size_t ipph=(ip+1)/2;
+  size_t idl1 = ido*l1;
+
+  auto CC = [cc,ido,cdim](size_t a, size_t b, size_t c) -> T&
+    { return cc[a+ido*(b+cdim*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto C1 = [cc,ido,l1] (size_t a, size_t b, size_t c) -> T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto C2 = [cc,idl1] (size_t a, size_t b) -> T&
+    { return cc[a+idl1*b]; };
+  auto CH2 = [ch,idl1] (size_t a, size_t b) -> T&
+    { return ch[a+idl1*b]; };
+
+  if (ido>1)
+    {
+    for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)              // 114
+      {
+      size_t is=(j-1)*(ido-1),
+             is2=(jc-1)*(ido-1);
+      for (size_t k=0; k<l1; ++k)                            // 113
+        {
+        size_t idij=is;
+        size_t idij2=is2;
+        for (size_t i=1; i<=ido-2; i+=2)                      // 112
+          {
+          T t1=C1(i,k,j ), t2=C1(i+1,k,j ),
+            t3=C1(i,k,jc), t4=C1(i+1,k,jc);
+          T x1=wa[idij]*t1 + wa[idij+1]*t2,
+            x2=wa[idij]*t2 - wa[idij+1]*t1,
+            x3=wa[idij2]*t3 + wa[idij2+1]*t4,
+            x4=wa[idij2]*t4 - wa[idij2+1]*t3;
+          PM(C1(i,k,j),C1(i+1,k,jc),x3,x1);
+          PM(C1(i+1,k,j),C1(i,k,jc),x2,x4);
+          idij+=2;
+          idij2+=2;
+          }
+        }
+      }
+    }
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)                // 123
+    for (size_t k=0; k<l1; ++k)                              // 122
+      MPINPLACE(C1(0,k,jc), C1(0,k,j));
+
+//everything in C
+//memset(ch,0,ip*l1*ido*sizeof(double));
+
+  for (size_t l=1,lc=ip-1; l<ipph; ++l,--lc)                 // 127
+    {
+    for (size_t ik=0; ik<idl1; ++ik)                         // 124
+      {
+      CH2(ik,l ) = C2(ik,0)+csarr[2*l]*C2(ik,1)+csarr[4*l]*C2(ik,2);
+      CH2(ik,lc) = csarr[2*l+1]*C2(ik,ip-1)+csarr[4*l+1]*C2(ik,ip-2);
+      }
+    size_t iang = 2*l;
+    size_t j=3, jc=ip-3;
+    for (; j<ipph-3; j+=4,jc-=4)              // 126
+      {
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar3=csarr[2*iang], ai3=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar4=csarr[2*iang], ai4=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)                       // 125
+        {
+        CH2(ik,l ) += ar1*C2(ik,j )+ar2*C2(ik,j +1)
+                     +ar3*C2(ik,j +2)+ar4*C2(ik,j +3);
+        CH2(ik,lc) += ai1*C2(ik,jc)+ai2*C2(ik,jc-1)
+                     +ai3*C2(ik,jc-2)+ai4*C2(ik,jc-3);
+        }
+      }
+    for (; j<ipph-1; j+=2,jc-=2)              // 126
+      {
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)                       // 125
+        {
+        CH2(ik,l ) += ar1*C2(ik,j )+ar2*C2(ik,j +1);
+        CH2(ik,lc) += ai1*C2(ik,jc)+ai2*C2(ik,jc-1);
+        }
+      }
+    for (; j<ipph; ++j,--jc)              // 126
+      {
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar=csarr[2*iang], ai=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)                       // 125
+        {
+        CH2(ik,l ) += ar*C2(ik,j );
+        CH2(ik,lc) += ai*C2(ik,jc);
+        }
+      }
+    }
+  for (size_t ik=0; ik<idl1; ++ik)                         // 101
+    CH2(ik,0) = C2(ik,0);
+  for (size_t j=1; j<ipph; ++j)                              // 129
+    for (size_t ik=0; ik<idl1; ++ik)                         // 128
+      CH2(ik,0) += C2(ik,j);
+
+// everything in CH at this point!
+//memset(cc,0,ip*l1*ido*sizeof(double));
+
+  for (size_t k=0; k<l1; ++k)                                // 131
+    for (size_t i=0; i<ido; ++i)                             // 130
+      CC(i,0,k) = CH(i,k,0);
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)                // 137
+    {
+    size_t j2=2*j-1;
+    for (size_t k=0; k<l1; ++k)                              // 136
+      {
+      CC(ido-1,j2,k) = CH(0,k,j);
+      CC(0,j2+1,k) = CH(0,k,jc);
+      }
+    }
+
+  if (ido==1) return;
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)                // 140
+    {
+    size_t j2=2*j-1;
+    for(size_t k=0; k<l1; ++k)                               // 139
+      for(size_t i=1, ic=ido-i-2; i<=ido-2; i+=2, ic-=2)      // 138
+        {
+        CC(i   ,j2+1,k) = CH(i  ,k,j )+CH(i  ,k,jc);
+        CC(ic  ,j2  ,k) = CH(i  ,k,j )-CH(i  ,k,jc);
+        CC(i+1 ,j2+1,k) = CH(i+1,k,j )+CH(i+1,k,jc);
+        CC(ic+1,j2  ,k) = CH(i+1,k,jc)-CH(i+1,k,j );
+        }
+    }
+  }
+
+template<typename T> void radb2(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+2*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    PM (CH(0,k,0),CH(0,k,1),CC(0,0,k),CC(ido-1,1,k));
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      CH(ido-1,k,0) = 2*CC(ido-1,0,k);
+      CH(ido-1,k,1) =-2*CC(0    ,1,k);
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T ti2, tr2;
+      PM (CH(i-1,k,0),tr2,CC(i-1,0,k),CC(ic-1,1,k));
+      PM (ti2,CH(i  ,k,0),CC(i  ,0,k),CC(ic  ,1,k));
+      MULPM (CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),ti2,tr2);
+      }
+  }
+
+template<typename T> void radb3(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 taur=-0.5, taui=T0(0.8660254037844386467637231707529362L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+3*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T tr2=2*CC(ido-1,1,k);
+    T cr2=CC(0,0,k)+taur*tr2;
+    CH(0,k,0)=CC(0,0,k)+tr2;
+    T ci3=2*taui*CC(0,2,k);
+    PM (CH(0,k,2),CH(0,k,1),cr2,ci3);
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2, ic=ido-2; i<ido; i+=2, ic-=2)
+      {
+      T tr2=CC(i-1,2,k)+CC(ic-1,1,k); // t2=CC(I) + conj(CC(ic))
+      T ti2=CC(i  ,2,k)-CC(ic  ,1,k);
+      T cr2=CC(i-1,0,k)+taur*tr2;     // c2=CC +taur*t2
+      T ci2=CC(i  ,0,k)+taur*ti2;
+      CH(i-1,k,0)=CC(i-1,0,k)+tr2;         // CH=CC+t2
+      CH(i  ,k,0)=CC(i  ,0,k)+ti2;
+      T cr3=taui*(CC(i-1,2,k)-CC(ic-1,1,k));// c3=taui*(CC(i)-conj(CC(ic)))
+      T ci3=taui*(CC(i  ,2,k)+CC(ic  ,1,k));
+      T di2, di3, dr2, dr3;
+      PM(dr3,dr2,cr2,ci3); // d2= (cr2-ci3, ci2+cr3) = c2+i*c3
+      PM(di2,di3,ci2,cr3); // d3= (cr2+ci3, ci2-cr3) = c2-i*c3
+      MULPM(CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),di2,dr2); // ch = WA*d2
+      MULPM(CH(i,k,2),CH(i-1,k,2),WA(1,i-2),WA(1,i-1),di3,dr3);
+      }
+  }
+
+template<typename T> void radb4(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+4*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T tr1, tr2;
+    PM (tr2,tr1,CC(0,0,k),CC(ido-1,3,k));
+    T tr3=2*CC(ido-1,1,k);
+    T tr4=2*CC(0,2,k);
+    PM (CH(0,k,0),CH(0,k,2),tr2,tr3);
+    PM (CH(0,k,3),CH(0,k,1),tr1,tr4);
+    }
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      T tr1,tr2,ti1,ti2;
+      PM (ti1,ti2,CC(0    ,3,k),CC(0    ,1,k));
+      PM (tr2,tr1,CC(ido-1,0,k),CC(ido-1,2,k));
+      CH(ido-1,k,0)=tr2+tr2;
+      CH(ido-1,k,1)=sqrt2*(tr1-ti1);
+      CH(ido-1,k,2)=ti2+ti2;
+      CH(ido-1,k,3)=-sqrt2*(tr1+ti1);
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      T ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
+      size_t ic=ido-i;
+      PM (tr2,tr1,CC(i-1,0,k),CC(ic-1,3,k));
+      PM (ti1,ti2,CC(i  ,0,k),CC(ic  ,3,k));
+      PM (tr4,ti3,CC(i  ,2,k),CC(ic  ,1,k));
+      PM (tr3,ti4,CC(i-1,2,k),CC(ic-1,1,k));
+      PM (CH(i-1,k,0),cr3,tr2,tr3);
+      PM (CH(i  ,k,0),ci3,ti2,ti3);
+      PM (cr4,cr2,tr1,tr4);
+      PM (ci2,ci4,ti1,ti4);
+      MULPM (CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),ci2,cr2);
+      MULPM (CH(i,k,2),CH(i-1,k,2),WA(1,i-2),WA(1,i-1),ci3,cr3);
+      MULPM (CH(i,k,3),CH(i-1,k,3),WA(2,i-2),WA(2,i-1),ci4,cr4);
+      }
+  }
+
+template<typename T> void radb5(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tr11= T0(0.3090169943749474241022934171828191L),
+               ti11= T0(0.9510565162951535721164393333793821L),
+               tr12= T0(-0.8090169943749474241022934171828191L),
+               ti12= T0(0.5877852522924731291687059546390728L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+5*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T ti5=CC(0,2,k)+CC(0,2,k);
+    T ti4=CC(0,4,k)+CC(0,4,k);
+    T tr2=CC(ido-1,1,k)+CC(ido-1,1,k);
+    T tr3=CC(ido-1,3,k)+CC(ido-1,3,k);
+    CH(0,k,0)=CC(0,0,k)+tr2+tr3;
+    T cr2=CC(0,0,k)+tr11*tr2+tr12*tr3;
+    T cr3=CC(0,0,k)+tr12*tr2+tr11*tr3;
+    T ci4, ci5;
+    MULPM(ci5,ci4,ti5,ti4,ti11,ti12);
+    PM(CH(0,k,4),CH(0,k,1),cr2,ci5);
+    PM(CH(0,k,3),CH(0,k,2),cr3,ci4);
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2, ic=ido-2; i<ido; i+=2, ic-=2)
+      {
+      T tr2, tr3, tr4, tr5, ti2, ti3, ti4, ti5;
+      PM(tr2,tr5,CC(i-1,2,k),CC(ic-1,1,k));
+      PM(ti5,ti2,CC(i  ,2,k),CC(ic  ,1,k));
+      PM(tr3,tr4,CC(i-1,4,k),CC(ic-1,3,k));
+      PM(ti4,ti3,CC(i  ,4,k),CC(ic  ,3,k));
+      CH(i-1,k,0)=CC(i-1,0,k)+tr2+tr3;
+      CH(i  ,k,0)=CC(i  ,0,k)+ti2+ti3;
+      T cr2=CC(i-1,0,k)+tr11*tr2+tr12*tr3;
+      T ci2=CC(i  ,0,k)+tr11*ti2+tr12*ti3;
+      T cr3=CC(i-1,0,k)+tr12*tr2+tr11*tr3;
+      T ci3=CC(i  ,0,k)+tr12*ti2+tr11*ti3;
+      T ci4, ci5, cr5, cr4;
+      MULPM(cr5,cr4,tr5,tr4,ti11,ti12);
+      MULPM(ci5,ci4,ti5,ti4,ti11,ti12);
+      T dr2, dr3, dr4, dr5, di2, di3, di4, di5;
+      PM(dr4,dr3,cr3,ci4);
+      PM(di3,di4,ci3,cr4);
+      PM(dr5,dr2,cr2,ci5);
+      PM(di2,di5,ci2,cr5);
+      MULPM(CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),di2,dr2);
+      MULPM(CH(i,k,2),CH(i-1,k,2),WA(1,i-2),WA(1,i-1),di3,dr3);
+      MULPM(CH(i,k,3),CH(i-1,k,3),WA(2,i-2),WA(2,i-1),di4,dr4);
+      MULPM(CH(i,k,4),CH(i-1,k,4),WA(3,i-2),WA(3,i-1),di5,dr5);
+      }
+  }
+
+template<typename T> void radbg(size_t ido, size_t ip, size_t l1,
+  T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa, const T0 * POCKETFFT_RESTRICT csarr) const
+  {
+  const size_t cdim=ip;
+  size_t ipph=(ip+1)/ 2;
+  size_t idl1 = ido*l1;
+
+  auto CC = [cc,ido,cdim](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+cdim*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto C1 = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto C2 = [cc,idl1](size_t a, size_t b) -> T&
+    { return cc[a+idl1*b]; };
+  auto CH2 = [ch,idl1](size_t a, size_t b) -> T&
+    { return ch[a+idl1*b]; };
+
+  for (size_t k=0; k<l1; ++k)        // 102
+    for (size_t i=0; i<ido; ++i)     // 101
+      CH(i,k,0) = CC(i,0,k);
+  for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)   // 108
+    {
+    size_t j2=2*j-1;
+    for (size_t k=0; k<l1; ++k)
+      {
+      CH(0,k,j ) = 2*CC(ido-1,j2,k);
+      CH(0,k,jc) = 2*CC(0,j2+1,k);
+      }
+    }
+
+  if (ido!=1)
+    {
+    for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)   // 111
+      {
+      size_t j2=2*j-1;
+      for (size_t k=0; k<l1; ++k)
+        for (size_t i=1, ic=ido-i-2; i<=ido-2; i+=2, ic-=2)      // 109
+          {
+          CH(i  ,k,j ) = CC(i  ,j2+1,k)+CC(ic  ,j2,k);
+          CH(i  ,k,jc) = CC(i  ,j2+1,k)-CC(ic  ,j2,k);
+          CH(i+1,k,j ) = CC(i+1,j2+1,k)-CC(ic+1,j2,k);
+          CH(i+1,k,jc) = CC(i+1,j2+1,k)+CC(ic+1,j2,k);
+          }
+      }
+    }
+  for (size_t l=1,lc=ip-1; l<ipph; ++l,--lc)
+    {
+    for (size_t ik=0; ik<idl1; ++ik)
+      {
+      C2(ik,l ) = CH2(ik,0)+csarr[2*l]*CH2(ik,1)+csarr[4*l]*CH2(ik,2);
+      C2(ik,lc) = csarr[2*l+1]*CH2(ik,ip-1)+csarr[4*l+1]*CH2(ik,ip-2);
+      }
+    size_t iang=2*l;
+    size_t j=3,jc=ip-3;
+    for(; j<ipph-3; j+=4,jc-=4)
+      {
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar3=csarr[2*iang], ai3=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar4=csarr[2*iang], ai4=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        C2(ik,l ) += ar1*CH2(ik,j )+ar2*CH2(ik,j +1)
+                    +ar3*CH2(ik,j +2)+ar4*CH2(ik,j +3);
+        C2(ik,lc) += ai1*CH2(ik,jc)+ai2*CH2(ik,jc-1)
+                    +ai3*CH2(ik,jc-2)+ai4*CH2(ik,jc-3);
+        }
+      }
+    for(; j<ipph-1; j+=2,jc-=2)
+      {
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        C2(ik,l ) += ar1*CH2(ik,j )+ar2*CH2(ik,j +1);
+        C2(ik,lc) += ai1*CH2(ik,jc)+ai2*CH2(ik,jc-1);
+        }
+      }
+    for(; j<ipph; ++j,--jc)
+      {
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 war=csarr[2*iang], wai=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        C2(ik,l ) += war*CH2(ik,j );
+        C2(ik,lc) += wai*CH2(ik,jc);
+        }
+      }
+    }
+  for (size_t j=1; j<ipph; ++j)
+    for (size_t ik=0; ik<idl1; ++ik)
+      CH2(ik,0) += CH2(ik,j);
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)   // 124
+    for (size_t k=0; k<l1; ++k)
+      PM(CH(0,k,jc),CH(0,k,j),C1(0,k,j),C1(0,k,jc));
+
+  if (ido==1) return;
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)  // 127
+    for (size_t k=0; k<l1; ++k)
+      for (size_t i=1; i<=ido-2; i+=2)
+        {
+        CH(i  ,k,j ) = C1(i  ,k,j)-C1(i+1,k,jc);
+        CH(i  ,k,jc) = C1(i  ,k,j)+C1(i+1,k,jc);
+        CH(i+1,k,j ) = C1(i+1,k,j)+C1(i  ,k,jc);
+        CH(i+1,k,jc) = C1(i+1,k,j)-C1(i  ,k,jc);
+        }
+
+// All in CH
+
+  for (size_t j=1; j<ip; ++j)
+    {
+    size_t is = (j-1)*(ido-1);
+    for (size_t k=0; k<l1; ++k)
+      {
+      size_t idij = is;
+      for (size_t i=1; i<=ido-2; i+=2)
+        {
+        T t1=CH(i,k,j), t2=CH(i+1,k,j);
+        CH(i  ,k,j) = wa[idij]*t1-wa[idij+1]*t2;
+        CH(i+1,k,j) = wa[idij]*t2+wa[idij+1]*t1;
+        idij+=2;
+        }
+      }
+    }
+  }
+
+    template<typename T> void copy_and_norm(T *c, T *p1, T0 fct) const
+      {
+      if (p1!=c)
+        {
+        if (fct!=1.)
+          for (size_t i=0; i<length; ++i)
+            c[i] = fct*p1[i];
+        else
+          std::copy_n (p1, length, c);
+        }
+      else
+        if (fct!=1.)
+          for (size_t i=0; i<length; ++i)
+            c[i] *= fct;
+      }
+
+  public:
+    template<typename T> void exec(T c[], T0 fct, bool r2hc) const
+      {
+      if (length==1) { c[0]*=fct; return; }
+      size_t nf=fact.size();
+      arr<T> ch(length);
+      T *p1=c, *p2=ch.data();
+
+      if (r2hc)
+        for(size_t k1=0, l1=length; k1<nf;++k1)
+          {
+          size_t k=nf-k1-1;
+          size_t ip=fact[k].fct;
+          size_t ido=length / l1;
+          l1 /= ip;
+          if(ip==4)
+            radf4(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==2)
+            radf2(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==3)
+            radf3(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==5)
+            radf5(ido, l1, p1, p2, fact[k].tw);
+          else
+            { radfg(ido, ip, l1, p1, p2, fact[k].tw, fact[k].tws); std::swap (p1,p2); }
+          std::swap (p1,p2);
+          }
+      else
+        for(size_t k=0, l1=1; k<nf; k++)
+          {
+          size_t ip = fact[k].fct,
+                 ido= length/(ip*l1);
+          if(ip==4)
+            radb4(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==2)
+            radb2(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==3)
+            radb3(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==5)
+            radb5(ido, l1, p1, p2, fact[k].tw);
+          else
+            radbg(ido, ip, l1, p1, p2, fact[k].tw, fact[k].tws);
+          std::swap (p1,p2);
+          l1*=ip;
+          }
+
+      copy_and_norm(c,p1,fct);
+      }
+
+  private:
+    void factorize()
+      {
+      size_t len=length;
+      while ((len%4)==0)
+        { add_factor(4); len>>=2; }
+      if ((len%2)==0)
+        {
+        len>>=1;
+        // factor 2 should be at the front of the factor list
+        add_factor(2);
+        std::swap(fact[0].fct, fact.back().fct);
+        }
+      for (size_t divisor=3; divisor*divisor<=len; divisor+=2)
+        while ((len%divisor)==0)
+          {
+          add_factor(divisor);
+          len/=divisor;
+          }
+      if (len>1) add_factor(len);
+      }
+
+    size_t twsize() const
+      {
+      size_t twsz=0, l1=1;
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido=length/(l1*ip);
+        twsz+=(ip-1)*(ido-1);
+        if (ip>5) twsz+=2*ip;
+        l1*=ip;
+        }
+      return twsz;
+      }
+
+    void comp_twiddle()
+      {
+      sincos_2pibyn<T0> twid(length);
+      size_t l1=1;
+      T0 *ptr=mem.data();
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido=length/(l1*ip);
+        if (k<fact.size()-1) // last factor doesn't need twiddles
+          {
+          fact[k].tw=ptr; ptr+=(ip-1)*(ido-1);
+          for (size_t j=1; j<ip; ++j)
+            for (size_t i=1; i<=(ido-1)/2; ++i)
+              {
+              fact[k].tw[(j-1)*(ido-1)+2*i-2] = twid[j*l1*i].r;
+              fact[k].tw[(j-1)*(ido-1)+2*i-1] = twid[j*l1*i].i;
+              }
+          }
+        if (ip>5) // special factors required by *g functions
+          {
+          fact[k].tws=ptr; ptr+=2*ip;
+          fact[k].tws[0] = 1.;
+          fact[k].tws[1] = 0.;
+          for (size_t i=2, ic=2*ip-2; i<=ic; i+=2, ic-=2)
+            {
+            fact[k].tws[i  ] = twid[i/2*(length/ip)].r;
+            fact[k].tws[i+1] = twid[i/2*(length/ip)].i;
+            fact[k].tws[ic]   = twid[i/2*(length/ip)].r;
+            fact[k].tws[ic+1] = -twid[i/2*(length/ip)].i;
+            }
+          }
+        l1*=ip;
+        }
+      }
+
+  public:
+    POCKETFFT_NOINLINE rfftp(size_t length_)
+      : length(length_)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      if (length==1) return;
+      factorize();
+      mem.resize(twsize());
+      comp_twiddle();
+      }
+};
+
+//
+// complex Bluestein transforms
+//
+
+template<typename T0> class fftblue
+  {
+  private:
+    size_t n, n2;
+    cfftp<T0> plan;
+    arr<cmplx<T0>> mem;
+    cmplx<T0> *bk, *bkf;
+
+    template<bool fwd, typename T> void fft(cmplx<T> c[], T0 fct) const
+      {
+      arr<cmplx<T>> akf(n2);
+
+      /* initialize a_k and FFT it */
+      for (size_t m=0; m<n; ++m)
+        special_mul<fwd>(c[m],bk[m],akf[m]);
+      auto zero = akf[0]*T0(0);
+      for (size_t m=n; m<n2; ++m)
+        akf[m]=zero;
+
+      plan.exec (akf.data(),1.,true);
+
+      /* do the convolution */
+      akf[0] = akf[0].template special_mul<!fwd>(bkf[0]);
+      for (size_t m=1; m<(n2+1)/2; ++m)
+        {
+        akf[m] = akf[m].template special_mul<!fwd>(bkf[m]);
+        akf[n2-m] = akf[n2-m].template special_mul<!fwd>(bkf[m]);
+        }
+      if ((n2&1)==0)
+        akf[n2/2] = akf[n2/2].template special_mul<!fwd>(bkf[n2/2]);
+
+      /* inverse FFT */
+      plan.exec (akf.data(),1.,false);
+
+      /* multiply by b_k */
+      for (size_t m=0; m<n; ++m)
+        c[m] = akf[m].template special_mul<fwd>(bk[m])*fct;
+      }
+
+  public:
+    POCKETFFT_NOINLINE fftblue(size_t length)
+      : n(length), n2(util::good_size_cmplx(n*2-1)), plan(n2), mem(n+n2/2+1),
+        bk(mem.data()), bkf(mem.data()+n)
+      {
+      /* initialize b_k */
+      sincos_2pibyn<T0> tmp(2*n);
+      bk[0].Set(1, 0);
+
+      size_t coeff=0;
+      for (size_t m=1; m<n; ++m)
+        {
+        coeff+=2*m-1;
+        if (coeff>=2*n) coeff-=2*n;
+        bk[m] = tmp[coeff];
+        }
+
+      /* initialize the zero-padded, Fourier transformed b_k. Add normalisation. */
+      arr<cmplx<T0>> tbkf(n2);
+      T0 xn2 = T0(1)/T0(n2);
+      tbkf[0] = bk[0]*xn2;
+      for (size_t m=1; m<n; ++m)
+        tbkf[m] = tbkf[n2-m] = bk[m]*xn2;
+      for (size_t m=n;m<=(n2-n);++m)
+        tbkf[m].Set(0.,0.);
+      plan.exec(tbkf.data(),1.,true);
+      for (size_t i=0; i<n2/2+1; ++i)
+        bkf[i] = tbkf[i];
+      }
+
+    template<typename T> void exec(cmplx<T> c[], T0 fct, bool fwd) const
+      { fwd ? fft<true>(c,fct) : fft<false>(c,fct); }
+
+    template<typename T> void exec_r(T c[], T0 fct, bool fwd)
+      {
+      arr<cmplx<T>> tmp(n);
+      if (fwd)
+        {
+        auto zero = T0(0)*c[0];
+        for (size_t m=0; m<n; ++m)
+          tmp[m].Set(c[m], zero);
+        fft<true>(tmp.data(),fct);
+        c[0] = tmp[0].r;
+        std::copy_n (&tmp[1].r, n-1, &c[1]);
+        }
+      else
+        {
+        tmp[0].Set(c[0],c[0]*0);
+        std::copy_n (c+1, n-1, &tmp[1].r);
+        if ((n&1)==0) tmp[n/2].i=T0(0)*c[0];
+        for (size_t m=1; 2*m<n; ++m)
+          tmp[n-m].Set(tmp[m].r, -tmp[m].i);
+        fft<false>(tmp.data(),fct);
+        for (size_t m=0; m<n; ++m)
+          c[m] = tmp[m].r;
+        }
+      }
+  };
+
+//
+// flexible (FFTPACK/Bluestein) complex 1D transform
+//
+
+template<typename T0> class pocketfft_c
+  {
+  private:
+    std::unique_ptr<cfftp<T0>> packplan;
+    std::unique_ptr<fftblue<T0>> blueplan;
+    size_t len;
+
+  public:
+    POCKETFFT_NOINLINE pocketfft_c(size_t length)
+      : len(length)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      size_t tmp = (length<50) ? 0 : util::largest_prime_factor(length);
+      if (tmp*tmp <= length)
+        {
+        packplan=std::unique_ptr<cfftp<T0>>(new cfftp<T0>(length));
+        return;
+        }
+      double comp1 = util::cost_guess(length);
+      double comp2 = 2*util::cost_guess(util::good_size_cmplx(2*length-1));
+      comp2*=1.5; /* fudge factor that appears to give good overall performance */
+      if (comp2<comp1) // use Bluestein
+        blueplan=std::unique_ptr<fftblue<T0>>(new fftblue<T0>(length));
+      else
+        packplan=std::unique_ptr<cfftp<T0>>(new cfftp<T0>(length));
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(cmplx<T> c[], T0 fct, bool fwd) const
+      { packplan ? packplan->exec(c,fct,fwd) : blueplan->exec(c,fct,fwd); }
+
+    size_t length() const { return len; }
+  };
+
+//
+// flexible (FFTPACK/Bluestein) real-valued 1D transform
+//
+
+template<typename T0> class pocketfft_r
+  {
+  private:
+    std::unique_ptr<rfftp<T0>> packplan;
+    std::unique_ptr<fftblue<T0>> blueplan;
+    size_t len;
+
+  public:
+    POCKETFFT_NOINLINE pocketfft_r(size_t length)
+      : len(length)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      size_t tmp = (length<50) ? 0 : util::largest_prime_factor(length);
+      if (tmp*tmp <= length)
+        {
+        packplan=std::unique_ptr<rfftp<T0>>(new rfftp<T0>(length));
+        return;
+        }
+      double comp1 = 0.5*util::cost_guess(length);
+      double comp2 = 2*util::cost_guess(util::good_size_cmplx(2*length-1));
+      comp2*=1.5; /* fudge factor that appears to give good overall performance */
+      if (comp2<comp1) // use Bluestein
+        blueplan=std::unique_ptr<fftblue<T0>>(new fftblue<T0>(length));
+      else
+        packplan=std::unique_ptr<rfftp<T0>>(new rfftp<T0>(length));
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct, bool fwd) const
+      { packplan ? packplan->exec(c,fct,fwd) : blueplan->exec_r(c,fct,fwd); }
+
+    size_t length() const { return len; }
+  };
+
+
+//
+// sine/cosine transforms
+//
+
+template<typename T0> class T_dct1
+  {
+  private:
+    pocketfft_r<T0> fftplan;
+
+  public:
+    POCKETFFT_NOINLINE T_dct1(size_t length)
+      : fftplan(2*(length-1)) {}
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct, bool ortho,
+      int /*type*/, bool /*cosine*/) const
+      {
+      constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+      size_t N=fftplan.length(), n=N/2+1;
+      if (ortho)
+        { c[0]*=sqrt2; c[n-1]*=sqrt2; }
+      arr<T> tmp(N);
+      tmp[0] = c[0];
+      for (size_t i=1; i<n; ++i)
+        tmp[i] = tmp[N-i] = c[i];
+      fftplan.exec(tmp.data(), fct, true);
+      c[0] = tmp[0];
+      for (size_t i=1; i<n; ++i)
+        c[i] = tmp[2*i-1];
+      if (ortho)
+        { c[0]*=sqrt2*T0(0.5); c[n-1]*=sqrt2*T0(0.5); }
+      }
+
+    size_t length() const { return fftplan.length()/2+1; }
+  };
+
+template<typename T0> class T_dst1
+  {
+  private:
+    pocketfft_r<T0> fftplan;
+
+  public:
+    POCKETFFT_NOINLINE T_dst1(size_t length)
+      : fftplan(2*(length+1)) {}
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct,
+      bool /*ortho*/, int /*type*/, bool /*cosine*/) const
+      {
+      size_t N=fftplan.length(), n=N/2-1;
+      arr<T> tmp(N);
+      tmp[0] = tmp[n+1] = c[0]*0;
+      for (size_t i=0; i<n; ++i)
+        { tmp[i+1]=c[i]; tmp[N-1-i]=-c[i]; }
+      fftplan.exec(tmp.data(), fct, true);
+      for (size_t i=0; i<n; ++i)
+        c[i] = -tmp[2*i+2];
+      }
+
+    size_t length() const { return fftplan.length()/2-1; }
+  };
+
+template<typename T0> class T_dcst23
+  {
+  private:
+    pocketfft_r<T0> fftplan;
+    std::vector<T0> twiddle;
+
+  public:
+    POCKETFFT_NOINLINE T_dcst23(size_t length)
+      : fftplan(length), twiddle(length)
+      {
+      sincos_2pibyn<T0> tw(4*length);
+      for (size_t i=0; i<length; ++i)
+        twiddle[i] = tw[i+1].r;
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct, bool ortho,
+      int type, bool cosine) const
+      {
+      constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+      size_t N=length();
+      size_t NS2 = (N+1)/2;
+      if (type==2)
+        {
+        if (!cosine)
+          for (size_t k=1; k<N; k+=2)
+            c[k] = -c[k];
+        c[0] *= 2;
+        if ((N&1)==0) c[N-1]*=2;
+        for (size_t k=1; k<N-1; k+=2)
+          MPINPLACE(c[k+1], c[k]);
+        fftplan.exec(c, fct, false);
+        for (size_t k=1, kc=N-1; k<NS2; ++k, --kc)
+          {
+          T t1 = twiddle[k-1]*c[kc]+twiddle[kc-1]*c[k];
+          T t2 = twiddle[k-1]*c[k]-twiddle[kc-1]*c[kc];
+          c[k] = T0(0.5)*(t1+t2); c[kc]=T0(0.5)*(t1-t2);
+          }
+        if ((N&1)==0)
+          c[NS2] *= twiddle[NS2-1];
+        if (!cosine)
+          for (size_t k=0, kc=N-1; k<kc; ++k, --kc)
+            std::swap(c[k], c[kc]);
+        if (ortho) c[0]*=sqrt2*T0(0.5);
+        }
+      else
+        {
+        if (ortho) c[0]*=sqrt2;
+        if (!cosine)
+          for (size_t k=0, kc=N-1; k<NS2; ++k, --kc)
+            std::swap(c[k], c[kc]);
+        for (size_t k=1, kc=N-1; k<NS2; ++k, --kc)
+          {
+          T t1=c[k]+c[kc], t2=c[k]-c[kc];
+          c[k] = twiddle[k-1]*t2+twiddle[kc-1]*t1;
+          c[kc]= twiddle[k-1]*t1-twiddle[kc-1]*t2;
+          }
+        if ((N&1)==0)
+          c[NS2] *= 2*twiddle[NS2-1];
+        fftplan.exec(c, fct, true);
+        for (size_t k=1; k<N-1; k+=2)
+          MPINPLACE(c[k], c[k+1]);
+        if (!cosine)
+          for (size_t k=1; k<N; k+=2)
+            c[k] = -c[k];
+        }
+      }
+
+    size_t length() const { return fftplan.length(); }
+  };
+
+template<typename T0> class T_dcst4
+  {
+  private:
+    size_t N;
+    std::unique_ptr<pocketfft_c<T0>> fft;
+    std::unique_ptr<pocketfft_r<T0>> rfft;
+    arr<cmplx<T0>> C2;
+
+  public:
+    POCKETFFT_NOINLINE T_dcst4(size_t length)
+      : N(length),
+        fft((N&1) ? nullptr : new pocketfft_c<T0>(N/2)),
+        rfft((N&1)? new pocketfft_r<T0>(N) : nullptr),
+        C2((N&1) ? 0 : N/2)
+      {
+      if ((N&1)==0)
+        {
+        sincos_2pibyn<T0> tw(16*N);
+        for (size_t i=0; i<N/2; ++i)
+          C2[i] = conj(tw[8*i+1]);
+        }
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct,
+      bool /*ortho*/, int /*type*/, bool cosine) const
+      {
+      size_t n2 = N/2;
+      if (!cosine)
+        for (size_t k=0, kc=N-1; k<n2; ++k, --kc)
+          std::swap(c[k], c[kc]);
+      if (N&1)
+        {
+        // The following code is derived from the FFTW3 function apply_re11()
+        // and is released under the 3-clause BSD license with friendly
+        // permission of Matteo Frigo and Steven G. Johnson.
+
+        arr<T> y(N);
+        {
+        size_t i=0, m=n2;
+        for (; m<N; ++i, m+=4)
+          y[i] = c[m];
+        for (; m<2*N; ++i, m+=4)
+          y[i] = -c[2*N-m-1];
+        for (; m<3*N; ++i, m+=4)
+          y[i] = -c[m-2*N];
+        for (; m<4*N; ++i, m+=4)
+          y[i] = c[4*N-m-1];
+        for (; i<N; ++i, m+=4)
+          y[i] = c[m-4*N];
+        }
+        rfft->exec(y.data(), fct, true);
+        {
+        auto SGN = [](size_t i)
+           {
+           constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+           return (i&2) ? -sqrt2 : sqrt2;
+           };
+        c[n2] = y[0]*SGN(n2+1);
+        size_t i=0, i1=1, k=1;
+        for (; k<n2; ++i, ++i1, k+=2)
+          {
+          c[i    ] = y[2*k-1]*SGN(i1)     + y[2*k  ]*SGN(i);
+          c[N -i1] = y[2*k-1]*SGN(N -i)   - y[2*k  ]*SGN(N -i1);
+          c[n2-i1] = y[2*k+1]*SGN(n2-i)   - y[2*k+2]*SGN(n2-i1);
+          c[n2+i1] = y[2*k+1]*SGN(n2+i+2) + y[2*k+2]*SGN(n2+i1);
+          }
+        if (k == n2)
+          {
+          c[i   ] = y[2*k-1]*SGN(i+1) + y[2*k]*SGN(i);
+          c[N-i1] = y[2*k-1]*SGN(i+2) + y[2*k]*SGN(i1);
+          }
+        }
+
+        // FFTW-derived code ends here
+        }
+      else
+        {
+        // even length algorithm from
+        // https://www.appletonaudio.com/blog/2013/derivation-of-fast-dct-4-algorithm-based-on-dft/
+        arr<cmplx<T>> y(n2);
+        for(size_t i=0; i<n2; ++i)
+          {
+          y[i].Set(c[2*i],c[N-1-2*i]);
+          y[i] *= C2[i];
+          }
+        fft->exec(y.data(), fct, true);
+        for(size_t i=0, ic=n2-1; i<n2; ++i, --ic)
+          {
+          c[2*i  ] =  2*(y[i ].r*C2[i ].r-y[i ].i*C2[i ].i);
+          c[2*i+1] = -2*(y[ic].i*C2[ic].r+y[ic].r*C2[ic].i);
+          }
+        }
+      if (!cosine)
+        for (size_t k=1; k<N; k+=2)
+          c[k] = -c[k];
+      }
+
+    size_t length() const { return N; }
+  };
+
+
+//
+// multi-D infrastructure
+//
+
+template<typename T> std::shared_ptr<T> get_plan(size_t length)
+  {
+#if POCKETFFT_CACHE_SIZE==0
+  return std::make_shared<T>(length);
+#else
+  constexpr size_t nmax=POCKETFFT_CACHE_SIZE;
+  static std::array<std::shared_ptr<T>, nmax> cache;
+  static std::array<size_t, nmax> last_access{{0}};
+  static size_t access_counter = 0;
+  static std::mutex mut;
+
+  auto find_in_cache = [&]() -> std::shared_ptr<T>
+    {
+    for (size_t i=0; i<nmax; ++i)
+      if (cache[i] && (cache[i]->length()==length))
+        {
+        // no need to update if this is already the most recent entry
+        if (last_access[i]!=access_counter)
+          {
+          last_access[i] = ++access_counter;
+          // Guard against overflow
+          if (access_counter == 0)
+            last_access.fill(0);
+          }
+        return cache[i];
+        }
+
+    return nullptr;
+    };
+
+  {
+  std::lock_guard<std::mutex> lock(mut);
+  auto p = find_in_cache();
+  if (p) return p;
+  }
+  auto plan = std::make_shared<T>(length);
+  {
+  std::lock_guard<std::mutex> lock(mut);
+  auto p = find_in_cache();
+  if (p) return p;
+
+  size_t lru = 0;
+  for (size_t i=1; i<nmax; ++i)
+    if (last_access[i] < last_access[lru])
+      lru = i;
+
+  cache[lru] = plan;
+  last_access[lru] = ++access_counter;
+  }
+  return plan;
+#endif
+  }
+
+class arr_info
+  {
+  protected:
+    shape_t shp;
+    stride_t str;
+
+  public:
+    arr_info(const shape_t &shape_, const stride_t &stride_)
+      : shp(shape_), str(stride_) {}
+    size_t ndim() const { return shp.size(); }
+    size_t size() const { return util::prod(shp); }
+    const shape_t &shape() const { return shp; }
+    size_t shape(size_t i) const { return shp[i]; }
+    const stride_t &stride() const { return str; }
+    const ptrdiff_t &stride(size_t i) const { return str[i]; }
+  };
+
+template<typename T> class cndarr: public arr_info
+  {
+  protected:
+    const char *d;
+
+  public:
+    cndarr(const void *data_, const shape_t &shape_, const stride_t &stride_)
+      : arr_info(shape_, stride_),
+        d(reinterpret_cast<const char *>(data_)) {}
+    const T &operator[](ptrdiff_t ofs) const
+      { return *reinterpret_cast<const T *>(d+ofs); }
+  };
+
+template<typename T> class ndarr: public cndarr<T>
+  {
+  public:
+    ndarr(void *data_, const shape_t &shape_, const stride_t &stride_)
+      : cndarr<T>::cndarr(const_cast<const void *>(data_), shape_, stride_)
+      {}
+    T &operator[](ptrdiff_t ofs)
+      { return *reinterpret_cast<T *>(const_cast<char *>(cndarr<T>::d+ofs)); }
+  };
+
+template<size_t N> class multi_iter
+  {
+  private:
+    shape_t pos;
+    const arr_info &iarr, &oarr;
+    ptrdiff_t p_ii, p_i[N], str_i, p_oi, p_o[N], str_o;
+    size_t idim, rem;
+
+    void advance_i()
+      {
+      for (int i_=int(pos.size())-1; i_>=0; --i_)
+        {
+        auto i = size_t(i_);
+        if (i==idim) continue;
+        p_ii += iarr.stride(i);
+        p_oi += oarr.stride(i);
+        if (++pos[i] < iarr.shape(i))
+          return;
+        pos[i] = 0;
+        p_ii -= ptrdiff_t(iarr.shape(i))*iarr.stride(i);
+        p_oi -= ptrdiff_t(oarr.shape(i))*oarr.stride(i);
+        }
+      }
+
+  public:
+    multi_iter(const arr_info &iarr_, const arr_info &oarr_, size_t idim_)
+      : pos(iarr_.ndim(), 0), iarr(iarr_), oarr(oarr_), p_ii(0),
+        str_i(iarr.stride(idim_)), p_oi(0), str_o(oarr.stride(idim_)),
+        idim(idim_), rem(iarr.size()/iarr.shape(idim))
+      {
+      auto nshares = threading::num_threads();
+      if (nshares==1) return;
+      if (nshares==0) throw std::runtime_error("can't run with zero threads");
+      auto myshare = threading::thread_id();
+      if (myshare>=nshares) throw std::runtime_error("impossible share requested");
+      size_t nbase = rem/nshares;
+      size_t additional = rem%nshares;
+      size_t lo = myshare*nbase + ((myshare<additional) ? myshare : additional);
+      size_t hi = lo+nbase+(myshare<additional);
+      size_t todo = hi-lo;
+
+      size_t chunk = rem;
+      for (size_t i=0; i<pos.size(); ++i)
+        {
+        if (i==idim) continue;
+        chunk /= iarr.shape(i);
+        size_t n_advance = lo/chunk;
+        pos[i] += n_advance;
+        p_ii += ptrdiff_t(n_advance)*iarr.stride(i);
+        p_oi += ptrdiff_t(n_advance)*oarr.stride(i);
+        lo -= n_advance*chunk;
+        }
+      rem = todo;
+      }
+    void advance(size_t n)
+      {
+      if (rem<n) throw std::runtime_error("underrun");
+      for (size_t i=0; i<n; ++i)
+        {
+        p_i[i] = p_ii;
+        p_o[i] = p_oi;
+        advance_i();
+        }
+      rem -= n;
+      }
+    ptrdiff_t iofs(size_t i) const { return p_i[0] + ptrdiff_t(i)*str_i; }
+    ptrdiff_t iofs(size_t j, size_t i) const { return p_i[j] + ptrdiff_t(i)*str_i; }
+    ptrdiff_t oofs(size_t i) const { return p_o[0] + ptrdiff_t(i)*str_o; }
+    ptrdiff_t oofs(size_t j, size_t i) const { return p_o[j] + ptrdiff_t(i)*str_o; }
+    size_t length_in() const { return iarr.shape(idim); }
+    size_t length_out() const { return oarr.shape(idim); }
+    ptrdiff_t stride_in() const { return str_i; }
+    ptrdiff_t stride_out() const { return str_o; }
+    size_t remaining() const { return rem; }
+  };
+
+class simple_iter
+  {
+  private:
+    shape_t pos;
+    const arr_info &arr;
+    ptrdiff_t p;
+    size_t rem;
+
+  public:
+    simple_iter(const arr_info &arr_)
+      : pos(arr_.ndim(), 0), arr(arr_), p(0), rem(arr_.size()) {}
+    void advance()
+      {
+      --rem;
+      for (int i_=int(pos.size())-1; i_>=0; --i_)
+        {
+        auto i = size_t(i_);
+        p += arr.stride(i);
+        if (++pos[i] < arr.shape(i))
+          return;
+        pos[i] = 0;
+        p -= ptrdiff_t(arr.shape(i))*arr.stride(i);
+        }
+      }
+    ptrdiff_t ofs() const { return p; }
+    size_t remaining() const { return rem; }
+  };
+
+class rev_iter
+  {
+  private:
+    shape_t pos;
+    const arr_info &arr;
+    std::vector<char> rev_axis;
+    std::vector<char> rev_jump;
+    size_t last_axis, last_size;
+    shape_t shp;
+    ptrdiff_t p, rp;
+    size_t rem;
+
+  public:
+    rev_iter(const arr_info &arr_, const shape_t &axes)
+      : pos(arr_.ndim(), 0), arr(arr_), rev_axis(arr_.ndim(), 0),
+        rev_jump(arr_.ndim(), 1), p(0), rp(0)
+      {
+      for (auto ax: axes)
+        rev_axis[ax]=1;
+      last_axis = axes.back();
+      last_size = arr.shape(last_axis)/2 + 1;
+      shp = arr.shape();
+      shp[last_axis] = last_size;
+      rem=1;
+      for (auto i: shp)
+        rem *= i;
+      }
+    void advance()
+      {
+      --rem;
+      for (int i_=int(pos.size())-1; i_>=0; --i_)
+        {
+        auto i = size_t(i_);
+        p += arr.stride(i);
+        if (!rev_axis[i])
+          rp += arr.stride(i);
+        else
+          {
+          rp -= arr.stride(i);
+          if (rev_jump[i])
+            {
+            rp += ptrdiff_t(arr.shape(i))*arr.stride(i);
+            rev_jump[i] = 0;
+            }
+          }
+        if (++pos[i] < shp[i])
+          return;
+        pos[i] = 0;
+        p -= ptrdiff_t(shp[i])*arr.stride(i);
+        if (rev_axis[i])
+          {
+          rp -= ptrdiff_t(arr.shape(i)-shp[i])*arr.stride(i);
+          rev_jump[i] = 1;
+          }
+        else
+          rp -= ptrdiff_t(shp[i])*arr.stride(i);
+        }
+      }
+    ptrdiff_t ofs() const { return p; }
+    ptrdiff_t rev_ofs() const { return rp; }
+    size_t remaining() const { return rem; }
+  };
+
+template<typename T> struct VTYPE {};
+template <typename T> using vtype_t = typename VTYPE<T>::type;
+
+#ifndef POCKETFFT_NO_VECTORS
+template<> struct VTYPE<float>
+  {
+  using type = float __attribute__ ((vector_size (VLEN<float>::val*sizeof(float))));
+  };
+template<> struct VTYPE<double>
+  {
+  using type = double __attribute__ ((vector_size (VLEN<double>::val*sizeof(double))));
+  };
+template<> struct VTYPE<long double>
+  {
+  using type = long double __attribute__ ((vector_size (VLEN<long double>::val*sizeof(long double))));
+  };
+#endif
+
+template<typename T> arr<char> alloc_tmp(const shape_t &shape,
+  size_t axsize, size_t elemsize)
+  {
+  auto othersize = util::prod(shape)/axsize;
+  auto tmpsize = axsize*((othersize>=VLEN<T>::val) ? VLEN<T>::val : 1);
+  return arr<char>(tmpsize*elemsize);
+  }
+template<typename T> arr<char> alloc_tmp(const shape_t &shape,
+  const shape_t &axes, size_t elemsize)
+  {
+  size_t fullsize=util::prod(shape);
+  size_t tmpsize=0;
+  for (size_t i=0; i<axes.size(); ++i)
+    {
+    auto axsize = shape[axes[i]];
+    auto othersize = fullsize/axsize;
+    auto sz = axsize*((othersize>=VLEN<T>::val) ? VLEN<T>::val : 1);
+    if (sz>tmpsize) tmpsize=sz;
+    }
+  return arr<char>(tmpsize*elemsize);
+  }
+
+template <typename T, size_t vlen> void copy_input(const multi_iter<vlen> &it,
+  const cndarr<cmplx<T>> &src, cmplx<vtype_t<T>> *POCKETFFT_RESTRICT dst)
+  {
+  for (size_t i=0; i<it.length_in(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      {
+      dst[i].r[j] = src[it.iofs(j,i)].r;
+      dst[i].i[j] = src[it.iofs(j,i)].i;
+      }
+  }
+
+template <typename T, size_t vlen> void copy_input(const multi_iter<vlen> &it,
+  const cndarr<T> &src, vtype_t<T> *POCKETFFT_RESTRICT dst)
+  {
+  for (size_t i=0; i<it.length_in(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      dst[i][j] = src[it.iofs(j,i)];
+  }
+
+template <typename T, size_t vlen> void copy_input(const multi_iter<vlen> &it,
+  const cndarr<T> &src, T *POCKETFFT_RESTRICT dst)
+  {
+  if (dst == &src[it.iofs(0)]) return;  // in-place
+  for (size_t i=0; i<it.length_in(); ++i)
+    dst[i] = src[it.iofs(i)];
+  }
+
+template<typename T, size_t vlen> void copy_output(const multi_iter<vlen> &it,
+  const cmplx<vtype_t<T>> *POCKETFFT_RESTRICT src, ndarr<cmplx<T>> &dst)
+  {
+  for (size_t i=0; i<it.length_out(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      dst[it.oofs(j,i)].Set(src[i].r[j],src[i].i[j]);
+  }
+
+template<typename T, size_t vlen> void copy_output(const multi_iter<vlen> &it,
+  const vtype_t<T> *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  for (size_t i=0; i<it.length_out(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      dst[it.oofs(j,i)] = src[i][j];
+  }
+
+template<typename T, size_t vlen> void copy_output(const multi_iter<vlen> &it,
+  const T *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  if (src == &dst[it.oofs(0)]) return;  // in-place
+  for (size_t i=0; i<it.length_out(); ++i)
+    dst[it.oofs(i)] = src[i];
+  }
+
+template <typename T> struct add_vec { using type = vtype_t<T>; };
+template <typename T> struct add_vec<cmplx<T>>
+  { using type = cmplx<vtype_t<T>>; };
+template <typename T> using add_vec_t = typename add_vec<T>::type;
+
+template<typename Tplan, typename T, typename T0, typename Exec>
+POCKETFFT_NOINLINE void general_nd(const cndarr<T> &in, ndarr<T> &out,
+  const shape_t &axes, T0 fct, size_t nthreads, const Exec & exec,
+  const bool allow_inplace=true)
+  {
+  std::shared_ptr<Tplan> plan;
+
+  for (size_t iax=0; iax<axes.size(); ++iax)
+    {
+    size_t len=in.shape(axes[iax]);
+    if ((!plan) || (len!=plan->length()))
+      plan = get_plan<Tplan>(len);
+
+    threading::thread_map(
+      util::thread_count(nthreads, in.shape(), axes[iax], VLEN<T>::val),
+      [&] {
+        constexpr auto vlen = VLEN<T0>::val;
+        auto storage = alloc_tmp<T0>(in.shape(), len, sizeof(T));
+        const auto &tin(iax==0? in : out);
+        multi_iter<vlen> it(tin, out, axes[iax]);
+#ifndef POCKETFFT_NO_VECTORS
+        if (vlen>1)
+          while (it.remaining()>=vlen)
+            {
+            it.advance(vlen);
+            auto tdatav = reinterpret_cast<add_vec_t<T> *>(storage.data());
+            exec(it, tin, out, tdatav, *plan, fct);
+            }
+#endif
+        while (it.remaining()>0)
+          {
+          it.advance(1);
+          auto buf = allow_inplace && it.stride_out() == sizeof(T) ?
+            &out[it.oofs(0)] : reinterpret_cast<T *>(storage.data());
+          exec(it, tin, out, buf, *plan, fct);
+          }
+      });  // end of parallel region
+    fct = T0(1); // factor has been applied, use 1 for remaining axes
+    }
+  }
+
+struct ExecC2C
+  {
+  bool forward;
+
+  template <typename T0, typename T, size_t vlen> void operator () (
+    const multi_iter<vlen> &it, const cndarr<cmplx<T0>> &in,
+    ndarr<cmplx<T0>> &out, T * buf, const pocketfft_c<T0> &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    plan.exec(buf, fct, forward);
+    copy_output(it, buf, out);
+    }
+  };
+
+template <typename T, size_t vlen> void copy_hartley(const multi_iter<vlen> &it,
+  const vtype_t<T> *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  for (size_t j=0; j<vlen; ++j)
+    dst[it.oofs(j,0)] = src[0][j];
+  size_t i=1, i1=1, i2=it.length_out()-1;
+  for (i=1; i<it.length_out()-1; i+=2, ++i1, --i2)
+    for (size_t j=0; j<vlen; ++j)
+      {
+        dst[it.oofs(j,i1)] = src[i][j]+src[i+1][j];
+        dst[it.oofs(j,i2)] = src[i][j]-src[i+1][j];
+      }
+  if (i<it.length_out())
+    for (size_t j=0; j<vlen; ++j)
+      dst[it.oofs(j,i1)] = src[i][j];
+  }
+
+template <typename T, size_t vlen> void copy_hartley(const multi_iter<vlen> &it,
+  const T *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  dst[it.oofs(0)] = src[0];
+  size_t i=1, i1=1, i2=it.length_out()-1;
+  for (i=1; i<it.length_out()-1; i+=2, ++i1, --i2)
+    {
+    dst[it.oofs(i1)] = src[i]+src[i+1];
+    dst[it.oofs(i2)] = src[i]-src[i+1];
+    }
+  if (i<it.length_out())
+    dst[it.oofs(i1)] = src[i];
+  }
+
+struct ExecHartley
+  {
+  template <typename T0, typename T, size_t vlen> void operator () (
+    const multi_iter<vlen> &it, const cndarr<T0> &in, ndarr<T0> &out,
+    T * buf, const pocketfft_r<T0> &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    plan.exec(buf, fct, true);
+    copy_hartley(it, buf, out);
+    }
+  };
+
+struct ExecDcst
+  {
+  bool ortho;
+  int type;
+  bool cosine;
+
+  template <typename T0, typename T, typename Tplan, size_t vlen>
+  void operator () (const multi_iter<vlen> &it, const cndarr<T0> &in,
+    ndarr<T0> &out, T * buf, const Tplan &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    plan.exec(buf, fct, ortho, type, cosine);
+    copy_output(it, buf, out);
+    }
+  };
+
+template<typename T> POCKETFFT_NOINLINE void general_r2c(
+  const cndarr<T> &in, ndarr<cmplx<T>> &out, size_t axis, bool forward, T fct,
+  size_t nthreads)
+  {
+  auto plan = get_plan<pocketfft_r<T>>(in.shape(axis));
+  size_t len=in.shape(axis);
+  threading::thread_map(
+    util::thread_count(nthreads, in.shape(), axis, VLEN<T>::val),
+    [&] {
+    constexpr auto vlen = VLEN<T>::val;
+    auto storage = alloc_tmp<T>(in.shape(), len, sizeof(T));
+    multi_iter<vlen> it(in, out, axis);
+#ifndef POCKETFFT_NO_VECTORS
+    if (vlen>1)
+      while (it.remaining()>=vlen)
+        {
+        it.advance(vlen);
+        auto tdatav = reinterpret_cast<vtype_t<T> *>(storage.data());
+        copy_input(it, in, tdatav);
+        plan->exec(tdatav, fct, true);
+        for (size_t j=0; j<vlen; ++j)
+          out[it.oofs(j,0)].Set(tdatav[0][j]);
+        size_t i=1, ii=1;
+        if (forward)
+          for (; i<len-1; i+=2, ++ii)
+            for (size_t j=0; j<vlen; ++j)
+              out[it.oofs(j,ii)].Set(tdatav[i][j], tdatav[i+1][j]);
+        else
+          for (; i<len-1; i+=2, ++ii)
+            for (size_t j=0; j<vlen; ++j)
+              out[it.oofs(j,ii)].Set(tdatav[i][j], -tdatav[i+1][j]);
+        if (i<len)
+          for (size_t j=0; j<vlen; ++j)
+            out[it.oofs(j,ii)].Set(tdatav[i][j]);
+        }
+#endif
+    while (it.remaining()>0)
+      {
+      it.advance(1);
+      auto tdata = reinterpret_cast<T *>(storage.data());
+      copy_input(it, in, tdata);
+      plan->exec(tdata, fct, true);
+      out[it.oofs(0)].Set(tdata[0]);
+      size_t i=1, ii=1;
+      if (forward)
+        for (; i<len-1; i+=2, ++ii)
+          out[it.oofs(ii)].Set(tdata[i], tdata[i+1]);
+      else
+        for (; i<len-1; i+=2, ++ii)
+          out[it.oofs(ii)].Set(tdata[i], -tdata[i+1]);
+      if (i<len)
+        out[it.oofs(ii)].Set(tdata[i]);
+      }
+    });  // end of parallel region
+  }
+template<typename T> POCKETFFT_NOINLINE void general_c2r(
+  const cndarr<cmplx<T>> &in, ndarr<T> &out, size_t axis, bool forward, T fct,
+  size_t nthreads)
+  {
+  auto plan = get_plan<pocketfft_r<T>>(out.shape(axis));
+  size_t len=out.shape(axis);
+  threading::thread_map(
+    util::thread_count(nthreads, in.shape(), axis, VLEN<T>::val),
+    [&] {
+      constexpr auto vlen = VLEN<T>::val;
+      auto storage = alloc_tmp<T>(out.shape(), len, sizeof(T));
+      multi_iter<vlen> it(in, out, axis);
+#ifndef POCKETFFT_NO_VECTORS
+      if (vlen>1)
+        while (it.remaining()>=vlen)
+          {
+          it.advance(vlen);
+          auto tdatav = reinterpret_cast<vtype_t<T> *>(storage.data());
+          for (size_t j=0; j<vlen; ++j)
+            tdatav[0][j]=in[it.iofs(j,0)].r;
+          {
+          size_t i=1, ii=1;
+          if (forward)
+            for (; i<len-1; i+=2, ++ii)
+              for (size_t j=0; j<vlen; ++j)
+                {
+                tdatav[i  ][j] =  in[it.iofs(j,ii)].r;
+                tdatav[i+1][j] = -in[it.iofs(j,ii)].i;
+                }
+          else
+            for (; i<len-1; i+=2, ++ii)
+              for (size_t j=0; j<vlen; ++j)
+                {
+                tdatav[i  ][j] = in[it.iofs(j,ii)].r;
+                tdatav[i+1][j] = in[it.iofs(j,ii)].i;
+                }
+          if (i<len)
+            for (size_t j=0; j<vlen; ++j)
+              tdatav[i][j] = in[it.iofs(j,ii)].r;
+          }
+          plan->exec(tdatav, fct, false);
+          copy_output(it, tdatav, out);
+          }
+#endif
+      while (it.remaining()>0)
+        {
+        it.advance(1);
+        auto tdata = reinterpret_cast<T *>(storage.data());
+        tdata[0]=in[it.iofs(0)].r;
+        {
+        size_t i=1, ii=1;
+        if (forward)
+          for (; i<len-1; i+=2, ++ii)
+            {
+            tdata[i  ] =  in[it.iofs(ii)].r;
+            tdata[i+1] = -in[it.iofs(ii)].i;
+            }
+        else
+          for (; i<len-1; i+=2, ++ii)
+            {
+            tdata[i  ] = in[it.iofs(ii)].r;
+            tdata[i+1] = in[it.iofs(ii)].i;
+            }
+        if (i<len)
+          tdata[i] = in[it.iofs(ii)].r;
+        }
+        plan->exec(tdata, fct, false);
+        copy_output(it, tdata, out);
+        }
+    });  // end of parallel region
+  }
+
+struct ExecR2R
+  {
+  bool r2h, forward;
+
+  template <typename T0, typename T, size_t vlen> void operator () (
+    const multi_iter<vlen> &it, const cndarr<T0> &in, ndarr<T0> &out, T * buf,
+    const pocketfft_r<T0> &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    if ((!r2h) && forward)
+      for (size_t i=2; i<it.length_out(); i+=2)
+        buf[i] = -buf[i];
+    plan.exec(buf, fct, r2h);
+    if (r2h && (!forward))
+      for (size_t i=2; i<it.length_out(); i+=2)
+        buf[i] = -buf[i];
+    copy_output(it, buf, out);
+    }
+  };
+
+template<typename T> void c2c(const shape_t &shape, const stride_t &stride_in,
+  const stride_t &stride_out, const shape_t &axes, bool forward,
+  const std::complex<T> *data_in, std::complex<T> *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<cmplx<T>> ain(data_in, shape, stride_in);
+  ndarr<cmplx<T>> aout(data_out, shape, stride_out);
+  general_nd<pocketfft_c<T>>(ain, aout, axes, fct, nthreads, ExecC2C{forward});
+  }
+
+template<typename T> void dct(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)
+  {
+  if ((type<1) || (type>4)) throw std::invalid_argument("invalid DCT type");
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  const ExecDcst exec{ortho, type, true};
+  if (type==1)
+    general_nd<T_dct1<T>>(ain, aout, axes, fct, nthreads, exec);
+  else if (type==4)
+    general_nd<T_dcst4<T>>(ain, aout, axes, fct, nthreads, exec);
+  else
+    general_nd<T_dcst23<T>>(ain, aout, axes, fct, nthreads, exec);
+  }
+
+template<typename T> void dst(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)
+  {
+  if ((type<1) || (type>4)) throw std::invalid_argument("invalid DST type");
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  const ExecDcst exec{ortho, type, false};
+  if (type==1)
+    general_nd<T_dst1<T>>(ain, aout, axes, fct, nthreads, exec);
+  else if (type==4)
+    general_nd<T_dcst4<T>>(ain, aout, axes, fct, nthreads, exec);
+  else
+    general_nd<T_dcst23<T>>(ain, aout, axes, fct, nthreads, exec);
+  }
+
+template<typename T> void r2c(const shape_t &shape_in,
+  const stride_t &stride_in, const stride_t &stride_out, size_t axis,
+  bool forward, const T *data_in, std::complex<T> *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_in)==0) return;
+  util::sanity_check(shape_in, stride_in, stride_out, false, axis);
+  cndarr<T> ain(data_in, shape_in, stride_in);
+  shape_t shape_out(shape_in);
+  shape_out[axis] = shape_in[axis]/2 + 1;
+  ndarr<cmplx<T>> aout(data_out, shape_out, stride_out);
+  general_r2c(ain, aout, axis, forward, fct, nthreads);
+  }
+
+template<typename T> void r2c(const shape_t &shape_in,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  bool forward, const T *data_in, std::complex<T> *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_in)==0) return;
+  util::sanity_check(shape_in, stride_in, stride_out, false, axes);
+  r2c(shape_in, stride_in, stride_out, axes.back(), forward, data_in, data_out,
+    fct, nthreads);
+  if (axes.size()==1) return;
+
+  shape_t shape_out(shape_in);
+  shape_out[axes.back()] = shape_in[axes.back()]/2 + 1;
+  auto newaxes = shape_t{axes.begin(), --axes.end()};
+  c2c(shape_out, stride_out, stride_out, newaxes, forward, data_out, data_out,
+    T(1), nthreads);
+  }
+
+template<typename T> void c2r(const shape_t &shape_out,
+  const stride_t &stride_in, const stride_t &stride_out, size_t axis,
+  bool forward, const std::complex<T> *data_in, T *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_out)==0) return;
+  util::sanity_check(shape_out, stride_in, stride_out, false, axis);
+  shape_t shape_in(shape_out);
+  shape_in[axis] = shape_out[axis]/2 + 1;
+  cndarr<cmplx<T>> ain(data_in, shape_in, stride_in);
+  ndarr<T> aout(data_out, shape_out, stride_out);
+  general_c2r(ain, aout, axis, forward, fct, nthreads);
+  }
+
+template<typename T> void c2r(const shape_t &shape_out,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  bool forward, const std::complex<T> *data_in, T *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_out)==0) return;
+  if (axes.size()==1)
+    return c2r(shape_out, stride_in, stride_out, axes[0], forward,
+      data_in, data_out, fct, nthreads);
+  util::sanity_check(shape_out, stride_in, stride_out, false, axes);
+  auto shape_in = shape_out;
+  shape_in[axes.back()] = shape_out[axes.back()]/2 + 1;
+  auto nval = util::prod(shape_in);
+  stride_t stride_inter(shape_in.size());
+  stride_inter.back() = sizeof(cmplx<T>);
+  for (int i=int(shape_in.size())-2; i>=0; --i)
+    stride_inter[size_t(i)] =
+      stride_inter[size_t(i+1)]*ptrdiff_t(shape_in[size_t(i+1)]);
+  arr<std::complex<T>> tmp(nval);
+  auto newaxes = shape_t{axes.begin(), --axes.end()};
+  c2c(shape_in, stride_in, stride_inter, newaxes, forward, data_in, tmp.data(),
+    T(1), nthreads);
+  c2r(shape_out, stride_inter, stride_out, axes.back(), forward,
+    tmp.data(), data_out, fct, nthreads);
+  }
+
+template<typename T> void r2r_fftpack(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  bool real2hermitian, bool forward, const T *data_in, T *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  general_nd<pocketfft_r<T>>(ain, aout, axes, fct, nthreads,
+    ExecR2R{real2hermitian, forward});
+  }
+
+template<typename T> void r2r_separable_hartley(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  const T *data_in, T *data_out, T fct, size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  general_nd<pocketfft_r<T>>(ain, aout, axes, fct, nthreads, ExecHartley{},
+    false);
+  }
+
+template<typename T> void r2r_genuine_hartley(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  const T *data_in, T *data_out, T fct, size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  if (axes.size()==1)
+    return r2r_separable_hartley(shape, stride_in, stride_out, axes, data_in,
+      data_out, fct, nthreads);
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  shape_t tshp(shape);
+  tshp[axes.back()] = tshp[axes.back()]/2+1;
+  arr<std::complex<T>> tdata(util::prod(tshp));
+  stride_t tstride(shape.size());
+  tstride.back()=sizeof(std::complex<T>);
+  for (size_t i=tstride.size()-1; i>0; --i)
+    tstride[i-1]=tstride[i]*ptrdiff_t(tshp[i]);
+  r2c(shape, stride_in, tstride, axes, true, data_in, tdata.data(), fct, nthreads);
+  cndarr<cmplx<T>> atmp(tdata.data(), tshp, tstride);
+  ndarr<T> aout(data_out, shape, stride_out);
+  simple_iter iin(atmp);
+  rev_iter iout(aout, axes);
+  while(iin.remaining()>0)
+    {
+    auto v = atmp[iin.ofs()];
+    aout[iout.ofs()] = v.r+v.i;
+    aout[iout.rev_ofs()] = v.r-v.i;
+    iin.advance(); iout.advance();
+    }
+  }
+
+} // namespace detail
+
+using detail::FORWARD;
+using detail::BACKWARD;
+using detail::shape_t;
+using detail::stride_t;
+using detail::c2c;
+using detail::c2r;
+using detail::r2c;
+using detail::r2r_fftpack;
+using detail::r2r_separable_hartley;
+using detail::r2r_genuine_hartley;
+using detail::dct;
+using detail::dst;
+
+} // namespace pocketfft
+
+#undef POCKETFFT_NOINLINE
+#undef POCKETFFT_RESTRICT
+
+#endif // POCKETFFT_HDRONLY_H
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/allocator.h b/lib/python3.11/site-packages/mlx/include/mlx/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..1061d6cce8a0c2fe01b155b30df0120be7b3f737
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/allocator.h
@@ -0,0 +1,66 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <cstdlib>
+
+namespace mlx::core::allocator {
+
+// Simple wrapper around buffer pointers
+// WARNING: Only Buffer objects constructed from and those that wrap
+//          raw pointers from mlx::allocator are supported.
+class Buffer {
+ private:
+  void* ptr_;
+
+ public:
+  Buffer(void* ptr) : ptr_(ptr){};
+
+  // Get the raw data pointer from the buffer
+  void* raw_ptr();
+
+  // Get the buffer pointer from the buffer
+  const void* ptr() const {
+    return ptr_;
+  };
+  void* ptr() {
+    return ptr_;
+  };
+};
+
+Buffer malloc(size_t size);
+
+void free(Buffer buffer);
+
+// Wait for running tasks to finish and free up memory
+// if allocation fails
+Buffer malloc_or_wait(size_t size);
+
+class Allocator {
+  /** Abstract base class for a memory allocator. */
+ public:
+  virtual Buffer malloc(size_t size, bool allow_swap = false) = 0;
+  virtual void free(Buffer buffer) = 0;
+
+  Allocator() = default;
+  Allocator(const Allocator& other) = delete;
+  Allocator(Allocator&& other) = delete;
+  Allocator& operator=(const Allocator& other) = delete;
+  Allocator& operator=(Allocator&& other) = delete;
+  virtual ~Allocator() = default;
+};
+
+Allocator& allocator();
+
+class CommonAllocator : public Allocator {
+  /** A general CPU allocator. */
+ public:
+  virtual Buffer malloc(size_t size, bool allow_swap = false) override;
+  virtual void free(Buffer buffer) override;
+
+ private:
+  CommonAllocator() = default;
+  friend Allocator& allocator();
+};
+
+} // namespace mlx::core::allocator
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/array.h b/lib/python3.11/site-packages/mlx/include/mlx/array.h
new file mode 100644
index 0000000000000000000000000000000000000000..3801fa1d0ab6282d11330a9996c50f21dd5cb83f
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/array.h
@@ -0,0 +1,438 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "mlx/allocator.h"
+#include "mlx/dtype.h"
+
+namespace mlx::core {
+
+// Forward declaration
+class Primitive;
+using deleter_t = std::function<void(allocator::Buffer)>;
+
+class array {
+  /* An array is really a node in a graph. It contains a shared ArrayDesc
+   * object */
+
+ public:
+  /** Construct a scalar array with zero dimensions. */
+  template <typename T>
+  explicit array(T val, Dtype dtype = TypeToDtype<T>());
+
+  /* Special case since std::complex can't be implicitly converted to other
+   * types. */
+  explicit array(const std::complex<float>& val, Dtype dtype = complex64);
+
+  template <typename It>
+  array(
+      It data,
+      const std::vector<int>& shape,
+      Dtype dtype =
+          TypeToDtype<typename std::iterator_traits<It>::value_type>());
+
+  template <typename T>
+  array(std::initializer_list<T> data, Dtype dtype = TypeToDtype<T>());
+
+  /* Special case so empty lists default to float32. */
+  array(std::initializer_list<float> data);
+
+  template <typename T>
+  array(
+      std::initializer_list<T> data,
+      const std::vector<int>& shape,
+      Dtype dtype = TypeToDtype<T>());
+
+  /* Build an array from a buffer */
+  array(
+      allocator::Buffer data,
+      const std::vector<int>& shape,
+      Dtype dtype,
+      deleter_t deleter = allocator::free);
+
+  /** Assignment to rvalue does not compile. */
+  array& operator=(const array& other) && = delete;
+  array& operator=(array&& other) && = delete;
+
+  /** Default copy and move constructors otherwise. */
+  array& operator=(array&& other) & = default;
+  array(const array& other) = default;
+  array(array&& other) = default;
+
+  array& operator=(const array& other) & {
+    if (this->id() != other.id()) {
+      this->array_desc_ = other.array_desc_;
+    }
+    return *this;
+  };
+
+  /** The size of the array's datatype in bytes. */
+  size_t itemsize() const {
+    return size_of(dtype());
+  };
+
+  /** The number of elements in the array. */
+  size_t size() const {
+    return array_desc_->size;
+  };
+
+  /** The number of bytes in the array. */
+  size_t nbytes() const {
+    return size() * itemsize();
+  };
+
+  /** The number of dimensions of the array. */
+  size_t ndim() const {
+    return array_desc_->shape.size();
+  };
+
+  /** The shape of the array as a vector of integers. */
+  const std::vector<int>& shape() const {
+    return array_desc_->shape;
+  };
+
+  /**
+   *  Get the size of the corresponding dimension.
+   *
+   *  This function supports negative indexing and provides
+   *  bounds checking. */
+  int shape(int dim) const {
+    return shape().at(dim < 0 ? dim + ndim() : dim);
+  };
+
+  /** The strides of the array. */
+  const std::vector<size_t>& strides() const {
+    return array_desc_->strides;
+  };
+
+  /** Get the arrays data type. */
+  Dtype dtype() const {
+    return array_desc_->dtype;
+  };
+
+  /** Evaluate the array. */
+  void eval(bool retain_graph = false);
+
+  /** Get the value from a scalar array. */
+  template <typename T>
+  T item(bool retain_graph = false);
+
+  struct ArrayIterator {
+    using iterator_category = std::random_access_iterator_tag;
+    using difference_type = size_t;
+    using value_type = const array;
+    using reference = value_type;
+
+    explicit ArrayIterator(const array& arr, int idx = 0) : arr(arr), idx(idx) {
+      if (arr.ndim() == 0) {
+        throw std::invalid_argument("Cannot iterate over 0-d array.");
+      }
+    }
+
+    reference operator*() const;
+
+    ArrayIterator& operator+(difference_type diff) {
+      idx += diff;
+      return *this;
+    }
+
+    ArrayIterator& operator++() {
+      idx++;
+      return *this;
+    }
+
+    friend bool operator==(const ArrayIterator& a, const ArrayIterator& b) {
+      return a.arr.id() == b.arr.id() && a.idx == b.idx;
+    };
+    friend bool operator!=(const ArrayIterator& a, const ArrayIterator& b) {
+      return !(a == b);
+    };
+
+   private:
+    const array& arr;
+    int idx;
+  };
+
+  ArrayIterator begin() const {
+    return ArrayIterator(*this);
+  }
+  ArrayIterator end() const {
+    return ArrayIterator(*this, shape(0));
+  }
+
+  /**
+   * The following methods should be used with caution.
+   * They are intended for use by the backend implementation and the
+   * API may change.
+   */
+
+  array(
+      const std::vector<int>& shape,
+      Dtype dtype,
+      std::unique_ptr<Primitive> primitive,
+      const std::vector<array>& inputs);
+
+  /** A unique identifier for an array. */
+  std::uintptr_t id() const {
+    return reinterpret_cast<std::uintptr_t>(array_desc_.get());
+  }
+
+  struct Data {
+    allocator::Buffer buffer;
+    deleter_t d;
+    Data(allocator::Buffer buffer, deleter_t d = allocator::free)
+        : buffer(buffer), d(d){};
+    // Not copyable
+    Data(const Data& d) = delete;
+    Data& operator=(const Data& d) = delete;
+    ~Data() {
+      d(buffer);
+    }
+  };
+
+  struct Flags {
+    // True if there are no gaps in the underlying data. Each item
+    // in the underlying data buffer belongs to at least one index.
+    bool contiguous : 1;
+
+    bool row_contiguous : 1;
+    bool col_contiguous : 1;
+  };
+
+  /** The array's primitive. */
+  Primitive& primitive() const {
+    return *(array_desc_->primitive);
+  };
+
+  /** Check if the array has an attached primitive or is a leaf node. */
+  bool has_primitive() const {
+    return array_desc_->primitive != nullptr;
+  };
+
+  /** The array's inputs. */
+  const std::vector<array>& inputs() const {
+    return array_desc_->inputs;
+  };
+
+  /** A non-const reference to the array's inputs so that they can be used to
+   * edit the graph. */
+  std::vector<array>& editable_inputs() {
+    return array_desc_->inputs;
+  }
+
+  /** Detach the array from the graph. */
+  void detach();
+
+  /** Get the Flags bit-field. */
+  const Flags& flags() const {
+    return array_desc_->flags;
+  };
+
+  /** The size (in elements) of the underlying buffer the array points to. */
+  size_t data_size() const {
+    return array_desc_->data_size;
+  };
+
+  allocator::Buffer& buffer() {
+    return array_desc_->data->buffer;
+  };
+  const allocator::Buffer& buffer() const {
+    return array_desc_->data->buffer;
+  };
+
+  template <typename T>
+  T* data() {
+    return static_cast<T*>(array_desc_->data_ptr);
+  };
+
+  template <typename T>
+  const T* data() const {
+    return static_cast<T*>(array_desc_->data_ptr);
+  };
+
+  // Check if the array has been evaluated
+  bool is_evaled() const {
+    return array_desc_->data != nullptr;
+  }
+
+  // Mark the array as a tracer array (true) or not.
+  void set_tracer(bool is_tracer) {
+    array_desc_->is_tracer = is_tracer;
+  }
+  // Check if the array is a tracer array
+  bool is_tracer() const {
+    return array_desc_->is_tracer;
+  }
+
+  void set_data(allocator::Buffer buffer, deleter_t d = allocator::free);
+
+  void set_data(
+      allocator::Buffer buffer,
+      size_t data_size,
+      std::vector<size_t> strides,
+      Flags flags,
+      deleter_t d = allocator::free);
+
+  void copy_shared_buffer(
+      const array& other,
+      const std::vector<size_t>& strides,
+      Flags flags,
+      size_t data_size,
+      size_t offset = 0);
+
+  void copy_shared_buffer(const array& other);
+
+  void overwrite_descriptor(const array& other) {
+    array_desc_ = other.array_desc_;
+  }
+
+ private:
+  // Initialize the arrays data
+  template <typename It>
+  void init(const It src);
+
+  struct ArrayDesc {
+    std::vector<int> shape;
+    std::vector<size_t> strides;
+    size_t size;
+    Dtype dtype;
+    std::unique_ptr<Primitive> primitive{nullptr};
+
+    // Indicates an array is being used in a graph transform
+    // and should not be detached from the graph
+    bool is_tracer{false};
+
+    // This is a shared pointer so that *different* arrays
+    // can share the underlying data buffer.
+    std::shared_ptr<Data> data{nullptr};
+
+    // Properly offset data pointer
+    void* data_ptr{nullptr};
+
+    // The size in elements of the data buffer the array accesses
+    // This can be different than the actual size of the array if it
+    // has been broadcast or irregularly strided.
+    size_t data_size;
+
+    // Contains useful meta data about the array
+    Flags flags;
+
+    std::vector<array> inputs;
+
+    explicit ArrayDesc(const std::vector<int>& shape, Dtype dtype);
+
+    explicit ArrayDesc(
+        const std::vector<int>& shape,
+        Dtype dtype,
+        std::unique_ptr<Primitive> primitive,
+        const std::vector<array>& inputs);
+
+    ~ArrayDesc();
+  };
+
+  // The ArrayDesc contains the details of the materialized array including the
+  // shape, strides, the data type. It also includes
+  // the primitive which knows how to compute the array's data from its inputs
+  // and a the list of array's inputs for the primitive.
+  std::shared_ptr<ArrayDesc> array_desc_{nullptr};
+};
+
+template <typename T>
+array::array(T val, Dtype dtype /* = TypeToDtype<T>() */)
+    : array_desc_(std::make_shared<ArrayDesc>(std::vector<int>{}, dtype)) {
+  init(&val);
+}
+
+template <typename It>
+array::array(
+  It data,
+  const std::vector<int>& shape,
+  Dtype dtype /* = TypeToDtype<typename std::iterator_traits<It>::value_type>() */) :
+    array_desc_(std::make_shared<ArrayDesc>(shape, dtype)) {
+  init(data);
+}
+
+template <typename T>
+array::array(
+    std::initializer_list<T> data,
+    Dtype dtype /* = TypeToDtype<T>() */)
+    : array_desc_(std::make_shared<ArrayDesc>(
+          std::vector<int>{static_cast<int>(data.size())},
+          dtype)) {
+  init(data.begin());
+}
+
+template <typename T>
+array::array(
+    std::initializer_list<T> data,
+    const std::vector<int>& shape,
+    Dtype dtype /* = TypeToDtype<T>() */)
+    : array_desc_(std::make_shared<ArrayDesc>(shape, dtype)) {
+  if (data.size() != size()) {
+    throw std::invalid_argument(
+        "Data size and provided shape mismatch in array construction.");
+  }
+  init(data.begin());
+}
+
+template <typename T>
+T array::item(bool retain_graph /* = false */) {
+  if (size() != 1) {
+    throw std::invalid_argument("item can only be called on arrays of size 1.");
+  }
+  eval(retain_graph);
+  return *data<T>();
+}
+
+template <typename It>
+void array::init(It src) {
+  set_data(allocator::malloc(size() * size_of(dtype())));
+  switch (dtype()) {
+    case bool_:
+      std::copy(src, src + size(), data<bool>());
+      break;
+    case uint8:
+      std::copy(src, src + size(), data<uint8_t>());
+      break;
+    case uint16:
+      std::copy(src, src + size(), data<uint16_t>());
+      break;
+    case uint32:
+      std::copy(src, src + size(), data<uint32_t>());
+      break;
+    case uint64:
+      std::copy(src, src + size(), data<uint64_t>());
+      break;
+    case int8:
+      std::copy(src, src + size(), data<int8_t>());
+      break;
+    case int16:
+      std::copy(src, src + size(), data<int16_t>());
+      break;
+    case int32:
+      std::copy(src, src + size(), data<int32_t>());
+      break;
+    case int64:
+      std::copy(src, src + size(), data<int64_t>());
+      break;
+    case float16:
+      std::copy(src, src + size(), data<float16_t>());
+      break;
+    case float32:
+      std::copy(src, src + size(), data<float>());
+      break;
+    case bfloat16:
+      std::copy(src, src + size(), data<bfloat16_t>());
+      break;
+    case complex64:
+      std::copy(src, src + size(), data<complex64_t>());
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/accelerate/utils.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/accelerate/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..1dbabe3045de58eb2223ef7f857f45475ee9c89f
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/accelerate/utils.h
@@ -0,0 +1,28 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <vecLib/BNNS/bnns.h>
+#include "mlx/dtype.h"
+
+namespace mlx::core {
+
+BNNSDataType to_bnns_dtype(Dtype mlx_dtype) {
+  uint32_t size_bits = size_of(mlx_dtype) * 8;
+  switch (kindof(mlx_dtype)) {
+    case Dtype::Kind::b:
+      return BNNSDataTypeBoolean;
+    case Dtype::Kind::u:
+      return BNNSDataType(BNNSDataTypeUIntBit | size_bits);
+    case Dtype::Kind::i:
+      return BNNSDataType(BNNSDataTypeIntBit | size_bits);
+    case Dtype::Kind::f:
+      return BNNSDataType(BNNSDataTypeFloatBit | size_bits);
+    case Dtype::Kind::V:
+      return BNNSDataTypeBFloat16;
+    case Dtype::Kind::c:
+      throw std::invalid_argument("BNNS does not support complex types");
+  }
+}
+
+} // namespace mlx::core
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/arange.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/arange.h
new file mode 100644
index 0000000000000000000000000000000000000000..5c155dc09cd541f6b6c43a2022d7a6feab86a587
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/arange.h
@@ -0,0 +1,74 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/allocator.h"
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T>
+void arange(T start, T next, array& out, size_t size) {
+  auto ptr = out.data<T>();
+  auto step_size = next - start;
+  for (int i = 0; i < size; ++i) {
+    ptr[i] = start;
+    start += step_size;
+  }
+}
+
+} // namespace
+
+void arange(
+    const std::vector<array>& inputs,
+    array& out,
+    double start,
+    double step) {
+  assert(inputs.size() == 0);
+  out.set_data(allocator::malloc_or_wait(out.nbytes()));
+  switch (out.dtype()) {
+    case bool_:
+      throw std::runtime_error("Bool type unsupported for arange.");
+      break;
+    case uint8:
+      arange<uint8_t>(start, start + step, out, out.size());
+      break;
+    case uint16:
+      arange<uint16_t>(start, start + step, out, out.size());
+      break;
+    case uint32:
+      arange<uint32_t>(start, start + step, out, out.size());
+      break;
+    case uint64:
+      arange<uint64_t>(start, start + step, out, out.size());
+      break;
+    case int8:
+      arange<int8_t>(start, start + step, out, out.size());
+      break;
+    case int16:
+      arange<int16_t>(start, start + step, out, out.size());
+      break;
+    case int32:
+      arange<int32_t>(start, start + step, out, out.size());
+      break;
+    case int64:
+      arange<int64_t>(start, start + step, out, out.size());
+      break;
+    case float16:
+      arange<float16_t>(start, start + step, out, out.size());
+      break;
+    case float32:
+      arange<float>(start, start + step, out, out.size());
+      break;
+    case bfloat16:
+      arange<bfloat16_t>(start, start + step, out, out.size());
+      break;
+    case complex64:
+      arange<complex64_t>(start, start + step, out, out.size());
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/binary.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/binary.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b06317462a5e1135c9d131347ffc5f5a18ad06d
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/binary.h
@@ -0,0 +1,556 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/allocator.h"
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+enum BinaryOpType {
+  ScalarScalar,
+  ScalarVector,
+  VectorScalar,
+  VectorVector,
+  General,
+};
+
+BinaryOpType get_binary_op_type(const array& a, const array& b) {
+  BinaryOpType bopt;
+  if (a.data_size() == 1 && b.data_size() == 1) {
+    bopt = ScalarScalar;
+  } else if (a.data_size() == 1 && b.flags().contiguous) {
+    bopt = ScalarVector;
+  } else if (b.data_size() == 1 && a.flags().contiguous) {
+    bopt = VectorScalar;
+  } else if (
+      a.flags().row_contiguous && b.flags().row_contiguous ||
+      a.flags().col_contiguous && b.flags().col_contiguous) {
+    bopt = VectorVector;
+  } else {
+    bopt = General;
+  }
+  return bopt;
+}
+
+void set_binary_op_output_data(
+    const array& a,
+    const array& b,
+    array& out,
+    BinaryOpType bopt) {
+  switch (bopt) {
+    case ScalarScalar:
+      out.set_data(
+          allocator::malloc_or_wait(out.itemsize()), 1, a.strides(), a.flags());
+      break;
+    case ScalarVector:
+      out.set_data(
+          allocator::malloc_or_wait(b.data_size() * out.itemsize()),
+          b.data_size(),
+          b.strides(),
+          b.flags());
+      break;
+    case VectorScalar:
+    case VectorVector:
+      out.set_data(
+          allocator::malloc_or_wait(a.data_size() * out.itemsize()),
+          a.data_size(),
+          a.strides(),
+          a.flags());
+      break;
+    case General:
+      out.set_data(allocator::malloc_or_wait(out.nbytes()));
+      break;
+  }
+}
+
+struct UseDefaultBinaryOp {
+  template <typename T, typename U>
+  void operator()(const T* a, const T* b, U* dst, int size) {
+    // Should we throw? This should normally never be called.
+    assert(false);
+  }
+};
+
+template <typename T, typename U, typename Op>
+struct DefaultVectorScalar {
+  Op op;
+
+  DefaultVectorScalar(Op op_) : op(op_) {}
+
+  void operator()(const T* a, const T* b, U* dst, int size) {
+    T scalar = *b;
+    while (size-- > 0) {
+      *dst = op(*a, scalar);
+      dst++;
+      a++;
+    }
+  }
+};
+
+template <typename T, typename U, typename Op>
+struct DefaultScalarVector {
+  Op op;
+
+  DefaultScalarVector(Op op_) : op(op_) {}
+
+  void operator()(const T* a, const T* b, U* dst, int size) {
+    T scalar = *a;
+    while (size-- > 0) {
+      *dst = op(scalar, *b);
+      dst++;
+      b++;
+    }
+  }
+};
+
+template <typename T, typename U, typename Op>
+struct DefaultVectorVector {
+  Op op;
+
+  DefaultVectorVector(Op op_) : op(op_) {}
+
+  void operator()(const T* a, const T* b, U* dst, int size) {
+    while (size-- > 0) {
+      *dst = op(*a, *b);
+      dst++;
+      a++;
+      b++;
+    }
+  }
+};
+
+template <typename T, typename U, typename Op>
+void binary_op_dims1(const array& a, const array& b, array& out, Op op) {
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  size_t a_idx = 0;
+  size_t b_idx = 0;
+  for (size_t i = 0; i < out.size(); ++i) {
+    dst[i] = op(a_ptr[a_idx], b_ptr[b_idx]);
+    a_idx += a.strides()[0];
+    b_idx += b.strides()[0];
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dims1(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    int stride) {
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  size_t a_idx = 0;
+  size_t b_idx = 0;
+  for (size_t i = 0; i < a.shape()[0]; i++) {
+    op(a_ptr + a_idx, b_ptr + b_idx, dst, stride);
+    a_idx += a.strides()[0];
+    b_idx += b.strides()[0];
+    dst += stride;
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dims2(const array& a, const array& b, array& out, Op op) {
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  size_t a_idx = 0;
+  size_t b_idx = 0;
+  size_t out_idx = 0;
+  for (size_t i = 0; i < a.shape()[0]; ++i) {
+    for (size_t j = 0; j < a.shape()[1]; ++j) {
+      dst[out_idx++] = op(a_ptr[a_idx], b_ptr[b_idx]);
+      a_idx += a.strides()[1];
+      b_idx += b.strides()[1];
+    }
+    a_idx += a.strides()[0] - a.strides()[1] * a.shape()[1];
+    b_idx += b.strides()[0] - b.strides()[1] * b.shape()[1];
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dims2(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    int stride) {
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  size_t a_idx = 0;
+  size_t b_idx = 0;
+  for (size_t i = 0; i < a.shape()[0]; ++i) {
+    for (size_t j = 0; j < a.shape()[1]; ++j) {
+      op(a_ptr + a_idx, b_ptr + b_idx, dst, stride);
+      a_idx += a.strides()[1];
+      b_idx += b.strides()[1];
+      dst += stride;
+    }
+    a_idx += a.strides()[0] - a.strides()[1] * a.shape()[1];
+    b_idx += b.strides()[0] - b.strides()[1] * b.shape()[1];
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dims3(const array& a, const array& b, array& out, Op op) {
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  size_t a_idx = 0;
+  size_t b_idx = 0;
+  size_t out_idx = 0;
+  for (size_t i = 0; i < a.shape()[0]; ++i) {
+    for (size_t j = 0; j < a.shape()[1]; ++j) {
+      for (size_t k = 0; k < a.shape()[2]; ++k) {
+        dst[out_idx++] = op(a_ptr[a_idx], b_ptr[b_idx]);
+        a_idx += a.strides()[2];
+        b_idx += b.strides()[2];
+      }
+      a_idx += a.strides()[1] - a.strides()[2] * a.shape()[2];
+      b_idx += b.strides()[1] - b.strides()[2] * b.shape()[2];
+    }
+    a_idx += a.strides()[0] - a.strides()[1] * a.shape()[1];
+    b_idx += b.strides()[0] - b.strides()[1] * b.shape()[1];
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dims4(const array& a, const array& b, array& out, Op op) {
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  size_t a_idx = 0;
+  size_t b_idx = 0;
+  size_t out_idx = 0;
+  for (size_t i = 0; i < a.shape()[0]; ++i) {
+    for (size_t j = 0; j < a.shape()[1]; ++j) {
+      for (size_t k = 0; k < a.shape()[2]; ++k) {
+        for (size_t ii = 0; ii < a.shape()[3]; ++ii) {
+          dst[out_idx++] = op(a_ptr[a_idx], b_ptr[b_idx]);
+          a_idx += a.strides()[3];
+          b_idx += b.strides()[3];
+        }
+        a_idx += a.strides()[2] - a.strides()[3] * a.shape()[3];
+        b_idx += b.strides()[2] - b.strides()[3] * b.shape()[3];
+      }
+      a_idx += a.strides()[1] - a.strides()[2] * a.shape()[2];
+      b_idx += b.strides()[1] - b.strides()[2] * b.shape()[2];
+    }
+    a_idx += a.strides()[0] - a.strides()[1] * a.shape()[1];
+    b_idx += b.strides()[0] - b.strides()[1] * b.shape()[1];
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dispatch_dims(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op) {
+  switch (out.ndim()) {
+    case 1:
+      binary_op_dims1<T, U, Op>(a, b, out, op);
+      return;
+    case 2:
+      binary_op_dims2<T, U, Op>(a, b, out, op);
+      return;
+    case 3:
+      binary_op_dims3<T, U, Op>(a, b, out, op);
+      return;
+    case 4:
+      binary_op_dims4<T, U, Op>(a, b, out, op);
+      return;
+  }
+
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  for (size_t i = 0; i < out.size(); i++) {
+    int a_idx = elem_to_loc(i, a.shape(), a.strides());
+    int b_idx = elem_to_loc(i, b.shape(), b.strides());
+    dst[i] = op(a_ptr[a_idx], b_ptr[b_idx]);
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dispatch_dims(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    int dim,
+    int stride) {
+  // Number of dimensions to loop over for vectorized ops
+  switch (dim) {
+    case 1:
+      binary_op_dims1<T, U, Op>(a, b, out, op, stride);
+      return;
+    case 2:
+      binary_op_dims2<T, U, Op>(a, b, out, op, stride);
+      return;
+  }
+
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* dst = out.data<U>();
+  for (size_t i = 0; i < out.size(); i += stride) {
+    int a_idx = elem_to_loc(i, a.shape(), a.strides());
+    int b_idx = elem_to_loc(i, b.shape(), b.strides());
+    op(a_ptr + a_idx, b_ptr + b_idx, dst, stride);
+    dst += stride;
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    typename OpSV,
+    typename OpVS,
+    typename OpVV>
+void binary_op(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    OpSV opsv,
+    OpVS opvs,
+    OpVV opvv) {
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out, bopt);
+
+  // The full computation is scalar scalar so call the base op once
+  if (bopt == ScalarScalar) {
+    *(out.data<U>()) = op(*a.data<T>(), *b.data<T>());
+    return;
+  }
+
+  // The full computation is scalar vector so delegate to the op
+  if (bopt == ScalarVector) {
+    opsv(a.data<T>(), b.data<T>(), out.data<U>(), b.data_size());
+    return;
+  }
+
+  // The full computation is vector scalar so delegate to the op
+  if (bopt == VectorScalar) {
+    opvs(a.data<T>(), b.data<T>(), out.data<U>(), a.data_size());
+    return;
+  }
+
+  // The full computation is vector vector so delegate to the op
+  if (bopt == VectorVector) {
+    opvv(a.data<T>(), b.data<T>(), out.data<U>(), out.size());
+    return;
+  }
+
+  // General computation so let's try to optimize
+
+  // Get the left-most dim such that the array is row contiguous after
+  auto& strides = out.strides();
+  auto leftmost_rc_dim = [&strides](const array& arr) {
+    int d = arr.ndim() - 1;
+    for (; d >= 0 && arr.strides()[d] == strides[d]; d--) {
+    }
+    return d + 1;
+  };
+  auto a_rc_dim = leftmost_rc_dim(a);
+  auto b_rc_dim = leftmost_rc_dim(b);
+
+  // Get the left-most dim such that the array is a broadcasted "scalar" after
+  auto leftmost_s_dim = [](const array& arr) {
+    int d = arr.ndim() - 1;
+    for (; d >= 0 && arr.strides()[d] == 0; d--) {
+    }
+    return d + 1;
+  };
+  auto a_s_dim = leftmost_s_dim(a);
+  auto b_s_dim = leftmost_s_dim(b);
+
+  auto ndim = out.ndim();
+
+  // Case 1: LxM and FxM where L and F are broadcastable and M is row contiguous
+  int dim = ndim;
+  if (int d = std::max(a_rc_dim, b_rc_dim); d < ndim) {
+    bopt = VectorVector;
+    dim = d;
+    // Case 2: LxM and Fx1 where L and F are broadcastable and M is row
+    // contiguous
+  } else if (int d = std::max(a_rc_dim, b_s_dim); d < ndim) {
+    bopt = VectorScalar;
+    dim = d;
+    // Case 3: Lx1 and FxM where L and F are broadcastable and M is row
+    // contiguous
+  } else if (int d = std::max(a_s_dim, b_rc_dim); d < ndim) {
+    bopt = ScalarVector;
+    dim = d;
+  }
+
+  // Can be sure dim > 0 since otherwise we would have used one of the fully
+  // contiguous methods above. Except for the case that the flags do not
+  // correspond to the underlying contiguity.
+  size_t stride;
+  if (dim == 0 || strides[dim - 1] < 16) {
+    stride = 1;
+    bopt = General;
+    dim = ndim;
+  } else {
+    stride = strides[dim - 1];
+  }
+
+  switch (bopt) {
+    case VectorVector:
+      binary_op_dispatch_dims<T, U>(a, b, out, opvv, dim, stride);
+      break;
+    case VectorScalar:
+      binary_op_dispatch_dims<T, U>(a, b, out, opvs, dim, stride);
+      break;
+    case ScalarVector:
+      binary_op_dispatch_dims<T, U>(a, b, out, opsv, dim, stride);
+      break;
+    default:
+      binary_op_dispatch_dims<T, U>(a, b, out, op);
+      break;
+  }
+}
+
+template <typename T, typename Op, typename OpSV, typename OpVS, typename OpVV>
+void binary_op(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    OpSV opsv,
+    OpVS opvs,
+    OpVV opvv) {
+  // TODO: The following mess of constexpr evaluations can probably be achieved
+  //       with template specializations and overloading. Would it be simpler?
+
+  if (std::is_same<decltype(opsv), UseDefaultBinaryOp>::value) {
+    if (std::is_same<decltype(opvs), UseDefaultBinaryOp>::value) {
+      if (std::is_same<decltype(opvv), UseDefaultBinaryOp>::value) {
+        // All ops are UseDefaultBinaryOp (why oh why would someone call that?)
+        binary_op<T, T>(
+            a,
+            b,
+            out,
+            op,
+            DefaultScalarVector<T, T, Op>(op),
+            DefaultVectorScalar<T, T, Op>(op),
+            DefaultVectorVector<T, T, Op>(op));
+      } else {
+        // opsv and opvs were UseDefaultBinaryOp
+        binary_op<T, T>(
+            a,
+            b,
+            out,
+            op,
+            DefaultScalarVector<T, T, Op>(op),
+            DefaultVectorScalar<T, T, Op>(op),
+            opvv);
+      }
+    } else if (std::is_same<decltype(opvv), UseDefaultBinaryOp>::value) {
+      // opsv and opvv were UseDefaultBinaryOp
+      binary_op<T, T>(
+          a,
+          b,
+          out,
+          op,
+          DefaultScalarVector<T, T, Op>(op),
+          opvs,
+          DefaultVectorVector<T, T, Op>(op));
+    } else {
+      // opsv was UseDefaultBinaryOp
+      binary_op<T, T>(
+          a, b, out, op, DefaultScalarVector<T, T, Op>(op), opvs, opvv);
+    }
+  } else if (std::is_same<decltype(opvs), UseDefaultBinaryOp>::value) {
+    if (std::is_same<decltype(opvv), UseDefaultBinaryOp>::value) {
+      // opvs and opvv were UseDefaultBinaryOp
+      binary_op<T, T>(
+          a,
+          b,
+          out,
+          op,
+          opsv,
+          DefaultVectorScalar<T, T, Op>(op),
+          DefaultVectorVector<T, T, Op>(op));
+    } else {
+      // opvs was UseDefaultBinaryOp
+      binary_op<T, T>(
+          a, b, out, op, opsv, DefaultVectorScalar<T, T, Op>(op), opvv);
+    }
+  } else if (std::is_same<decltype(opvv), UseDefaultBinaryOp>::value) {
+    // opvv was UseDefaultBinaryOp
+    binary_op<T, T>(
+        a, b, out, op, opsv, opvs, DefaultVectorVector<T, T, Op>(op));
+  } else {
+    // All ops provided
+    binary_op<T, T>(a, b, out, op, opsv, opvs, opvv);
+  }
+}
+
+template <typename T, typename Op>
+void binary_op(const array& a, const array& b, array& out, Op op) {
+  DefaultScalarVector<T, T, Op> opsv(op);
+  DefaultVectorScalar<T, T, Op> opvs(op);
+  DefaultVectorVector<T, T, Op> opvv(op);
+  binary_op<T, T>(a, b, out, op, opsv, opvs, opvv);
+}
+
+template <typename... Ops>
+void binary(const array& a, const array& b, array& out, Ops... ops) {
+  switch (out.dtype()) {
+    case bool_:
+      binary_op<bool>(a, b, out, ops...);
+      break;
+    case uint8:
+      binary_op<uint8_t>(a, b, out, ops...);
+      break;
+    case uint16:
+      binary_op<uint16_t>(a, b, out, ops...);
+      break;
+    case uint32:
+      binary_op<uint32_t>(a, b, out, ops...);
+      break;
+    case uint64:
+      binary_op<uint64_t>(a, b, out, ops...);
+      break;
+    case int8:
+      binary_op<int8_t>(a, b, out, ops...);
+      break;
+    case int16:
+      binary_op<int16_t>(a, b, out, ops...);
+      break;
+    case int32:
+      binary_op<int32_t>(a, b, out, ops...);
+      break;
+    case int64:
+      binary_op<int64_t>(a, b, out, ops...);
+      break;
+    case float16:
+      binary_op<float16_t>(a, b, out, ops...);
+      break;
+    case float32:
+      binary_op<float>(a, b, out, ops...);
+      break;
+    case bfloat16:
+      binary_op<bfloat16_t>(a, b, out, ops...);
+      break;
+    case complex64:
+      binary_op<complex64_t>(a, b, out, ops...);
+      break;
+  }
+}
+
+} // namespace
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/copy.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..0affddec340f0e533e4ff0b0a0d519ed18e67512
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/copy.h
@@ -0,0 +1,29 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+enum class CopyType {
+  // Copy a raw scalar input into the full contiguous output
+  Scalar,
+
+  // Copy the raw input buffer contiguously into a raw output buffer of the same
+  // size
+  Vector,
+
+  // Copy the full virtual input to the full contiguous output
+  General,
+
+  // Copy the full virtual input to the full virtual output. We assume the
+  // input and output have the same shape.
+  GeneralGeneral
+};
+
+void copy(const array& src, array& dst, CopyType ctype);
+void copy_inplace(const array& src, array& dst, CopyType ctype);
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/erf.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/erf.h
new file mode 100644
index 0000000000000000000000000000000000000000..a175a0c43b8ae6b483ad0e9c8d31f31095944ccb
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/erf.h
@@ -0,0 +1,11 @@
+// Copyright © 2023 Apple Inc.
+
+namespace mlx::core {
+
+/* Approximation to the inverse error function.
+ * Based on code from:
+ *   https://stackoverflow.com/questions/27229371/inverse-error-function-in-c#answer-49743348
+ */
+float erfinv(float a);
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/reduce.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..da1d1658aa8b61856d389c5e9a5e46b9770f58f8
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/reduce.h
@@ -0,0 +1,366 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+enum ReductionOpType {
+  // Self-explanatory. Read everything and produce 1 output.
+  ContiguousAllReduce,
+
+  // The input is contiguous and the last axis is reduced
+  // N1xR1xN2xR2x...xNnxRn
+  ContiguousReduce,
+
+  // The input is contiguous and the last axis is not reduced
+  // R1xN1xR2xN2x...xRnxNn
+  ContiguousStridedReduce,
+
+  // The input is not contiguous but the last axis is and it is reduced so we
+  // need to figure out the offsets but we can call the contiguous reduce after
+  // that.
+  // N3xR1xN1xR4x...xRn
+  GeneralContiguousReduce,
+
+  // The input is not contiguous but the last reduction axis and the last axis
+  // are so we need to figure out the offset but we can call the strided reduce
+  // after that.
+  GeneralStridedReduce,
+
+  // The input is not contiguous after the reduction axis and it may contain
+  // 0-stride axes or transpositions. We could copy the strides and produce a
+  // transposed outcome or we can read the input out of order and write the
+  // output in order.
+  GeneralReduce
+};
+
+// Helper for the ndimensional strided loop
+// Should this be in utils?
+inline void nd_loop(
+    std::function<void(int)> callback,
+    const std::vector<int>& shape,
+    const std::vector<size_t>& strides) {
+  std::function<void(int, int)> loop_inner;
+  loop_inner = [&](int dim, int offset) {
+    if (dim < shape.size() - 1) {
+      int size = shape[dim];
+      size_t stride = strides[dim];
+      for (int i = 0; i < size; i++) {
+        loop_inner(dim + 1, offset + i * stride);
+      }
+    } else {
+      int size = shape[dim];
+      size_t stride = strides[dim];
+      for (int i = 0; i < size; i++) {
+        callback(offset + i * stride);
+      }
+    }
+  };
+  loop_inner(0, 0);
+}
+
+std::pair<std::vector<int>, std::vector<size_t>> shapes_without_reduction_axes(
+    const array& x,
+    const std::vector<int>& axes) {
+  std::vector<int> shape = x.shape();
+  std::vector<size_t> strides = x.strides();
+
+  for (int i = axes.size() - 1; i >= 0; i--) {
+    int a = axes[i];
+    shape.erase(shape.begin() + a);
+    strides.erase(strides.begin() + a);
+  }
+
+  return std::make_pair(shape, strides);
+}
+
+template <typename T, typename U, typename Op>
+struct DefaultStridedReduce {
+  Op op;
+
+  DefaultStridedReduce(Op op_) : op(op_) {}
+
+  void operator()(const T* x, U* accumulator, int size, size_t stride) {
+    for (int i = 0; i < size; i++) {
+      U* moving_accumulator = accumulator;
+      for (int j = 0; j < stride; j++) {
+        op(moving_accumulator, *x);
+        moving_accumulator++;
+        x++;
+      }
+    }
+  }
+};
+
+template <typename T, typename U, typename Op>
+struct DefaultContiguousReduce {
+  Op op;
+
+  DefaultContiguousReduce(Op op_) : op(op_) {}
+
+  void operator()(const T* x, U* accumulator, int size) {
+    while (size-- > 0) {
+      op(accumulator, *x);
+      x++;
+    }
+  }
+};
+
+struct ReductionPlan {
+  ReductionOpType type;
+  std::vector<int> shape;
+  std::vector<size_t> strides;
+
+  ReductionPlan(
+      ReductionOpType type_,
+      std::vector<int> shape_,
+      std::vector<size_t> strides_)
+      : type(type_), shape(std::move(shape_)), strides(std::move(strides_)) {}
+  ReductionPlan(ReductionOpType type_) : type(type_) {}
+};
+
+ReductionPlan get_reduction_plan(const array& x, const std::vector<int> axes) {
+  // The data is all there and we are reducing over everything
+  if (x.size() == x.data_size() && axes.size() == x.ndim() &&
+      x.flags().contiguous) {
+    return ContiguousAllReduce;
+  }
+
+  // Row contiguous input so the output is row contiguous
+  if (x.flags().row_contiguous) {
+    // Merge consecutive axes
+    std::vector<int> shape = {x.shape(axes[0])};
+    std::vector<size_t> strides = {x.strides()[axes[0]]};
+    for (int i = 1; i < axes.size(); i++) {
+      if (axes[i] - 1 == axes[i - 1]) {
+        shape.back() *= x.shape(axes[i]);
+        strides.back() = x.strides()[axes[i]];
+      } else {
+        shape.push_back(x.shape(axes[i]));
+        strides.push_back(x.strides()[axes[i]]);
+      }
+    }
+
+    if (strides.back() == 1) {
+      return ReductionPlan(ContiguousReduce, shape, strides);
+    } else if (strides.back() > 1) {
+      return ReductionPlan(ContiguousStridedReduce, shape, strides);
+    }
+  }
+
+  // Let's check if we can optimize our access patterns
+  //
+  // 1. We have a reduction axis with stride 1. Simply call
+  //    GeneralContiguousReduce and be done with it.
+  // 2. We have transpositions and we are not reducing over the axis with
+  //    stride 1. However, we are reducing over an axis where everything is
+  //    contiguous in memory to the right of that axis. We can call strided
+  //    reduce and be done with it.
+  // 2. We have weird transpositions and expands. Copy the strides to the
+  //    output, then call strided reduce.
+
+  // Sort reduction axes by stride in order to merge them and figure out if we
+  // have a contiguous reduction.
+  std::vector<std::pair<int, size_t>> reductions;
+  for (auto a : axes) {
+    reductions.push_back(std::make_pair(x.shape(a), x.strides()[a]));
+  }
+  std::sort(reductions.begin(), reductions.end(), [](auto a, auto b) {
+    return a.second > b.second;
+  });
+  // Extract the two smallest and try to merge them in case the contiguous
+  // reduction can be bigger than just the last axis.
+  for (int i = reductions.size() - 1; i >= 1; i--) {
+    auto a = reductions[i];
+    auto b = reductions[i - 1];
+
+    // b.stride = a.shape * a.stride then a and b are contiguous
+    if (b.second == a.first * a.second) {
+      reductions.erase(reductions.begin() + i);
+      reductions[i - 1] = std::make_pair(a.first * b.first, a.second);
+    }
+  }
+
+  std::vector<int> shape;
+  std::vector<size_t> strides;
+  for (auto r : reductions) {
+    shape.push_back(r.first);
+    strides.push_back(r.second);
+  }
+
+  // We can call the contiguous reduction op for every weird way the input is
+  // structured in the rest of the axes.
+  if (strides.back() == 1) {
+    return ReductionPlan(GeneralContiguousReduce, shape, strides);
+  }
+
+  // Delegate to the general strided reduction op if the axes after
+  // strides.back() are contiguous.
+  if (strides.back() > 1) {
+    int size = 1;
+    for (int i = x.ndim() - 1; i >= 0; i--) {
+      if (axes.back() == i) {
+        continue;
+      }
+      if (x.strides()[i] != size) {
+        break;
+      }
+      size *= x.shape(i);
+    }
+    if (size >= strides.back()) {
+      return ReductionPlan(GeneralStridedReduce, shape, strides);
+    }
+  }
+
+  return ReductionPlan(GeneralReduce, shape, strides);
+}
+
+template <typename T, typename U, typename OpS, typename OpC, typename Op>
+void reduction_op(
+    const array& x,
+    array& out,
+    const std::vector<int>& axes,
+    U init,
+    OpS ops,
+    OpC opc,
+    Op op) {
+  out.set_data(allocator::malloc_or_wait(out.nbytes()));
+  ReductionPlan plan = get_reduction_plan(x, axes);
+
+  if (plan.type == ContiguousAllReduce) {
+    U* out_ptr = out.data<U>();
+    *out_ptr = init;
+    opc(x.data<T>(), out_ptr, x.size());
+    return;
+  }
+
+  std::vector<int> shape;
+  std::vector<size_t> strides;
+
+  if (plan.type == ContiguousReduce && plan.shape.size() == 1) {
+    int reduction_size = plan.shape[0];
+    const T* x_ptr = x.data<T>();
+    U* out_ptr = out.data<U>();
+    for (int i = 0; i < out.size(); i++, out_ptr++, x_ptr += reduction_size) {
+      *out_ptr = init;
+      opc(x_ptr, out_ptr, reduction_size);
+    }
+    return;
+  }
+
+  if (plan.type == GeneralContiguousReduce || plan.type == ContiguousReduce) {
+    int reduction_size = plan.shape.back();
+    plan.shape.pop_back();
+    plan.strides.pop_back();
+    const T* x_ptr = x.data<T>();
+    U* out_ptr = out.data<U>();
+    // Unrolling the following loop (and implementing it in order for
+    // ContiguousReduce) should hold extra performance boost.
+    std::tie(shape, strides) = shapes_without_reduction_axes(x, axes);
+    if (plan.shape.size() == 0) {
+      for (int i = 0; i < out.size(); i++, out_ptr++) {
+        int offset = elem_to_loc(i, shape, strides);
+        *out_ptr = init;
+        opc(x_ptr + offset, out_ptr, reduction_size);
+      }
+    } else {
+      for (int i = 0; i < out.size(); i++, out_ptr++) {
+        int offset = elem_to_loc(i, shape, strides);
+        *out_ptr = init;
+        nd_loop(
+            [&](int extra_offset) {
+              opc(x_ptr + offset + extra_offset, out_ptr, reduction_size);
+            },
+            plan.shape,
+            plan.strides);
+      }
+    }
+    return;
+  }
+
+  if (plan.type == ContiguousStridedReduce && plan.shape.size() == 1) {
+    int reduction_size = plan.shape.back();
+    size_t reduction_stride = plan.strides.back();
+    plan.shape.pop_back();
+    plan.strides.pop_back();
+    const T* x_ptr = x.data<T>();
+    U* out_ptr = out.data<U>();
+    for (int i = 0; i < out.size(); i += reduction_stride) {
+      std::fill_n(out_ptr, reduction_stride, init);
+      ops(x_ptr, out_ptr, reduction_size, reduction_stride);
+      x_ptr += reduction_stride * reduction_size;
+      out_ptr += reduction_stride;
+    }
+    return;
+  }
+
+  if (plan.type == GeneralStridedReduce ||
+      plan.type == ContiguousStridedReduce) {
+    int reduction_size = plan.shape.back();
+    size_t reduction_stride = plan.strides.back();
+    plan.shape.pop_back();
+    plan.strides.pop_back();
+    const T* x_ptr = x.data<T>();
+    U* out_ptr = out.data<U>();
+    std::tie(shape, strides) = shapes_without_reduction_axes(x, axes);
+    if (plan.shape.size() == 0) {
+      for (int i = 0; i < out.size(); i += reduction_stride) {
+        int offset = elem_to_loc(i, shape, strides);
+        std::fill_n(out_ptr, reduction_stride, init);
+        ops(x_ptr + offset, out_ptr, reduction_size, reduction_stride);
+        out_ptr += reduction_stride;
+      }
+    } else {
+      for (int i = 0; i < out.size(); i += reduction_stride) {
+        int offset = elem_to_loc(i, shape, strides);
+        std::fill_n(out_ptr, reduction_stride, init);
+        nd_loop(
+            [&](int extra_offset) {
+              ops(x_ptr + offset + extra_offset,
+                  out_ptr,
+                  reduction_size,
+                  reduction_stride);
+            },
+            plan.shape,
+            plan.strides);
+        out_ptr += reduction_stride;
+      }
+    }
+    return;
+  }
+
+  if (plan.type == GeneralReduce) {
+    const T* x_ptr = x.data<T>();
+    U* out_ptr = out.data<U>();
+    std::tie(shape, strides) = shapes_without_reduction_axes(x, axes);
+    for (int i = 0; i < out.size(); i++, out_ptr++) {
+      int offset = elem_to_loc(i, shape, strides);
+      U val = init;
+      nd_loop(
+          [&](int extra_offset) { op(&val, *(x_ptr + offset + extra_offset)); },
+          plan.shape,
+          plan.strides);
+      *out_ptr = val;
+    }
+  }
+}
+
+template <typename T, typename U, typename Op>
+void reduction_op(
+    const array& x,
+    array& out,
+    const std::vector<int>& axes,
+    U init,
+    Op op) {
+  DefaultStridedReduce<T, U, Op> ops(op);
+  DefaultContiguousReduce<T, U, Op> opc(op);
+  reduction_op<T, U>(x, out, axes, init, ops, opc, op);
+}
+
+} // namespace
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/threefry.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/threefry.h
new file mode 100644
index 0000000000000000000000000000000000000000..0fc485fcbdc880ccd289ff0bb6de1bb202f7014c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/threefry.h
@@ -0,0 +1,21 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <cstdint>
+#include <utility>
+
+namespace mlx::core::random {
+
+/** Applies the Threefry 2x32 hash function.
+ * This code is based on the Jax counter-based and splittable PRNG
+ * https://github.com/google/jax/blob/main/docs/jep/263-prng.md
+ *
+ * Original Threefry reference:
+ * http://www.thesalmons.org/john/random123/papers/random123sc11.pdf
+ */
+std::pair<uint32_t, uint32_t> threefry2x32_hash(
+    const std::pair<uint32_t, uint32_t>& key,
+    std::pair<uint32_t, uint32_t> count);
+
+} // namespace mlx::core::random
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/unary.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/unary.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbf118b9bbbc1a2b71197e8c4951312a456aa542
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/unary.h
@@ -0,0 +1,160 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/allocator.h"
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+struct AbsOp {
+  template <typename T>
+  T operator()(T x) {
+    return std::abs(x);
+  }
+  uint8_t operator()(uint8_t x) {
+    return x;
+  }
+  uint16_t operator()(uint16_t x) {
+    return x;
+  }
+  uint32_t operator()(uint32_t x) {
+    return x;
+  }
+  uint64_t operator()(uint64_t x) {
+    return x;
+  }
+  bool operator()(bool x) {
+    return x;
+  }
+};
+
+struct SignOp {
+  template <typename T>
+  T operator()(T x) {
+    return (x > T(0)) - (x < T(0));
+  }
+
+  uint8_t operator()(uint8_t x) {
+    return x != 0;
+  }
+  uint16_t operator()(uint16_t x) {
+    return x != 0;
+  }
+  uint32_t operator()(uint32_t x) {
+    return x != 0;
+  }
+  uint64_t operator()(uint64_t x) {
+    return x != 0;
+  }
+};
+
+struct RoundOp {
+  template <typename T>
+  T operator()(T x) {
+    return std::round(x);
+  }
+
+  complex64_t operator()(complex64_t x) {
+    return {std::round(x.real()), std::round(x.imag())};
+  }
+};
+
+template <typename T, typename Op>
+void unary_op(const array& a, array& out, Op op) {
+  const T* a_ptr = a.data<T>();
+  if (a.flags().contiguous) {
+    out.set_data(
+        allocator::malloc_or_wait(a.data_size() * out.itemsize()),
+        a.data_size(),
+        a.strides(),
+        a.flags());
+    T* dst = out.data<T>();
+    for (size_t i = 0; i < a.data_size(); ++i) {
+      dst[i] = op(a_ptr[i]);
+    }
+  } else {
+    out.set_data(allocator::malloc_or_wait(out.nbytes()));
+    T* dst = out.data<T>();
+    for (size_t i = 0; i < out.size(); ++i) {
+      // TODO this is super inefficient, need to fix.
+      int a_idx = elem_to_loc(i, a.shape(), a.strides());
+      dst[i] = op(a_ptr[a_idx]);
+    }
+  }
+}
+
+template <typename Op>
+void unary(const array& a, array& out, Op op) {
+  switch (out.dtype()) {
+    case bool_:
+      unary_op<bool>(a, out, op);
+      break;
+    case uint8:
+      unary_op<uint8_t>(a, out, op);
+      break;
+    case uint16:
+      unary_op<uint16_t>(a, out, op);
+      break;
+    case uint32:
+      unary_op<uint32_t>(a, out, op);
+      break;
+    case uint64:
+      unary_op<uint64_t>(a, out, op);
+      break;
+    case int8:
+      unary_op<int8_t>(a, out, op);
+      break;
+    case int16:
+      unary_op<int16_t>(a, out, op);
+      break;
+    case int32:
+      unary_op<int32_t>(a, out, op);
+      break;
+    case int64:
+      unary_op<int64_t>(a, out, op);
+      break;
+    case float16:
+      unary_op<float16_t>(a, out, op);
+      break;
+    case float32:
+      unary_op<float>(a, out, op);
+      break;
+    case bfloat16:
+      unary_op<bfloat16_t>(a, out, op);
+      break;
+    case complex64:
+      unary_op<complex64_t>(a, out, op);
+      break;
+  }
+}
+
+template <typename Op>
+void unary_fp(const array& a, array& out, Op op) {
+  switch (out.dtype()) {
+    case bfloat16:
+      unary_op<bfloat16_t>(a, out, op);
+      break;
+    case float16:
+      unary_op<float16_t>(a, out, op);
+      break;
+    case float32:
+      unary_op<float>(a, out, op);
+      break;
+    case complex64:
+      unary_op<complex64_t>(a, out, op);
+      break;
+    default:
+      std::ostringstream err;
+      err << "[unary_fp] Does not support " << out.dtype();
+      throw std::runtime_error(err.str());
+  }
+}
+
+} // namespace
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/common/utils.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..e170f5dfa34dd808a311edf632d1055da90700f2
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/common/utils.h
@@ -0,0 +1,31 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <vector>
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+inline size_t elem_to_loc(
+    int elem,
+    const std::vector<int>& shape,
+    const std::vector<size_t>& strides) {
+  size_t loc = 0;
+  for (int i = shape.size() - 1; i >= 0; --i) {
+    auto q_and_r = ldiv(elem, shape[i]);
+    loc += q_and_r.rem * strides[i];
+    elem = q_and_r.quot;
+  }
+  return loc;
+}
+
+inline size_t elem_to_loc(int elem, const array& a) {
+  if (a.flags().row_contiguous) {
+    return elem;
+  }
+  return elem_to_loc(elem, a.shape(), a.strides());
+}
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/allocator.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..45a58bc13e9ffe32ec80a6644d6142e441392b88
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/allocator.h
@@ -0,0 +1,74 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <map>
+#include <mutex>
+#include <vector>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/metal/device.h"
+
+namespace mlx::core::metal {
+
+using allocator::Buffer;
+
+namespace {
+
+class BufferCache {
+ public:
+  BufferCache(MTL::Device* device);
+  ~BufferCache();
+  void clear();
+
+  MTL::Buffer* reuse_from_cache(size_t size);
+  void recycle_to_cache(MTL::Buffer* buf);
+  void release_cached_buffers(size_t min_bytes_to_free);
+
+ private:
+  struct BufferHolder {
+   public:
+    BufferHolder(MTL::Buffer* buf_) : buf(buf_), prev(nullptr), next(nullptr) {}
+
+    BufferHolder* prev;
+    BufferHolder* next;
+    MTL::Buffer* buf;
+  };
+
+  void add_at_head(BufferHolder* to_add);
+  void remove_from_list(BufferHolder* to_remove);
+
+  MTL::Device* device_;
+  std::mutex cache_mutex_;
+
+  std::multimap<size_t, BufferHolder*> buffer_pool_;
+  BufferHolder* head_;
+  BufferHolder* tail_;
+  size_t pool_size_;
+};
+
+} // namespace
+
+class MetalAllocator : public allocator::Allocator {
+  /** Allocator for Metal GPUs. */
+ public:
+  virtual Buffer malloc(size_t size, bool allow_swap = false) override;
+  virtual void free(Buffer buffer) override;
+
+ private:
+  MTL::Device* device_;
+  MetalAllocator();
+  friend MetalAllocator& allocator();
+
+  // Caching allocator
+  BufferCache buffer_cache_;
+
+  // Allocation stats
+  size_t peak_allocated_size_;
+  size_t block_limit_;
+  size_t gc_limit_;
+};
+
+MetalAllocator& allocator();
+
+} // namespace mlx::core::metal
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/copy.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..c08ae2cf7b4f8872bcc39f4daaadfde59fc8172f
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/copy.h
@@ -0,0 +1,18 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/copy.h"
+#include "mlx/stream.h"
+
+namespace mlx::core {
+
+void copy_gpu(const array& src, array& out, CopyType ctype, const Stream& s);
+void copy_gpu(const array& src, array& out, CopyType ctype);
+void copy_gpu_inplace(
+    const array& src,
+    array& out,
+    CopyType ctype,
+    const Stream& s);
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/device.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/device.h
new file mode 100644
index 0000000000000000000000000000000000000000..45449a3326c2b022bfb3000f1958d2ce427b01de
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/device.h
@@ -0,0 +1,81 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <Metal/Metal.hpp>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include <dlfcn.h>
+#include <filesystem>
+
+#include "mlx/device.h"
+
+namespace fs = std::filesystem;
+
+namespace mlx::core::metal {
+
+inline std::string get_colocated_mtllib_path(const std::string& lib_name) {
+  Dl_info info;
+  std::string mtllib_path;
+  std::string lib_ext = lib_name + ".metallib";
+
+  int success = dladdr((void*)get_colocated_mtllib_path, &info);
+  if (success) {
+    auto mtllib = fs::path(info.dli_fname).remove_filename() / lib_ext;
+    mtllib_path = mtllib.c_str();
+  }
+
+  return mtllib_path;
+}
+
+class Device {
+ public:
+  Device();
+  Device(const Device&) = delete;
+  Device& operator=(const Device&) = delete;
+  ~Device();
+
+  MTL::Device* mtl_device() {
+    return device_;
+  };
+
+  void new_queue(int index);
+  MTL::CommandBuffer* new_command_buffer(int index);
+  MTL::CommandBuffer* get_command_buffer(int index);
+  int get_command_buffer_ops(int index);
+  void increment_command_buffer_ops(int index);
+  void commit_command_buffer(int index);
+  MTL::ComputeCommandEncoder* get_command_encoder(int index);
+  void end_encoding(int index);
+
+  void register_library(
+      const std::string& lib_name,
+      const std::string& lib_path);
+  void register_library(
+      const std::string& lib_name,
+      const std::function<std::string(const std::string&)>& lib_path_func =
+          get_colocated_mtllib_path);
+
+  MTL::ComputePipelineState* get_kernel(
+      const std::string& name,
+      const std::string& lib_name = "mlx");
+
+  MTL::ArgumentEncoder* argument_encoder(
+      const std::vector<MTL::ArgumentDescriptor*>& arg_descs) const;
+
+ private:
+  MTL::Device* device_;
+  std::unordered_map<int32_t, MTL::CommandQueue*> queue_map_;
+  std::unordered_map<int32_t, std::pair<int, MTL::CommandBuffer*>> buffer_map_;
+  std::unordered_map<int32_t, MTL::ComputeCommandEncoder*> encoder_map_;
+  std::unordered_map<std::string, MTL::ComputePipelineState*> kernel_map_;
+  std::unordered_map<std::string, MTL::Library*> library_map_;
+  std::mutex mtx_;
+};
+
+Device& device(mlx::core::Device);
+
+} // namespace mlx::core::metal
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/atomic.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/atomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..1c260d1b600936d3c9875f00fe99d80e3c52fad6
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/atomic.h
@@ -0,0 +1,322 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_atomic>
+#include <metal_stdlib>
+#include "mlx/backend/metal/kernels/bf16.h"
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// Atomic utils
+///////////////////////////////////////////////////////////////////////////////
+
+#pragma METAL internals : enable
+template <typename T>
+constexpr constant bool is_metal_atomic = _disjunction<
+    is_same<T, int>,
+    is_same<T, uint>,
+    is_same<T, ulong>,
+    is_same<T, float>>::value;
+
+#pragma METAL internals : disable
+
+template <typename T, typename = void>
+struct mlx_atomic {
+  atomic<uint> val;
+};
+
+template <typename T>
+struct mlx_atomic<T, enable_if_t<is_metal_atomic<T>>> {
+  atomic<T> val;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Native metal atomics
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC T
+mlx_atomic_load_explicit(device mlx_atomic<T>* object, int offset) {
+  return atomic_load_explicit(&(object[offset].val), memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_store_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  atomic_store_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_and_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  atomic_fetch_and_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_or_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  atomic_fetch_or_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_min_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  atomic_fetch_min_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_max_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  atomic_fetch_max_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_add_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  atomic_fetch_add_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_mul_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  T expected = mlx_atomic_load_explicit(object, offset);
+  while (!mlx_atomic_compare_exchange_weak_explicit(
+      object, &expected, val * expected, offset)) {
+  }
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC bool mlx_atomic_compare_exchange_weak_explicit(
+    device mlx_atomic<T>* object,
+    thread T* expected,
+    T val,
+    int offset) {
+  return atomic_compare_exchange_weak_explicit(
+      &(object[offset].val),
+      expected,
+      val,
+      memory_order_relaxed,
+      memory_order_relaxed);
+}
+
+// Specialization for float since it does not atomic_fetch_min_explicit
+template <>
+METAL_FUNC void mlx_atomic_fetch_min_explicit<float>(
+    device mlx_atomic<float>* object,
+    float val,
+    int offset) {
+  float expected = mlx_atomic_load_explicit(object, offset);
+  while (val < expected) {
+    if (mlx_atomic_compare_exchange_weak_explicit(
+            object, &expected, val, offset)) {
+      return;
+    }
+  }
+}
+
+// Specialization for float since it does not atomic_fetch_max_explicit
+template <>
+METAL_FUNC void mlx_atomic_fetch_max_explicit<float>(
+    device mlx_atomic<float>* object,
+    float val,
+    int offset) {
+  float expected = mlx_atomic_load_explicit(object, offset);
+  while (val > expected) {
+    if (mlx_atomic_compare_exchange_weak_explicit(
+            object, &expected, val, offset)) {
+      return;
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Custom atomics
+///////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+template <typename T>
+constexpr constant uint packing_size = sizeof(uint) / sizeof(T);
+
+template <typename T>
+union uint_or_packed {
+  T val[packing_size<T>];
+  uint bits;
+};
+
+template <typename T, typename Op>
+struct mlx_atomic_update_helper {
+  uint operator()(uint_or_packed<T> init, T update, int elem_offset) {
+    Op op;
+    init.val[elem_offset] = op(update, init.val[elem_offset]);
+    return init.bits;
+  }
+};
+
+template <typename T, typename Op>
+METAL_FUNC void mlx_atomic_update_and_store(
+    device mlx_atomic<T>* object,
+    T update,
+    int offset) {
+  int pack_offset = offset / packing_size<T>;
+  int elem_offset = offset % packing_size<T>;
+
+  mlx_atomic_update_helper<T, Op> helper;
+  uint_or_packed<T> expected;
+  expected.bits =
+      atomic_load_explicit(&(object[pack_offset].val), memory_order_relaxed);
+
+  while (Op::condition(update, expected.val[elem_offset]) &&
+         !mlx_atomic_compare_exchange_weak_explicit(
+             object,
+             &(expected.bits),
+             helper(expected, update, elem_offset),
+             pack_offset)) {
+  }
+}
+
+template <typename T>
+struct __None {
+  static bool condition(T a, T b) {
+#pragma unused(a)
+#pragma unused(b)
+    return true;
+  }
+
+  T operator()(T a, T b) {
+#pragma unused(b)
+    return a;
+  }
+};
+
+template <typename T>
+struct __Add {
+  static bool condition(T a, T b) {
+#pragma unused(a)
+#pragma unused(b)
+    return true;
+  }
+
+  T operator()(T a, T b) {
+    return a + b;
+  }
+};
+
+template <typename T>
+struct __Mul {
+  static bool condition(T a, T b) {
+#pragma unused(a)
+    return b != 0;
+  }
+
+  T operator()(T a, T b) {
+    return a * b;
+  }
+};
+
+template <typename T>
+struct __Max {
+  static bool condition(T a, T b) {
+    return a > b;
+  }
+
+  T operator()(T a, T b) {
+    return max(a, b);
+  }
+};
+
+template <typename T>
+struct __Min {
+  static bool condition(T a, T b) {
+    return a < b;
+  }
+
+  T operator()(T a, T b) {
+    return min(a, b);
+  }
+};
+
+} // namespace
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC T
+mlx_atomic_load_explicit(device mlx_atomic<T>* object, int offset) {
+  int pack_offset = offset / sizeof(T);
+  int elem_offset = offset % sizeof(T);
+  uint_or_packed<T> packed_val;
+  packed_val.bits =
+      atomic_load_explicit(&(object[pack_offset].val), memory_order_relaxed);
+  return packed_val.val[elem_offset];
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_store_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  mlx_atomic_update_and_store<T, __None<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_and_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  int pack_offset = offset / packing_size<T>;
+  int elem_offset = offset % packing_size<T>;
+  uint_or_packed<T> identity;
+  identity.bits = __UINT32_MAX__;
+  identity.val[elem_offset] = val;
+
+  atomic_fetch_and_explicit(
+      &(object[pack_offset].val), identity.bits, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_or_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  int pack_offset = offset / packing_size<T>;
+  int elem_offset = offset % packing_size<T>;
+  uint_or_packed<T> identity;
+  identity.bits = 0;
+  identity.val[elem_offset] = val;
+
+  atomic_fetch_or_explicit(
+      &(object[pack_offset].val), identity.bits, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_min_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  mlx_atomic_update_and_store<T, __Min<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_max_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  mlx_atomic_update_and_store<T, __Max<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_add_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  mlx_atomic_update_and_store<T, __Add<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_fetch_mul_explicit(device mlx_atomic<T>* object, T val, int offset) {
+  mlx_atomic_update_and_store<T, __Mul<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC bool mlx_atomic_compare_exchange_weak_explicit(
+    device mlx_atomic<T>* object,
+    thread uint* expected,
+    uint val,
+    int offset) {
+  return atomic_compare_exchange_weak_explicit(
+      &(object[offset].val),
+      expected,
+      val,
+      memory_order_relaxed,
+      memory_order_relaxed);
+}
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/bf16.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/bf16.h
new file mode 100644
index 0000000000000000000000000000000000000000..71a45e1c55c3b4f59a765b79ddf3f7d597c81c34
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/bf16.h
@@ -0,0 +1,317 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+using namespace metal;
+
+#if defined(__HAVE_BFLOAT__)
+
+typedef bfloat bfloat16_t;
+
+#else
+
+/////////////////////////////////////////////////////////////////////////////
+// Helpers
+/////////////////////////////////////////////////////////////////////////////
+
+constexpr METAL_FUNC uint16_t float_to_bfloat_bits(float x) {
+  // Check for nan
+  if ((as_type<uint32_t>(x) & ~_fp_encoding_traits<float>::sign_mask) >
+      _fp_encoding_traits<float>::inf_mask) {
+    return uint16_t(as_type<uint32_t>(0x7FC0));
+  }
+  // Take bits
+  uint32_t float_bits = as_type<uint32_t>(x);
+
+  // Round to nearest even
+  float_bits += ((float_bits >> 16) & 1) + as_type<uint32_t>(0x7FFF);
+
+  // Take upper 16 bits
+  return float_bits >> 16;
+}
+
+constexpr METAL_FUNC float bfloat_bits_to_float(uint16_t x) {
+  // Upper 16 bits are the data and lower 16 bits are 0s
+  return as_type<float>((uint32_t)x << 16);
+}
+
+struct _MLX_BFloat16;
+
+template <typename T>
+static constexpr constant bool can_convert_to_bfloat =
+    !is_same_v<T, _MLX_BFloat16> && is_convertible_v<T, float>;
+
+template <typename T>
+static constexpr constant bool can_convert_from_bfloat =
+    !is_same_v<T, _MLX_BFloat16> && is_convertible_v<float, T>;
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat struct
+/////////////////////////////////////////////////////////////////////////////
+
+struct _MLX_BFloat16 {
+  /////////////////////////////////////////////////////////////////////////////
+  // Constructors
+  uint16_t bits_;
+  _MLX_BFloat16() thread = default;
+  _MLX_BFloat16() threadgroup = default;
+  _MLX_BFloat16() device = default;
+  _MLX_BFloat16() constant = default;
+
+  struct bits_to_bfloat_struct {};
+  static constexpr METAL_FUNC bits_to_bfloat_struct bits_to_bfloat() {
+    return bits_to_bfloat_struct();
+  }
+  constexpr METAL_FUNC _MLX_BFloat16(uint16_t bits, bits_to_bfloat_struct)
+      : bits_(bits) {}
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Conversions to bfloat
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) thread
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) threadgroup
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) device
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) constant
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Conversions from bfloat
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const thread {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const threadgroup {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const device {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const constant {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat operators
+/////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////////////////
+// Unary ops
+constexpr METAL_FUNC _MLX_BFloat16 operator-(_MLX_BFloat16 x) {
+  return -static_cast<float>(x);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Binary operators
+#define bfloat_binop_base(__op__, __operator__, otype, atype, btype, ctype) \
+  constexpr METAL_FUNC otype __operator__(atype lhs, btype rhs) {           \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);          \
+  }
+
+#define bfloat_binop_helper(__op__, __operator__, otype, itype, ctype)    \
+  constexpr METAL_FUNC otype __operator__(_MLX_BFloat16 lhs, itype rhs) { \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);        \
+  }                                                                       \
+  constexpr METAL_FUNC otype __operator__(itype lhs, _MLX_BFloat16 rhs) { \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);        \
+  }
+
+/////////////////////////////////////////////////////////////////////////////
+// Arithmetic Operators
+#define bfloat_binop(_op_, _operator_)                                       \
+  bfloat_binop_base(                                                         \
+      _op_, _operator_, _MLX_BFloat16, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(_op_, _operator_, float, float, float);                \
+  bfloat_binop_helper(_op_, _operator_, float, half, float);                 \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int32_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint32_t, float);     \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int64_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint64_t, float);
+
+bfloat_binop(+, operator+);
+bfloat_binop(-, operator-);
+bfloat_binop(*, operator*);
+bfloat_binop(/, operator/);
+
+/////////////////////////////////////////////////////////////////////////////
+// Comparison ops
+#define bfloat_compop(__op__, __operator__)                             \
+  bfloat_binop_base(                                                    \
+      __op__, __operator__, bool, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(__op__, __operator__, bool, float, float);        \
+  bfloat_binop_helper(__op__, __operator__, bool, half, float);         \
+  bfloat_binop_helper(__op__, __operator__, bool, int32_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint32_t, float);     \
+  bfloat_binop_helper(__op__, __operator__, bool, int64_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint64_t, float);
+
+bfloat_compop(>, operator>);
+bfloat_compop(<, operator<);
+bfloat_compop(>=, operator>=);
+bfloat_compop(<=, operator<=);
+bfloat_compop(==, operator==);
+bfloat_compop(!=, operator!=);
+
+#undef bfloat_compop
+#undef bfloat_binop_base
+#undef bfloat_binop_helper
+#undef bfloat_binop
+
+/////////////////////////////////////////////////////////////////////////////
+// Inplace Operators
+#define bfloat_inplace_op_helper(__op__, __operator__, itype, addr_space) \
+  constexpr METAL_FUNC addr_space _MLX_BFloat16& __operator__(            \
+      addr_space _MLX_BFloat16& lhs, itype rhs) {                         \
+    lhs = static_cast<float>(lhs) __op__ static_cast<float>(rhs);         \
+    return lhs;                                                           \
+  }                                                                       \
+  constexpr METAL_FUNC addr_space itype& __operator__(                    \
+      addr_space itype& lhs, _MLX_BFloat16 rhs) {                         \
+    lhs = static_cast<float>(lhs) __op__ static_cast<float>(rhs);         \
+    return lhs;                                                           \
+  }
+
+#define bfloat_inplace_op_addr_space_helper(__op__, __operator__, itype) \
+  bfloat_inplace_op_helper(__op__, __operator__, itype, device);         \
+  bfloat_inplace_op_helper(__op__, __operator__, itype, thread);         \
+  bfloat_inplace_op_helper(__op__, __operator__, itype, threadgroup);
+
+#define bfloat_inplace_op(itype)                             \
+  bfloat_inplace_op_addr_space_helper(+, operator+=, itype); \
+  bfloat_inplace_op_addr_space_helper(-, operator-=, itype); \
+  bfloat_inplace_op_addr_space_helper(*, operator*=, itype); \
+  bfloat_inplace_op_addr_space_helper(/, operator/=, itype);
+
+bfloat_inplace_op(float);
+bfloat_inplace_op(half);
+bfloat_inplace_op(int16_t);
+bfloat_inplace_op(int32_t);
+bfloat_inplace_op(int64_t);
+bfloat_inplace_op(uint16_t);
+bfloat_inplace_op(uint32_t);
+bfloat_inplace_op(uint64_t);
+
+#undef bfloat_inplace_op_helper
+#undef bfloat_inplace_op_addr_space_helper
+#undef bfloat_inplace_op
+
+#define bfloat_inplace_op_helper(__op__, __operator__, addr_space) \
+  constexpr METAL_FUNC addr_space _MLX_BFloat16& __operator__(     \
+      addr_space _MLX_BFloat16& lhs, _MLX_BFloat16 rhs) {          \
+    lhs = static_cast<float>(lhs) __op__ static_cast<float>(rhs);  \
+    return lhs;                                                    \
+  }
+
+#define bfloat_inplace_op_addr_space_helper(__op__, __operator__) \
+  bfloat_inplace_op_helper(__op__, __operator__, device);         \
+  bfloat_inplace_op_helper(__op__, __operator__, thread);         \
+  bfloat_inplace_op_helper(__op__, __operator__, threadgroup);
+
+bfloat_inplace_op_addr_space_helper(+, operator+=);
+bfloat_inplace_op_addr_space_helper(-, operator-=);
+bfloat_inplace_op_addr_space_helper(*, operator*=);
+bfloat_inplace_op_addr_space_helper(/, operator/=);
+
+#undef bfloat_inplace_op_helper
+#undef bfloat_inplace_op_addr_space_helper
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat typedef
+/////////////////////////////////////////////////////////////////////////////
+
+typedef struct _MLX_BFloat16 bfloat16_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat numeric limits
+/////////////////////////////////////////////////////////////////////////////
+
+#pragma METAL internals : enable
+
+namespace metal {
+
+template <>
+struct _numeric_limits_impl<bfloat16_t> : _fp_numeric_limits_impl_base {
+  static constexpr constant int digits = 8;
+  static constexpr constant int digits10 = 2;
+  static constexpr constant int max_digits10 = 4;
+  static constexpr constant int radix = 2;
+  static constexpr constant int min_exponent = -125;
+  static constexpr constant int min_exponent10 = -37;
+  static constexpr constant int max_exponent = 128;
+  static constexpr constant int max_exponent10 = 38;
+
+  static constexpr bfloat16_t min() {
+    return _MLX_BFloat16(0x0080, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t lowest() {
+    return _MLX_BFloat16(0xFF7F, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t max() {
+    return _MLX_BFloat16(0x7F7F, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t epsilon() {
+    return _MLX_BFloat16(0x3C00, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t round_error() {
+    return _MLX_BFloat16(0x3F00, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t infinity() {
+    return _MLX_BFloat16(0x7F80, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t quiet_NaN() {
+    return _MLX_BFloat16(0x7FC0, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t signaling_NaN() {
+    return _MLX_BFloat16(0x7F80, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t denorm_min() {
+    return _MLX_BFloat16(0x0001, _MLX_BFloat16::bits_to_bfloat());
+  }
+};
+
+METAL_FUNC bool isnan(_MLX_BFloat16 x) {
+  return x != x;
+}
+
+} // namespace metal
+
+#pragma METAL internals : disable
+
+#endif // defined(__HAVE_BFLOAT__)
+
+#include "mlx/backend/metal/kernels/bf16_math.h"
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/bf16_math.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/bf16_math.h
new file mode 100644
index 0000000000000000000000000000000000000000..f1fec4336c867ac83ad8846aec2877f4a6e9928a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/bf16_math.h
@@ -0,0 +1,394 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/bf16.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Metal math for bfloat16
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+
+Following the Metal Shading Language Specification (Metal 3.1)
+
+"bfloat is an extended itypeing point type that only allows implicit conversion
+ to a type of greater itypeing point rank. While bfloat can be implicitly
+ converted to itype, it cannot be implicitly converted to half, and neither
+ itype nor half can be implicitly converted to bfloat."
+
+Further, as far as I can tell, the stdlib math/simd functions are not defined
+for bfloat and calling with an argument of type bfloat will result in that
+argument getting implicitly converted to itype which then returns an output
+that is (likely) a itype which cannot be implicitly converted into a bfloat
+
+This leads to situations where
+bfloat a = 5.0bf;
+bfloat b = metal::abs(a); // this will throw an error since abs return itype
+bfloat c = static_cast<bfloat>(metal::abs(a)); // this is fine
+
+For the moment, I will be adding overloaded instantiations of the math
+functions to accordingly automatically handle the casting
+
+*/
+
+#define instantiate_metal_math_funcs(itype, otype, ctype, mfast)               \
+                                                                               \
+  METAL_FUNC otype abs(itype x) {                                              \
+    return static_cast<otype>(__metal_fabs(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype acos(itype x) {                                             \
+    return static_cast<otype>(__metal_acos(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype acosh(itype x) {                                            \
+    return static_cast<otype>(__metal_acosh(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype asin(itype x) {                                             \
+    return static_cast<otype>(__metal_asin(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype asinh(itype x) {                                            \
+    return static_cast<otype>(__metal_asinh(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype atan(itype y_over_x) {                                      \
+    return static_cast<otype>(                                                 \
+        __metal_atan(static_cast<ctype>(y_over_x), mfast));                    \
+  }                                                                            \
+  METAL_FUNC otype atan2(itype y, itype x) {                                   \
+    return static_cast<otype>(                                                 \
+        __metal_atan2(static_cast<ctype>(y), static_cast<ctype>(x), mfast));   \
+  }                                                                            \
+  METAL_FUNC otype atanh(itype x) {                                            \
+    return static_cast<otype>(__metal_atanh(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype ceil(itype x) {                                             \
+    return static_cast<otype>(__metal_ceil(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype cos(itype x) {                                              \
+    return static_cast<otype>(__metal_cos(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype cosh(itype x) {                                             \
+    return static_cast<otype>(__metal_cosh(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype cospi(itype x) {                                            \
+    return static_cast<otype>(__metal_cospi(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype divide(itype x, itype y) {                                  \
+    return static_cast<otype>(                                                 \
+        __metal_divide(static_cast<ctype>(x), static_cast<ctype>(y), mfast));  \
+  }                                                                            \
+  METAL_FUNC otype exp(itype x) {                                              \
+    return static_cast<otype>(__metal_exp(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype exp10(itype x) {                                            \
+    return static_cast<otype>(__metal_exp10(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype exp2(itype x) {                                             \
+    return static_cast<otype>(__metal_exp2(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype fabs(itype x) {                                             \
+    return static_cast<otype>(__metal_fabs(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype fdim(itype x, itype y) {                                    \
+    ctype t = static_cast<ctype>(x - y);                                       \
+    return static_cast<otype>(select(t, ctype(0), t < ctype(0) || x == y));    \
+  }                                                                            \
+  METAL_FUNC otype floor(itype x) {                                            \
+    return static_cast<otype>(__metal_floor(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fma(itype x, itype y, itype z) {                            \
+    return static_cast<otype>(__metal_fma(                                     \
+        static_cast<ctype>(x), static_cast<ctype>(y), static_cast<ctype>(z))); \
+  }                                                                            \
+  METAL_FUNC otype fmax(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_fmax(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fmax3(itype x, itype y, itype z) {                          \
+    return static_cast<otype>(__metal_fmax3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype fmedian3(itype x, itype y, itype z) {                       \
+    return static_cast<otype>(__metal_fmedian3(                                \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype fmin(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_fmin(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fmin3(itype x, itype y, itype z) {                          \
+    return static_cast<otype>(__metal_fmin3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype fmod(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_fmod(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fract(itype x) {                                            \
+    return static_cast<otype>(__metal_fract(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype frexp(itype x, thread int& exp) {                           \
+    return static_cast<otype>(__metal_frexp(static_cast<ctype>(x), &exp));     \
+  }                                                                            \
+  METAL_FUNC otype ldexp(itype x, int k) {                                     \
+    return static_cast<otype>(__metal_ldexp(static_cast<ctype>(x), k, mfast)); \
+  }                                                                            \
+  METAL_FUNC otype log(itype x) {                                              \
+    return static_cast<otype>(__metal_log(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype log10(itype x) {                                            \
+    return static_cast<otype>(__metal_log10(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype log2(itype x) {                                             \
+    return static_cast<otype>(__metal_log2(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype max(itype x, itype y) {                                     \
+    return static_cast<otype>(                                                 \
+        __metal_fmax(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype max3(itype x, itype y, itype z) {                           \
+    return static_cast<otype>(__metal_fmax3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype median3(itype x, itype y, itype z) {                        \
+    return static_cast<otype>(__metal_fmedian3(                                \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype min(itype x, itype y) {                                     \
+    return static_cast<otype>(                                                 \
+        __metal_fmin(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype min3(itype x, itype y, itype z) {                           \
+    return static_cast<otype>(__metal_fmin3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype nextafter(itype x, itype y) {                               \
+    return static_cast<otype>(                                                 \
+        __metal_nextafter(static_cast<ctype>(x), static_cast<ctype>(y)));      \
+  }                                                                            \
+  METAL_FUNC otype pow(itype x, itype y) {                                     \
+    return static_cast<otype>(                                                 \
+        __metal_pow(static_cast<ctype>(x), static_cast<ctype>(y), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype powr(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_powr(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype rint(itype x) {                                             \
+    return static_cast<otype>(__metal_rint(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype round(itype x) {                                            \
+    return static_cast<otype>(__metal_round(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype rsqrt(itype x) {                                            \
+    return static_cast<otype>(__metal_rsqrt(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype sin(itype x) {                                              \
+    return static_cast<otype>(__metal_sin(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype sinh(itype x) {                                             \
+    return static_cast<otype>(__metal_sinh(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype sinpi(itype x) {                                            \
+    return static_cast<otype>(__metal_sinpi(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype sqrt(itype x) {                                             \
+    return static_cast<otype>(__metal_sqrt(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype tan(itype x) {                                              \
+    return static_cast<otype>(__metal_tan(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype tanh(itype x) {                                             \
+    return static_cast<otype>(__metal_tanh(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype tanpi(itype x) {                                            \
+    return static_cast<otype>(__metal_tanpi(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype trunc(itype x) {                                            \
+    return static_cast<otype>(__metal_trunc(static_cast<ctype>(x), mfast));    \
+  }
+
+namespace metal {
+
+instantiate_metal_math_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    float,
+    __METAL_MAYBE_FAST_MATH__);
+
+namespace fast {
+
+instantiate_metal_math_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    float,
+    __METAL_FAST_MATH__);
+
+} // namespace fast
+
+namespace precise {
+
+instantiate_metal_math_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    float,
+    __METAL_PRECISE_MATH__);
+
+} // namespace precise
+
+} // namespace metal
+
+///////////////////////////////////////////////////////////////////////////////
+// Metal simd for bfloat16
+///////////////////////////////////////////////////////////////////////////////
+
+#define instantiate_metal_simd_comm_funcs(                                   \
+    itype, otype, ctype, itype_to_ctype, ctype_to_otype)                     \
+                                                                             \
+  METAL_FUNC otype simd_broadcast(itype data, ushort broadcast_lane_id) {    \
+    return ctype_to_otype(                                                   \
+        __metal_simd_broadcast(itype_to_ctype(data), broadcast_lane_id));    \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle(itype data, ushort simd_lane_id) {           \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle(itype_to_ctype(data), simd_lane_id));           \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_down(                               \
+      itype data, itype filling_data, ushort delta, ushort modulo) {         \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_down(                \
+        itype_to_ctype(data), itype_to_ctype(filling_data), delta, modulo)); \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_down(                               \
+      itype data, itype filling_data, ushort delta) {                        \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_down(                \
+        itype_to_ctype(data),                                                \
+        itype_to_ctype(filling_data),                                        \
+        delta,                                                               \
+        __metal_get_simdgroup_size(ushort())));                              \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_up(                                 \
+      itype data, itype filling_data, ushort delta, ushort modulo) {         \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_up(                  \
+        itype_to_ctype(data), itype_to_ctype(filling_data), delta, modulo)); \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_up(                                 \
+      itype data, itype filling_data, ushort delta) {                        \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_up(                  \
+        itype_to_ctype(data),                                                \
+        itype_to_ctype(filling_data),                                        \
+        delta,                                                               \
+        __metal_get_simdgroup_size(ushort())));                              \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_down(itype data, ushort delta) {             \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_down(itype_to_ctype(data), delta));             \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_rotate_down(itype data, ushort delta) {      \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_rotate_down(itype_to_ctype(data), delta));      \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_rotate_up(itype data, ushort delta) {        \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_rotate_up(itype_to_ctype(data), delta));        \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_up(itype data, ushort delta) {               \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_up(itype_to_ctype(data), delta));               \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_xor(itype data, ushort mask) {               \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_xor(itype_to_ctype(data), mask));               \
+  }
+
+#define instantiate_metal_simd_reduction_funcs(itype, otype, ctype)            \
+                                                                               \
+  METAL_FUNC otype simd_max(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_max(static_cast<ctype>(data)));     \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_min(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_min(static_cast<ctype>(data)));     \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_exclusive_product(itype data) {                 \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_exclusive_product(static_cast<ctype>(data)));      \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_exclusive_sum(itype data) {                     \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_exclusive_sum(static_cast<ctype>(data)));          \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_inclusive_product(itype data) {                 \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_inclusive_product(static_cast<ctype>(data)));      \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_inclusive_sum(itype data) {                     \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_inclusive_sum(static_cast<ctype>(data)));          \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_product(itype data) {                                  \
+    return static_cast<otype>(__metal_simd_product(static_cast<ctype>(data))); \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_sum(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_sum(static_cast<ctype>(data)));     \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_xor(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_xor(static_cast<ctype>(data)));     \
+  }
+
+#if defined(__HAVE_BFLOAT__)
+
+#define bfloat16_to_uint16(x) as_type<uint16_t>(x)
+#define uint16_to_bfloat16(x) as_type<bfloat16_t>(x)
+
+#else
+
+#define bfloat16_to_uint16(x) x.bits_
+#define uint16_to_bfloat16(x) _MLX_BFloat16(x, _MLX_BFloat16::bits_to_bfloat())
+
+#endif
+
+namespace metal {
+
+instantiate_metal_simd_comm_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    uint16_t,
+    bfloat16_to_uint16,
+    uint16_to_bfloat16);
+instantiate_metal_simd_reduction_funcs(bfloat16_t, bfloat16_t, float);
+
+} // namespace metal
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/complex.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/complex.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac966a2937ca0f8d05b8c79f406617c684b57690
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/complex.h
@@ -0,0 +1,125 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+using namespace metal;
+
+struct complex64_t;
+
+template <typename T>
+static constexpr constant bool can_convert_to_complex64 =
+    !is_same_v<T, complex64_t> && is_convertible_v<T, float>;
+
+template <typename T>
+static constexpr constant bool can_convert_from_complex64 =
+    !is_same_v<T, complex64_t> &&
+    (is_convertible_v<float, T> || is_convertible_v<bfloat16_t, T>);
+
+struct complex64_t {
+  float real;
+  float imag;
+
+  // Constructors
+  constexpr complex64_t(float real, float imag) : real(real), imag(imag){};
+
+  // Conversions to complex64_t
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) thread : real(x), imag(0) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) threadgroup : real(x), imag(0) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) device : real(x), imag(0) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) constant : real(x), imag(0) {}
+
+  // Conversions from complex64_t
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const thread {
+    return static_cast<T>(real);
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const threadgroup {
+    return static_cast<T>(real);
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const device {
+    return static_cast<T>(real);
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const constant {
+    return static_cast<T>(real);
+  }
+};
+
+constexpr complex64_t operator-(complex64_t x) {
+  return {-x.real, -x.imag};
+}
+
+constexpr bool operator>=(complex64_t a, complex64_t b) {
+  return (a.real > b.real) || (a.real == b.real && a.imag >= b.imag);
+}
+
+constexpr bool operator>(complex64_t a, complex64_t b) {
+  return (a.real > b.real) || (a.real == b.real && a.imag > b.imag);
+}
+
+constexpr bool operator<=(complex64_t a, complex64_t b) {
+  return operator>=(b, a);
+}
+
+constexpr bool operator<(complex64_t a, complex64_t b) {
+  return operator>(b, a);
+}
+
+constexpr bool operator==(complex64_t a, complex64_t b) {
+  return a.real == b.real && a.imag == b.imag;
+}
+
+constexpr complex64_t operator+(complex64_t a, complex64_t b) {
+  return {a.real + b.real, a.imag + b.imag};
+}
+
+constexpr complex64_t operator-(complex64_t a, complex64_t b) {
+  return {a.real - b.real, a.imag - b.imag};
+}
+
+constexpr complex64_t operator*(complex64_t a, complex64_t b) {
+  return {a.real * b.real - a.imag * b.imag, a.real * b.imag + a.imag * b.real};
+}
+
+constexpr complex64_t operator/(complex64_t a, complex64_t b) {
+  auto denom = b.real * b.real + b.imag * b.imag;
+  auto x = a.real * b.real + a.imag * b.imag;
+  auto y = a.imag * b.real - a.real * b.imag;
+  return {x / denom, y / denom};
+}
+
+constexpr complex64_t operator%(complex64_t a, complex64_t b) {
+  auto real = a.real - (b.real * static_cast<int64_t>(a.real / b.real));
+  auto imag = a.imag - (b.imag * static_cast<int64_t>(a.imag / b.imag));
+  return {real, imag};
+}
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/conv_params.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/conv_params.h
new file mode 100644
index 0000000000000000000000000000000000000000..b216bb9764a880bddfd6c238dd8109c3c99d2507
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/conv_params.h
@@ -0,0 +1,19 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+template <int NDIM>
+struct MLXConvParams {
+  const int N; // Batch size
+  const int C; // In channels
+  const int O; // Out channels
+  const int iS[NDIM]; // Input spatial dim
+  const int wS[NDIM]; // Weight spatial dim
+  const int oS[NDIM]; // Output spatial dim
+  const int str[NDIM]; // Kernel strides
+  const int pad[NDIM]; // Input padding
+  const int dil[NDIM]; // Kernel dilation
+  const size_t in_strides[NDIM + 2]; // In strides
+  const size_t wt_strides[NDIM + 2]; // Wt strides
+  const size_t out_strides[NDIM + 2]; // Out strides
+};
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/defines.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/defines.h
new file mode 100644
index 0000000000000000000000000000000000000000..bdd1419f2ebd61b1c1b50baa46be2f2c3991be31
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/defines.h
@@ -0,0 +1,16 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#ifdef __METAL__
+#define MTL_CONST constant
+#else
+#define MTL_CONST
+#endif
+
+static MTL_CONST constexpr int MAX_BINARY_SPECIALIZED_DIMS = 5;
+static MTL_CONST constexpr int MAX_COPY_SPECIALIZED_DIMS = 5;
+static MTL_CONST constexpr int MAX_REDUCE_SPECIALIZED_DIMS = 4;
+static MTL_CONST constexpr int REDUCE_N_READS = 16;
+static MTL_CONST constexpr int SOFTMAX_N_READS = 4;
+static MTL_CONST constexpr int SOFTMAX_LOOPED_LIMIT = 4096;
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/erf.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/erf.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a370d3048bc26dcd6b5a6a33eb13370c341a3ce
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/erf.h
@@ -0,0 +1,70 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_math>
+
+/*
+ * Approximation to the error function.
+ * Based on code from:
+ * https://stackoverflow.com/questions/35148198/efficient-faithfully-rounded-implementation-of-error-function-erff#answer-35148199
+ */
+float erf(float a) {
+  float r, s, t, u;
+  t = metal::abs(a);
+  s = a * a;
+  if (t > 0.927734375f) {
+    // maximum error 0.99527 ulp
+    r = metal::fma(
+        -1.72853470e-5f, t, 3.83197126e-4f); // -0x1.220000p-16,0x1.91cfb2p-12
+    u = metal::fma(
+        -3.88396438e-3f, t, 2.42546219e-2f); // -0x1.fd1438p-9, 0x1.8d6342p-6
+    r = metal::fma(r, s, u);
+    r = metal::fma(r, t, -1.06777877e-1f); // -0x1.b55cb8p-4
+    r = metal::fma(r, t, -6.34846687e-1f); // -0x1.450aa0p-1
+    r = metal::fma(r, t, -1.28717512e-1f); // -0x1.079d0cp-3
+    r = metal::fma(r, t, -t);
+    // TODO, replace with expm1 when implemented
+    r = 1.0f - metal::exp(r);
+    r = metal::copysign(r, a);
+  } else {
+    // maximum error 0.98929 ulp
+    r = -5.96761703e-4f; // -0x1.38e000p-11
+    r = metal::fma(r, s, 4.99119423e-3f); //  0x1.471a58p-8
+    r = metal::fma(r, s, -2.67681349e-2f); // -0x1.b691b2p-6
+    r = metal::fma(r, s, 1.12819925e-1f); //  0x1.ce1c44p-4
+    r = metal::fma(r, s, -3.76125336e-1f); // -0x1.812700p-2
+    r = metal::fma(r, s, 1.28379166e-1f); //  0x1.06eba8p-3
+    r = metal::fma(r, a, a);
+  }
+  return r;
+}
+
+float erfinv(float a) {
+  auto t = metal::fma(a, 0.0f - a, 1.0f);
+  t = metal::log(t);
+  float p;
+  if (metal::abs(t) > 6.125f) { // maximum ulp error = 2.35793
+    p = 3.03697567e-10f; //  0x1.4deb44p-32
+    p = metal::fma(p, t, 2.93243101e-8f); //  0x1.f7c9aep-26
+    p = metal::fma(p, t, 1.22150334e-6f); //  0x1.47e512p-20
+    p = metal::fma(p, t, 2.84108955e-5f); //  0x1.dca7dep-16
+    p = metal::fma(p, t, 3.93552968e-4f); //  0x1.9cab92p-12
+    p = metal::fma(p, t, 3.02698812e-3f); //  0x1.8cc0dep-9
+    p = metal::fma(p, t, 4.83185798e-3f); //  0x1.3ca920p-8
+    p = metal::fma(p, t, -2.64646143e-1f); // -0x1.0eff66p-2
+    p = metal::fma(p, t, 8.40016484e-1f); //  0x1.ae16a4p-1
+  } else { // maximum ulp error = 2.35002
+    p = 5.43877832e-9f; //  0x1.75c000p-28
+    p = metal::fma(p, t, 1.43285448e-7f); //  0x1.33b402p-23
+    p = metal::fma(p, t, 1.22774793e-6f); //  0x1.499232p-20
+    p = metal::fma(p, t, 1.12963626e-7f); //  0x1.e52cd2p-24
+    p = metal::fma(p, t, -5.61530760e-5f); // -0x1.d70bd0p-15
+    p = metal::fma(p, t, -1.47697632e-4f); // -0x1.35be90p-13
+    p = metal::fma(p, t, 2.31468678e-3f); //  0x1.2f6400p-9
+    p = metal::fma(p, t, 1.15392581e-2f); //  0x1.7a1e50p-7
+    p = metal::fma(p, t, -2.32015476e-1f); // -0x1.db2aeep-3
+    p = metal::fma(p, t, 8.86226892e-1f); //  0x1.c5bf88p-1
+  }
+  return a * p;
+}
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/gemm/conv.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/gemm/conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..1db3ebac895d25f5563745ba9bda3fb233990950
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/gemm/conv.h
@@ -0,0 +1,481 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_simdgroup>
+#include <metal_simdgroup_matrix>
+#include <metal_stdlib>
+
+#include "mlx/backend/metal/kernels/bf16.h"
+#include "mlx/backend/metal/kernels/conv_params.h"
+
+#define MLX_MTL_CONST static constant constexpr const
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading helper
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int vec_size,
+    int tgp_size,
+    int tgp_padding = 0>
+struct Conv2DInputBlockLoader {
+  // Destination dimensions
+  MLX_MTL_CONST int dst_fd = BM;
+  MLX_MTL_CONST int dst_ld = BK + tgp_padding;
+  MLX_MTL_CONST int n_vecs = BK / vec_size;
+
+  // Stride along block row within the block
+  MLX_MTL_CONST int bstride = tgp_size / n_vecs;
+  MLX_MTL_CONST int n_rows = dst_fd / bstride;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  const constant MLXConvParams<2>& params;
+
+  int weight_h;
+  int weight_w;
+
+  int offsets_n[n_rows];
+  int offsets_oh[n_rows];
+  int offsets_ow[n_rows];
+
+  /* Constructor */
+  METAL_FUNC Conv2DInputBlockLoader(
+      const device T* src_,
+      threadgroup T* dst_,
+      const constant MLXConvParams<2>& params_,
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]],
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / n_vecs),
+        bj(vec_size * (thread_idx % n_vecs)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bj),
+        params(params_),
+        weight_h(0),
+        weight_w(0) {
+    int out_n_pixels = params.oS[0] * params.oS[1];
+
+    for (int i = 0; i < n_rows; ++i) {
+      int offset_nhw = tid.y * BM + bi + i * bstride;
+      offsets_n[i] = offset_nhw / out_n_pixels;
+      int hw = offset_nhw % out_n_pixels;
+      offsets_oh[i] = hw / params.oS[1];
+      offsets_ow[i] = hw % params.oS[1];
+    }
+
+    (void)lid;
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+#pragma clang loop unroll(full)
+    for (short i = 0, is = 0; i < n_rows; ++i, is += bstride) {
+      int n = offsets_n[i];
+      int oh = offsets_oh[i];
+      int ow = offsets_ow[i];
+
+      int ih = oh * params.str[0] - params.pad[0] + weight_h * params.dil[0];
+      int iw = ow * params.str[1] - params.pad[1] + weight_w * params.dil[1];
+
+      // Read from input if in bounds
+      if (ih >= 0 && ih < params.iS[0] && iw >= 0 && iw < params.iS[1]) {
+        const device T* curr_src = src + n * params.in_strides[0] +
+            ih * params.in_strides[1] + iw * params.in_strides[2];
+
+#pragma clang loop unroll(full)
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = curr_src[j];
+        }
+      }
+
+      // Zero pad otherwise
+      else {
+#pragma clang loop unroll(full)
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = T(0);
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    if (++weight_w < params.wS[1]) {
+      return;
+    }
+
+    weight_w = 0;
+
+    if (++weight_h < params.wS[0]) {
+      return;
+    }
+
+    weight_h = 0;
+
+    src += BK;
+  }
+};
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int vec_size,
+    int tgp_size,
+    int tgp_padding = 0>
+struct Conv2DWeightBlockLoader {
+  // Destination dimensions
+  MLX_MTL_CONST int dst_fd = BN;
+  MLX_MTL_CONST int dst_ld = BK + tgp_padding;
+  MLX_MTL_CONST int n_vecs = BK / vec_size;
+
+  // Stride along block row within the block
+  MLX_MTL_CONST int bstride = tgp_size / n_vecs;
+  MLX_MTL_CONST int n_rows = dst_fd / bstride;
+
+  // Leading dimension for src
+  const int src_ld;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  const constant MLXConvParams<2>& params;
+
+  int weight_h;
+  int weight_w;
+
+  /* Constructor */
+  METAL_FUNC Conv2DWeightBlockLoader(
+      const device T* src_,
+      threadgroup T* dst_,
+      const constant MLXConvParams<2>& params_,
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]],
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(params_.wt_strides[0]),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / n_vecs),
+        bj(vec_size * (thread_idx % n_vecs)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bi * src_ld + bj),
+        params(params_),
+        weight_h(0),
+        weight_w(0) {
+    (void)lid;
+    (void)tid;
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    const device T* curr_src =
+        src + weight_h * params.wt_strides[1] + weight_w * params.wt_strides[2];
+#pragma clang loop unroll(full)
+    for (short i = 0; i < dst_fd; i += bstride) {
+#pragma clang loop unroll(full)
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    if (++weight_w < params.wS[1]) {
+      return;
+    }
+
+    weight_w = 0;
+
+    if (++weight_h < params.wS[0]) {
+      return;
+    }
+
+    weight_h = 0;
+
+    src += BK;
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Transforms
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename OutT, typename InT>
+struct TransformNone {
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+};
+
+template <typename T>
+struct AccumHelper {
+  typedef float accum_type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// MMA helper
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    int tgp_padding_a = 0,
+    int tgp_padding_b = 0,
+    typename AccumType = typename AccumHelper<T>::accum_type,
+    typename Epilogue = TransformNone<T, AccumType>>
+struct Conv2DBlockMMA {
+  // Warp tile size along M
+  MLX_MTL_CONST int TM = BM / (WM * 8);
+  // Warp tile size along N
+  MLX_MTL_CONST int TN = BN / (WN * 8);
+
+  // Warp tile simdgroup matrix strides along M
+  MLX_MTL_CONST int TM_stride = 8 * WM;
+  // Warp tile simdgroup matrix strides along M
+  MLX_MTL_CONST int TN_stride = 8 * WN;
+
+  // Leading dimensions of threadgroup A, B blocks
+  MLX_MTL_CONST int lda_tgp = (transpose_a ? BM : BK) + tgp_padding_a;
+  MLX_MTL_CONST int ldb_tgp = (transpose_b ? BK : BN) + tgp_padding_b;
+
+  // Strides of A, B along reduction axis
+  MLX_MTL_CONST short simd_stride_a =
+      transpose_a ? TM_stride : TM_stride * lda_tgp;
+  MLX_MTL_CONST short simd_stride_b =
+      transpose_b ? TN_stride * ldb_tgp : TN_stride;
+
+  // Jump between elements
+  MLX_MTL_CONST short jump_a = transpose_a ? lda_tgp : 1;
+  MLX_MTL_CONST short jump_b = transpose_b ? ldb_tgp : 1;
+
+  // Offsets within threadgroup
+  const int tm;
+  const int tn;
+
+  // Simdgroup matrices
+  simdgroup_matrix<AccumType, 8, 8> Asimd[TM];
+  simdgroup_matrix<AccumType, 8, 8> Bsimd[TN];
+  simdgroup_matrix<AccumType, 8, 8> results[TM * TN] = {
+      simdgroup_matrix<AccumType, 8, 8>(0)};
+
+  short sm;
+  short sn;
+
+  /* Constructor */
+  METAL_FUNC Conv2DBlockMMA(
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : tm(8 * (simd_group_id / WN)), tn(8 * (simd_group_id % WN)) {
+    short qid = simd_lane_id / 4;
+    sm = (qid & 4) + (simd_lane_id / 2) % 4;
+    sn = (qid & 2) * 2 + (simd_lane_id % 2) * 2;
+  }
+
+  /* (BM, BK) X (BK, BN) multiply accumulate function */
+  METAL_FUNC void mma(const threadgroup T* As, const threadgroup T* Bs) {
+// Iterate over BK in blocks of 8
+#pragma clang loop unroll(full)
+    for (short kk = 0; kk < BK; kk += 8) {
+      short2 offset_a =
+          transpose_a ? short2(tm + sm, kk + sn) : short2(kk + sn, tm + sm);
+      short2 offset_b =
+          transpose_b ? short2(kk + sm, tn + sn) : short2(tn + sn, kk + sm);
+
+      const threadgroup T* As__ = As + offset_a.y * lda_tgp + offset_a.x;
+      const threadgroup T* Bs__ = Bs + offset_b.y * ldb_tgp + offset_b.x;
+
+      simdgroup_barrier(mem_flags::mem_none);
+// Load elements from threadgroup A as simdgroup matrices
+#pragma clang loop unroll(full)
+      for (short i = 0; i < TM; i++) {
+        Asimd[i].thread_elements()[0] = static_cast<AccumType>(As__[0]);
+        Asimd[i].thread_elements()[1] = static_cast<AccumType>(As__[jump_a]);
+        As__ += simd_stride_a;
+      }
+
+      simdgroup_barrier(mem_flags::mem_none);
+// Load elements from threadgroup B as simdgroup matrices
+#pragma clang loop unroll(full)
+      for (short j = 0; j < TN; j++) {
+        Bsimd[j].thread_elements()[0] = static_cast<AccumType>(Bs__[0]);
+        Bsimd[j].thread_elements()[1] = static_cast<AccumType>(Bs__[jump_b]);
+        Bs__ += simd_stride_b;
+      }
+
+      simdgroup_barrier(mem_flags::mem_none);
+// Multiply and accumulate into result simdgroup matrices
+#pragma clang loop unroll(full)
+      for (short i = 0; i < TM; i++) {
+#pragma clang loop unroll(full)
+        for (short j = 0; j < TN; j++) {
+          simdgroup_multiply_accumulate(
+              results[i * TN + j], Asimd[i], Bsimd[j], results[i * TN + j]);
+        }
+      }
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(device T* C, const int ldc) const {
+#pragma clang loop unroll(full)
+    for (int i = 0; i < TM; i++) {
+#pragma clang loop unroll(full)
+      for (int j = 0; j < TN; j++) {
+        C[(i * TM_stride + sm + tm) * ldc + j * TN_stride + tn + sn] =
+            Epilogue::apply(results[i * TN + j].thread_elements()[0]);
+        C[(i * TM_stride + sm + tm) * ldc + j * TN_stride + tn + sn + 1] =
+            Epilogue::apply(results[i * TN + j].thread_elements()[1]);
+      }
+    }
+  }
+
+  METAL_FUNC void
+  store_result_safe(device T* C, const int ldc, short2 dst_tile_dims) const {
+#pragma clang loop unroll(full)
+    for (int i = 0; i < TM; i++) {
+      if (tm + i * TM_stride + sm < dst_tile_dims.y) {
+#pragma clang loop unroll(full)
+        for (int j = 0; j < TN; j++) {
+          if (tn + j * TN_stride + sn < dst_tile_dims.x) {
+            C[(tm + i * TM_stride + sm) * ldc + tn + j * TN_stride + sn] =
+                Epilogue::apply(results[i * TN + j].thread_elements()[0]);
+          }
+
+          if (tn + j * TN_stride + sn + 1 < dst_tile_dims.x) {
+            C[(tm + i * TM_stride + sm) * ldc + tn + j * TN_stride + sn + 1] =
+                Epilogue::apply(results[i * TN + j].thread_elements()[1]);
+          }
+        }
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernels
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    typename AccumType = typename AccumHelper<T>::accum_type,
+    typename Epilogue = TransformNone<T, AccumType>>
+struct Conv2DImplicitGEMMKernel {
+  MLX_MTL_CONST short tgp_padding_a = 16 / sizeof(T);
+  MLX_MTL_CONST short tgp_padding_b = 16 / sizeof(T);
+  MLX_MTL_CONST short tgp_mem_size_a =
+      transpose_a ? BK * (BM + tgp_padding_a) : BM * (BK + tgp_padding_a);
+  MLX_MTL_CONST short tgp_mem_size_b =
+      transpose_b ? BN * (BK + tgp_padding_b) : BK * (BN + tgp_padding_b);
+  MLX_MTL_CONST short tgp_mem_size = tgp_mem_size_a + tgp_mem_size_b;
+
+  MLX_MTL_CONST short tgp_size = WM * WN * 32;
+  MLX_MTL_CONST short vec_size = (BM == 64 && BN == 64) ? 8 : 4;
+
+  using loader_a_t =
+      Conv2DInputBlockLoader<T, BM, BN, BK, vec_size, tgp_size, tgp_padding_a>;
+  using loader_b_t =
+      Conv2DWeightBlockLoader<T, BM, BN, BK, vec_size, tgp_size, tgp_padding_b>;
+  using mma_t = Conv2DBlockMMA<
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      tgp_padding_a,
+      tgp_padding_b,
+      AccumType,
+      Epilogue>;
+
+  /* Main kernel function */
+  static METAL_FUNC void run(
+      const device T* A [[buffer(0)]],
+      const device T* B [[buffer(1)]],
+      device T* C [[buffer(2)]],
+      const constant MLXConvParams<2>& params [[buffer(3)]],
+      threadgroup T* tgp_memory [[threadgroup(0)]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]],
+      uint simd_gid [[simdgroup_index_in_threadgroup]],
+      uint simd_lid [[thread_index_in_simdgroup]]) {
+    const int c_row = tid.y * BM;
+    const int c_col = tid.x * BN;
+    const int K = params.wt_strides[0];
+    const int N = params.O;
+
+    B += c_col * K;
+    C += c_row * N + c_col;
+
+    // Prepare threadgroup memory for loading
+    threadgroup T* As = tgp_memory;
+    threadgroup T* Bs = tgp_memory + tgp_mem_size_a;
+
+    // Prepare threadgroup loading operations
+    loader_a_t loader_a(A, As, params, tid, lid, simd_gid, simd_lid);
+    loader_b_t loader_b(B, Bs, params, tid, lid, simd_gid, simd_lid);
+
+    // Prepare threadgroup mma operation
+    mma_t mma_op(simd_gid, simd_lid);
+
+    for (int k = 0; k < K; k += BK) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      // Load elements into threadgroup
+      loader_a.load_unsafe();
+      loader_b.load_unsafe();
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Store results to device memory
+    mma_op.store_result(C, N);
+  }
+};
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/gemm/gemm.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/gemm/gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..95d2e6497f55eb8d464ce7a11cfeb354d8602e0f
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/gemm/gemm.h
@@ -0,0 +1,538 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_simdgroup>
+#include <metal_simdgroup_matrix>
+#include <metal_stdlib>
+
+#define MLX_MTL_CONST static constant constexpr const
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading helper
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    int BROWS,
+    int BCOLS,
+    int BK,
+    int vec_size,
+    int tgp_size,
+    bool transpose,
+    bool ldK,
+    int tgp_padding = 0>
+struct BlockLoader {
+  // Destination dimensions
+  MLX_MTL_CONST int dst_fd = transpose ? BCOLS : BROWS;
+  MLX_MTL_CONST int dst_ld = (transpose ? BROWS : BCOLS) + tgp_padding;
+  MLX_MTL_CONST int n_vecs = (transpose ? BROWS : BCOLS) / vec_size;
+
+  // Stride along block row within the block
+  MLX_MTL_CONST int bstride = tgp_size / n_vecs;
+
+  // Leading dimension for src
+  const int src_ld;
+  // Stride along reduction axis between blocks
+  const int tstride;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  /* Constructor */
+  METAL_FUNC BlockLoader(
+      const device T* src_,
+      const int src_ld_,
+      threadgroup T* dst_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(src_ld_),
+        tstride(
+            BK * ((int)(transpose ^ !ldK) * src_ld + (int)(transpose ^ ldK))),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / n_vecs),
+        bj(vec_size * (thread_idx % n_vecs)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bi * src_ld + bj) {}
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+#pragma clang loop unroll(full)
+    for (short i = 0; i < dst_fd; i += bstride) {
+#pragma clang loop unroll(full)
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * dst_ld + j] = src[i * src_ld + j];
+      }
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - with bound checking */
+  METAL_FUNC void load_safe(short2 src_tile_dim) const {
+    src_tile_dim = transpose ? src_tile_dim.yx : src_tile_dim.xy;
+
+    // Iterate over rows of block
+#pragma clang loop unroll(full)
+    for (short i = 0; i < dst_fd; i += bstride) {
+      // Row is in bounds, we check against column
+      if ((bi + i) < src_tile_dim.y) {
+        // Use fast thread memory for bound checks
+        short tmp_idx[vec_size];
+        T tmp_val[vec_size];
+
+        // Make sure tmp_idx only contains valid indices
+#pragma clang loop unroll(full)
+        for (short j = 0; j < vec_size; j++) {
+          tmp_idx[j] = bj + j < src_tile_dim.x ? j : 0;
+        }
+
+        // Read all valid indices into tmp_val
+#pragma clang loop unroll(full)
+        for (short j = 0; j < vec_size; j++) {
+          tmp_val[j] = src[i * src_ld + tmp_idx[j]];
+        }
+
+        // Zero out unneeded values
+#pragma clang loop unroll(full)
+        for (short j = 0; j < vec_size; j++) {
+          tmp_val[j] = bj + j < src_tile_dim.x ? tmp_val[j] : T(0);
+        }
+
+        // Copy values to threadgroup memory
+#pragma clang loop unroll(full)
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = tmp_val[j];
+        }
+      }
+
+      // Row is out of bounds, we just fill tgp memory with zeros
+      else {
+#pragma clang loop unroll(full)
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = T(0);
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    src += tstride;
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Transforms
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename OutT, typename InT>
+struct TransformNone {
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+};
+
+template <typename T>
+struct AccumHelper {
+  typedef float accum_type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// MMA helper
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    int tgp_padding_a = 0,
+    int tgp_padding_b = 0,
+    typename AccumType = typename AccumHelper<T>::accum_type,
+    typename Epilogue = TransformNone<T, AccumType>>
+struct BlockMMA {
+  // Warp tile size along M
+  MLX_MTL_CONST int TM = BM / (WM * 8);
+  // Warp tile size along N
+  MLX_MTL_CONST int TN = BN / (WN * 8);
+
+  // Warp tile simdgroup matrix strides along M
+  MLX_MTL_CONST int TM_stride = 8 * WM;
+  // Warp tile simdgroup matrix strides along M
+  MLX_MTL_CONST int TN_stride = 8 * WN;
+
+  // Leading dimensions of threadgroup A, B blocks
+  MLX_MTL_CONST int lda_tgp = (transpose_a ? BM : BK) + tgp_padding_a;
+  MLX_MTL_CONST int ldb_tgp = (transpose_b ? BK : BN) + tgp_padding_b;
+
+  // Strides of A, B along reduction axis
+  MLX_MTL_CONST short simd_stride_a =
+      transpose_a ? TM_stride : TM_stride * lda_tgp;
+  MLX_MTL_CONST short simd_stride_b =
+      transpose_b ? TN_stride * ldb_tgp : TN_stride;
+
+  // Jump between elements
+  MLX_MTL_CONST short jump_a = transpose_a ? lda_tgp : 1;
+  MLX_MTL_CONST short jump_b = transpose_b ? ldb_tgp : 1;
+
+  // Offsets within threadgroup
+  const int tm;
+  const int tn;
+
+  // Simdgroup matrices
+  simdgroup_matrix<AccumType, 8, 8> Asimd[TM];
+  simdgroup_matrix<AccumType, 8, 8> Bsimd[TN];
+  simdgroup_matrix<AccumType, 8, 8> results[TM * TN] = {
+      simdgroup_matrix<AccumType, 8, 8>(0)};
+
+  short sm;
+  short sn;
+
+  /* Constructor */
+  METAL_FUNC BlockMMA(
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : tm(8 * (simd_group_id / WN)), tn(8 * (simd_group_id % WN)) {
+    short qid = simd_lane_id / 4;
+    sm = (qid & 4) + (simd_lane_id / 2) % 4;
+    sn = (qid & 2) * 2 + (simd_lane_id % 2) * 2;
+  }
+
+  /* (BM, BK) X (BK, BN) multiply accumulate function */
+  METAL_FUNC void mma(const threadgroup T* As, const threadgroup T* Bs) {
+// Iterate over BK in blocks of 8
+#pragma clang loop unroll(full)
+    for (short kk = 0; kk < BK; kk += 8) {
+      short2 offset_a =
+          transpose_a ? short2(tm + sm, kk + sn) : short2(kk + sn, tm + sm);
+      short2 offset_b =
+          transpose_b ? short2(kk + sm, tn + sn) : short2(tn + sn, kk + sm);
+
+      const threadgroup T* As__ = As + offset_a.y * lda_tgp + offset_a.x;
+      const threadgroup T* Bs__ = Bs + offset_b.y * ldb_tgp + offset_b.x;
+
+      simdgroup_barrier(mem_flags::mem_none);
+// Load elements from threadgroup A as simdgroup matrices
+#pragma clang loop unroll(full)
+      for (short i = 0; i < TM; i++) {
+        Asimd[i].thread_elements()[0] = static_cast<AccumType>(As__[0]);
+        Asimd[i].thread_elements()[1] = static_cast<AccumType>(As__[jump_a]);
+        As__ += simd_stride_a;
+      }
+
+      simdgroup_barrier(mem_flags::mem_none);
+// Load elements from threadgroup B as simdgroup matrices
+#pragma clang loop unroll(full)
+      for (short j = 0; j < TN; j++) {
+        Bsimd[j].thread_elements()[0] = static_cast<AccumType>(Bs__[0]);
+        Bsimd[j].thread_elements()[1] = static_cast<AccumType>(Bs__[jump_b]);
+        Bs__ += simd_stride_b;
+      }
+
+      simdgroup_barrier(mem_flags::mem_none);
+// Multiply and accumulate into result simdgroup matrices
+#pragma clang loop unroll(full)
+      for (short i = 0; i < TM; i++) {
+#pragma clang loop unroll(full)
+        for (short j = 0; j < TN; j++) {
+          simdgroup_multiply_accumulate(
+              results[i * TN + j], Asimd[i], Bsimd[j], results[i * TN + j]);
+        }
+      }
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(device T* C, const int ldc) const {
+#pragma clang loop unroll(full)
+    for (int i = 0; i < TM; i++) {
+#pragma clang loop unroll(full)
+      for (int j = 0; j < TN; j++) {
+        C[(i * TM_stride + sm + tm) * ldc + j * TN_stride + tn + sn] =
+            Epilogue::apply(results[i * TN + j].thread_elements()[0]);
+        C[(i * TM_stride + sm + tm) * ldc + j * TN_stride + tn + sn + 1] =
+            Epilogue::apply(results[i * TN + j].thread_elements()[1]);
+      }
+    }
+  }
+
+  METAL_FUNC void
+  store_result_safe(device T* C, const int ldc, short2 dst_tile_dims) const {
+#pragma clang loop unroll(full)
+    for (int i = 0; i < TM; i++) {
+      if (tm + i * TM_stride + sm < dst_tile_dims.y) {
+#pragma clang loop unroll(full)
+        for (int j = 0; j < TN; j++) {
+          if (tn + j * TN_stride + sn < dst_tile_dims.x) {
+            C[(tm + i * TM_stride + sm) * ldc + tn + j * TN_stride + sn] =
+                Epilogue::apply(results[i * TN + j].thread_elements()[0]);
+          }
+
+          if (tn + j * TN_stride + sn + 1 < dst_tile_dims.x) {
+            C[(tm + i * TM_stride + sm) * ldc + tn + j * TN_stride + sn + 1] =
+                Epilogue::apply(results[i * TN + j].thread_elements()[1]);
+          }
+        }
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernels
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    bool MN_aligned,
+    bool K_aligned,
+    typename AccumType = typename AccumHelper<T>::accum_type,
+    typename Epilogue = TransformNone<T, AccumType>>
+struct GEMMKernel {
+  MLX_MTL_CONST short tgp_padding_a = 16 / sizeof(T);
+  MLX_MTL_CONST short tgp_padding_b = 16 / sizeof(T);
+  MLX_MTL_CONST short tgp_mem_size_a =
+      transpose_a ? BK * (BM + tgp_padding_a) : BM * (BK + tgp_padding_a);
+  MLX_MTL_CONST short tgp_mem_size_b =
+      transpose_b ? BN * (BK + tgp_padding_b) : BK * (BN + tgp_padding_b);
+  MLX_MTL_CONST short tgp_mem_size = tgp_mem_size_a + tgp_mem_size_b;
+
+  MLX_MTL_CONST short tgp_size = WM * WN * 32;
+  MLX_MTL_CONST short vec_size = (BM == 64 && BN == 64) ? 8 : 4;
+
+  using loader_a_t = BlockLoader<
+      T,
+      BM,
+      BK,
+      BK,
+      vec_size,
+      tgp_size,
+      transpose_a,
+      true,
+      tgp_padding_a>;
+  using loader_b_t = BlockLoader<
+      T,
+      BK,
+      BN,
+      BK,
+      vec_size,
+      tgp_size,
+      transpose_b,
+      false,
+      tgp_padding_b>;
+  using mma_t = BlockMMA<
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      tgp_padding_a,
+      tgp_padding_b,
+      AccumType,
+      Epilogue>;
+
+  /* Main kernel function */
+  static METAL_FUNC void run(
+      const device T* A [[buffer(0)]],
+      const device T* B [[buffer(1)]],
+      device T* C [[buffer(2)]],
+      const constant int& M [[buffer(3)]],
+      const constant int& N [[buffer(4)]],
+      const constant int& K [[buffer(5)]],
+      const constant int& batch_stride_a [[buffer(6)]],
+      const constant int& batch_stride_b [[buffer(7)]],
+      const constant int& batch_stride_c [[buffer(8)]],
+      threadgroup T* tgp_memory [[threadgroup(0)]],
+      uint simd_lane_id [[thread_index_in_simdgroup]],
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]]) {
+    // Pacifying compiler
+    (void)lid;
+
+    // Adjust for batch
+    A += batch_stride_a * tid.z;
+    B += batch_stride_b * tid.z;
+    C += batch_stride_c * tid.z;
+
+    // Adjust for transpose
+    const int lda_dev = transpose_a ? M : K;
+    const int ldb_dev = transpose_b ? K : N;
+
+    // Find block in A, B, C
+    const int c_row = tid.y * BM;
+    const int c_col = tid.x * BN;
+
+    A += transpose_a ? c_row : c_row * K;
+    B += transpose_b ? c_col * K : c_col;
+    C += c_row * N + c_col;
+
+    // Prepare threadgroup memory for loading
+    threadgroup T* As = tgp_memory;
+    threadgroup T* Bs = tgp_memory + tgp_mem_size_a;
+
+    // Prepare threadgroup loading operations
+    loader_a_t loader_a(A, lda_dev, As, simd_group_id, simd_lane_id);
+    loader_b_t loader_b(B, ldb_dev, Bs, simd_group_id, simd_lane_id);
+
+    // Prepare threadgroup mma operation
+    mma_t mma_op(simd_group_id, simd_lane_id);
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // MNK aligned loop
+    if (MN_aligned && K_aligned) {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+
+      threadgroup_barrier(mem_flags::mem_none);
+
+      // Store results to device memory
+      mma_op.store_result(C, N);
+      return;
+
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    // MN aligned, K unaligned loop
+    else if (MN_aligned && !K_aligned) {
+      // Main loop
+      int k = 0;
+      for (; k + BK <= K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+
+      // Loop tail
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      loader_a.load_safe(short2(K - k, BM));
+      loader_b.load_safe(short2(BN, K - k));
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      mma_op.mma(As, Bs);
+
+      // Store results to device memory
+      mma_op.store_result(C, N);
+      return;
+
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    // MNK unaligned loop
+    else { // Loop over K - unaligned case
+
+      short2 src_tile_dims(min(BN, N - c_col), min(BM, M - c_row));
+
+      if (src_tile_dims.y == BM && src_tile_dims.x == BN) {
+        int k = 0;
+        for (; k + BK <= K; k += BK) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          // Load elements into threadgroup
+          loader_a.load_unsafe();
+          loader_b.load_unsafe();
+
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+
+          // Multiply and accumulate threadgroup elements
+          mma_op.mma(As, Bs);
+
+          // Prepare for next iteration
+          loader_a.next();
+          loader_b.next();
+        }
+
+        threadgroup_barrier(mem_flags::mem_none);
+
+        if (k < K) {
+          loader_a.load_safe(short2(K - k, BM));
+          loader_b.load_safe(short2(BN, K - k));
+
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+
+          mma_op.mma(As, Bs);
+        }
+
+        mma_op.store_result(C, N);
+        return;
+
+      } else {
+        int k = 0;
+        for (; k + BK <= K; k += BK) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          // Load elements into threadgroup
+          loader_a.load_safe(short2(BK, src_tile_dims.y));
+          loader_b.load_safe(short2(src_tile_dims.x, BK));
+
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+
+          // Multiply and accumulate threadgroup elements
+          mma_op.mma(As, Bs);
+
+          // Prepare for next iteration
+          loader_a.next();
+          loader_b.next();
+        }
+
+        threadgroup_barrier(mem_flags::mem_none);
+
+        if (k < K) {
+          loader_a.load_safe(short2(K - k, src_tile_dims.y));
+          loader_b.load_safe(short2(src_tile_dims.x, K - k));
+
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+
+          mma_op.mma(As, Bs);
+        }
+
+        threadgroup_barrier(mem_flags::mem_none);
+        mma_op.store_result_safe(C, N, src_tile_dims);
+
+        return;
+      }
+    }
+  }
+};
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/reduce.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d2b971b29dba8fb78b9b3cca7da6b19c0fd39ce
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/reduce.h
@@ -0,0 +1,176 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_atomic>
+#include <metal_simdgroup>
+
+#include "mlx/backend/metal/kernels/atomic.h"
+#include "mlx/backend/metal/kernels/bf16.h"
+#include "mlx/backend/metal/kernels/utils.h"
+
+union bool4_or_uint {
+  bool4 b;
+  unsigned int i;
+};
+
+struct None {
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, int offset = 0) {
+    mlx_atomic_store_explicit(out, val, offset);
+  }
+};
+
+struct And {
+  bool simd_reduce(bool val) {
+    return simd_all(val);
+  };
+
+  static constexpr constant bool init = true;
+
+  void atomic_update(
+      device mlx_atomic<unsigned int>* out,
+      bool val,
+      int elem_idx,
+      int offset = 0) {
+    if (!val) {
+      bool4_or_uint update;
+      update.b = {true, true, true, true};
+      update.b[elem_idx] = false;
+      mlx_atomic_fetch_and_explicit(out, update.i, offset);
+    }
+  }
+
+  void atomic_update(device mlx_atomic<bool>* out, bool val, int offset = 0) {
+    if (!val) {
+      mlx_atomic_store_explicit(out, val, offset);
+    }
+  }
+
+  // Non atomic update
+  void update(device bool* out, bool val) {
+    *out &= val;
+  }
+
+  // Operator
+  bool operator()(bool a, bool b) {
+    return a && b;
+  }
+};
+
+struct Or {
+  bool simd_reduce(bool val) {
+    return simd_any(val);
+  };
+
+  static constexpr constant bool init = false;
+
+  void atomic_update(
+      device mlx_atomic<unsigned int>* out,
+      bool val,
+      int elem_idx,
+      int offset = 0) {
+    if (val) {
+      bool4_or_uint update;
+      update.b = {false, false, false, false};
+      update.b[elem_idx] = true;
+      mlx_atomic_fetch_or_explicit(out, update.i, offset);
+    }
+  }
+
+  void atomic_update(device mlx_atomic<bool>* out, bool val, int offset = 0) {
+    if (val) {
+      mlx_atomic_store_explicit(out, val, offset);
+    }
+  }
+
+  // Non atomic update
+  void update(device bool* out, bool val) {
+    *out |= val;
+  }
+
+  // Operator
+  bool operator()(bool a, bool b) {
+    return a || b;
+  }
+};
+
+template <typename U>
+struct Sum {
+  template <typename T>
+  T simd_reduce(T val) {
+    return simd_sum(val);
+  };
+
+  static constexpr constant U init = U(0);
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, int offset = 0) {
+    mlx_atomic_fetch_add_explicit(out, val, offset);
+  }
+
+  // Operator
+  U operator()(U a, U b) {
+    return a + b;
+  }
+};
+
+template <typename U>
+struct Prod {
+  template <typename T>
+  T simd_reduce(T val) {
+    return simd_product(val);
+  };
+
+  static constexpr constant U init = U(1);
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, int offset = 0) {
+    mlx_atomic_fetch_mul_explicit(out, val, offset);
+  }
+
+  // Operator
+  U operator()(U a, U b) {
+    return a * b;
+  }
+};
+
+template <typename U>
+struct Min {
+  template <typename T>
+  T simd_reduce(T val) {
+    return simd_min(val);
+  };
+
+  static constexpr constant U init = Limits<U>::max;
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, int offset = 0) {
+    mlx_atomic_fetch_min_explicit(out, val, offset);
+  }
+
+  // Operator
+  U operator()(U a, U b) {
+    return a < b ? a : b;
+  }
+};
+
+template <typename U>
+struct Max {
+  template <typename T>
+  T simd_reduce(T val) {
+    return simd_max(val);
+  };
+
+  static constexpr constant U init = Limits<U>::min;
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, int offset = 0) {
+    mlx_atomic_fetch_max_explicit(out, val, offset);
+  }
+
+  // Operator
+  U operator()(U a, U b) {
+    return a > b ? a : b;
+  }
+};
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/utils.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..72cdd8b20446a5a802895de2755108dadfedc0ab
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/kernels/utils.h
@@ -0,0 +1,246 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_math>
+#include "mlx/backend/metal/kernels/bf16.h"
+#include "mlx/backend/metal/kernels/complex.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Type limits utils
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename U>
+struct Limits {
+  static const constant U max;
+  static const constant U min;
+  static const constant U finite_max;
+  static const constant U finite_min;
+};
+
+#define instantiate_default_limit(type)                                      \
+  template <>                                                                \
+  struct Limits<type> {                                                      \
+    static constexpr constant type max = metal::numeric_limits<type>::max(); \
+    static constexpr constant type min = metal::numeric_limits<type>::min(); \
+    static constexpr constant type finite_max =                              \
+        metal::numeric_limits<type>::max();                                  \
+    static constexpr constant type finite_min =                              \
+        metal::numeric_limits<type>::min();                                  \
+  };
+
+instantiate_default_limit(uint8_t);
+instantiate_default_limit(uint16_t);
+instantiate_default_limit(uint32_t);
+instantiate_default_limit(uint64_t);
+instantiate_default_limit(int8_t);
+instantiate_default_limit(int16_t);
+instantiate_default_limit(int32_t);
+instantiate_default_limit(int64_t);
+
+#define instantiate_float_limit(type)             \
+  template <>                                     \
+  struct Limits<type> {                           \
+    static constexpr constant type max =          \
+        metal::numeric_limits<type>::infinity();  \
+    static constexpr constant type min =          \
+        -metal::numeric_limits<type>::infinity(); \
+    static constexpr constant type finite_max =   \
+        metal::numeric_limits<type>::max();       \
+    static constexpr constant type finite_min =   \
+        -metal::numeric_limits<type>::max();      \
+  };
+
+instantiate_float_limit(half);
+instantiate_float_limit(float);
+instantiate_float_limit(bfloat16_t);
+
+template <>
+struct Limits<bool> {
+  static constexpr constant bool max = true;
+  static constexpr constant bool min = false;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Indexing utils
+///////////////////////////////////////////////////////////////////////////////
+
+inline size_t elem_to_loc(
+    uint elem,
+    device const int* shape,
+    device const size_t* strides,
+    int ndim) {
+  size_t loc = 0;
+  for (int i = ndim - 1; i >= 0; --i) {
+    loc += (elem % shape[i]) * strides[i];
+    elem /= shape[i];
+  }
+  return loc;
+}
+
+inline size_t elem_to_loc(
+    uint elem,
+    constant const int* shape,
+    constant const size_t* strides,
+    int ndim) {
+  size_t loc = 0;
+  for (int i = ndim - 1; i >= 0; --i) {
+    loc += (elem % shape[i]) * strides[i];
+    elem /= shape[i];
+  }
+  return loc;
+}
+
+template <int NDIM>
+inline uint2 elem_to_loc_2_nd(
+    uint3 elem,
+    constant const int shape[NDIM],
+    constant const size_t a_strides[NDIM],
+    constant const size_t b_strides[NDIM]) {
+  uint2 loc = {
+      static_cast<uint>(
+          elem.x * a_strides[NDIM - 1] + elem.y * a_strides[NDIM - 2]),
+      static_cast<uint>(
+          elem.x * b_strides[NDIM - 1] + elem.y * b_strides[NDIM - 2])};
+  for (int d = NDIM - 3; d >= 0; --d) {
+    uint l = elem.z % shape[d];
+    loc.x += l * a_strides[d];
+    loc.y += l * b_strides[d];
+    elem.z /= shape[d];
+  }
+  return loc;
+}
+
+template <int NDIM>
+inline size_t elem_to_loc_nd(
+    uint3 elem,
+    constant const int shape[NDIM],
+    constant const size_t strides[NDIM]) {
+  size_t loc = elem.x * strides[NDIM - 1] + elem.y * strides[NDIM - 2];
+  for (int d = NDIM - 3; d >= 0; --d) {
+    loc += (elem.z % shape[d]) * strides[d];
+    elem.z /= shape[d];
+  }
+  return loc;
+}
+
+inline size_t elem_to_loc_1(uint elem, constant const size_t& stride) {
+  return elem * stride;
+}
+
+inline size_t elem_to_loc_2(uint2 elem, constant const size_t strides[2]) {
+  return elem.x * strides[1] + elem.y * strides[0];
+}
+
+inline size_t elem_to_loc_3(uint3 elem, constant const size_t strides[3]) {
+  return elem.x * strides[2] + elem.y * strides[1] + elem.z * strides[0];
+}
+
+// Non templated version to handle arbitrary dims
+inline size_t elem_to_loc(
+    uint3 elem,
+    constant const int* shape,
+    constant const size_t* strides,
+    int ndim) {
+  size_t loc = elem.x * strides[ndim - 1] + elem.y * strides[ndim - 2];
+  for (int d = ndim - 3; d >= 0; --d) {
+    loc += (elem.z % shape[d]) * strides[d];
+    elem.z /= shape[d];
+  }
+  return loc;
+}
+
+inline uint2 elem_to_loc_2_nd(
+    uint3 elem,
+    constant const int* shape,
+    constant const size_t* a_strides,
+    constant const size_t* b_strides,
+    int ndim) {
+  uint2 loc = {
+      static_cast<uint>(
+          elem.x * a_strides[ndim - 1] + elem.y * a_strides[ndim - 2]),
+      static_cast<uint>(
+          elem.x * b_strides[ndim - 1] + elem.y * b_strides[ndim - 2])};
+  for (int d = ndim - 3; d >= 0; --d) {
+    uint l = elem.z % shape[d];
+    loc.x += l * a_strides[d];
+    loc.y += l * b_strides[d];
+    elem.z /= shape[d];
+  }
+  return loc;
+}
+
+template <int NDIM>
+inline uint elem_to_loc_nd(
+    uint elem,
+    device const int* shape,
+    device const size_t* strides);
+
+template <>
+inline uint elem_to_loc_nd<1>(
+    uint elem,
+    device const int* shape,
+    device const size_t* strides) {
+  return (elem % shape[0]) * strides[0];
+}
+
+template <>
+inline uint elem_to_loc_nd<2>(
+    uint elem,
+    device const int* shape,
+    device const size_t* strides) {
+  uint loc = (elem % shape[1]) * strides[1];
+  elem /= shape[1];
+  loc += (elem % shape[0]) * strides[0];
+  return loc;
+}
+
+template <>
+inline uint elem_to_loc_nd<3>(
+    uint elem,
+    device const int* shape,
+    device const size_t* strides) {
+  uint loc = (elem % shape[2]) * strides[2];
+  elem /= shape[2];
+  loc += (elem % shape[1]) * strides[1];
+  elem /= shape[1];
+  loc += (elem % shape[0]) * strides[0];
+  return loc;
+}
+
+template <>
+inline uint elem_to_loc_nd<4>(
+    uint elem,
+    device const int* shape,
+    device const size_t* strides) {
+  uint loc = (elem % shape[3]) * strides[3];
+  elem /= shape[3];
+  loc += (elem % shape[2]) * strides[2];
+  elem /= shape[2];
+  loc += (elem % shape[1]) * strides[1];
+  elem /= shape[1];
+  loc += (elem % shape[0]) * strides[0];
+  return loc;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Calculation utils
+///////////////////////////////////////////////////////////////////////////////
+
+/** Compute ceil((float)N/(float)M) */
+inline size_t ceildiv(size_t N, size_t M) {
+  return (N + M - 1) / M;
+}
+
+// https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html#1202
+inline float log1p(float x) {
+  float xp1 = 1.0f + x;
+  return (xp1 == 1.0f) ? x : x * (metal::log(xp1) / (xp1 - 1.0f));
+}
+
+inline bfloat16_t log1p(bfloat16_t x) {
+  float xp1 = 1.0f + static_cast<float>(x);
+  bfloat16_t ret =
+      (xp1 == 1.0f) ? x : bfloat16_t(x * (metal::log(xp1) / (xp1 - 1.0f)));
+  return ret;
+}
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/matmul.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/matmul.h
new file mode 100644
index 0000000000000000000000000000000000000000..78a0e7f2695a49bbbcc737accaeaa162fe6818a1
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/matmul.h
@@ -0,0 +1,31 @@
+// Copyright © 2023 Apple Inc.
+
+#include <algorithm>
+#include <cassert>
+#include <sstream>
+
+#include "mlx/backend/metal/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/mps/gemm.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+void mlx_matmul(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies);
+
+} // namespace mlx::core
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/metal.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/metal.h
new file mode 100644
index 0000000000000000000000000000000000000000..99f4009568826f417303f3399bec32c88b0100e7
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/metal.h
@@ -0,0 +1,31 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <future>
+#include <memory>
+#include <vector>
+
+#include "mlx/array.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::metal {
+
+constexpr bool is_available() {
+#ifdef _METAL_
+  return true;
+#else
+  return false;
+#endif
+}
+
+void new_stream(Stream stream);
+std::shared_ptr<void> new_scoped_memory_pool();
+
+std::function<void()> make_task(
+    array& arr,
+    std::vector<std::shared_future<void>> deps,
+    std::shared_ptr<std::promise<void>> p,
+    bool retain_graph);
+
+} // namespace mlx::core::metal
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/mps/gemm.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/mps/gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..c93df68d8317356a24f342ff06635b2ffe2ff3b3
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/mps/gemm.h
@@ -0,0 +1,370 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <Metal/Metal.hpp>
+
+#define _MPS_PRIVATE_CLS(symbol) (MTL::Private::Class::s_k##symbol)
+#define _MPS_PRIVATE_SEL(accessor) (MTL::Private::Selector::s_k##accessor)
+
+namespace MTL::Private::Class {
+_MTL_PRIVATE_DEF_CLS(MPSMatrixDescriptor);
+_MTL_PRIVATE_DEF_CLS(MPSMatrix);
+_MTL_PRIVATE_DEF_CLS(MPSVectorDescriptor);
+_MTL_PRIVATE_DEF_CLS(MPSVector);
+_MTL_PRIVATE_DEF_CLS(MPSKernel);
+_MTL_PRIVATE_DEF_CLS(MPSMatrixMultiplication);
+_MTL_PRIVATE_DEF_CLS(MPSMatrixVectorMultiplication);
+} // namespace MTL::Private::Class
+
+namespace MTL::Private::Selector {
+_MTL_PRIVATE_DEF_SEL(
+    matrixDescriptorWithRows_columns_rowBytes_dataType,
+    "matrixDescriptorWithRows:columns:rowBytes:dataType:");
+_MTL_PRIVATE_DEF_SEL(
+    matrixDescriptorWithRows_columns_matrices_rowBytes_matrixBytes_dataType,
+    "matrixDescriptorWithRows:columns:matrices:rowBytes:matrixBytes:dataType:");
+_MTL_PRIVATE_DEF_SEL(rows, "rows");
+_MTL_PRIVATE_DEF_SEL(initWithBuffer_descriptor, "initWithBuffer:descriptor:");
+_MTL_PRIVATE_DEF_SEL(
+    initWithDevice_,
+    "initWithDevice:transposeLeft:transposeRight:"
+    "resultRows:resultColumns:interiorColumns:alpha:beta:");
+_MTL_PRIVATE_DEF_SEL(
+    encodeToCommandBuffer_leftMatrix_rightMatrix_resultMatrix,
+    "encodeToCommandBuffer:leftMatrix:rightMatrix:resultMatrix:");
+_MTL_PRIVATE_DEF_SEL(setLeftMatrixOrigin_, "setLeftMatrixOrigin:");
+_MTL_PRIVATE_DEF_SEL(setRightMatrixOrigin_, "setRightMatrixOrigin:");
+_MTL_PRIVATE_DEF_SEL(setResultMatrixOrigin_, "setResultMatrixOrigin:");
+_MTL_PRIVATE_DEF_SEL(setBatchStart_, "setBatchStart:");
+_MTL_PRIVATE_DEF_SEL(setBatchSize_, "setBatchSize:");
+_MTL_PRIVATE_DEF_SEL(
+    vectorDescriptorWithLength_dataType,
+    "vectorDescriptorWithLength:dataType:");
+_MTL_PRIVATE_DEF_SEL(
+    vectorDescriptorWithLength_vectors_vectorBytes_dataType,
+    "vectorDescriptorWithLength:vectors:vectorBytes:dataType:");
+_MTL_PRIVATE_DEF_SEL(
+    initWithDevice_transpose_rows_columns_alpha_beta,
+    "initWithDevice:transpose:rows:columns:alpha:beta:");
+_MTL_PRIVATE_DEF_SEL(
+    encodeToCommandBuffer_inputMatrix_inputVector_resultVector,
+    "encodeToCommandBuffer:inputMatrix:inputVector:resultVector:");
+} // namespace MTL::Private::Selector
+
+namespace MPS {
+
+typedef enum DataType : uint32_t {
+  DataTypeFloatBit = 0x10000000,
+  DataTypeAlternateEncodingBit = 0x80000000,
+  DataTypeFloat16 = DataTypeFloatBit | 16,
+  DataTypeFloat32 = DataTypeFloatBit | 32,
+  DataTypeBFloat16 = DataTypeAlternateEncodingBit | DataTypeFloat16
+} DataType;
+
+class MatrixDescriptor : public NS::Copying<MatrixDescriptor> {
+ public:
+  static class MatrixDescriptor* matrixDescriptor(
+      NS::UInteger rows,
+      NS::UInteger columns,
+      NS::UInteger rowBytes,
+      NS::UInteger dataType);
+  static class MatrixDescriptor* matrixDescriptor(
+      NS::UInteger rows,
+      NS::UInteger columns,
+      NS::UInteger matrices,
+      NS::UInteger rowBytes,
+      NS::UInteger matrixBytes,
+      NS::UInteger dataType);
+  NS::UInteger rows() const;
+};
+
+class Matrix : public NS::Referencing<Matrix> {
+ public:
+  static class Matrix* alloc();
+  Matrix* init(MTL::Buffer* buffer, MatrixDescriptor* descriptor);
+  Matrix* init(const MTL::Buffer* buffer, MatrixDescriptor* descriptor);
+};
+
+class Kernel : public NS::Referencing<Kernel> {
+ public:
+  NS::String* label() const;
+  MTL::Device* device() const;
+};
+
+class MatrixMultiplication
+    : public NS::Referencing<MatrixMultiplication, Kernel> {
+ public:
+  static class MatrixMultiplication* alloc();
+
+  MatrixMultiplication* init(
+      MTL::Device* device,
+      bool transposeLeft,
+      bool transposeRight,
+      NS::UInteger resultRows,
+      NS::UInteger resultColumns,
+      NS::UInteger interiorColumns,
+      double alpha,
+      double beta);
+
+  void encodeToCommandBuffer(
+      MTL::CommandBuffer* commandBuffer,
+      Matrix* leftMatrix,
+      Matrix* rightMatrix,
+      Matrix* resultMatrix);
+
+  void setLeftMatrixOrigin(MTL::Origin origin);
+  void setRightMatrixOrigin(MTL::Origin origin);
+  void setResultMatrixOrigin(MTL::Origin origin);
+  void setBatchStart(NS::UInteger batchStart);
+  void setBatchSize(NS::UInteger batchSize);
+};
+
+class VectorDescriptor : public NS::Copying<VectorDescriptor> {
+ public:
+  static class VectorDescriptor* vectorDescriptor(
+      NS::UInteger length,
+      NS::UInteger dataType);
+  static class VectorDescriptor* vectorDescriptor(
+      NS::UInteger length,
+      NS::UInteger vectors,
+      NS::UInteger vectorBytes,
+      NS::UInteger dataType);
+};
+
+class Vector : public NS::Referencing<Vector> {
+ public:
+  static class Vector* alloc();
+  Vector* init(MTL::Buffer* buffer, VectorDescriptor* descriptor);
+  Vector* init(const MTL::Buffer* buffer, VectorDescriptor* descriptor);
+};
+
+class MatrixVectorMultiplication
+    : public NS::Referencing<MatrixVectorMultiplication, Kernel> {
+ public:
+  static class MatrixVectorMultiplication* alloc();
+
+  MatrixVectorMultiplication* init(
+      MTL::Device* device,
+      bool transpose,
+      NS::UInteger rows,
+      NS::UInteger columns,
+      double alpha,
+      double beta);
+
+  void encodeToCommandBuffer(
+      MTL::CommandBuffer* commandBuffer,
+      Matrix* inputMatrix,
+      Vector* inputVector,
+      Vector* resultVector);
+};
+
+_MTL_INLINE MatrixDescriptor* MatrixDescriptor::matrixDescriptor(
+    NS::UInteger rows,
+    NS::UInteger columns,
+    NS::UInteger rowBytes,
+    NS::UInteger dataType) {
+  return Object::sendMessage<MatrixDescriptor*>(
+      _MPS_PRIVATE_CLS(MPSMatrixDescriptor),
+      _MPS_PRIVATE_SEL(matrixDescriptorWithRows_columns_rowBytes_dataType),
+      rows,
+      columns,
+      rowBytes,
+      dataType);
+}
+
+_MTL_INLINE MatrixDescriptor* MatrixDescriptor::matrixDescriptor(
+    NS::UInteger rows,
+    NS::UInteger columns,
+    NS::UInteger matrices,
+    NS::UInteger rowBytes,
+    NS::UInteger matrixBytes,
+    NS::UInteger dataType) {
+  return Object::sendMessage<MatrixDescriptor*>(
+      _MPS_PRIVATE_CLS(MPSMatrixDescriptor),
+      _MPS_PRIVATE_SEL(
+          matrixDescriptorWithRows_columns_matrices_rowBytes_matrixBytes_dataType),
+      rows,
+      columns,
+      matrices,
+      rowBytes,
+      matrixBytes,
+      dataType);
+}
+
+_MTL_INLINE NS::UInteger MatrixDescriptor::rows() const {
+  return Object::sendMessage<NS::UInteger>(this, _MPS_PRIVATE_SEL(rows));
+}
+
+_MTL_INLINE Matrix* Matrix::alloc() {
+  return NS::Object::alloc<Matrix>(_MPS_PRIVATE_CLS(MPSMatrix));
+}
+
+_MTL_INLINE Matrix* Matrix::init(
+    MTL::Buffer* buffer,
+    MatrixDescriptor* descriptor) {
+  return Object::sendMessage<Matrix*>(
+      this, _MPS_PRIVATE_SEL(initWithBuffer_descriptor), buffer, descriptor);
+}
+
+_MTL_INLINE Matrix* Matrix::init(
+    const MTL::Buffer* buffer,
+    MatrixDescriptor* descriptor) {
+  return init(const_cast<MTL::Buffer*>(buffer), descriptor);
+}
+
+_MTL_INLINE NS::String* Kernel::label() const {
+  return Object::sendMessage<NS::String*>(this, _MPS_PRIVATE_SEL(label));
+}
+
+_MTL_INLINE MTL::Device* Kernel::device() const {
+  return Object::sendMessage<MTL::Device*>(this, _MPS_PRIVATE_SEL(device));
+}
+
+_MTL_INLINE MatrixMultiplication* MatrixMultiplication::alloc() {
+  return NS::Object::alloc<MatrixMultiplication>(
+      _MPS_PRIVATE_CLS(MPSMatrixMultiplication));
+}
+
+_MTL_INLINE MatrixMultiplication* MatrixMultiplication::init(
+    MTL::Device* device,
+    bool transposeLeft,
+    bool transposeRight,
+    NS::UInteger resultRows,
+    NS::UInteger resultColumns,
+    NS::UInteger interiorColumns,
+    double alpha,
+    double beta) {
+  return Object::sendMessage<MatrixMultiplication*>(
+      this,
+      _MPS_PRIVATE_SEL(initWithDevice_),
+      device,
+      transposeLeft,
+      transposeRight,
+      resultRows,
+      resultColumns,
+      interiorColumns,
+      alpha,
+      beta);
+}
+
+_MTL_INLINE void MatrixMultiplication::encodeToCommandBuffer(
+    MTL::CommandBuffer* commandBuffer,
+    Matrix* leftMatrix,
+    Matrix* rightMatrix,
+    Matrix* resultMatrix) {
+  return Object::sendMessage<void>(
+      this,
+      _MPS_PRIVATE_SEL(
+          encodeToCommandBuffer_leftMatrix_rightMatrix_resultMatrix),
+      commandBuffer,
+      leftMatrix,
+      rightMatrix,
+      resultMatrix);
+}
+
+_MTL_INLINE void MatrixMultiplication::setLeftMatrixOrigin(MTL::Origin origin) {
+  Object::sendMessage<void>(
+      this, _MPS_PRIVATE_SEL(setLeftMatrixOrigin_), origin);
+}
+
+_MTL_INLINE void MatrixMultiplication::setRightMatrixOrigin(
+    MTL::Origin origin) {
+  Object::sendMessage<void>(
+      this, _MPS_PRIVATE_SEL(setRightMatrixOrigin_), origin);
+}
+
+_MTL_INLINE void MatrixMultiplication::setResultMatrixOrigin(
+    MTL::Origin origin) {
+  Object::sendMessage<void>(
+      this, _MPS_PRIVATE_SEL(setResultMatrixOrigin_), origin);
+}
+
+_MTL_INLINE void MatrixMultiplication::setBatchStart(NS::UInteger batchStart) {
+  Object::sendMessage<void>(this, _MPS_PRIVATE_SEL(setBatchStart_), batchStart);
+}
+
+_MTL_INLINE void MatrixMultiplication::setBatchSize(NS::UInteger batchSize) {
+  Object::sendMessage<void>(this, _MPS_PRIVATE_SEL(setBatchSize_), batchSize);
+}
+
+_MTL_INLINE VectorDescriptor* VectorDescriptor::vectorDescriptor(
+    NS::UInteger length,
+    NS::UInteger dataType) {
+  return Object::sendMessage<VectorDescriptor*>(
+      _MPS_PRIVATE_CLS(MPSVectorDescriptor),
+      _MPS_PRIVATE_SEL(vectorDescriptorWithLength_dataType),
+      length,
+      dataType);
+}
+
+_MTL_INLINE VectorDescriptor* VectorDescriptor::vectorDescriptor(
+    NS::UInteger length,
+    NS::UInteger vectors,
+    NS::UInteger vectorBytes,
+    NS::UInteger dataType) {
+  return Object::sendMessage<VectorDescriptor*>(
+      _MPS_PRIVATE_CLS(MPSVectorDescriptor),
+      _MPS_PRIVATE_SEL(vectorDescriptorWithLength_vectors_vectorBytes_dataType),
+      length,
+      vectors,
+      vectorBytes,
+      dataType);
+}
+
+_MTL_INLINE Vector* Vector::alloc() {
+  return NS::Object::alloc<Vector>(_MPS_PRIVATE_CLS(MPSVector));
+}
+
+_MTL_INLINE Vector* Vector::init(
+    MTL::Buffer* buffer,
+    VectorDescriptor* descriptor) {
+  return Object::sendMessage<Vector*>(
+      this, _MPS_PRIVATE_SEL(initWithBuffer_descriptor), buffer, descriptor);
+}
+
+_MTL_INLINE Vector* Vector::init(
+    const MTL::Buffer* buffer,
+    VectorDescriptor* descriptor) {
+  return init(const_cast<MTL::Buffer*>(buffer), descriptor);
+}
+
+_MTL_INLINE MatrixVectorMultiplication* MatrixVectorMultiplication::alloc() {
+  return NS::Object::alloc<MatrixVectorMultiplication>(
+      _MPS_PRIVATE_CLS(MPSMatrixVectorMultiplication));
+}
+
+_MTL_INLINE MatrixVectorMultiplication* MatrixVectorMultiplication::init(
+    MTL::Device* device,
+    bool transpose,
+    NS::UInteger rows,
+    NS::UInteger columns,
+    double alpha,
+    double beta) {
+  return Object::sendMessage<MatrixVectorMultiplication*>(
+      this,
+      _MPS_PRIVATE_SEL(initWithDevice_transpose_rows_columns_alpha_beta),
+      device,
+      transpose,
+      rows,
+      columns,
+      alpha,
+      beta);
+}
+
+_MTL_INLINE void MatrixVectorMultiplication::encodeToCommandBuffer(
+    MTL::CommandBuffer* commandBuffer,
+    Matrix* inputMatrix,
+    Vector* inputVector,
+    Vector* resultVector) {
+  return Object::sendMessage<void>(
+      this,
+      _MPS_PRIVATE_SEL(
+          encodeToCommandBuffer_inputMatrix_inputVector_resultVector),
+      commandBuffer,
+      inputMatrix,
+      inputVector,
+      resultVector);
+}
+
+} // namespace MPS
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/utils.h b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..378850802212cab755d77aca4267ada4b525005c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/backend/metal/utils.h
@@ -0,0 +1,169 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/metal/device.h"
+
+namespace mlx::core {
+
+namespace {
+
+void set_array_buffer(
+    MTL::ComputeCommandEncoder* compute_encoder,
+    MTL::ArgumentEncoder* enc,
+    const array& a,
+    int idx) {
+  auto a_buf = static_cast<const MTL::Buffer*>(a.buffer().ptr());
+  auto offset = a.data<char>() -
+      static_cast<char*>(const_cast<MTL::Buffer*>(a_buf)->contents());
+  enc->setBuffer(a_buf, offset, idx);
+  // MTL::Resource usage through argument buffer needs to be explicitly
+  // flagged to enable hazard tracking
+  compute_encoder->useResource(a_buf, MTL::ResourceUsageRead);
+}
+
+void set_array_buffer(
+    MTL::ComputeCommandEncoder* enc,
+    const array& a,
+    int idx) {
+  auto a_buf = static_cast<const MTL::Buffer*>(a.buffer().ptr());
+  auto offset = a.data<char>() -
+      static_cast<char*>(const_cast<MTL::Buffer*>(a_buf)->contents());
+  enc->setBuffer(a_buf, offset, idx);
+}
+
+std::string type_to_name(const array& a) {
+  std::string tname;
+  switch (a.dtype()) {
+    case bool_:
+      tname = "bool_";
+      break;
+    case uint8:
+      tname = "uint8";
+      break;
+    case uint16:
+      tname = "uint16";
+      break;
+    case uint32:
+      tname = "uint32";
+      break;
+    case uint64:
+      tname = "uint64";
+      break;
+    case int8:
+      tname = "int8";
+      break;
+    case int16:
+      tname = "int16";
+      break;
+    case int32:
+      tname = "int32";
+      break;
+    case int64:
+      tname = "int64";
+      break;
+    case float16:
+      tname = "float16";
+      break;
+    case float32:
+      tname = "float32";
+      break;
+    case bfloat16:
+      tname = "bfloat16";
+      break;
+    case complex64:
+      tname = "complex64";
+      break;
+  }
+  return tname;
+}
+
+MTL::Size get_block_dims(int dim0, int dim1, int dim2) {
+  int pows[3] = {0, 0, 0};
+  int sum = 0;
+  while (true) {
+    int presum = sum;
+    // Check all the pows
+    if (dim0 >= (1 << (pows[0] + 1))) {
+      pows[0]++;
+      sum++;
+    }
+    if (sum == 10) {
+      break;
+    }
+    if (dim1 >= (1 << (pows[1] + 1))) {
+      pows[1]++;
+      sum++;
+    }
+    if (sum == 10) {
+      break;
+    }
+    if (dim2 >= (1 << (pows[2] + 1))) {
+      pows[2]++;
+      sum++;
+    }
+    if (sum == presum || sum == 10) {
+      break;
+    }
+  }
+  return MTL::Size{1ul << pows[0], 1ul << pows[1], 1ul << pows[2]};
+}
+
+// Collapse dims that are contiguous to possibly route to a better kernel
+// e.g. for x = transpose(array({0, 1, 2, 3, 4, 5, 6, 7}, {2, 2, 2}), {2, 0, 1})
+// should return {{2, 4}, {{1, 2}}}.
+//
+// When multiple arrays are passed they should all have the same shape. The
+// collapsed axes are also the same so one shape is returned.
+std::tuple<std::vector<int>, std::vector<std::vector<size_t>>>
+collapse_contiguous_dims(const std::vector<array>& xs) {
+  // Make a vector that has axes separated with -1. Collapse all axes between
+  // -1.
+  std::vector<int> to_collapse;
+  if (xs[0].ndim() > 0) {
+    to_collapse.push_back(0);
+    for (int i = 1; i < xs[0].ndim(); i++) {
+      bool contiguous = true;
+      for (auto& x : xs) {
+        if (x.strides()[i] * x.shape()[i] != x.strides()[i - 1]) {
+          contiguous = false;
+        }
+        if (!contiguous) {
+          break;
+        }
+      }
+      if (!contiguous) {
+        to_collapse.push_back(-1);
+      }
+      to_collapse.push_back(i);
+    }
+    to_collapse.push_back(-1);
+  }
+
+  std::vector<int> out_shape;
+  std::vector<std::vector<size_t>> out_strides(xs.size());
+  for (int i = 0; i < to_collapse.size(); i++) {
+    int current_shape = xs[0].shape()[to_collapse[i]];
+    while (to_collapse[++i] != -1) {
+      current_shape *= xs[0].shape()[to_collapse[i]];
+    }
+    out_shape.push_back(current_shape);
+    for (int j = 0; j < xs.size(); j++) {
+      out_strides[j].push_back(xs[j].strides()[to_collapse[i - 1]]);
+    }
+  }
+
+  return std::make_tuple(out_shape, out_strides);
+}
+
+template <typename... Arrays>
+std::tuple<std::vector<int>, std::vector<std::vector<size_t>>>
+collapse_contiguous_dims(Arrays... xs) {
+  return collapse_contiguous_dims(
+      std::vector<array>{std::forward<Arrays>(xs)...});
+}
+
+} // namespace
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/device.h b/lib/python3.11/site-packages/mlx/include/mlx/device.h
new file mode 100644
index 0000000000000000000000000000000000000000..e11edf7936176aef0f5bf56863c14715c94f8b0c
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/device.h
@@ -0,0 +1,29 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+namespace mlx::core {
+
+struct Device {
+  enum class DeviceType {
+    cpu,
+    gpu,
+  };
+
+  static constexpr DeviceType cpu = DeviceType::cpu;
+  static constexpr DeviceType gpu = DeviceType::gpu;
+
+  Device(DeviceType type, int index = 0) : type(type), index(index){};
+
+  DeviceType type;
+  int index;
+};
+
+const Device& default_device();
+
+void set_default_device(const Device& d);
+
+bool operator==(const Device& lhs, const Device& rhs);
+bool operator!=(const Device& lhs, const Device& rhs);
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/dtype.h b/lib/python3.11/site-packages/mlx/include/mlx/dtype.h
new file mode 100644
index 0000000000000000000000000000000000000000..d5283048505a80cf9c17fe89d5113903c903a10a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/dtype.h
@@ -0,0 +1,105 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <complex>
+#include <cstdint>
+#include <ostream>
+#include <string>
+
+#include "mlx/types/complex.h"
+#include "mlx/types/half_types.h"
+
+namespace mlx::core {
+
+struct Dtype {
+  enum class Val {
+    bool_,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    int8,
+    int16,
+    int32,
+    int64,
+    float16,
+    float32,
+    bfloat16,
+    complex64,
+  };
+
+  enum class Kind {
+    b, /* bool */
+    u, /* unsigned int */
+    i, /* signed int */
+    f, /* float */
+    c, /* complex */
+    V, /* void - used for brain float */
+  };
+
+  Val val;
+  const uint8_t size;
+  constexpr explicit Dtype(Val val, uint8_t size) : val(val), size(size){};
+  constexpr operator Val() const {
+    return val;
+  };
+};
+
+inline bool is_available(const Dtype& dtype) {
+  return true;
+}
+
+static constexpr Dtype bool_{Dtype::Val::bool_, sizeof(bool)};
+
+static constexpr Dtype uint8{Dtype::Val::uint8, sizeof(uint8_t)};
+static constexpr Dtype uint16{Dtype::Val::uint16, sizeof(uint16_t)};
+static constexpr Dtype uint32{Dtype::Val::uint32, sizeof(uint32_t)};
+static constexpr Dtype uint64{Dtype::Val::uint64, sizeof(uint64_t)};
+
+static constexpr Dtype int8{Dtype::Val::int8, sizeof(int8_t)};
+static constexpr Dtype int16{Dtype::Val::int16, sizeof(int16_t)};
+static constexpr Dtype int32{Dtype::Val::int32, sizeof(int32_t)};
+static constexpr Dtype int64{Dtype::Val::int64, sizeof(int64_t)};
+
+static constexpr Dtype float16{Dtype::Val::float16, sizeof(uint16_t)};
+static constexpr Dtype float32{Dtype::Val::float32, sizeof(float)};
+static constexpr Dtype bfloat16{Dtype::Val::bfloat16, sizeof(uint16_t)};
+static constexpr Dtype complex64{Dtype::Val::complex64, sizeof(complex64_t)};
+
+Dtype promote_types(const Dtype& t1, const Dtype& t2);
+
+inline uint8_t size_of(const Dtype& t) {
+  return t.size;
+}
+
+Dtype::Kind kindof(const Dtype& t);
+
+inline bool is_unsigned(const Dtype& t) {
+  return kindof(t) == Dtype::Kind::u || kindof(t) == Dtype::Kind::b;
+}
+
+inline bool is_floating_point(const Dtype& t) {
+  return kindof(t) == Dtype::Kind::f || kindof(t) == Dtype::Kind::V ||
+      kindof(t) == Dtype::Kind::c;
+}
+
+inline bool is_complex(const Dtype& t) {
+  return kindof(t) == Dtype::Kind::c;
+}
+
+inline bool is_integral(const Dtype& t) {
+  return !(is_floating_point(t));
+}
+
+template <typename T>
+struct TypeToDtype {
+  operator Dtype();
+};
+
+// Array protocol typestring for Dtype
+std::string dtype_to_array_protocol(const Dtype& t);
+// Dtype from array protocol type string
+Dtype dtype_from_array_protocol(const std::string& t);
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/fft.h b/lib/python3.11/site-packages/mlx/include/mlx/fft.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbcc777fed3e68742d017e5b9df85bb95f34c780
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/fft.h
@@ -0,0 +1,151 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <variant>
+
+#include "array.h"
+#include "device.h"
+#include "stream.h"
+
+namespace mlx::core::fft {
+
+using StreamOrDevice = std::variant<std::monostate, Stream, Device>;
+
+/** Compute the n-dimensional Fourier Transform. */
+array fftn(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array fftn(const array& a, const std::vector<int>& axes, StreamOrDevice s = {});
+array fftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the n-dimensional inverse Fourier Transform. */
+array ifftn(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array ifftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array ifftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the one-dimensional Fourier Transform. */
+inline array fft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return fftn(a, {n}, {axis}, s);
+}
+inline array fft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return fftn(a, {axis}, s);
+}
+
+/** Compute the one-dimensional inverse Fourier Transform. */
+inline array ifft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return ifftn(a, {n}, {axis}, s);
+}
+inline array ifft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return ifftn(a, {axis}, s);
+}
+
+/** Compute the two-dimensional Fourier Transform. */
+inline array fft2(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return fftn(a, n, axes, s);
+}
+inline array fft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return fftn(a, axes, s);
+}
+
+/** Compute the two-dimensional inverse Fourier Transform. */
+inline array ifft2(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return ifftn(a, n, axes, s);
+}
+inline array ifft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return ifftn(a, axes, s);
+}
+
+/** Compute the n-dimensional Fourier Transform on a real input. */
+array rfftn(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array rfftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array rfftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the n-dimensional inverse of `rfftn`. */
+array irfftn(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array irfftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array irfftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the one-dimensional Fourier Transform on a real input. */
+inline array rfft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return rfftn(a, {n}, {axis}, s);
+}
+inline array rfft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return rfftn(a, {axis}, s);
+}
+/** Compute the one-dimensional inverse of `rfft`. */
+inline array irfft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return irfftn(a, {n}, {axis}, s);
+}
+inline array irfft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return irfftn(a, {axis}, s);
+}
+
+/** Compute the two-dimensional Fourier Transform on a real input. */
+inline array rfft2(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return rfftn(a, n, axes, s);
+}
+inline array rfft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return rfftn(a, axes, s);
+}
+
+/** Compute the two-dimensional inverse of `rfft2`. */
+inline array irfft2(
+    const array& a,
+    const std::vector<int>& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return irfftn(a, n, axes, s);
+}
+inline array irfft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return irfftn(a, axes, s);
+}
+
+} // namespace mlx::core::fft
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/graph_utils.h b/lib/python3.11/site-packages/mlx/include/mlx/graph_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..3bd373beca78c75dcea7058dca91a689e8496969
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/graph_utils.h
@@ -0,0 +1,23 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+void print_graph(std::ostream& os, const std::vector<array>& outputs);
+
+template <typename... Arrays>
+void print_graph(std::ostream& os, Arrays... outputs) {
+  print_graph(os, std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+void export_to_dot(std::ostream& os, const std::vector<array>& outputs);
+
+template <typename... Arrays>
+void export_to_dot(std::ostream& os, Arrays... outputs) {
+  export_to_dot(os, std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/io/load.h b/lib/python3.11/site-packages/mlx/include/mlx/io/load.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d193392a71b347337996d52a5f7b8bfc75e3fcf
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/io/load.h
@@ -0,0 +1,114 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <fstream>
+#include <istream>
+#include <memory>
+
+namespace mlx::core {
+
+namespace io {
+
+class Reader {
+ public:
+  virtual bool is_open() const = 0;
+  virtual bool good() const = 0;
+  virtual size_t tell() const = 0;
+  virtual void seek(
+      int64_t off,
+      std::ios_base::seekdir way = std::ios_base::beg) = 0;
+  virtual void read(char* data, size_t n) = 0;
+  virtual std::string label() const = 0;
+};
+
+class Writer {
+ public:
+  virtual bool is_open() const = 0;
+  virtual bool good() const = 0;
+  virtual size_t tell() const = 0;
+  virtual void seek(
+      int64_t off,
+      std::ios_base::seekdir way = std::ios_base::beg) = 0;
+  virtual void write(const char* data, size_t n) = 0;
+  virtual std::string label() const = 0;
+};
+
+class FileReader : public Reader {
+ public:
+  explicit FileReader(const std::shared_ptr<std::ifstream>& is)
+      : is_(is), label_("stream") {}
+  explicit FileReader(const std::string& file_path)
+      : is_(std::make_shared<std::ifstream>(file_path, std::ios::binary)),
+        label_(file_path) {}
+
+  bool is_open() const override {
+    return is_->is_open();
+  }
+
+  bool good() const override {
+    return is_->good();
+  }
+
+  size_t tell() const override {
+    return is_->tellg();
+  }
+
+  void seek(int64_t off, std::ios_base::seekdir way = std::ios_base::beg)
+      override {
+    is_->seekg(off, way);
+  }
+
+  void read(char* data, size_t n) override {
+    is_->read(data, n);
+  }
+
+  std::string label() const override {
+    return "file " + label_;
+  }
+
+ private:
+  std::shared_ptr<std::ifstream> is_;
+  std::string label_;
+};
+
+class FileWriter : public Writer {
+ public:
+  explicit FileWriter(const std::shared_ptr<std::ofstream>& is)
+      : os_(is), label_("stream") {}
+  explicit FileWriter(const std::string& file_path)
+      : os_(std::make_shared<std::ofstream>(file_path, std::ios::binary)),
+        label_(file_path) {}
+
+  bool is_open() const override {
+    return os_->is_open();
+  }
+
+  bool good() const override {
+    return os_->good();
+  }
+
+  size_t tell() const override {
+    return os_->tellp();
+  }
+
+  void seek(int64_t off, std::ios_base::seekdir way = std::ios_base::beg)
+      override {
+    os_->seekp(off, way);
+  }
+
+  void write(const char* data, size_t n) override {
+    os_->write(data, n);
+  }
+
+  std::string label() const override {
+    return "file " + label_;
+  }
+
+ private:
+  std::shared_ptr<std::ofstream> os_;
+  std::string label_;
+};
+
+} // namespace io
+} // namespace mlx::core
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/io/safetensor.h b/lib/python3.11/site-packages/mlx/include/mlx/io/safetensor.h
new file mode 100644
index 0000000000000000000000000000000000000000..104a226ce8042b72ad3d0b3dd7167d4ca12fda13
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/io/safetensor.h
@@ -0,0 +1,32 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <json.hpp>
+
+#include "mlx/io/load.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+
+using json = nlohmann::json;
+
+namespace mlx::core {
+
+#define ST_F16 "F16"
+#define ST_BF16 "BF16"
+#define ST_F32 "F32"
+
+#define ST_BOOL "BOOL"
+#define ST_I8 "I8"
+#define ST_I16 "I16"
+#define ST_I32 "I32"
+#define ST_I64 "I64"
+#define ST_U8 "U8"
+#define ST_U16 "U16"
+#define ST_U32 "U32"
+#define ST_U64 "U64"
+
+// Note: Complex numbers aren't in the spec yet so this could change -
+// https://github.com/huggingface/safetensors/issues/389
+#define ST_C64 "C64"
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/linalg.h b/lib/python3.11/site-packages/mlx/include/mlx/linalg.h
new file mode 100644
index 0000000000000000000000000000000000000000..80e484eb5d5fea92139400820abdf6f6aef9a716
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/linalg.h
@@ -0,0 +1,63 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <optional>
+
+#include "mlx/array.h"
+#include "mlx/device.h"
+#include "mlx/ops.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::linalg {
+
+/**
+ * Compute vector or matrix norms.
+ *
+ * - If axis and ord are both unspecified, computes the 2-norm of flatten(x).
+ * - If axis is not provided but ord is, then x must be either 1D or 2D.
+ * - If axis is provided, but ord is not, then the 2-norm (or Frobenius norm
+ *   for matrices) is computed along the given axes. At most 2 axes can be
+ *   specified.
+ * - If both axis and ord are provided, then the corresponding matrix or vector
+ *   norm is computed. At most 2 axes can be specified.
+ */
+array norm(
+    const array& a,
+    const double ord,
+    const std::optional<std::vector<int>>& axis = std::nullopt,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+inline array norm(
+    const array& a,
+    const double ord,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {}) {
+  return norm(a, ord, std::vector<int>{axis}, keepdims, s);
+}
+array norm(
+    const array& a,
+    const std::string& ord,
+    const std::optional<std::vector<int>>& axis = std::nullopt,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+inline array norm(
+    const array& a,
+    const std::string& ord,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {}) {
+  return norm(a, ord, std::vector<int>{axis}, keepdims, s);
+}
+array norm(
+    const array& a,
+    const std::optional<std::vector<int>>& axis = std::nullopt,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+inline array
+norm(const array& a, int axis, bool keepdims = false, StreamOrDevice s = {}) {
+  return norm(a, std::vector<int>{axis}, keepdims, s);
+}
+
+} // namespace mlx::core::linalg
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/mlx.h b/lib/python3.11/site-packages/mlx/include/mlx/mlx.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d785c39fcdd9246dd6e7c21e54fb00b26f1a234
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/mlx.h
@@ -0,0 +1,14 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/metal/metal.h"
+#include "mlx/device.h"
+#include "mlx/fft.h"
+#include "mlx/linalg.h"
+#include "mlx/ops.h"
+#include "mlx/random.h"
+#include "mlx/stream.h"
+#include "mlx/transforms.h"
+#include "mlx/utils.h"
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/ops.h b/lib/python3.11/site-packages/mlx/include/mlx/ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f7b52da445b609a1f55d4f64c30736bc0056c61
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/ops.h
@@ -0,0 +1,1094 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <optional>
+#include <variant>
+
+#include "array.h"
+#include "device.h"
+#include "io/load.h"
+#include "stream.h"
+
+namespace mlx::core {
+
+using StreamOrDevice = std::variant<std::monostate, Stream, Device>;
+
+Stream to_stream(StreamOrDevice s);
+
+/** Creation operations */
+
+/**
+ * A 1D array of numbers starting at `start` (optional),
+ * stopping at stop, stepping by `step` (optional). */
+array arange(
+    double start,
+    double stop,
+    double step,
+    Dtype dtype,
+    StreamOrDevice s = {});
+array arange(double start, double stop, double step, StreamOrDevice s = {});
+array arange(double start, double stop, Dtype dtype, StreamOrDevice s = {});
+array arange(double start, double stop, StreamOrDevice s = {});
+array arange(double stop, Dtype dtype, StreamOrDevice s = {});
+array arange(double stop, StreamOrDevice s = {});
+
+array arange(int start, int stop, int step, StreamOrDevice s = {});
+array arange(int start, int stop, StreamOrDevice s = {});
+array arange(int stop, StreamOrDevice s = {});
+
+/** A 1D array of `num` evenly spaced numbers in the range `[start, stop]` */
+array linspace(
+    double start,
+    double stop,
+    int num = 50,
+    Dtype dtype = float32,
+    StreamOrDevice s = {});
+
+/** Convert an array to the given data type. */
+array astype(const array& a, Dtype dtype, StreamOrDevice s = {});
+
+/** Create a view of an array with the given shape and strides. */
+array as_strided(
+    const array& a,
+    std::vector<int> shape,
+    std::vector<size_t> strides,
+    size_t offset,
+    StreamOrDevice s = {});
+
+/** Copy another array. */
+array copy(const array& a, StreamOrDevice s = {});
+
+/** Fill an array of the given shape with the given value(s). */
+array full(
+    const std::vector<int>& shape,
+    const array& vals,
+    Dtype dtype,
+    StreamOrDevice s = {});
+array full(
+    const std::vector<int>& shape,
+    const array& vals,
+    StreamOrDevice s = {});
+template <typename T>
+array full(
+    const std::vector<int>& shape,
+    T val,
+    Dtype dtype,
+    StreamOrDevice s = {}) {
+  return full(shape, array(val, dtype), to_stream(s));
+}
+template <typename T>
+array full(const std::vector<int>& shape, T val, StreamOrDevice s = {}) {
+  return full(shape, array(val), to_stream(s));
+}
+
+/** Fill an array of the given shape with zeros. */
+array zeros(const std::vector<int>& shape, Dtype dtype, StreamOrDevice s = {});
+inline array zeros(const std::vector<int>& shape, StreamOrDevice s = {}) {
+  return zeros(shape, float32, s);
+}
+array zeros_like(const array& a, StreamOrDevice s = {});
+
+/** Fill an array of the given shape with ones. */
+array ones(const std::vector<int>& shape, Dtype dtype, StreamOrDevice s = {});
+inline array ones(const std::vector<int>& shape, StreamOrDevice s = {}) {
+  return ones(shape, float32, s);
+}
+array ones_like(const array& a, StreamOrDevice s = {});
+
+/** Fill an array of the given shape (n,m) with ones in the specified diagonal
+ * k, and zeros everywhere else. */
+array eye(int n, int m, int k, Dtype dtype, StreamOrDevice s = {});
+inline array eye(int n, Dtype dtype, StreamOrDevice s = {}) {
+  return eye(n, n, 0, dtype, s);
+}
+inline array eye(int n, int m, StreamOrDevice s = {}) {
+  return eye(n, m, 0, float32, s);
+}
+inline array eye(int n, int m, int k, StreamOrDevice s = {}) {
+  return eye(n, m, k, float32, s);
+}
+inline array eye(int n, StreamOrDevice s = {}) {
+  return eye(n, n, 0, float32, s);
+}
+
+/** Create a square matrix of shape (n,n) of zeros, and ones in the major
+ * diagonal. */
+array identity(int n, Dtype dtype, StreamOrDevice s = {});
+inline array identity(int n, StreamOrDevice s = {}) {
+  return identity(n, float32, s);
+}
+
+array tri(int n, int m, int k, Dtype type, StreamOrDevice s = {});
+inline array tri(int n, Dtype type, StreamOrDevice s = {}) {
+  return tri(n, n, 0, type, s);
+}
+
+array tril(array x, int k, StreamOrDevice s = {});
+array triu(array x, int k, StreamOrDevice s = {});
+
+/** array manipulation */
+
+/** Reshape an array to the given shape. */
+array reshape(const array& a, std::vector<int> shape, StreamOrDevice s = {});
+
+/** Flatten the dimensions in the range `[start_axis, end_axis]` . */
+array flatten(
+    const array& a,
+    int start_axis,
+    int end_axis = -1,
+    StreamOrDevice s = {});
+
+/** Flatten the array to 1D. */
+array flatten(const array& a, StreamOrDevice s = {});
+
+/** Remove singleton dimensions at the given axes. */
+array squeeze(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+/** Remove singleton dimensions at the given axis. */
+inline array squeeze(const array& a, int axis, StreamOrDevice s = {}) {
+  return squeeze(a, std::vector<int>{axis}, s);
+}
+
+/** Remove all singleton dimensions. */
+array squeeze(const array& a, StreamOrDevice s = {});
+
+/** Add a singleton dimension at the given axes. */
+array expand_dims(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+/** Add a singleton dimension at the given axis. */
+inline array expand_dims(const array& a, int axis, StreamOrDevice s = {}) {
+  return expand_dims(a, std::vector<int>{axis}, s);
+}
+
+/** Slice an array. */
+array slice(
+    const array& a,
+    std::vector<int> start,
+    std::vector<int> stop,
+    std::vector<int> strides,
+    StreamOrDevice s = {});
+
+/** Slice an array with a stride of 1 in each dimension. */
+array slice(
+    const array& a,
+    const std::vector<int>& start,
+    const std::vector<int>& stop,
+    StreamOrDevice s = {});
+
+/** Split an array into sub-arrays along a given axis. */
+std::vector<array>
+split(const array& a, int num_splits, int axis, StreamOrDevice s = {});
+std::vector<array> split(const array& a, int num_splits, StreamOrDevice s = {});
+std::vector<array> split(
+    const array& a,
+    const std::vector<int>& indices,
+    int axis,
+    StreamOrDevice s = {});
+std::vector<array>
+split(const array& a, const std::vector<int>& indices, StreamOrDevice s = {});
+
+/**
+ * Clip (limit) the values in an array.
+ */
+array clip(
+    const array& a,
+    const std::optional<array>& a_min = std::nullopt,
+    const std::optional<array>& a_max = std::nullopt,
+    StreamOrDevice s = {});
+
+/** Concatenate arrays along a given axis. */
+array concatenate(
+    const std::vector<array>& arrays,
+    int axis,
+    StreamOrDevice s = {});
+array concatenate(const std::vector<array>& arrays, StreamOrDevice s = {});
+
+/** Stack arrays along a new axis. */
+array stack(const std::vector<array>& arrays, int axis, StreamOrDevice s = {});
+array stack(const std::vector<array>& arrays, StreamOrDevice s = {});
+
+/** Repeat an array along an axis. */
+array repeat(const array& arr, int repeats, int axis, StreamOrDevice s = {});
+array repeat(const array& arr, int repeats, StreamOrDevice s = {});
+
+/** Permutes the dimensions according to the given axes. */
+array transpose(const array& a, std::vector<int> axes, StreamOrDevice s = {});
+inline array transpose(
+    const array& a,
+    std::initializer_list<int> axes,
+    StreamOrDevice s = {}) {
+  return transpose(a, std::vector<int>(axes), s);
+}
+
+/** Swap two axes of an array. */
+array swapaxes(const array& a, int axis1, int axis2, StreamOrDevice s = {});
+
+/** Move an axis of an array. */
+array moveaxis(
+    const array& a,
+    int source,
+    int destination,
+    StreamOrDevice s = {});
+
+/** Pad an array with a constant value */
+array pad(
+    const array& a,
+    const std::vector<int>& axes,
+    const std::vector<int>& low_pad_size,
+    const std::vector<int>& high_pad_size,
+    const array& pad_value = array(0),
+    StreamOrDevice s = {});
+
+/** Pad an array with a constant value along all axes */
+array pad(
+    const array& a,
+    const std::vector<std::pair<int, int>>& pad_width,
+    const array& pad_value = array(0),
+    StreamOrDevice s = {});
+array pad(
+    const array& a,
+    const std::pair<int, int>& pad_width,
+    const array& pad_value = array(0),
+    StreamOrDevice s = {});
+array pad(
+    const array& a,
+    int pad_width,
+    const array& pad_value = array(0),
+    StreamOrDevice s = {});
+
+/** Permutes the dimensions in reverse order. */
+array transpose(const array& a, StreamOrDevice s = {});
+
+/** Broadcast an array to a given shape. */
+array broadcast_to(
+    const array& a,
+    const std::vector<int>& shape,
+    StreamOrDevice s = {});
+
+/** Broadcast a vector of arrays against one another. */
+std::vector<array> broadcast_arrays(
+    const std::vector<array>& inputs,
+    StreamOrDevice s = {});
+
+/** Comparison operations */
+
+/** Returns the bool array with (a == b) element-wise. */
+array equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator==(const array& a, const array& b) {
+  return equal(a, b);
+}
+template <typename T>
+array operator==(T a, const array& b) {
+  return equal(array(a), b);
+}
+template <typename T>
+array operator==(const array& a, T b) {
+  return equal(a, array(b));
+}
+
+/** Returns the bool array with (a != b) element-wise. */
+array not_equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator!=(const array& a, const array& b) {
+  return not_equal(a, b);
+}
+template <typename T>
+array operator!=(T a, const array& b) {
+  return not_equal(array(a), b);
+}
+template <typename T>
+array operator!=(const array& a, T b) {
+  return not_equal(a, array(b));
+}
+
+/** Returns bool array with (a > b) element-wise. */
+array greater(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator>(const array& a, const array& b) {
+  return greater(a, b);
+}
+template <typename T>
+array operator>(T a, const array& b) {
+  return greater(array(a), b);
+}
+template <typename T>
+array operator>(const array& a, T b) {
+  return greater(a, array(b));
+}
+
+/** Returns bool array with (a >= b) element-wise. */
+array greater_equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator>=(const array& a, const array& b) {
+  return greater_equal(a, b);
+}
+template <typename T>
+array operator>=(T a, const array& b) {
+  return greater_equal(array(a), b);
+}
+template <typename T>
+array operator>=(const array& a, T b) {
+  return greater_equal(a, array(b));
+}
+
+/** Returns bool array with (a < b) element-wise. */
+array less(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator<(const array& a, const array& b) {
+  return less(a, b);
+}
+template <typename T>
+array operator<(T a, const array& b) {
+  return less(array(a), b);
+}
+template <typename T>
+array operator<(const array& a, T b) {
+  return less(a, array(b));
+}
+
+/** Returns bool array with (a <= b) element-wise. */
+array less_equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator<=(const array& a, const array& b) {
+  return less_equal(a, b);
+}
+template <typename T>
+array operator<=(T a, const array& b) {
+  return less_equal(array(a), b);
+}
+template <typename T>
+array operator<=(const array& a, T b) {
+  return less_equal(a, array(b));
+}
+
+/** True if two arrays have the same shape and elements. */
+array array_equal(
+    const array& a,
+    const array& b,
+    bool equal_nan,
+    StreamOrDevice s = {});
+inline array
+array_equal(const array& a, const array& b, StreamOrDevice s = {}) {
+  return array_equal(a, b, false, s);
+}
+
+/** Select from x or y depending on condition. */
+array where(
+    const array& condition,
+    const array& x,
+    const array& y,
+    StreamOrDevice s = {});
+
+/** Reduction operations */
+
+/** True if all elements in the array are true (or non-zero). **/
+array all(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array all(const array& a, StreamOrDevice s = {}) {
+  return all(a, false, to_stream(s));
+}
+
+/** True if the two arrays are equal within the specified tolerance. */
+array allclose(
+    const array& a,
+    const array& b,
+    double rtol = 1e-5,
+    double atol = 1e-8,
+    StreamOrDevice s = {});
+
+/**
+ *  Reduces the input along the given axes. An output value is true
+ *  if all the corresponding inputs are true.
+ **/
+array all(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/**
+ *  Reduces the input along the given axis. An output value is true
+ *  if all the corresponding inputs are true.
+ **/
+array all(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** True if any elements in the array are true (or non-zero). **/
+array any(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array any(const array& a, StreamOrDevice s = {}) {
+  return any(a, false, to_stream(s));
+}
+
+/**
+ *  Reduces the input along the given axes. An output value is true
+ *  if any of the corresponding inputs are true.
+ **/
+array any(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/**
+ *  Reduces the input along the given axis. An output value is true
+ *  if any of the corresponding inputs are true.
+ **/
+array any(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Sums the elements of an array. */
+array sum(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array sum(const array& a, StreamOrDevice s = {}) {
+  return sum(a, false, to_stream(s));
+}
+
+/** Sums the elements of an array along the given axes. */
+array sum(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Sums the elements of an array along the given axis. */
+array sum(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Computes the mean of the elements of an array. */
+array mean(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array mean(const array& a, StreamOrDevice s = {}) {
+  return mean(a, false, to_stream(s));
+}
+
+/** Computes the mean of the elements of an array along the given axes */
+array mean(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Computes the mean of the elements of an array along the given axis */
+array mean(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Computes the mean of the elements of an array. */
+array var(const array& a, bool keepdims, int ddof = 0, StreamOrDevice s = {});
+inline array var(const array& a, StreamOrDevice s = {}) {
+  return var(a, false, 0, to_stream(s));
+}
+
+/** Computes the var of the elements of an array along the given axes */
+array var(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    int ddof = 0,
+    StreamOrDevice s = {});
+
+/** Computes the var of the elements of an array along the given axis */
+array var(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    int ddof = 0,
+    StreamOrDevice s = {});
+
+/** The product of all elements of the array. */
+array prod(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array prod(const array& a, StreamOrDevice s = {}) {
+  return prod(a, false, to_stream(s));
+}
+
+/** The product of the elements of an array along the given axes. */
+array prod(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The product of the elements of an array along the given axis. */
+array prod(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The maximum of all elements of the array. */
+array max(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array max(const array& a, StreamOrDevice s = {}) {
+  return max(a, false, to_stream(s));
+}
+
+/** The maximum of the elements of an array along the given axes. */
+array max(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The maximum of the elements of an array along the given axis. */
+array max(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The minimum of all elements of the array. */
+array min(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array min(const array& a, StreamOrDevice s = {}) {
+  return min(a, false, to_stream(s));
+}
+
+/** The minimum of the elements of an array along the given axes. */
+array min(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The minimum of the elements of an array along the given axis. */
+array min(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Returns the index of the minimum value in the array. */
+array argmin(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array argmin(const array& a, StreamOrDevice s = {}) {
+  return argmin(a, false, s);
+}
+
+/** Returns the indices of the minimum values along a given axis. */
+array argmin(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Returns the index of the maximum value in the array. */
+array argmax(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array argmax(const array& a, StreamOrDevice s = {}) {
+  return argmax(a, false, s);
+}
+
+/** Returns the indices of the maximum values along a given axis. */
+array argmax(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Returns a sorted copy of the flattened array. */
+array sort(const array& a, StreamOrDevice s = {});
+
+/** Returns a sorted copy of the array along a given axis. */
+array sort(const array& a, int axis, StreamOrDevice s = {});
+
+/** Returns indices that sort the flattened array. */
+array argsort(const array& a, StreamOrDevice s = {});
+
+/** Returns indices that sort the array along a given axis. */
+array argsort(const array& a, int axis, StreamOrDevice s = {});
+
+/**
+ * Returns a partitioned copy of the flattened array
+ * such that the smaller kth elements are first.
+ **/
+array partition(const array& a, int kth, StreamOrDevice s = {});
+
+/**
+ * Returns a partitioned copy of the array along a given axis
+ * such that the smaller kth elements are first.
+ **/
+array partition(const array& a, int kth, int axis, StreamOrDevice s = {});
+
+/**
+ * Returns indices that partition the flattened array
+ * such that the smaller kth elements are first.
+ **/
+array argpartition(const array& a, int kth, StreamOrDevice s = {});
+
+/**
+ * Returns indices that partition the array along a given axis
+ * such that the smaller kth elements are first.
+ **/
+array argpartition(const array& a, int kth, int axis, StreamOrDevice s = {});
+
+/** Returns topk elements of the flattened array. */
+array topk(const array& a, int k, StreamOrDevice s = {});
+
+/** Returns topk elements of the array along a given axis. */
+array topk(const array& a, int k, int axis, StreamOrDevice s = {});
+
+/** The logsumexp of all elements of the array. */
+array logsumexp(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array logsumexp(const array& a, StreamOrDevice s = {}) {
+  return logsumexp(a, false, to_stream(s));
+}
+
+/** The logsumexp of the elements of an array along the given axes. */
+array logsumexp(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The logsumexp of the elements of an array along the given axis. */
+array logsumexp(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Simple arithmetic operations */
+
+/** Absolute value of elements in an array. */
+array abs(const array& a, StreamOrDevice s = {});
+
+/** Negate an array. */
+array negative(const array& a, StreamOrDevice s = {});
+array operator-(const array& a);
+
+/** The sign of the elements in an array. */
+array sign(const array& a, StreamOrDevice s = {});
+
+/** Logical not of an array */
+array logical_not(const array& a, StreamOrDevice s = {});
+
+/** The reciprocal (1/x) of the elements in an array. */
+array reciprocal(const array& a, StreamOrDevice s = {});
+
+/** Add two arrays. */
+array add(const array& a, const array& b, StreamOrDevice s = {});
+array operator+(const array& a, const array& b);
+template <typename T>
+array operator+(T a, const array& b) {
+  return add(array(a), b);
+}
+template <typename T>
+array operator+(const array& a, T b) {
+  return add(a, array(b));
+}
+
+/** Subtract two arrays. */
+array subtract(const array& a, const array& b, StreamOrDevice s = {});
+array operator-(const array& a, const array& b);
+template <typename T>
+array operator-(T a, const array& b) {
+  return subtract(array(a), b);
+}
+template <typename T>
+array operator-(const array& a, T b) {
+  return subtract(a, array(b));
+}
+
+/** Multiply two arrays. */
+array multiply(const array& a, const array& b, StreamOrDevice s = {});
+array operator*(const array& a, const array& b);
+template <typename T>
+array operator*(T a, const array& b) {
+  return multiply(array(a), b);
+}
+template <typename T>
+array operator*(const array& a, T b) {
+  return multiply(a, array(b));
+}
+
+/** Divide two arrays. */
+array divide(const array& a, const array& b, StreamOrDevice s = {});
+array operator/(const array& a, const array& b);
+array operator/(double a, const array& b);
+array operator/(const array& a, double b);
+
+/** Compute integer division. Equivalent to doing floor(a / x). */
+array floor_divide(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Compute the element-wise remainder of division */
+array remainder(const array& a, const array& b, StreamOrDevice s = {});
+array operator%(const array& a, const array& b);
+template <typename T>
+array operator%(T a, const array& b) {
+  return remainder(array(a), b);
+}
+template <typename T>
+array operator%(const array& a, T b) {
+  return remainder(a, array(b));
+}
+
+/** Element-wise maximum between two arrays. */
+array maximum(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Element-wise minimum between two arrays. */
+array minimum(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Floor the element of an array. **/
+array floor(const array& a, StreamOrDevice s = {});
+
+/** Ceil the element of an array. **/
+array ceil(const array& a, StreamOrDevice s = {});
+
+/** Square the elements of an array. */
+array square(const array& a, StreamOrDevice s = {});
+
+/** Exponential of the elements of an array. */
+array exp(const array& a, StreamOrDevice s = {});
+
+/** Sine of the elements of an array */
+array sin(const array& a, StreamOrDevice s = {});
+
+/** Cosine of the elements of an array */
+array cos(const array& a, StreamOrDevice s = {});
+
+/** Tangent of the elements of an array */
+array tan(const array& a, StreamOrDevice s = {});
+
+/** Arc Sine of the elements of an array */
+array arcsin(const array& a, StreamOrDevice s = {});
+
+/** Arc Cosine of the elements of an array */
+array arccos(const array& a, StreamOrDevice s = {});
+
+/** Arc Tangent of the elements of an array */
+array arctan(const array& a, StreamOrDevice s = {});
+
+/** Hyperbolic Sine of the elements of an array */
+array sinh(const array& a, StreamOrDevice s = {});
+
+/** Hyperbolic Cosine of the elements of an array */
+array cosh(const array& a, StreamOrDevice s = {});
+
+/** Hyperbolic Tangent of the elements of an array */
+array tanh(const array& a, StreamOrDevice s = {});
+
+/** Inverse Hyperbolic Sine of the elements of an array */
+array arcsinh(const array& a, StreamOrDevice s = {});
+
+/** Inverse Hyperbolic Cosine of the elements of an array */
+array arccosh(const array& a, StreamOrDevice s = {});
+
+/** Inverse Hyperbolic Tangent of the elements of an array */
+array arctanh(const array& a, StreamOrDevice s = {});
+
+/** Natural logarithm of the elements of an array. */
+array log(const array& a, StreamOrDevice s = {});
+
+/** Log base 2 of the elements of an array. */
+array log2(const array& a, StreamOrDevice s = {});
+
+/** Log base 10 of the elements of an array. */
+array log10(const array& a, StreamOrDevice s = {});
+
+/** Natural logarithm of one plus elements in the array: `log(1 + a)`. */
+array log1p(const array& a, StreamOrDevice s = {});
+
+/** Log-add-exp of one elements in the array: `log(exp(a) + exp(b))`. */
+array logaddexp(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Element-wise logistic sigmoid of the array: `1 / (1 + exp(-x)`. */
+array sigmoid(const array& a, StreamOrDevice s = {});
+
+/** Computes the error function of the elements of an array. */
+array erf(const array& a, StreamOrDevice s = {});
+
+/** Computes the inverse error function of the elements of an array. */
+array erfinv(const array& a, StreamOrDevice s = {});
+
+/** Stop the flow of gradients. */
+array stop_gradient(const array& a, StreamOrDevice s = {});
+
+/** Round a floating point number */
+array round(const array& a, int decimals, StreamOrDevice s = {});
+inline array round(const array& a, StreamOrDevice s = {}) {
+  return round(a, 0, s);
+}
+
+/** Matrix-matrix multiplication. */
+array matmul(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Gather array entries given indices and slices */
+array gather(
+    const array& a,
+    const std::vector<array>& indices,
+    const std::vector<int>& axes,
+    const std::vector<int>& slice_sizes,
+    StreamOrDevice s = {});
+inline array gather(
+    const array& a,
+    const array& indices,
+    int axis,
+    const std::vector<int>& slice_sizes,
+    StreamOrDevice s = {}) {
+  return gather(a, {indices}, std::vector<int>{axis}, slice_sizes, s);
+}
+
+/** Take array slices at the given indices of the specified axis. */
+array take(
+    const array& a,
+    const array& indices,
+    int axis,
+    StreamOrDevice s = {});
+
+/** Take array entries at the given indices treating the array as flattened. */
+array take(const array& a, const array& indices, StreamOrDevice s = {});
+
+/** Take array entries given indices along the axis */
+array take_along_axis(
+    const array& a,
+    const array& indices,
+    int axis,
+    StreamOrDevice s = {});
+
+/** Scatter updates to given linear indices */
+array scatter(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Scatter and add updates to given indices */
+array scatter_add(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_add(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_add(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Scatter and prod updates to given indices */
+array scatter_prod(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_prod(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_prod(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Scatter and max updates to given linear indices */
+array scatter_max(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_max(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_max(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+/** Scatter and min updates to given linear indices */
+array scatter_min(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_min(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_min(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Square root the elements of an array. */
+array sqrt(const array& a, StreamOrDevice s = {});
+
+/** Square root and reciprocal the elements of an array. */
+array rsqrt(const array& a, StreamOrDevice s = {});
+
+/** Softmax of an array. */
+array softmax(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+/** Softmax of an array. */
+array softmax(const array& a, StreamOrDevice s = {});
+
+/** Softmax of an array. */
+inline array softmax(const array& a, int axis, StreamOrDevice s = {}) {
+  return softmax(a, std::vector<int>{axis}, s);
+}
+
+/** Raise elements of a to the power of b element-wise */
+array power(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator^(const array& a, const array& b) {
+  return power(a, b);
+}
+template <typename T>
+array operator^(T a, const array& b) {
+  return power(array(a), b);
+}
+template <typename T>
+array operator^(const array& a, T b) {
+  return power(a, array(b));
+}
+
+/** Cumulative sum of an array. */
+array cumsum(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** Cumulative product of an array. */
+array cumprod(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** Cumulative max of an array. */
+array cummax(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** Cumulative min of an array. */
+array cummin(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** Convolution operations */
+
+/** 1D convolution with a filter */
+array conv1d(
+    const array& input,
+    const array& weight,
+    int stride = 1,
+    int padding = 0,
+    int dilation = 1,
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** 2D convolution with a filter */
+array conv2d(
+    const array& input,
+    const array& weight,
+    const std::pair<int, int>& stride = {1, 1},
+    const std::pair<int, int>& padding = {0, 0},
+    const std::pair<int, int>& dilation = {1, 1},
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** Serialization operations */
+
+/** Save array to out stream in .npy format */
+void save(
+    std::shared_ptr<io::Writer> out_stream,
+    array a,
+    bool retain_graph = true);
+
+/** Save array to file in .npy format */
+void save(const std::string& file, array a, bool retain_graph = true);
+
+/** Load array from reader in .npy format */
+array load(std::shared_ptr<io::Reader> in_stream, StreamOrDevice s = {});
+
+/** Load array from file in .npy format */
+array load(const std::string& file, StreamOrDevice s = {});
+
+/** Quantized matmul multiplies x with a quantized matrix w*/
+array quantized_matmul(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const array& biases,
+    bool transpose = true,
+    int group_size = 64,
+    int bits = 4,
+    StreamOrDevice s = {});
+
+/** Quantize a matrix along its last axis */
+std::tuple<array, array, array> quantize(
+    const array& w,
+    int group_size = 64,
+    int bits = 4,
+    StreamOrDevice s = {});
+
+/** Dequantize a matrix produced by quantize() */
+array dequantize(
+    const array& w,
+    const array& scales,
+    const array& biases,
+    int group_size = 64,
+    int bits = 4,
+    StreamOrDevice s = {});
+
+/** TensorDot returns a contraction of a and b over multiple dimensions. */
+array tensordot(
+    const array& a,
+    const array& b,
+    const int dims = 2,
+    StreamOrDevice s = {});
+
+array tensordot(
+    const array& a,
+    const array& b,
+    const std::pair<std::vector<int>, std::vector<int>>& dims,
+    StreamOrDevice s = {});
+
+/** Load array map from .safetensors file format */
+std::unordered_map<std::string, array> load_safetensors(
+    std::shared_ptr<io::Reader> in_stream,
+    StreamOrDevice s = {});
+std::unordered_map<std::string, array> load_safetensors(
+    const std::string& file,
+    StreamOrDevice s = {});
+
+void save_safetensors(
+    std::shared_ptr<io::Writer> in_stream,
+    std::unordered_map<std::string, array>,
+    std::optional<bool> retain_graph = std::nullopt);
+void save_safetensors(
+    const std::string& file,
+    std::unordered_map<std::string, array>,
+    std::optional<bool> retain_graph = std::nullopt);
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/primitives.h b/lib/python3.11/site-packages/mlx/include/mlx/primitives.h
new file mode 100644
index 0000000000000000000000000000000000000000..e87e934ab4cbea12936ed788b6723bc8d0f6268a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/primitives.h
@@ -0,0 +1,1636 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "array.h"
+#include "device.h"
+#include "io/load.h"
+#include "stream.h"
+
+#define DEFINE_GRADS()                           \
+  array jvp(                                     \
+      const std::vector<array>& primals,         \
+      const std::vector<array>& tangents,        \
+      const std::vector<int>& argnums) override; \
+                                                 \
+  std::vector<array> vjp(                        \
+      const std::vector<array>& primals,         \
+      const array& cotan,                        \
+      const std::vector<int>& argnums) override;
+
+#define DEFINE_PRINT(PRIMITIVE)           \
+  void print(std::ostream& os) override { \
+    os << #PRIMITIVE;                     \
+  }
+
+#define DEFINE_DEFAULT_IS_EQUIVALENT()                        \
+  bool is_equivalent(const Primitive& other) const override { \
+    return true;                                              \
+  }
+
+namespace mlx::core {
+
+// Abstract base class
+class Primitive {
+ public:
+  explicit Primitive(Stream stream) : stream_(stream) {}
+
+  /** The device the primitive will run on. */
+  const Device& device() {
+    return stream().device;
+  }
+
+  /** The stream the primitive will run on. */
+  const Stream& stream() {
+    return stream_;
+  }
+
+  /**
+   * A primitive must know how to evaluate itself on
+   * the CPU/GPU for the given inputs and populate the output array.
+   *
+   * To avoid unnecessary allocations, the evaluation function
+   * is responsible for allocating space for the array.
+   */
+  virtual void eval_cpu(const std::vector<array>& inputs, array& out) = 0;
+  virtual void eval_gpu(const std::vector<array>& inputs, array& out) = 0;
+
+  /**
+   * The Jacobian-vector product.
+   */
+  virtual array jvp(
+      const std::vector<array>& primals,
+      const std::vector<array>& tangents,
+      const std::vector<int>& argnums);
+
+  /**
+   * The vector-Jacobian product.
+   */
+  virtual std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const array& cotan,
+      const std::vector<int>& argnums);
+
+  /**
+   * The primitive must know how to vectorize itself across
+   * the given axes. The output is a pair containing the array
+   * representing the vectorized computation and the axis which
+   * corresponds to the output vectorized dimension.
+   */
+  virtual std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes);
+
+  /** Print the primitive. */
+  virtual void print(std::ostream& os) = 0;
+
+  /** Equivalence check defaults to false unless overridden by the primitive */
+  virtual bool is_equivalent(const Primitive& other) const {
+    return false;
+  }
+
+  virtual ~Primitive() = default;
+  Primitive(const Primitive& other) = delete;
+  Primitive(Primitive&& other) = delete;
+  Primitive& operator=(const Primitive& other) = delete;
+  Primitive& operator=(Primitive&& other) = delete;
+
+ private:
+  // Every primitive stores the stream it should run in
+  Stream stream_;
+};
+
+class Abs : public Primitive {
+ public:
+  explicit Abs(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Abs)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Add : public Primitive {
+ public:
+  explicit Add(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Add)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Arange : public Primitive {
+ public:
+  explicit Arange(Stream stream, double start, double stop, double step)
+      : Primitive(stream), start_(start), stop_(stop), step_(step){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_PRINT(Arange)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  double start_;
+  double stop_;
+  double step_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArcCos : public Primitive {
+ public:
+  explicit ArcCos(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(ArcCos)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArcCosh : public Primitive {
+ public:
+  explicit ArcCosh(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(ArcCosh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArcSin : public Primitive {
+ public:
+  explicit ArcSin(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(ArcSin)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArcSinh : public Primitive {
+ public:
+  explicit ArcSinh(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(ArcSinh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArcTan : public Primitive {
+ public:
+  explicit ArcTan(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(ArcTan)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArcTanh : public Primitive {
+ public:
+  explicit ArcTanh(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(ArcTanh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArgPartition : public Primitive {
+ public:
+  explicit ArgPartition(Stream stream, int kth, int axis)
+      : Primitive(stream), kth_(kth), axis_(axis){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_PRINT(ArgPartition)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  int kth_;
+  int axis_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArgReduce : public Primitive {
+ public:
+  enum ReduceType {
+    ArgMin,
+    ArgMax,
+  };
+
+  explicit ArgReduce(Stream stream, ReduceType reduce_type, int axis)
+      : Primitive(stream), reduce_type_(reduce_type), axis_(axis){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_PRINT(ArgReduce)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  ReduceType reduce_type_;
+  int axis_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ArgSort : public Primitive {
+ public:
+  explicit ArgSort(Stream stream, int axis) : Primitive(stream), axis_(axis){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_PRINT(ArgSort)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  int axis_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class AsType : public Primitive {
+ public:
+  explicit AsType(Stream stream, Dtype dtype)
+      : Primitive(stream), dtype_(dtype){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(AsType)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  Dtype dtype_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class AsStrided : public Primitive {
+ public:
+  explicit AsStrided(
+      Stream stream,
+      const std::vector<int>& shape,
+      const std::vector<size_t>& strides,
+      size_t offset)
+      : Primitive(stream), shape_(shape), strides_(strides), offset_(offset){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(AsStrided)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> shape_;
+  std::vector<size_t> strides_;
+  size_t offset_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Broadcast : public Primitive {
+ public:
+  explicit Broadcast(Stream stream, const std::vector<int>& shape)
+      : Primitive(stream), shape_(shape){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Broadcast)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> shape_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Ceil : public Primitive {
+ public:
+  explicit Ceil(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Ceil)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Concatenate : public Primitive {
+ public:
+  explicit Concatenate(Stream stream, int axis)
+      : Primitive(stream), axis_(axis){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Concatenate)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  int axis_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Convolution : public Primitive {
+ public:
+  explicit Convolution(
+      Stream stream,
+      const std::vector<int>& padding,
+      const std::vector<int>& kernel_strides,
+      const std::vector<int>& kernel_dilation,
+      const std::vector<int>& input_dilation)
+      : Primitive(stream),
+        padding_(padding),
+        kernel_strides_(kernel_strides),
+        kernel_dilation_(kernel_dilation),
+        input_dilation_(input_dilation){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const array& cotan,
+      const std::vector<int>& argnums) override;
+
+  DEFINE_PRINT(Convolution)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> padding_;
+  std::vector<int> kernel_strides_;
+  std::vector<int> kernel_dilation_;
+  std::vector<int> input_dilation_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Copy : public Primitive {
+ public:
+  explicit Copy(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Copy)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Cos : public Primitive {
+ public:
+  explicit Cos(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Cos)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Cosh : public Primitive {
+ public:
+  explicit Cosh(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Cosh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Divide : public Primitive {
+ public:
+  explicit Divide(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Divide)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Remainder : public Primitive {
+ public:
+  explicit Remainder(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Remainder)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Equal : public Primitive {
+ public:
+  explicit Equal(Stream stream, bool equal_nan = false)
+      : Primitive(stream), equal_nan_(equal_nan){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Equal)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  bool equal_nan_;
+};
+
+class Erf : public Primitive {
+ public:
+  explicit Erf(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Erf)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class ErfInv : public Primitive {
+ public:
+  explicit ErfInv(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(ErfInv)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Exp : public Primitive {
+ public:
+  explicit Exp(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Exp)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class FFT : public Primitive {
+ public:
+  explicit FFT(
+      Stream stream,
+      const std::vector<size_t>& axes,
+      bool inverse,
+      bool real)
+      : Primitive(stream), axes_(axes), inverse_(inverse), real_(real){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(FFT)
+
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<size_t> axes_;
+  bool inverse_;
+  bool real_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Floor : public Primitive {
+ public:
+  explicit Floor(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Floor)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Full : public Primitive {
+ public:
+  explicit Full(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Full)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Gather : public Primitive {
+ public:
+  explicit Gather(
+      Stream stream,
+      const std::vector<int>& axes,
+      const std::vector<int>& slice_sizes)
+      : Primitive(stream), axes_(axes), slice_sizes_(slice_sizes){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Gather)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  std::vector<int> axes_;
+  std::vector<int> slice_sizes_;
+};
+
+class Greater : public Primitive {
+ public:
+  explicit Greater(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Greater)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class GreaterEqual : public Primitive {
+ public:
+  explicit GreaterEqual(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(GreaterEqual)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Less : public Primitive {
+ public:
+  explicit Less(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Less)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class LessEqual : public Primitive {
+ public:
+  explicit LessEqual(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(LessEqual)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Load : public Primitive {
+ public:
+  explicit Load(
+      Stream stream,
+      std::shared_ptr<io::Reader> reader,
+      size_t offset,
+      bool swap_endianness = false)
+      : Primitive(stream),
+        reader_(reader),
+        offset_(offset),
+        swap_endianness_(swap_endianness){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_PRINT(Load)
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  std::shared_ptr<io::Reader> reader_;
+  size_t offset_;
+  bool swap_endianness_;
+};
+
+class Log : public Primitive {
+ public:
+  enum Base { two, ten, e };
+
+  explicit Log(Stream stream, Base base) : Primitive(stream), base_(base){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Log)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  Base base_;
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Log1p : public Primitive {
+ public:
+  explicit Log1p(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Log1p)
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class LogicalNot : public Primitive {
+ public:
+  explicit LogicalNot(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(LogicalNot)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class LogAddExp : public Primitive {
+ public:
+  explicit LogAddExp(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(LogAddExp)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Matmul : public Primitive {
+ public:
+  explicit Matmul(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const array& cotan,
+      const std::vector<int>& argnums) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_PRINT(Matmul)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+};
+
+class Maximum : public Primitive {
+ public:
+  explicit Maximum(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Maximum)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Minimum : public Primitive {
+ public:
+  explicit Minimum(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Minimum)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Multiply : public Primitive {
+ public:
+  explicit Multiply(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Multiply)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Negative : public Primitive {
+ public:
+  explicit Negative(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Negative)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class NotEqual : public Primitive {
+ public:
+  explicit NotEqual(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(NotEqual)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Pad : public Primitive {
+ public:
+  explicit Pad(
+      Stream stream,
+      const std::vector<int>& axes,
+      const std::vector<int>& low_pad_size,
+      const std::vector<int>& high_pad_size)
+      : Primitive(stream),
+        axes_(axes),
+        low_pad_size_(low_pad_size),
+        high_pad_size_(high_pad_size){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Pad)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> axes_;
+  std::vector<int> low_pad_size_;
+  std::vector<int> high_pad_size_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Partition : public Primitive {
+ public:
+  explicit Partition(Stream stream, int kth, int axis)
+      : Primitive(stream), kth_(kth), axis_(axis){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Partition)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  int kth_;
+  int axis_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Power : public Primitive {
+ public:
+  explicit Power(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Power)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class QuantizedMatmul : public Primitive {
+ public:
+  explicit QuantizedMatmul(
+      Stream stream,
+      int group_size,
+      int bits,
+      bool transpose)
+      : Primitive(stream),
+        group_size_(group_size),
+        bits_(bits),
+        transpose_(transpose){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(QuantizedMatmul)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  int group_size_;
+  int bits_;
+  bool transpose_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class RandomBits : public Primitive {
+ public:
+  explicit RandomBits(Stream stream, const std::vector<int>& shape, int width)
+      : Primitive(stream), shape_(shape), width_(width){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_PRINT(RandomBits)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> shape_;
+  int width_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Reshape : public Primitive {
+ public:
+  explicit Reshape(Stream stream, const std::vector<int>& shape)
+      : Primitive(stream), shape_(shape){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Reshape)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> shape_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Reduce : public Primitive {
+ public:
+  enum ReduceType { And, Or, Sum, Prod, Min, Max };
+
+  explicit Reduce(
+      Stream stream,
+      ReduceType reduce_type,
+      const std::vector<int>& axes)
+      : Primitive(stream), reduce_type_(reduce_type), axes_(axes){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const array& cotan,
+      const std::vector<int>& argnums) override;
+
+  void print(std::ostream& os) override {
+    switch (reduce_type_) {
+      case And:
+        os << "And";
+      case Or:
+        os << "And";
+        break;
+      case Sum:
+        os << "Sum";
+        break;
+      case Prod:
+        os << "Prod";
+        break;
+      case Min:
+        os << "Min";
+        break;
+      case Max:
+        os << "Max";
+        break;
+    }
+    os << " Reduce";
+  }
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  ReduceType reduce_type_;
+  std::vector<int> axes_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Round : public Primitive {
+ public:
+  explicit Round(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Round)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Scan : public Primitive {
+ public:
+  enum ReduceType { Max, Min, Sum, Prod };
+
+  explicit Scan(
+      Stream stream,
+      ReduceType reduce_type,
+      int axis,
+      bool reverse,
+      bool inclusive)
+      : Primitive(stream),
+        reduce_type_(reduce_type),
+        axis_(axis),
+        reverse_(reverse),
+        inclusive_(inclusive){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS();
+  void print(std::ostream& os) override {
+    os << "Cum";
+    switch (reduce_type_) {
+      case Sum:
+        os << "Sum";
+        break;
+      case Prod:
+        os << "Prod";
+        break;
+      case Min:
+        os << "Min";
+        break;
+      case Max:
+        os << "Max";
+        break;
+    }
+    os << " Reduce";
+  }
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  ReduceType reduce_type_;
+  int axis_;
+  bool reverse_;
+  bool inclusive_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Scatter : public Primitive {
+ public:
+  enum ReduceType { Max, Min, Sum, Prod, None };
+
+  explicit Scatter(
+      Stream stream,
+      ReduceType reduce_type,
+      const std::vector<int>& axes)
+      : Primitive(stream), reduce_type_(reduce_type), axes_(axes){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_PRINT(Scatter)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  ReduceType reduce_type_;
+  std::vector<int> axes_;
+};
+
+class Sigmoid : public Primitive {
+ public:
+  explicit Sigmoid(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Sigmoid)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Sign : public Primitive {
+ public:
+  explicit Sign(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Sign)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Sin : public Primitive {
+ public:
+  explicit Sin(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Sin)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Sinh : public Primitive {
+ public:
+  explicit Sinh(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Sinh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Slice : public Primitive {
+ public:
+  explicit Slice(
+      Stream stream,
+      const std::vector<int>& start_indices,
+      const std::vector<int>& end_indices,
+      const std::vector<int>& strides)
+      : Primitive(stream),
+        start_indices_(start_indices),
+        end_indices_(end_indices),
+        strides_(strides){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Slice)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> start_indices_;
+  std::vector<int> end_indices_;
+  std::vector<int> strides_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Softmax : public Primitive {
+ public:
+  explicit Softmax(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Softmax)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Sort : public Primitive {
+ public:
+  explicit Sort(Stream stream, int axis) : Primitive(stream), axis_(axis){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Sort)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  int axis_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Square : public Primitive {
+ public:
+  explicit Square(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Square)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Sqrt : public Primitive {
+ public:
+  explicit Sqrt(Stream stream, bool recip = false)
+      : Primitive(stream), recip_(recip){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Sqrt)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  bool recip_;
+};
+
+class StopGradient : public Primitive {
+ public:
+  explicit StopGradient(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_PRINT(StopGradient)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Subtract : public Primitive {
+ public:
+  explicit Subtract(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Subtract)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Tan : public Primitive {
+ public:
+  explicit Tan(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Tan)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Tanh : public Primitive {
+ public:
+  explicit Tanh(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Tanh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Uniform : public Primitive {
+ public:
+  explicit Uniform(Stream stream) : Primitive(stream){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_PRINT(Uniform)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Transpose : public Primitive {
+ public:
+  explicit Transpose(Stream stream, const std::vector<int>& axes)
+      : Primitive(stream), axes_(axes){};
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::pair<array, int> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_GRADS()
+  DEFINE_PRINT(Transpose)
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  std::vector<int> axes_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/random.h b/lib/python3.11/site-packages/mlx/include/mlx/random.h
new file mode 100644
index 0000000000000000000000000000000000000000..360bdbdb11d8e5fa65f9966edea91e5e07b61d24
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/random.h
@@ -0,0 +1,193 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <optional>
+
+#include "mlx/array.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::random {
+
+class KeySequence {
+ public:
+  explicit KeySequence(uint64_t seed);
+
+  void seed(uint64_t seed);
+  array next();
+
+  // static default
+  static KeySequence& default_() {
+    static KeySequence ks(0);
+    return ks;
+  }
+
+ private:
+  array key_;
+};
+
+/** Get a PRNG key from a seed. */
+array key(uint64_t seed);
+
+/** Seed the default PRNG key. */
+void seed(uint64_t seed);
+
+/** Generate an array with type uint32 filled with random bits. */
+array bits(
+    const std::vector<int>& shape,
+    int width,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+inline array bits(
+    const std::vector<int>& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return bits(shape, 4, key, s);
+}
+
+/** Split the rng key into a pair of keys. */
+std::pair<array, array> split(const array& key, StreamOrDevice s = {});
+
+/** Split the rng key into `num` keys. */
+array split(const array& key, int num, StreamOrDevice s = {});
+
+/** Generate uniform random numbers between low and high. */
+array uniform(
+    const array& low,
+    const array& high,
+    const std::vector<int>& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+template <typename T, typename U>
+array uniform(
+    T low,
+    U high,
+    const std::vector<int>& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return uniform(array(low), array(high), shape, dtype, key, to_stream(s));
+}
+
+/** Generate uniform random numbers between 0 and 1. */
+array uniform(
+    const std::vector<int>& shape,
+    Dtype dtype,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+inline array uniform(
+    const std::vector<int>& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return uniform(shape, float32, key);
+}
+
+/** Generate samples from the standard normal distribution. */
+array normal(
+    const std::vector<int>& shape,
+    Dtype dtype,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+inline array normal(
+    const std::vector<int>& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return normal(shape, float32, key, s);
+}
+
+/** Generate integer samples uniformly at random */
+array randint(
+    const array& low,
+    const array& high,
+    const std::vector<int>& shape,
+    Dtype dtype = int32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+template <typename T, typename U>
+array randint(
+    T low,
+    U high,
+    const std::vector<int>& shape,
+    Dtype dtype = int32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return randint(array(low), array(high), shape, dtype, key, to_stream(s));
+};
+
+/** Generate binary variables with probability to be true equal to p */
+array bernoulli(
+    const array& p,
+    const std::vector<int>& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+array bernoulli(
+    const array& p,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+template <typename T>
+array bernoulli(
+    T p,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return bernoulli(array(p), key, s);
+};
+
+template <typename T>
+array bernoulli(
+    T p,
+    const std::vector<int>& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return bernoulli(array(p), shape, key, s);
+};
+
+array bernoulli(
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array truncated_normal(
+    const array& lower,
+    const array& upper,
+    const std::vector<int>& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array truncated_normal(
+    const array& lower,
+    const array& upper,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array gumbel(
+    const std::vector<int>& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array categorical(
+    const array& logits,
+    int axis,
+    const std::vector<int>& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array categorical(
+    const array& logits_,
+    int axis,
+    int num_samples,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array categorical(
+    const array& logits,
+    int axis = -1,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+} // namespace mlx::core::random
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/scheduler.h b/lib/python3.11/site-packages/mlx/include/mlx/scheduler.h
new file mode 100644
index 0000000000000000000000000000000000000000..150cc96dbe6def42d2f6c3b6fe851c19cdbb7dbc
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/scheduler.h
@@ -0,0 +1,173 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <atomic>
+#include <future>
+#include <queue>
+#include <thread>
+#include <unordered_map>
+
+#include "mlx/backend/metal/metal.h"
+#include "mlx/device.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::scheduler {
+
+struct StreamThread {
+  std::mutex mtx;
+  std::queue<std::function<void()>> q;
+  std::condition_variable cond;
+  bool stop;
+  Stream stream;
+  std::thread thread;
+
+  StreamThread(Stream stream)
+      : stop(false), stream(stream), thread(&StreamThread::thread_fn, this) {}
+
+  ~StreamThread() {
+    {
+      std::unique_lock<std::mutex> lk(mtx);
+      stop = true;
+    }
+    cond.notify_one();
+    thread.join();
+  }
+
+  void thread_fn() {
+    auto thread_pool = metal::new_scoped_memory_pool();
+    metal::new_stream(stream);
+    while (true) {
+      std::function<void()> task;
+      {
+        std::unique_lock<std::mutex> lk(mtx);
+        cond.wait(lk, [this] { return !this->q.empty() || this->stop; });
+        if (q.empty() && stop) {
+          return;
+        }
+        task = std::move(q.front());
+        q.pop();
+      }
+      task();
+    }
+  }
+
+  template <typename F>
+  void enqueue(F&& f) {
+    {
+      std::unique_lock<std::mutex> lk(mtx);
+      if (stop) {
+        throw std::runtime_error(
+            "Cannot enqueue work after stream is stopped.");
+      }
+      q.emplace(std::forward<F>(f));
+    }
+    cond.notify_one();
+  }
+};
+
+class Scheduler {
+ public:
+  Scheduler() : n_active_tasks_(0) {
+    if (metal::is_available()) {
+      default_streams_.insert({Device::gpu, new_stream(Device::gpu)});
+    }
+    default_streams_.insert({Device::cpu, new_stream(Device::cpu)});
+  }
+
+  // Not copyable or moveable
+  Scheduler(const Scheduler&) = delete;
+  Scheduler(Scheduler&&) = delete;
+  Scheduler& operator=(const Scheduler&) = delete;
+  Scheduler& operator=(Scheduler&&) = delete;
+
+  Stream new_stream(const Device& d) {
+    auto stream = Stream(streams_.size(), d);
+    streams_.push_back(new StreamThread{stream});
+    return stream;
+  }
+
+  template <typename F>
+  void enqueue(const Stream& stream, F&& f);
+
+  Stream get_default_stream(const Device& d) {
+    return default_streams_.at(d.type);
+  }
+
+  void set_default_stream(const Stream& s) {
+    default_streams_.at(s.device.type) = s;
+  }
+
+  void notify_new_task(const Stream& stream) {
+    {
+      std::unique_lock<std::mutex> lk(mtx);
+      n_active_tasks_++;
+    }
+    completion_cv.notify_all();
+  }
+
+  void notify_task_completion(const Stream& stream) {
+    {
+      std::unique_lock<std::mutex> lk(mtx);
+      n_active_tasks_--;
+    }
+    completion_cv.notify_all();
+  }
+
+  int n_active_tasks() const {
+    return n_active_tasks_;
+  }
+
+  void wait_for_one() {
+    std::unique_lock<std::mutex> lk(mtx);
+    int n_tasks_old = n_active_tasks();
+    if (n_tasks_old > 1) {
+      completion_cv.wait(lk, [this, n_tasks_old] {
+        return this->n_active_tasks() != n_tasks_old;
+      });
+    }
+  }
+
+  ~Scheduler() {
+    for (auto s : streams_) {
+      delete s;
+    }
+  }
+
+ private:
+  int n_active_tasks_;
+  std::vector<StreamThread*> streams_;
+  std::unordered_map<Device::DeviceType, Stream> default_streams_;
+  std::condition_variable completion_cv;
+  std::mutex mtx;
+};
+
+template <typename F>
+void Scheduler::enqueue(const Stream& stream, F&& f) {
+  streams_[stream.index]->enqueue(std::forward<F>(f));
+}
+
+Scheduler& scheduler();
+
+template <typename F>
+void enqueue(const Stream& stream, F&& f) {
+  scheduler().enqueue(stream, std::forward<F>(f));
+}
+
+inline int n_active_tasks() {
+  return scheduler().n_active_tasks();
+}
+
+inline void notify_new_task(const Stream& stream) {
+  scheduler().notify_new_task(stream);
+}
+
+inline void notify_task_completion(const Stream& stream) {
+  scheduler().notify_task_completion(stream);
+}
+
+inline void wait_for_one() {
+  scheduler().wait_for_one();
+}
+
+} // namespace mlx::core::scheduler
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/stream.h b/lib/python3.11/site-packages/mlx/include/mlx/stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..d7b4268fd0a203685b7e080b20277716c28fb088
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/stream.h
@@ -0,0 +1,32 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/device.h"
+
+namespace mlx::core {
+
+struct Stream {
+  int index;
+  Device device;
+  explicit Stream(int index, Device device) : index(index), device(device) {}
+};
+
+/** Get the default stream for the given device. */
+Stream default_stream(Device d);
+
+/** Make the stream the default for its device. */
+void set_default_stream(Stream s);
+
+/** Make a new stream on the given device. */
+Stream new_stream(Device d);
+
+inline bool operator==(const Stream& lhs, const Stream& rhs) {
+  return lhs.index == rhs.index;
+}
+
+inline bool operator!=(const Stream& lhs, const Stream& rhs) {
+  return !(lhs == rhs);
+}
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/transforms.h b/lib/python3.11/site-packages/mlx/include/mlx/transforms.h
new file mode 100644
index 0000000000000000000000000000000000000000..caf648163aef9e2da3b0f1cac14dd95f28841bcc
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/transforms.h
@@ -0,0 +1,187 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "array.h"
+
+namespace mlx::core {
+
+/** Fuse equivalent arrays to avoid duplicate execution. */
+void simplify(const std::vector<array>& outputs);
+
+template <typename... Arrays>
+void simplify(Arrays... outputs) {
+  simplify(std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+void eval(const std::vector<array>& outputs, bool retain_graph = false);
+
+template <typename... Arrays>
+void eval(Arrays... outputs) {
+  eval(std::vector<array>{std::forward<Arrays>(outputs)...}, false);
+}
+
+/**
+ *  Computes the output and vector-Jacobian product (VJP) of a function.
+ *
+ *  Computes the vector-Jacobian product of the vector of cotangents with the
+ *  Jacobian of the function evaluated at the primals. Returns a pair of
+ *  vectors of output arrays and VJP arrays.
+ **/
+std::pair<std::vector<array>, std::vector<array>> vjp(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents);
+
+/**
+ *  Computes the output and vector-Jacobian product (VJP) of a unary function.
+ */
+std::pair<array, array> vjp(
+    const std::function<array(const array&)>& fun,
+    const array& primal,
+    const array& cotangent);
+
+/**
+ *  Computes the output and Jacobian-vector product (JVP) of a function.
+ *
+ *  Computes the Jacobian-vector product of the Jacobian of the function
+ *  evaluated at the primals with the vector of tangents. Returns a pair of
+ *  vectors of output arrays and JVP arrays.
+ **/
+std::pair<std::vector<array>, std::vector<array>> jvp(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents);
+
+/**
+ *  Computes the output and Jacobian-vector product (JVP) of a unary function.
+ */
+std::pair<array, array> jvp(
+    const std::function<array(const array&)>& fun,
+    const array& primal,
+    const array& tangent);
+
+// Return type of general value_and_grad: a function which takes an input
+// vector of arrays and returns a pair of vectors of arrays one for the
+// values and one for the gradients wrt the first value.
+using ValueAndGradFn =
+    std::function<std::pair<std::vector<array>, std::vector<array>>(
+        const std::vector<array>&)>;
+using SimpleValueAndGradFn = std::function<std::pair<array, std::vector<array>>(
+    const std::vector<array>&)>;
+
+/**
+ *  Returns a function which computes the value and gradient of the input
+ *  function with respect to a vector of input arrays.
+ **/
+ValueAndGradFn value_and_grad(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<int>& argnums);
+
+/**
+ *  Returns a function which computes the value and gradient of the input
+ *  function with respect to a single input array.
+ **/
+ValueAndGradFn inline value_and_grad(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    int argnum = 0) {
+  return value_and_grad(fun, std::vector<int>{argnum});
+}
+
+/**
+ *  Returns a function which computes the value and gradient of the unary
+ *  input function.
+ **/
+std::function<std::pair<array, array>(const array&)> inline value_and_grad(
+    const std::function<array(const array&)>& fun) {
+  return [fun](auto inputs) { return vjp(fun, inputs, array(1.0f)); };
+}
+
+SimpleValueAndGradFn inline value_and_grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    const std::vector<int>& argnums) {
+  return [fun, argnums](auto inputs) {
+    auto result = value_and_grad(
+        [fun](auto inputs) { return std::vector<array>{fun(inputs)}; },
+        argnums)(inputs);
+
+    return std::make_pair(result.first[0], result.second);
+  };
+}
+
+SimpleValueAndGradFn inline value_and_grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    int argnum = 0) {
+  return value_and_grad(fun, std::vector<int>{argnum});
+}
+
+/**
+ *  Returns a function which computes the gradient of the input function with
+ *  respect to a vector of input arrays.
+ *
+ *  The function being differentiated takes a vector of arrays and returns an
+ *  array. The vector of `argnums` specifies which the arguments to compute
+ *  the gradient with respect to. At least one argument must be specified.
+ **/
+std::function<std::vector<array>(const std::vector<array>&)> inline grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    const std::vector<int>& argnums) {
+  auto fn = value_and_grad(fun, argnums);
+  return [fn](const std::vector<array>& inputs) { return fn(inputs).second; };
+}
+
+/**
+ *  Returns a function which computes the gradient of the input function with
+ *  respect to a single input array.
+ *
+ *  The function being differentiated takes a vector of arrays and returns an
+ *  array. The optional `argnum` index specifies which the argument to compute
+ *  the gradient with respect to and defaults to 0.
+ **/
+std::function<std::vector<array>(const std::vector<array>&)> inline grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    int argnum = 0) {
+  return grad(fun, std::vector<int>{argnum});
+}
+
+/**
+ *  Returns a function which computes the gradient of the unary input function.
+ **/
+std::function<array(const array&)> inline grad(
+    const std::function<array(const array&)>& fun) {
+  auto fn = value_and_grad(fun);
+  return [fn](const array& input) { return fn(input).second; };
+}
+
+/**
+ * Automatically vectorize a unary function over the requested axes.
+ */
+std::function<array(const array&)> vmap(
+    const std::function<array(const array&)>& fun,
+    int in_axis = 0,
+    int out_axis = 0);
+
+/**
+ * Automatically vectorize a binary function over the requested axes.
+ */
+std::function<array(const array&, const array&)> vmap(
+    const std::function<array(const array&, const array&)>& fun,
+    int in_axis_a = 0,
+    int in_axis_b = 0,
+    int out_axis = 0);
+
+/**
+ * Automatically vectorize a function over the requested axes.
+ *
+ * The input function to `vmap` takes as an argument a vector of arrays and
+ * returns a vector of arrays. Optionally specify the axes to vectorize over
+ * with `in_axes` and `out_axes`, otherwise a default of 0 is used.
+ * Returns a vectorized function with the same signature as the input
+ * function.
+ */
+std::function<std::vector<array>(const std::vector<array>&)> vmap(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<int>& in_axes = {},
+    const std::vector<int>& out_axes = {});
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/transforms_impl.h b/lib/python3.11/site-packages/mlx/include/mlx/transforms_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..201e8009b314607b93005d5a8bb493e0baa43804
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/transforms_impl.h
@@ -0,0 +1,17 @@
+// Copyright © 2023 Apple Inc.
+
+namespace mlx::core::detail {
+
+std::pair<std::vector<array>, std::vector<array>> vmap_trace(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& inputs,
+    const std::vector<int>& in_axes);
+
+std::vector<array> vmap_replace(
+    const std::vector<array>& inputs,
+    const std::vector<array>& s_inputs,
+    const std::vector<array>& s_outputs,
+    const std::vector<int>& in_axes,
+    const std::vector<int>& out_axes);
+
+} // namespace mlx::core::detail
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/types/bf16.h b/lib/python3.11/site-packages/mlx/include/mlx/types/bf16.h
new file mode 100644
index 0000000000000000000000000000000000000000..5951941747c022284e7926b88ac4bfebbdf78226
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/types/bf16.h
@@ -0,0 +1,187 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+
+#define __MLX_BFLOAT_NAN__ 0x7FC0
+
+namespace mlx::core {
+
+namespace {
+union float_bits_bf16 {
+  float f;
+  uint32_t u;
+};
+} // namespace
+
+struct _MLX_BFloat16 {
+  uint16_t bits_;
+
+  // Default constructor
+  _MLX_BFloat16() = default;
+
+  // Default copy constructor
+  _MLX_BFloat16(_MLX_BFloat16 const&) = default;
+
+  // Appease std::vector<bool> for being special
+  _MLX_BFloat16& operator=(std::vector<bool>::reference x) {
+    bits_ = x;
+    return *this;
+  }
+
+  _MLX_BFloat16& operator=(const float& x) {
+    return (*this = _MLX_BFloat16(x));
+  }
+
+  // From float32
+  _MLX_BFloat16(const float& x) {
+    if (std::isnan(x)) {
+      bits_ = __MLX_BFLOAT_NAN__;
+    } else {
+      // Union
+      float_bits_bf16 in;
+
+      // Take bits
+      in.f = x;
+
+      // Round to nearest even
+      in.u += (in.u >> 16 & 1) + uint32_t(0x7FFF);
+
+      // Take upper 16 bits
+      bits_ = in.u >> 16;
+    }
+  }
+
+  // To float32
+  operator float() const {
+    // Union
+    float_bits_bf16 out;
+
+    // Upper 16 bits are the data and lower 16 bits are 0s
+    out.u = ((uint32_t)bits_) << 16;
+
+    return out.f;
+  }
+};
+
+#define bfloat_binop_base(__op__, __operator__, otype, atype, btype, ctype) \
+  inline otype __operator__(atype lhs, btype rhs) {                         \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);          \
+  }
+
+#define bfloat_binop_helper(__op__, __operator__, otype, itype, ctype) \
+  inline otype __operator__(_MLX_BFloat16 lhs, itype rhs) {            \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);     \
+  }                                                                    \
+  inline otype __operator__(itype lhs, _MLX_BFloat16 rhs) {            \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);     \
+  }
+
+// Operators
+#define bfloat_binop(_op_, _operator_)                                       \
+  bfloat_binop_base(                                                         \
+      _op_, _operator_, _MLX_BFloat16, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(_op_, _operator_, float, float, float);                \
+  bfloat_binop_helper(_op_, _operator_, double, double, double);             \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, bool, float);         \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int32_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint32_t, float);     \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int64_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint64_t, float);
+
+bfloat_binop(+, operator+);
+bfloat_binop(-, operator-);
+bfloat_binop(*, operator*);
+bfloat_binop(/, operator/);
+
+#undef bfloat_binop
+
+// Comparison ops
+#define bfloat_compop(__op__, __operator__)                             \
+  bfloat_binop_base(                                                    \
+      __op__, __operator__, bool, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(__op__, __operator__, bool, float, float);        \
+  bfloat_binop_helper(__op__, __operator__, bool, double, double);      \
+  bfloat_binop_helper(__op__, __operator__, bool, int32_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint32_t, float);     \
+  bfloat_binop_helper(__op__, __operator__, bool, int64_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint64_t, float);
+
+bfloat_compop(>, operator>);
+bfloat_compop(<, operator<);
+bfloat_compop(>=, operator>=);
+bfloat_compop(<=, operator<=);
+bfloat_compop(==, operator==);
+bfloat_compop(!=, operator!=);
+
+#undef bfloat_compop
+
+// Negative
+inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs) {
+  return -static_cast<float>(lhs);
+}
+
+// Inplace ops
+#define bfloat_inplace_op(__op__, __operator__)                              \
+  inline _MLX_BFloat16& __operator__(_MLX_BFloat16& lhs, const float& rhs) { \
+    lhs = lhs __op__ rhs;                                                    \
+    return lhs;                                                              \
+  }                                                                          \
+  inline float& __operator__(float& lhs, _MLX_BFloat16 rhs) {                \
+    lhs = lhs __op__ rhs;                                                    \
+    return lhs;                                                              \
+  }
+
+bfloat_inplace_op(+, operator+=);
+bfloat_inplace_op(-, operator-=);
+bfloat_inplace_op(*, operator*=);
+bfloat_inplace_op(/, operator/=);
+
+#undef bfloat_inplace_op
+
+// Bitwise ops
+
+#define bfloat_bitop(__op__, __operator__)                                  \
+  inline _MLX_BFloat16 __operator__(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { \
+    _MLX_BFloat16 out;                                                      \
+    out.bits_ = lhs.bits_ __op__ rhs.bits_;                                 \
+    return out;                                                             \
+  }                                                                         \
+  inline _MLX_BFloat16 __operator__(_MLX_BFloat16 lhs, uint16_t rhs) {      \
+    _MLX_BFloat16 out;                                                      \
+    out.bits_ = lhs.bits_ __op__ rhs;                                       \
+    return out;                                                             \
+  }                                                                         \
+  inline _MLX_BFloat16 __operator__(uint16_t lhs, _MLX_BFloat16 rhs) {      \
+    _MLX_BFloat16 out;                                                      \
+    out.bits_ = lhs __op__ rhs.bits_;                                       \
+    return out;                                                             \
+  }
+
+bfloat_bitop(|, operator|);
+bfloat_bitop(&, operator&);
+bfloat_bitop(^, operator^);
+
+#undef bfloat_bitop
+
+#define bfloat_inplace_bitop(__op__, __operator__)                            \
+  inline _MLX_BFloat16& __operator__(_MLX_BFloat16& lhs, _MLX_BFloat16 rhs) { \
+    lhs.bits_ = lhs.bits_ __op__ rhs.bits_;                                   \
+    return lhs;                                                               \
+  }                                                                           \
+  inline _MLX_BFloat16& __operator__(_MLX_BFloat16& lhs, uint16_t rhs) {      \
+    lhs.bits_ = lhs.bits_ __op__ rhs;                                         \
+    return lhs;                                                               \
+  }
+
+bfloat_inplace_bitop(|, operator|=);
+bfloat_inplace_bitop(&, operator&=);
+bfloat_inplace_bitop(^, operator^=);
+
+#undef bfloat_inplace_bitop
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/types/complex.h b/lib/python3.11/site-packages/mlx/include/mlx/types/complex.h
new file mode 100644
index 0000000000000000000000000000000000000000..55cbe447af0b659771d6cc0f6c84664cf5fba2ae
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/types/complex.h
@@ -0,0 +1,77 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#include <complex>
+#include "mlx/types/half_types.h"
+
+namespace mlx::core {
+
+struct complex64_t;
+
+template <typename T>
+static constexpr bool can_convert_to_complex64 =
+    !std::is_same_v<T, complex64_t> && std::is_convertible_v<T, float>;
+
+struct complex64_t : public std::complex<float> {
+  complex64_t(float v, float u) : std::complex<float>(v, u){};
+  complex64_t(std::complex<float> v) : std::complex<float>(v){};
+
+  template <
+      typename T,
+      typename = typename std::enable_if<can_convert_to_complex64<T>>::type>
+  complex64_t(T x) : std::complex<float>(x){};
+
+  operator float() const {
+    return real();
+  };
+};
+
+inline bool operator>=(const complex64_t& a, const complex64_t& b) {
+  return (a.real() > b.real()) ||
+      (a.real() == b.real() && a.imag() >= b.imag());
+}
+
+inline bool operator>(const complex64_t& a, const complex64_t& b) {
+  return (a.real() > b.real()) || (a.real() == b.real() && a.imag() > b.imag());
+}
+
+inline bool operator<=(const complex64_t& a, const complex64_t& b) {
+  return operator>=(b, a);
+}
+
+inline bool operator<(const complex64_t& a, const complex64_t& b) {
+  return operator>(b, a);
+}
+
+inline complex64_t operator-(const complex64_t& v) {
+  return -static_cast<std::complex<float>>(v);
+}
+
+// clang-format off
+#define complex_binop_helper(_op_, _operator_, itype)            \
+  inline complex64_t _operator_(itype x, const complex64_t& y) { \
+    return x _op_ static_cast<std::complex<float>>(y);           \
+  }                                                              \
+  inline complex64_t _operator_(const complex64_t& x, itype y) { \
+    return static_cast<std::complex<float>>(x) _op_ y;           \
+  }
+
+#define complex_binop(_op_, _operator_)                                       \
+  inline complex64_t _operator_(const complex64_t& x, const complex64_t& y) { \
+    return static_cast<std::complex<float>>(x)                                \
+        _op_ static_cast<std::complex<float>>(y);                             \
+  }                                                                           \
+  complex_binop_helper(_op_, _operator_, bool)                                \
+  complex_binop_helper(_op_, _operator_, uint32_t)                            \
+  complex_binop_helper(_op_, _operator_, uint64_t)                            \
+  complex_binop_helper(_op_, _operator_, int32_t)                             \
+  complex_binop_helper(_op_, _operator_, int64_t)                             \
+  complex_binop_helper(_op_, _operator_, float16_t)                           \
+  complex_binop_helper(_op_, _operator_, bfloat16_t)                          \
+  complex_binop_helper(_op_, _operator_, const std::complex<float>&)          \
+  complex_binop_helper(_op_, _operator_, float)
+// clang-format on
+
+complex_binop(+, operator+)
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/types/fp16.h b/lib/python3.11/site-packages/mlx/include/mlx/types/fp16.h
new file mode 100644
index 0000000000000000000000000000000000000000..c174afebcb4e221a7437af2ff6e0e6812fe97939
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/types/fp16.h
@@ -0,0 +1,234 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+
+#define __MLX_HALF_NAN__ 0x7D00
+
+namespace mlx::core {
+
+namespace {
+union float_bits_fp16 {
+  float f;
+  uint32_t u;
+};
+} // namespace
+
+struct _MLX_Float16 {
+  uint16_t bits_;
+
+  // Default constructor
+  _MLX_Float16() = default;
+
+  // Default copy constructor
+  _MLX_Float16(_MLX_Float16 const&) = default;
+
+  // Appease std::vector<bool> for being special
+  _MLX_Float16& operator=(std::vector<bool>::reference x) {
+    bits_ = x;
+    return *this;
+  }
+
+  _MLX_Float16& operator=(const float& x) {
+    return (*this = _MLX_Float16(x));
+  }
+
+  // From float32
+  _MLX_Float16(const float& x) : bits_(0) {
+    // Conversion following
+    // https://github.com/Maratyszcza/FP16/blob/master/include/fp16/fp16.h
+
+    // Union
+    float_bits_fp16 in;
+
+    // Take fp32 bits
+    in.f = x;
+
+    // Find and take sign bit
+    uint32_t x_sign_32 = in.u & uint32_t(0x80000000);
+    uint16_t x_sign_16 = (x_sign_32 >> 16);
+
+    if (std::isnan(x)) {
+      bits_ = x_sign_16 | uint16_t(__MLX_HALF_NAN__);
+    } else {
+      // Union
+      float_bits_fp16 inf_scale, zero_scale, magic_bits;
+
+      // Find exponent bits and take the max supported by half
+      uint32_t x_expo_32 = in.u & uint32_t(0x7f800000);
+      uint32_t max_expo_32 = uint32_t(0x38800000);
+      x_expo_32 = x_expo_32 < max_expo_32 ? max_expo_32 : x_expo_32;
+      x_expo_32 += uint32_t(15) << 23;
+
+      // Handle scaling to inf as needed
+      inf_scale.u = uint32_t(0x77800000);
+      zero_scale.u = uint32_t(0x08800000);
+
+      // Combine with magic and let addition do rounding
+      magic_bits.u = x_expo_32;
+      magic_bits.f += (std::abs(x) * inf_scale.f) * zero_scale.f;
+
+      // Take the lower 5 bits of the exponent
+      uint32_t x_expo_16 = ((magic_bits.u >> 13) & uint32_t(0x7c00));
+
+      // Collect the lower 12 bits which have the mantissa
+      uint32_t x_mant_16 = magic_bits.u & uint32_t(0x0fff);
+
+      // Combine sign, exp and mantissa
+      bits_ = (x_sign_16 | uint16_t(x_expo_16 + x_mant_16));
+    }
+  }
+
+  // To float32
+  operator float() const {
+    // Conversion following
+    // https://github.com/Maratyszcza/FP16/blob/master/include/fp16/fp16.h
+
+    // Union
+    float_bits_fp16 out;
+
+    uint32_t x_sign_32 = (bits_ << 16) & uint32_t(0x80000000);
+    uint32_t base = (bits_ << 16);
+    uint32_t two_base = base + base;
+
+    uint32_t denorm_max = 1u << 27;
+    if (two_base < denorm_max) {
+      out.u = uint32_t(126) << 23; // magic mask
+      out.u |= (two_base >> 17); // Bits from fp16
+      out.f -= 0.5f; // magic bias
+    } else {
+      out.u = uint32_t(0xE0) << 23; // exponent offset
+      out.u += (two_base >> 4); // Bits from fp16
+      float out_unscaled = out.f; // Store value
+      out.u = uint32_t(0x7800000); // exponent scale
+      out.f *= out_unscaled;
+    }
+
+    // Add sign
+    out.u |= x_sign_32;
+
+    return out.f;
+  }
+};
+
+#define half_binop_base(__op__, __operator__, otype, atype, btype, ctype) \
+  inline otype __operator__(atype lhs, btype rhs) {                       \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);        \
+  }
+
+#define half_binop_helper(__op__, __operator__, otype, itype, ctype) \
+  inline otype __operator__(_MLX_Float16 lhs, itype rhs) {           \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);   \
+  }                                                                  \
+  inline otype __operator__(itype lhs, _MLX_Float16 rhs) {           \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);   \
+  }
+
+// Operators
+#define half_binop(__op__, __operator__)                                      \
+  half_binop_base(                                                            \
+      __op__, __operator__, _MLX_Float16, _MLX_Float16, _MLX_Float16, float); \
+  half_binop_helper(__op__, __operator__, float, float, float);               \
+  half_binop_helper(__op__, __operator__, double, double, double);            \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, bool, float);         \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, int32_t, float);      \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, uint32_t, float);     \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, int64_t, float);      \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, uint64_t, float);
+
+half_binop(+, operator+);
+half_binop(-, operator-);
+half_binop(*, operator*);
+half_binop(/, operator/);
+
+#undef half_binop
+
+// Comparison ops
+#define half_compop(__op__, __operator__)                             \
+  half_binop_base(                                                    \
+      __op__, __operator__, bool, _MLX_Float16, _MLX_Float16, float); \
+  half_binop_helper(__op__, __operator__, bool, float, float);        \
+  half_binop_helper(__op__, __operator__, bool, double, double);      \
+  half_binop_helper(__op__, __operator__, bool, int32_t, float);      \
+  half_binop_helper(__op__, __operator__, bool, uint32_t, float);     \
+  half_binop_helper(__op__, __operator__, bool, int64_t, float);      \
+  half_binop_helper(__op__, __operator__, bool, uint64_t, float);
+
+half_compop(>, operator>);
+half_compop(<, operator<);
+half_compop(>=, operator>=);
+half_compop(<=, operator<=);
+half_compop(==, operator==);
+half_compop(!=, operator!=);
+
+#undef half_compop
+
+// Negative
+inline _MLX_Float16 operator-(_MLX_Float16 lhs) {
+  return -static_cast<float>(lhs);
+}
+
+// Inplace ops
+#define half_inplace_op(__op__, __operator__)                              \
+  inline _MLX_Float16& __operator__(_MLX_Float16& lhs, const float& rhs) { \
+    lhs = lhs __op__ rhs;                                                  \
+    return lhs;                                                            \
+  }                                                                        \
+  inline float& __operator__(float& lhs, _MLX_Float16 rhs) {               \
+    lhs = lhs __op__ rhs;                                                  \
+    return lhs;                                                            \
+  }
+
+half_inplace_op(+, operator+=);
+half_inplace_op(-, operator-=);
+half_inplace_op(*, operator*=);
+half_inplace_op(/, operator/=);
+
+#undef half_inplace_op
+
+// Bitwise ops
+
+#define half_bitop(__op__, __operator__)                                 \
+  inline _MLX_Float16 __operator__(_MLX_Float16 lhs, _MLX_Float16 rhs) { \
+    _MLX_Float16 out;                                                    \
+    out.bits_ = lhs.bits_ __op__ rhs.bits_;                              \
+    return out;                                                          \
+  }                                                                      \
+  inline _MLX_Float16 __operator__(_MLX_Float16 lhs, uint16_t rhs) {     \
+    _MLX_Float16 out;                                                    \
+    out.bits_ = lhs.bits_ __op__ rhs;                                    \
+    return out;                                                          \
+  }                                                                      \
+  inline _MLX_Float16 __operator__(uint16_t lhs, _MLX_Float16 rhs) {     \
+    _MLX_Float16 out;                                                    \
+    out.bits_ = lhs __op__ rhs.bits_;                                    \
+    return out;                                                          \
+  }
+
+half_bitop(|, operator|);
+half_bitop(&, operator&);
+half_bitop(^, operator^);
+
+#undef half_bitop
+
+#define half_inplace_bitop(__op__, __operator__)                           \
+  inline _MLX_Float16& __operator__(_MLX_Float16& lhs, _MLX_Float16 rhs) { \
+    lhs.bits_ = lhs.bits_ __op__ rhs.bits_;                                \
+    return lhs;                                                            \
+  }                                                                        \
+  inline _MLX_Float16& __operator__(_MLX_Float16& lhs, uint16_t rhs) {     \
+    lhs.bits_ = lhs.bits_ __op__ rhs;                                      \
+    return lhs;                                                            \
+  }
+
+half_inplace_bitop(|, operator|=);
+half_inplace_bitop(&, operator&=);
+half_inplace_bitop(^, operator^=);
+
+#undef half_inplace_bitop
+
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/types/half_types.h b/lib/python3.11/site-packages/mlx/include/mlx/types/half_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..430279565726e75bc0b9b5b421e2f61eb8502b7a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/types/half_types.h
@@ -0,0 +1,56 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#ifdef __ARM_FEATURE_FP16_SCALAR_ARITHMETIC
+
+#include <arm_fp16.h>
+namespace mlx::core {
+typedef __fp16 float16_t;
+} // namespace mlx::core
+
+#else
+
+#define ADD_HALF_BINOPS
+#include "mlx/types/fp16.h"
+namespace mlx::core {
+typedef struct _MLX_Float16 float16_t;
+} // namespace mlx::core
+
+#endif // __ARM_FEATURE_FP16_SCALAR_ARITHMETIC
+#ifdef __ARM_FEATURE_BF16
+
+#include <arm_bf16.h>
+namespace mlx::core {
+typedef __bf16 bfloat16_t;
+} // namespace mlx::core
+
+#else
+
+#define ADD_HALF_BINOPS
+#include "mlx/types/bf16.h"
+namespace mlx::core {
+typedef struct _MLX_BFloat16 bfloat16_t;
+} // namespace mlx::core
+
+#endif // __ARM_FEATURE_BF16
+
+#ifdef ADD_HALF_BINOPS
+namespace mlx::core {
+
+// clang-format off
+#define fp16_bf16_binop_helper(__op__, __operator__)               \
+  inline float __operator__(float16_t lhs, bfloat16_t rhs) {       \
+    return static_cast<float>(lhs) __op__ static_cast<float>(rhs); \
+  }                                                                \
+  inline float __operator__(bfloat16_t lhs, float16_t rhs) {       \
+    return static_cast<float>(lhs) __op__ static_cast<float>(rhs); \
+  }
+
+fp16_bf16_binop_helper(+, operator+)
+fp16_bf16_binop_helper(-, operator-)
+fp16_bf16_binop_helper(*, operator*)
+fp16_bf16_binop_helper(/, operator/)
+// clang-format on
+
+} // namespace mlx::core
+#endif
diff --git a/lib/python3.11/site-packages/mlx/include/mlx/utils.h b/lib/python3.11/site-packages/mlx/include/mlx/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..823b4c872a1cfff1e047e28945fe87d74c8babb5
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/include/mlx/utils.h
@@ -0,0 +1,44 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "array.h"
+#include "device.h"
+#include "dtype.h"
+#include "stream.h"
+
+namespace mlx::core {
+
+/** The type from promoting the arrays' types with one another. */
+Dtype result_type(const std::vector<array>& arrays);
+
+std::vector<int> broadcast_shapes(
+    const std::vector<int>& s1,
+    const std::vector<int>& s2);
+
+bool is_same_shape(const std::vector<array>& arrays);
+
+/**
+ * Returns the axis normalized to be in the range [0, ndim).
+ * Based on numpy's normalize_axis_index. See
+ * https://numpy.org/devdocs/reference/generated/numpy.lib.array_utils.normalize_axis_index.html
+ */
+int normalize_axis(int axis, int ndim);
+
+std::ostream& operator<<(std::ostream& os, const Device& d);
+std::ostream& operator<<(std::ostream& os, const Stream& s);
+std::ostream& operator<<(std::ostream& os, const Dtype& d);
+std::ostream& operator<<(std::ostream& os, const Dtype::Kind& k);
+std::ostream& operator<<(std::ostream& os, array a);
+std::ostream& operator<<(std::ostream& os, const std::vector<int>& v);
+std::ostream& operator<<(std::ostream& os, const std::vector<size_t>& v);
+inline std::ostream& operator<<(std::ostream& os, const complex64_t& v) {
+  return os << v.real() << (v.imag() > 0 ? "+" : "") << v.imag() << "j";
+}
+inline std::ostream& operator<<(std::ostream& os, const float16_t& v) {
+  return os << static_cast<float>(v);
+}
+inline std::ostream& operator<<(std::ostream& os, const bfloat16_t& v) {
+  return os << static_cast<float>(v);
+}
+} // namespace mlx::core
diff --git a/lib/python3.11/site-packages/mlx/lib/libmlx.dylib b/lib/python3.11/site-packages/mlx/lib/libmlx.dylib
new file mode 100644
index 0000000000000000000000000000000000000000..a9b17d74e39b1690b24d9f70b6d0fdc1477e49d6
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/lib/libmlx.dylib
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8abefe46a1f39c92b28464814f05a730fa9899b17757703403c6ef362f06ac93
+size 12420704
diff --git a/lib/python3.11/site-packages/mlx/lib/mlx.metallib b/lib/python3.11/site-packages/mlx/lib/mlx.metallib
new file mode 100644
index 0000000000000000000000000000000000000000..111aa15f90129127d5f8c559a7cdae722534dcd9
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/lib/mlx.metallib
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2eedf41000ed270283da11d889bb101aa4c88c6f8f0ec68fe6b040a5be424501
+size 59495531
diff --git a/lib/python3.11/site-packages/mlx/nn/__init__.py b/lib/python3.11/site-packages/mlx/nn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bb7cc63d28f1655b5951e2ed3105b5bb65189a1
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/__init__.py
@@ -0,0 +1,5 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn import losses
+from mlx.nn.layers import *
+from mlx.nn.utils import value_and_grad
diff --git a/lib/python3.11/site-packages/mlx/nn/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..89ccbda6a22dab2afda4af184e00c6ecd4ab888a
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/__pycache__/losses.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/__pycache__/losses.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8371c6275032768ce291c9ffc2f2123559cae047
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/__pycache__/losses.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/__pycache__/utils.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d4ded89a910dd42237f2a077690f78510c3555a8
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/__pycache__/utils.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__init__.py b/lib/python3.11/site-packages/mlx/nn/layers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..80d500c9faeaa5351d9b554c60c5ed006243e780
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/__init__.py
@@ -0,0 +1,63 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn.layers.activations import (
+    CELU,
+    ELU,
+    GELU,
+    SELU,
+    Hardswish,
+    LeakyReLU,
+    LogSigmoid,
+    LogSoftmax,
+    Mish,
+    PReLU,
+    ReLU,
+    ReLU6,
+    SiLU,
+    Softmax,
+    Softplus,
+    Softsign,
+    Step,
+    Tanh,
+    celu,
+    elu,
+    gelu,
+    gelu_approx,
+    gelu_fast_approx,
+    hardswish,
+    leaky_relu,
+    log_sigmoid,
+    log_softmax,
+    mish,
+    prelu,
+    relu,
+    relu6,
+    selu,
+    silu,
+    softmax,
+    softplus,
+    softsign,
+    step,
+    tanh,
+)
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.containers import Sequential
+from mlx.nn.layers.convolution import Conv1d, Conv2d
+from mlx.nn.layers.dropout import Dropout, Dropout2d, Dropout3d
+from mlx.nn.layers.embedding import Embedding
+from mlx.nn.layers.linear import Bilinear, Identity, Linear
+from mlx.nn.layers.normalization import (
+    BatchNorm,
+    GroupNorm,
+    InstanceNorm,
+    LayerNorm,
+    RMSNorm,
+)
+from mlx.nn.layers.positional_encoding import ALiBi, RoPE, SinusoidalPositionalEncoding
+from mlx.nn.layers.quantized import QuantizedLinear
+from mlx.nn.layers.transformer import (
+    MultiHeadAttention,
+    Transformer,
+    TransformerEncoder,
+    TransformerEncoderLayer,
+)
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49fd39acdb57f5985b6276ccaa677d96576af8f7
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/activations.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/activations.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66be8623924c8fa753040396fcfb4702204c7cde
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/activations.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/base.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/base.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbb2721e78295c4237307856d09b64f70795661a
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/base.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/containers.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/containers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..383a0074044b157fbc5e180b000f9908bf2e0c88
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/containers.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/convolution.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/convolution.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9760a34bca18d61775836f1a2893d7e52ce9f3fe
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/convolution.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/dropout.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/dropout.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d3173ca1e44ab94df19aed0c610d539b71554481
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/dropout.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/embedding.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/embedding.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4dbcc0a5805e5c55bf9ac1ea6ef46509383bc7b
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/embedding.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/linear.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/linear.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4b6078542c8c9f1ac05b0392f3233ac8e019abd
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/linear.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/normalization.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/normalization.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b439138b76426bdd609dae2212aa9432a125939d
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/normalization.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/positional_encoding.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/positional_encoding.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..553cc4920f4cfa7bb81a575cc410e54dbdf124f9
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/positional_encoding.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/quantized.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/quantized.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ecc0d0fc7720f260f5650ed3ad99735c4c291a3
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/quantized.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/transformer.cpython-311.pyc b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/transformer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23ca9ca9ff46e1b8a05f2a1cbd826e4330d0bc8a
Binary files /dev/null and b/lib/python3.11/site-packages/mlx/nn/layers/__pycache__/transformer.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/activations.py b/lib/python3.11/site-packages/mlx/nn/layers/activations.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcb4483ac6aea8ce6c6d3a2010ad45cec39c8d50
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/activations.py
@@ -0,0 +1,501 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def _make_activation_module(f):
+    def decorator(klass):
+        klass.__doc__ = f.__doc__
+        klass.__call__ = lambda self, x: f(x)
+        return klass
+
+    return decorator
+
+
+def sigmoid(x):
+    r"""Applies the element-wise function:
+
+    .. math::
+        \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
+    """
+    return mx.sigmoid(x)
+
+
+def relu(x):
+    r"""Applies the Rectified Linear Unit.
+
+    Simply ``mx.maximum(x, 0)``.
+    """
+    return mx.maximum(x, 0)
+
+
+def leaky_relu(x, negative_slope=0.01):
+    r"""Applies the Leaky Rectified Linear Unit.
+
+    Simply ``mx.maximum(negative_slope * x, x)``.
+    """
+    return mx.maximum(negative_slope * x, x)
+
+
+def log_softmax(x, axis=-1):
+    r"""Applies the Log Softmax function.
+
+    Applies :math:`x + \log \sum_i e^{x_i}` element wise.
+    """
+    return x - mx.logsumexp(x, axis=axis, keepdims=True)
+
+
+def elu(x, alpha=1.0):
+    r"""Applies the Exponential Linear Unit.
+
+    Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.
+    """
+    return mx.where(x > 0, x, alpha * (mx.exp(x) - 1))
+
+
+def relu6(x):
+    r"""Applies the Rectified Linear Unit 6.
+
+    Applies :math:`\min(\max(x, 0), 6)` element wise.
+    """
+    return mx.minimum(mx.maximum(x, 0), 6.0)
+
+
+def softmax(x, axis=-1):
+    r"""Applies the Softmax function.
+
+    Applies :math:`\frac{e^{x_i}}{\sum_j e^{x_j}}` element wise.
+    """
+    return mx.softmax(x, axis=axis)
+
+
+def softplus(x):
+    r"""Applies the Softplus function.
+
+    Applies :math:`\log(1 + \exp(x))` element wise.
+    """
+    return mx.logaddexp(x, 0)
+
+
+def softsign(x):
+    r"""Applies the Softsign function.
+
+    Applies :math:`\frac{x}{1 + |x|}` element wise.
+    """
+    return mx.divide(x, 1 + mx.abs(x))
+
+
+def celu(x, alpha=1.0):
+    r"""Applies the Continuously Differentiable Exponential Linear Unit.
+
+    Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
+    element wise.
+    """
+    return mx.maximum(x, 0.0) + alpha * (mx.exp(mx.minimum(x, 0.0) / alpha) - 1)
+
+
+def silu(x):
+    r"""Applies the Sigmoid Linear Unit. Also known as Swish.
+
+    Applies :math:`x \sigma(x)` element wise, where :math:`\sigma(\cdot)` is
+    the logistic sigmoid.
+    """
+    return x * mx.sigmoid(x)
+
+
+def log_sigmoid(x):
+    r"""Applies the Log Sigmoid function.
+
+    Applies :math:`\log(\sigma(x)) = -\log(1 + e^{-x})` element wise.
+    """
+    return -softplus(-x)
+
+
+def gelu(x):
+    r"""Applies the Gaussian Error Linear Units function.
+
+    .. math::
+        \\textrm{GELU}(x) = x * \Phi(x)
+
+    where :math:`\Phi(x)` is the Gaussian CDF.
+
+    See also :func:`gelu_approx` and :func:`gelu_fast_approx` for faster
+    approximations.
+    """
+    return x * (1 + mx.erf(x / math.sqrt(2))) / 2
+
+
+def gelu_approx(x):
+    r"""An approximation to Gaussian Error Linear Unit.
+
+    See :func:`gelu` for the exact computation.
+
+    This function approximates ``gelu`` with a maximum absolute error :math:`<
+    0.0003` in the range :math:`[-6, 6]` using the following
+
+    .. math::
+
+        x = x \sigma\left(1.60033 x \left(1 + 0.0433603 x^2\right)\right)
+
+    where :math:`\sigma(\cdot)` is the logistic sigmoid.
+    """
+    return x * mx.sigmoid(1.60033 * x * (1 + 0.0433603 * x.square()))
+
+
+def gelu_fast_approx(x):
+    r"""A fast approximation to Gaussian Error Linear Unit.
+
+    See :func:`gelu` for the exact computation.
+
+    This function approximates ``gelu`` with a maximum absolute error :math:`<
+    0.015` in the range :math:`[-6, 6]` using the following
+
+    .. math::
+
+        x = x \sigma\left(1.773 x\right)
+
+    where :math:`\sigma(\cdot)` is the logistic sigmoid.
+    """
+    return x * mx.sigmoid(1.773 * x)
+
+
+@_make_activation_module
+class Sigmoid(Module):
+    r"""Applies the sigmoid function, element-wise.
+
+    .. math::
+        \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
+    """
+    pass
+
+
+def step(x: mx.array, threshold: float = 0.0):
+    r"""Applies the Step Activation Function.
+
+    This function implements a binary step activation, where the output is set
+    to 1 if the input is greater than a specified threshold, and 0 otherwise.
+
+    .. math::
+        \text{step}(x) = \begin{cases}
+        0 & \text{if } x < \text{threshold} \\
+        1 & \text{if } x \geq \text{threshold}
+        \end{cases}
+
+    Args:
+        threshold: The value to threshold at.
+    """
+
+    return mx.where(x > threshold, 1, 0)
+
+
+def selu(x):
+    r"""Applies the Scaled Exponential Linear Unit.
+
+    .. math::
+        \text{selu}(x) = \begin{cases}
+        \lambda x & \text{if } x > 0 \\
+        \lambda \alpha (\exp(x) - 1) & \text{if } x \leq 0
+        \end{cases}
+
+    where :math:`\lambda = 1.0507` and :math:`\alpha = 1.67326`.
+
+    See also :func:`elu`.
+    """
+    return elu(x, 1.67326) * 1.0507
+
+
+def prelu(x: mx.array, alpha: mx.array) -> mx.array:
+    r"""Applies the element-wise parametric ReLU.
+
+    .. math::
+        \text{PReLU}(x) = \max(0,x) + a * \min(0,x)
+
+    where :math:`a` is an array.
+    """
+    return mx.maximum(0, x) + alpha * mx.minimum(0, x)
+
+
+def mish(x: mx.array) -> mx.array:
+    r"""Applies the Mish function, element-wise.
+    Mish: A Self Regularized Non-Monotonic Neural Activation Function.
+
+    Reference: https://arxiv.org/abs/1908.08681
+
+    .. math::
+        \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))
+
+    """
+    return x * mx.tanh(softplus(x))
+
+
+def hardswish(x):
+    r"""Applies the hardswish function, element-wise.
+
+    .. math::
+        \text{Hardswish}(x) = x * \min(\max(x + 3, 0), 6) / 6
+    """
+    max_x_3 = mx.maximum(x + 3, 0)
+    return x * mx.minimum(max_x_3, 6) / 6
+
+
+@_make_activation_module(mish)
+class Mish(Module):
+    r"""Applies the Mish function, element-wise.
+
+    Reference: https://arxiv.org/abs/1908.08681
+
+    .. math::
+        \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))
+
+    """
+    pass
+
+
+@_make_activation_module(relu)
+class ReLU(Module):
+    r"""Applies the Rectified Linear Unit.
+        Simply ``mx.maximum(x, 0)``.
+
+    See :func:`relu`, for the functional equivalent.
+    """
+    pass
+
+
+class LeakyReLU(Module):
+    r"""Applies the Leaky Rectified Linear Unit.
+
+    Simply ``mx.maximum(negative_slope * x, x)``.
+
+    Args:
+        negative_slope: Controls the angle of the negative slope. Default: 1e-2.
+    """
+
+    def __init__(self, negative_slope=1e-2):
+        super().__init__()
+        self._negative_slope = negative_slope
+
+    def __call__(self, x):
+        return leaky_relu(x, self._negative_slope)
+
+
+class ELU(Module):
+    r"""Applies the Exponential Linear Unit.
+        Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.
+
+    See :func:`elu`, for the functional equivalent.
+
+    Args:
+        alpha: the :math:`\alpha` value for the ELU formulation. Default: 1.0
+    """
+
+    def __init__(self, alpha=1.0):
+        super().__init__()
+        self._alpha = alpha
+
+    def __call__(self, x):
+        return elu(x, self._alpha)
+
+
+@_make_activation_module(relu6)
+class ReLU6(Module):
+    r"""Applies the Rectified Linear Unit 6.
+
+    See :func:`relu6`, for the functional equivalent.
+    """
+    pass
+
+
+@_make_activation_module(softmax)
+class Softmax(Module):
+    r"""Applies the Softmax function.
+
+    See :func:`softmax`, for the functional equivalent.
+    """
+    pass
+
+
+@_make_activation_module(softplus)
+class Softplus(Module):
+    r"""Applies the Softplus function.
+
+    See :func:`softplus`, for the functional equivalent.
+    """
+    pass
+
+
+@_make_activation_module(softsign)
+class Softsign(Module):
+    r"""Applies the Softsign function.
+
+    See :func:`softsign`, for the functional equivalent.
+    """
+    pass
+
+
+class CELU(Module):
+    r"""Applies the Continuously Differentiable Exponential Linear Unit.
+        Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
+        element wise.
+
+    See :func:`celu`, for the functional equivalent.
+
+    Args:
+        alpha: the :math:`\alpha` value for the CELU formulation. Default: 1.0
+    """
+
+    def __init__(self, alpha=1.0):
+        super().__init__()
+        self._alpha = alpha
+
+    def __call__(self, x):
+        return celu(x, self._alpha)
+
+
+@_make_activation_module(silu)
+class SiLU(Module):
+    r"""Applies the Sigmoid Linear Unit. Also known as Swish.
+
+    See :func:`silu`, for the functional equivalent.
+    """
+    pass
+
+
+@_make_activation_module(log_softmax)
+class LogSoftmax(Module):
+    r"""Applies the Log Softmax function.
+
+    See :func:`log_softmax`, for the functional equivalent.
+    """
+    pass
+
+
+@_make_activation_module(log_sigmoid)
+class LogSigmoid(Module):
+    r"""Applies the Log Sigmoid function.
+
+    See :func:`log_sigmoid`, for the functional equivalent.
+    """
+    pass
+
+
+class PReLU(Module):
+    r"""Applies the element-wise parametric ReLU.
+        Applies :math:`\max(0, x) + a * \min(0, x)` element wise, where :math:`a`
+        is an array.
+
+    See :func:`prelu`, for the functional equivalent.
+
+    Args:
+        num_parameters: number of :math:`a` to learn. Default: 1
+        init: the initial value of :math:`a`. Default: 0.25
+    """
+
+    def __init__(self, num_parameters=1, init=0.25):
+        super().__init__()
+        self.weight = mx.full([num_parameters], init)
+
+    def __call__(self, x: mx.array):
+        return prelu(x, self.weight)
+
+
+class GELU(Module):
+    r"""Applies the Gaussian Error Linear Units.
+
+    .. math::
+        \textrm{GELU}(x) = x * \Phi(x)
+
+    where :math:`\Phi(x)` is the Gaussian CDF.
+
+    However, if ``approx`` is set to 'precise' or 'fast' it applies
+
+    .. math::
+        \textrm{GELUApprox}(x) &= x * \sigma\left(1.60033 * x \left(1 + 0.0433603 * x^2\right)\right) \\
+        \textrm{GELUFast}(x) &= x * \sigma\left(1.773 * x\right)
+
+    respectively.
+
+    See :func:`gelu`, :func:`gelu_approx` and :func:`gelu_fast_approx` for the
+    functional equivalents and information regarding error bounds.
+
+    Args:
+        approx ('none' | 'precise' | 'fast'): Which approximation to gelu to use if any.
+    """
+
+    def __init__(self, approx="none"):
+        super().__init__()
+
+        if approx == "none":
+            self._act = gelu
+        elif approx == "precise":
+            self._act = gelu_approx
+        elif approx == "fast":
+            self._act = gelu_fast_approx
+        else:
+            raise ValueError(
+                f"The approximation should be in ['none', 'precise', 'fast'] but '{approx}' was given"
+            )
+
+    def __call__(self, x):
+        return self._act(x)
+
+
+def tanh(x):
+    """Applies the hyperbolic tangent function.
+
+    Simply ``mx.tanh(x)``.
+    """
+    return mx.tanh(x)
+
+
+@_make_activation_module(tanh)
+class Tanh(Module):
+    r"""Applies the hyperbolic tangent function.
+
+    See :func:`tanh`, for the functional equivalent.
+    """
+    pass
+
+
+@_make_activation_module(hardswish)
+class Hardswish(Module):
+    r"""Applies the hardswish function, element-wise.
+
+    See :func:`hardswish`, for the functional equivalent.
+    """
+    pass
+
+
+class Step(Module):
+    r"""Applies the Step Activation Function.
+
+    This function implements a binary step activation, where the output is set
+    to 1 if the input is greater than a specified threshold, and 0 otherwise.
+
+    .. math::
+        \text{step}(x) = \begin{cases}
+        0 & \text{if } x < \text{threshold} \\
+        1 & \text{if } x \geq \text{threshold}
+        \end{cases}
+
+    Args:
+        threshold: The value to threshold at.
+    """
+
+    def __init__(self, threshold: float = 0.0):
+        super().__init__()
+        self.threshold = threshold
+
+    def __call__(self, x: mx.array):
+        return step(x, self.threshold)
+
+
+@_make_activation_module(selu)
+class SELU(Module):
+    r"""Applies the Scaled Exponential Linear Unit.
+
+    See :func:`selu`, for the functional equivalent.
+    """
+    pass
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/base.py b/lib/python3.11/site-packages/mlx/nn/layers/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..646f5f2dcc661e4397253958bd82ad4b28d0b134
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/base.py
@@ -0,0 +1,532 @@
+# Copyright © 2023 Apple Inc.
+
+import textwrap
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+import mlx.core as mx
+from mlx.utils import tree_flatten, tree_unflatten
+
+
+class Module(dict):
+    """Base class for building neural networks with MLX.
+
+    All the layers provided in :mod:`mlx.nn.layers` subclass this class and
+    your models should do the same.
+
+    A ``Module`` can contain other ``Module`` instances or :class:`mlx.core.array`
+    instances in arbitrary nesting of python lists or dicts. The ``Module``
+    then allows recursively extracting all the :class:`mlx.core.array` instances
+    using :meth:`mlx.nn.Module.parameters`.
+
+    In addition, the ``Module`` has the concept of trainable and non trainable
+    parameters (called "frozen"). When using :func:`mlx.nn.value_and_grad`
+    the gradients are returned only with respect to the trainable parameters.
+    All arrays in a module are trainable unless they are added in the "frozen"
+    set by calling :meth:`freeze`.
+
+    .. code-block:: python
+
+        import mlx.core as mx
+        import mlx.nn as nn
+
+        class MyMLP(nn.Module):
+            def __init__(self, in_dims: int, out_dims: int, hidden_dims: int = 16):
+                super().__init__()
+
+                self.in_proj = nn.Linear(in_dims, hidden_dims)
+                self.out_proj = nn.Linear(hidden_dims, out_dims)
+
+            def __call__(self, x):
+                x = self.in_proj(x)
+                x = mx.maximum(x, 0)
+                return self.out_proj(x)
+
+        model = MyMLP(2, 1)
+
+        # All the model parameters are created but since MLX is lazy by
+        # default, they are not evaluated yet. Calling `mx.eval` actually
+        # allocates memory and initializes the parameters.
+        mx.eval(model.parameters())
+
+        # Setting a parameter to a new value is as simply as accessing that
+        # parameter and assigning a new array to it.
+        model.in_proj.weight = model.in_proj.weight * 2
+        mx.eval(model.parameters())
+    """
+
+    def __init__(self):
+        """Should be called by the subclasses of ``Module``."""
+        self._no_grad = set()
+        self._training = True
+
+    @property
+    def training(self):
+        """Boolean indicating if the model is in training mode."""
+        return self._training
+
+    def _extra_repr(self):
+        return ""
+
+    def __repr__(self):
+        children = tree_flatten(self.children(), is_leaf=self.is_module)
+        value = f"{type(self).__name__}({self._extra_repr()}"
+        for k, v in children:
+            value += "\n"
+            value += textwrap.indent(f"({k}): {repr(v)}", prefix="  ")
+        if children:
+            value += "\n"
+        value += ")"
+
+        return value
+
+    def __getattr__(self, key: str):
+        if key in self:
+            return self[key]
+        else:
+            raise AttributeError(f"{type(self)!r} has no attribute {key!r}")
+
+    def __setattr__(self, key: str, val: Any):
+        self[key] = val
+
+    def load_weights(
+        self,
+        file_or_weights: Union[str, List[Tuple[str, mx.array]]],
+        strict: bool = True,
+    ):
+        """
+        Update the model's weights from a ``.npz`` or a list.
+
+        Args:
+            file_or_weights (str or list(tuple(str, mx.array))): The path to
+                the weights ``.npz`` file or a list of pairs of parameter names
+                and arrays.
+            strict (bool, optional): If ``True`` then checks that the provided
+              weights exactly match the parameters of the model. Otherwise,
+              only the weights actually contained in the model are loaded and
+              shapes are not checked. Default: ``True``.
+
+        Example:
+
+            .. code-block:: python
+
+                import mlx.core as mx
+                import mlx.nn as nn
+                model = nn.Linear(10, 10)
+
+                # Load from file
+                model.load_weights("weights.npz")
+
+                # Load from list
+                weights = [
+                    ("weight", mx.random.uniform(shape=(10, 10))),
+                    ("bias",  mx.zeros((10,))),
+                ]
+                model.load_weights(weights)
+
+                # Missing weight
+                weights = [
+                    ("weight", mx.random.uniform(shape=(10, 10))),
+                ]
+
+                # Raises a ValueError exception
+                model.load_weights(weights)
+
+                # Ok, only updates the weight but not the bias
+                model.load_weights(weights, strict=False)
+        """
+        weights = file_or_weights
+        if isinstance(weights, str):
+            weights = list(mx.load(weights).items())
+
+        if strict:
+            new_weights = dict(weights)
+            curr_weights = dict(tree_flatten(self.parameters()))
+            if extras := (new_weights.keys() - curr_weights.keys()):
+                extras = " ".join(extras)
+                raise ValueError(f"Received parameters not in model: {extras}.")
+            if missing := (curr_weights.keys() - new_weights.keys()):
+                missing = " ".join(missing)
+                raise ValueError(f"Missing parameters: {missing}.")
+            for k, v in curr_weights.items():
+                v_new = new_weights[k]
+                if not isinstance(v_new, mx.array):
+                    raise ValueError(
+                        "Expected mx.array but received "
+                        f"{type(v_new)} for parameter {k}"
+                    )
+                if v_new.shape != v.shape:
+                    raise ValueError(
+                        f"Expected shape {v.shape} but received "
+                        f" shape {v_new.shape} for parameter {k}"
+                    )
+
+        self.update(tree_unflatten(weights))
+
+    def save_weights(self, file: str):
+        """
+        Save the model's weights to a ``.npz`` file.
+        """
+        mx.savez(file, **dict(tree_flatten(self.parameters())))
+
+    @staticmethod
+    def is_module(value):
+        return isinstance(value, Module)
+
+    @staticmethod
+    def valid_child_filter(module, key, value):
+        return isinstance(value, (dict, list))
+
+    @staticmethod
+    def valid_parameter_filter(module, key, value):
+        return isinstance(value, (dict, list, mx.array)) and not key.startswith("_")
+
+    @staticmethod
+    def trainable_parameter_filter(module, key, value):
+        return (
+            Module.valid_parameter_filter(module, key, value)
+            and key not in module._no_grad
+        )
+
+    def filter_and_map(
+        self,
+        filter_fn: Callable[["mlx.nn.Module", str, Any], bool],
+        map_fn: Optional[Callable] = None,
+        is_leaf_fn: Optional[Callable[["mlx.nn.Module", str, Any], bool]] = None,
+    ):
+        """Recursively filter the contents of the module using ``filter_fn``,
+        namely only select keys and values where ``filter_fn`` returns true.
+
+        This is used to implement :meth:`parameters` and :meth:`trainable_parameters`
+        but it can also be used to extract any subset of the module's parameters.
+
+        Args:
+            filter_fn (Callable): Given a value, the key in which it is found
+                and the containing module, decide whether to keep the value or
+                drop it.
+            map_fn (Callable, optional): Optionally transform the value before
+                returning it.
+            is_leaf_fn (Callable, optional): Given a value, the key in which it
+                is found and the containing module decide if it is a leaf.
+
+        Returns:
+            A dictionary containing the contents of the module recursively filtered
+        """
+
+        map_fn = map_fn or (lambda x: x)
+        is_leaf_fn = is_leaf_fn or (
+            lambda m, k, v: not isinstance(v, (Module, dict, list))
+        )
+
+        def unwrap(vk, v):
+            if is_leaf_fn(self, vk, v):
+                return map_fn(v)
+
+            if isinstance(v, Module):
+                return v.filter_and_map(filter_fn, map_fn, is_leaf_fn)
+
+            if isinstance(v, dict):
+                nd = {}
+                for k, v in v.items():
+                    tk = f"{vk}.{k}"
+                    nd[k] = unwrap(tk, v) if filter_fn(self, tk, v) else {}
+                return nd
+
+            if isinstance(v, list):
+                nl = []
+                for i, vi in enumerate(v):
+                    tk = f"{vk}.{i}"
+                    nl.append(unwrap(tk, vi) if filter_fn(self, tk, vi) else {})
+                return nl
+
+            raise RuntimeError("Unexpected leaf found while traversing the module")
+
+        return {k: unwrap(k, v) for k, v in self.items() if filter_fn(self, k, v)}
+
+    def parameters(self):
+        """Recursively return all the :class:`mlx.core.array` members of this Module
+        as a dict of dicts and lists."""
+        return self.filter_and_map(self.valid_parameter_filter)
+
+    def trainable_parameters(self):
+        """Recursively return all the non frozen :class:`mlx.core.array` members of
+        this Module as a dict of dicts and lists."""
+        return self.filter_and_map(self.trainable_parameter_filter)
+
+    def children(self):
+        """Return the direct descendants of this Module instance."""
+        return self.filter_and_map(
+            self.valid_child_filter, is_leaf_fn=lambda m, k, v: isinstance(v, Module)
+        )
+
+    def leaf_modules(self):
+        """Return the submodules that do not contain other modules."""
+
+        def _is_leaf_module(m, k, v):
+            return isinstance(v, Module) and len(tree_flatten(v.children())) == 0
+
+        return self.filter_and_map(self.valid_child_filter, is_leaf_fn=_is_leaf_module)
+
+    def update(self, parameters: dict):
+        """Replace the parameters of this Module with the provided ones in the
+        dict of dicts and lists.
+
+        Commonly used by the optimizer to change the model to the updated
+        (optimized) parameters. Also used by the :meth:`mlx.nn.value_and_grad` to set the
+        tracers in the model in order to compute gradients.
+
+        The passed in parameters dictionary need not be a full dictionary
+        similar to :meth:`parameters`. Only the provided locations will be
+        updated.
+
+        Args:
+            parameters (dict): A complete or partial dictionary of the modules
+                               parameters.
+        """
+
+        def apply(dst, parameters):
+            if isinstance(parameters, dict):
+                for k in parameters:
+                    if k in dst:
+                        current_value = dst[k]
+                        new_value = parameters[k]
+                        if isinstance(current_value, mx.array):
+                            dst[k] = new_value
+                        elif isinstance(current_value, Module):
+                            current_value.update(new_value)
+                        elif isinstance(current_value, (dict, list)):
+                            apply(current_value, new_value)
+            elif isinstance(parameters, list):
+                for i in range(len(dst)):
+                    current_value = dst[i]
+                    new_value = parameters[i]
+                    if isinstance(current_value, mx.array):
+                        dst[i] = new_value
+                    elif isinstance(current_value, Module):
+                        current_value.update(new_value)
+                    elif isinstance(current_value, (dict, list)):
+                        apply(current_value, new_value)
+
+        apply(self, parameters)
+
+    def apply(
+        self,
+        map_fn: Callable[[mx.array], mx.array],
+        filter_fn: Optional[Callable[["mlx.nn.Module", str, Any], bool]] = None,
+    ):
+        """Map all the parameters using the provided ``map_fn`` and immediately
+        update the module with the mapped parameters.
+
+        For instance running ``model.apply(lambda x: x.astype(mx.float16))``
+        casts all parameters to 16 bit floats.
+
+        Args:
+            map_fn (Callable): Maps an array to another array
+            filter_fn (Callable, optional): Filter to select which arrays to
+                map (default: :meth:`Module.valid_parameter_filter`).
+        """
+        filter_fn = filter_fn or Module.valid_parameter_filter
+        self.update(self.filter_and_map(filter_fn, map_fn))
+
+    def update_modules(self, modules: dict):
+        """Replace the child modules of this :class:`Module` instance with the
+        provided ones in the dict of dicts and lists.
+
+        It is the equivalent of :meth:`Module.update` but for modules instead
+        of parameters and allows us to flexibly edit complex architectures by
+        programmatically swapping layers.
+
+        The passed in parameters dictionary need not be a full dictionary
+        similar to :meth:`parameters`. Only the provided locations will be
+        updated.
+
+        Args:
+            modules (dict): A complete or partial dictionary of the modules
+                submodules.
+        """
+
+        def apply(dst, modules):
+            if isinstance(modules, dict):
+                for k in modules:
+                    if k in dst:
+                        current_value = dst[k]
+                        new_value = modules[k]
+                        if self.is_module(current_value) and self.is_module(new_value):
+                            dst[k] = new_value
+                        elif isinstance(current_value, (dict, list)):
+                            apply(current_value, new_value)
+            elif isinstance(modules, list):
+                for i in range(len(dst)):
+                    current_value = dst[i]
+                    new_value = modules[i]
+                    if self.is_module(current_value) and self.is_module(new_value):
+                        dst[i] = new_value
+                    elif isinstance(current_value, (dict, list)):
+                        apply(current_value, new_value)
+
+        apply(self, modules)
+
+    def apply_to_modules(self, apply_fn: Callable[[str, "mlx.nn.Module"], Any]):
+        """Apply a function to all the modules in this instance (including this
+        instance).
+
+        Args:
+            apply_fn (Callable): The function to apply to the modules.
+        """
+        module_stack = [("", self)]
+        while module_stack:
+            prefix, mod = module_stack.pop()
+            apply_fn(prefix, mod)
+            prefix = "." + prefix if prefix else ""
+            module_stack.extend(
+                tree_flatten(mod.children(), prefix=prefix, is_leaf=self.is_module)
+            )
+
+    def modules(self):
+        """Return a list with all the modules in this instance.
+
+        Returns:
+            A list of :class:`mlx.nn.Module` instances.
+        """
+        modulelist = []
+        self.apply_to_modules(lambda k, m: modulelist.append(m))
+        return modulelist
+
+    def named_modules(self):
+        """Return a list with all the modules in this instance and their name
+        with dot notation.
+
+        Returns:
+            A list of tuples (str, :class:`mlx.nn.Module`).
+        """
+        modulelist = []
+        self.apply_to_modules(lambda k, m: modulelist.append((k, m)))
+        return modulelist
+
+    def _validate_keys(self, keys, strict):
+        keys = keys if isinstance(keys, list) else [keys]
+        if strict:
+            for k in keys:
+                if k not in self:
+                    raise KeyError(f"Module doesn't contain member {k}.")
+        return keys
+
+    def freeze(
+        self,
+        *,
+        recurse: bool = True,
+        keys: Optional[Union[str, List[str]]] = None,
+        strict: bool = False,
+    ):
+        """Freeze the Module's parameters or some of them. Freezing a parameter means not
+        computing gradients for it.
+
+        This function is idempotent i.e. freezing a frozen model is a no-op.
+
+        Example:
+            For instance to only train the attention parameters from a Transformer:
+
+            .. code-block:: python
+
+                model = nn.Transformer()
+                model.freeze()
+                model.apply_to_modules(lambda k, v: v.unfreeze() if k.endswith("attention") else None)
+
+        Args:
+            recurse (bool, optional): If True then freeze the parameters of the
+                submodules as well. Default: ``True``.
+            keys (str or list[str], optional): If provided then only these
+                parameters will be frozen otherwise all the parameters of a
+                module. For instance freeze all biases by calling
+                ``module.freeze(keys="bias")``.
+            strict (bool, optional): If set to ``True`` validate that the passed keys exist.
+                Default: ``False``.
+        """
+
+        def _freeze_impl(_, m):
+            local_keys = keys
+            if local_keys is None:
+                local_keys = tree_flatten(
+                    m.filter_and_map(
+                        lambda m, k, v: (not isinstance(v, Module))
+                        and m.valid_parameter_filter(m, k, v)
+                    )
+                )
+                local_keys = [k for (k, v) in local_keys]
+
+            local_keys = m._validate_keys(local_keys, strict)
+            m._no_grad.update(local_keys)
+
+        if recurse:
+            self.apply_to_modules(_freeze_impl)
+        else:
+            _freeze_impl("", self)
+
+    def unfreeze(
+        self,
+        *,
+        recurse: bool = True,
+        keys: Optional[Union[str, List[str]]] = None,
+        strict: bool = False,
+    ):
+        """Unfreeze the Module's parameters or some of them.
+
+        This function is idempotent ie unfreezing a model that is not frozen is
+        a noop.
+
+        Example:
+
+            For instance to only train the biases of a Transformer one can do:
+
+            .. code-block:: python
+
+                model = nn.Transformer()
+                model.freeze()
+                model.unfreeze(keys="bias")
+
+        Args:
+            recurse (bool, optional): If True then unfreeze the parameters of the
+                submodules as well. Default: ``True``.
+            keys (str or list[str], optional): If provided then only these
+                parameters will be unfrozen otherwise all the parameters of a
+                module. For instance unfreeze all biases by calling
+                ``module.unfreeze(keys="bias")``.
+            strict (bool, optional): If set to ``True`` validate that the passed keys exist.
+                Default: ``False``.
+        """
+
+        def _unfreeze_impl(_, m):
+            if keys is None:
+                m._no_grad.clear()
+
+            else:
+                local_keys = m._validate_keys(keys, strict)
+                m._no_grad.difference_update(local_keys)
+
+        if recurse:
+            self.apply_to_modules(_unfreeze_impl)
+        else:
+            _unfreeze_impl("", self)
+
+    def train(self, mode: bool = True):
+        """Set the model in or out of training mode.
+
+        Training mode only applies to certain layers. For example
+        :obj:`Dropout` applies a random mask in training mode, but is the
+        identity in evaluation mode.
+
+        Args:
+            mode (bool): Indicate if the model should be in training or
+                evaluation mode. Default: ``True``.
+        """
+
+        def _set_train(_, m):
+            m._training = mode
+
+        self.apply_to_modules(_set_train)
+
+    def eval(self):
+        """Set the model to evaluation mode.
+
+        See :func:`train`.
+        """
+        self.train(False)
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/containers.py b/lib/python3.11/site-packages/mlx/nn/layers/containers.py
new file mode 100644
index 0000000000000000000000000000000000000000..c57fbb9922b494e72f830419cd5e0277c311dd4b
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/containers.py
@@ -0,0 +1,24 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn.layers.base import Module
+
+
+class Sequential(Module):
+    """A layer that calls the passed callables in order.
+
+    We can pass either modules or plain callables to the Sequential module. If
+    our functions have learnable parameters they should be implemented as
+    ``nn.Module`` instances.
+
+    Args:
+        modules (tuple of Callables): The modules to call in order
+    """
+
+    def __init__(self, *modules):
+        super().__init__()
+        self.layers = list(modules)
+
+    def __call__(self, x):
+        for m in self.layers:
+            x = m(x)
+        return x
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/convolution.py b/lib/python3.11/site-packages/mlx/nn/layers/convolution.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6928e18897397b2070319b2c081cdd3fcb9cdfc
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/convolution.py
@@ -0,0 +1,126 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Conv1d(Module):
+    """Applies a 1-dimensional convolution over the multi-channel input sequence.
+
+    The channels are expected to be last i.e. the input shape should be ``NLC`` where:
+        - ``N`` is the batch dimension
+        - ``L`` is the sequence length
+        - ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels
+        out_channels (int): The number of output channels
+        kernel_size (int): The size of the convolution filters
+        stride (int, optional): The stride when applying the filter.
+            Default: 1.
+        padding (int, optional): How many positions to 0-pad the input with.
+            Default: 0.
+        bias (bool, optional): If ``True`` add a learnable bias to the output.
+            Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int,
+        stride: int = 1,
+        padding: int = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        scale = math.sqrt(1 / (in_channels * kernel_size))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1]}, stride={self.stride}, "
+            f"padding={self.padding}, bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv1d(x, self.weight, self.stride, self.padding)
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class Conv2d(Module):
+    """Applies a 2-dimensional convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NHWC`` where:
+        - ``N`` is the batch dimension
+        - ``H`` is the input image height
+        - ``W`` is the input image width
+        - ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: 1.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: 0.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        kernel_size, stride, padding = map(
+            lambda x: (x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding),
+        )
+        scale = math.sqrt(1 / (in_channels * kernel_size[0] * kernel_size[1]))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:2]}, stride={self.stride}, "
+            f"padding={self.padding}, bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv2d(x, self.weight, self.stride, self.padding)
+        if "bias" in self:
+            y = y + self.bias
+        return y
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/dropout.py b/lib/python3.11/site-packages/mlx/nn/layers/dropout.py
new file mode 100644
index 0000000000000000000000000000000000000000..18b9b03a6ec82e6a770bdc243d431912cab4f6c0
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/dropout.py
@@ -0,0 +1,137 @@
+# Copyright © 2023 Apple Inc.
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Dropout(Module):
+    r"""Randomly zero a portion of the elements during training.
+
+    The remaining elements are multiplied with :math:`\frac{1}{1-p}` where
+    :math:`p` is the probability of zeroing an element. This is done so the
+    expected value of a given element will remain the same.
+
+    Args:
+        p (float): The probability to zero an element
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self):
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x):
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        mask = mx.random.bernoulli(self._p_1, x.shape)
+
+        return (1 / self._p_1) * mask * x
+
+
+class Dropout2d(Module):
+    r"""Apply 2D channel-wise dropout during training.
+
+    Randomly zero out entire channels independently with probability :math:`p`.
+    This layer expects the channels to be last, i.e. the input shape should be
+    ``NWHC`` or ``WHC`` where:``N`` is the batch dimension,``H`` is the input
+    image height,``W`` is the input image width, and``C`` is the number of
+    input channels
+
+    The remaining channels are scaled by :math:`\frac{1}{1-p}` to
+    maintain the expected value of each element. Unlike traditional dropout,
+    which zeros individual entries, this layer zeros entire channels. This is
+    beneficial for early convolution layers where adjacent pixels are
+    correlated. In such case, traditional dropout may not effectively
+    regularize activations. For more details, see [1].
+
+    [1]: Thompson, J., Goroshin, R., Jain, A., LeCun, Y. and Bregler C., 2015.
+    Efficient Object Localization Using Convolutional Networks. CVPR 2015.
+
+    Args:
+        p (float): Probability of zeroing a channel during training.
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self):
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x):
+        if x.ndim not in (3, 4):
+            raise ValueError(
+                f"Received input with {x.ndim} dimensions. Expected 3 or 4 dimensions."
+            )
+
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        # Dropout is applied on the whole channel
+        # 3D input: (1, 1, C)
+        # 4D input: (B, 1, 1, C)
+        mask_shape = x.shape
+        mask_shape[-2] = mask_shape[-3] = 1
+
+        mask = mx.random.bernoulli(p=self._p_1, shape=mask_shape)
+        return (1 / self._p_1) * mask * x
+
+
+class Dropout3d(Module):
+    r"""Apply 3D channel-wise dropout during training.
+
+    Randomly zero out entire channels independently with probability :math:`p`.
+    This layer expects the channels to be last, i.e., the input shape should be
+    `NDHWC` or `DHWC` where: `N` is the batch dimension, `D` is the depth,
+    `H` is the input image height, `W` is the input image width, and `C` is
+    the number of input channels.
+
+    The remaining channels are scaled by :math:`\frac{1}{1-p}` to
+    maintain the expected value of each element. Unlike traditional dropout,
+    which zeros individual entries, this layer zeros entire channels. This is
+    often beneficial for convolutional layers processing 3D data, like in
+    medical imaging or video processing.
+
+    Args:
+        p (float): Probability of zeroing a channel during training.
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self):
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x):
+        if x.ndim not in (4, 5):
+            raise ValueError(
+                f"Received input with {x.ndim} dimensions. Expected 4 or 5 dimensions."
+            )
+
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        # Dropout is applied on the whole channel
+        # 4D input: (1, 1, 1, C)
+        # 5D input: (B, 1, 1, 1, C)
+        mask_shape = list(x.shape)
+        mask_shape[-2] = mask_shape[-3] = mask_shape[-4] = 1
+
+        mask = mx.random.bernoulli(p=self._p_1, shape=mask_shape)
+        return (1 / self._p_1) * mask * x
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/embedding.py b/lib/python3.11/site-packages/mlx/nn/layers/embedding.py
new file mode 100644
index 0000000000000000000000000000000000000000..c62b1206f9d864d3b76119e998019c408bca4a4b
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/embedding.py
@@ -0,0 +1,30 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Embedding(Module):
+    """Implements a simple lookup table that maps each input integer to a
+    high-dimensional vector.
+
+    Typically used to embed discrete tokens for processing by neural networks.
+
+    Args:
+        num_embeddings (int): How many possible discrete tokens can we embed.
+                              Usually called the vocabulary size.
+        dims (int): The dimensionality of the embeddings.
+    """
+
+    def __init__(self, num_embeddings: int, dims: int):
+        super().__init__()
+        scale = math.sqrt(1 / dims)
+        self.weight = mx.random.normal((num_embeddings, dims)) * scale
+
+    def _extra_repr(self):
+        return f"{self.weight.shape[0]}, {self.weight.shape[1]}"
+
+    def __call__(self, x):
+        return self.weight[x]
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/linear.py b/lib/python3.11/site-packages/mlx/nn/layers/linear.py
new file mode 100644
index 0000000000000000000000000000000000000000..77b3407211e434ef1573fbf73fa84d8098a5f201
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/linear.py
@@ -0,0 +1,141 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Any
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Identity(Module):
+    r"""A placeholder identity operator that is argument-insensitive.
+
+    Args:
+        args: any argument (unused)
+        kwargs: any keyword argument (unused)
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__()
+
+    def __call__(self, x: mx.array) -> mx.array:
+        return x
+
+
+class Linear(Module):
+    r"""Applies an affine transformation to the input.
+
+    Concretely:
+
+    .. math::
+
+        y = x W^\top + b
+
+    where:
+    where :math:`W` has shape ``[output_dims, input_dims]`` and :math:`b` has shape ``[output_dims]``.
+
+    The values are initialized from the uniform distribution :math:`\mathcal{U}(-{k}, {k})`,
+    where :math:`k = \frac{1}{\sqrt{D_i}}` and :math:`D_i` is equal to ``input_dims``.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` then the layer will
+          not use a bias. Default is ``True``.
+    """
+
+    def __init__(self, input_dims: int, output_dims: int, bias: bool = True) -> None:
+        super().__init__()
+        scale = math.sqrt(1.0 / input_dims)
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        return f"input_dims={self.weight.shape[1]}, output_dims={self.weight.shape[0]}, bias={'bias' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        x = x @ self.weight.T
+        if "bias" in self:
+            x = x + self.bias
+        return x
+
+
+class Bilinear(Module):
+    r"""Applies a bilinear transformation to the inputs.
+
+    Concretely:
+
+    .. math::
+
+        y_i = x_1^\top W_i x_2 + b_i
+
+    where:
+    :math:`W` has shape ``[output_dims, input1_dims, input2_dims]``, :math:`b` has shape ``[output_dims ]``,
+    and :math:`i` indexes the output dimension.
+
+    The values are initialized from the uniform distribution :math:`\mathcal{U}(-{k}, {k})`,
+    where :math:`k = \frac{1}{\sqrt{D_1}}` and :math:`D_1` is ``input1_dims``.
+
+    Args:
+        input1_dims (int): The dimensionality of the input1 features
+        input2_dims (int): The dimensionality of the input2 features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` then the layer will
+          not use a bias. Default is ``True``.
+    """
+
+    def __init__(
+        self, input1_dims: int, input2_dims: int, output_dims: int, bias: bool = True
+    ) -> None:
+        super().__init__()
+        scale = math.sqrt(1.0 / input1_dims)
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input2_dims, input1_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        out, in2, in1 = self.weight.shape
+        return (
+            f"input1_dims={in1}, input2_dims={in2}, output_dims={out}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x1: mx.array, x2: mx.array) -> mx.array:
+        # Normalize shapes
+        out, in2, in1 = self.weight.shape
+        xshape = x1.shape[:-1]
+        x1 = x1.reshape(-1, in1)
+        x2 = x2.reshape(-1, 1, in2)
+
+        # Perform the bilinear transformation
+        w = self.weight.reshape(out * in2, in1)
+        y = x1 @ w.T
+        y = y.reshape(-1, out, in2).swapaxes(-2, -1)
+        y = x2 @ y
+        y = y.squeeze(1)
+
+        # Reset the shape
+        y = y.reshape(*xshape, out)
+
+        # Apply the bias
+        if "bias" in self:
+            y = y + self.bias
+
+        return y
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/normalization.py b/lib/python3.11/site-packages/mlx/nn/layers/normalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2b60ccba945669d1e29164c2c8e6f1eed063701
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/normalization.py
@@ -0,0 +1,368 @@
+# Copyright © 2023 Apple Inc.
+
+from typing import Tuple
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class InstanceNorm(Module):
+    r"""Applies instance normalization [1] on the inputs.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively. Both are of size :attr:`dims`,
+    if :attr:`affine` is ``True``.
+
+    Args:
+        dims (int): The number of features of the input.
+        eps (float): A value added to the denominator for numerical stability. Default: ``1e-5``.
+        affine (bool): Default: ``False``.
+
+    Shape:
+      - Input: :math:`(..., C)` where :math:`C` is equal to :attr:`dims`.
+      - Output: Same shape as the input.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.random.normal((8, 4, 4, 16))
+        >>> inorm = nn.InstanceNorm(dims=16)
+        >>> output = inorm(x)
+
+    References:
+        [1]: https://arxiv.org/abs/1607.08022
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        eps: float = 1e-5,
+        affine: bool = False,
+    ):
+        super().__init__()
+        if affine:
+            self.weight = mx.ones((dims,))
+            self.bias = mx.zeros((dims,))
+        self.dims = dims
+        self.eps = eps
+
+    def _extra_repr(self):
+        return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        reduction_axes = tuple(range(1, x.ndim - 1))
+        # Compute stats
+        mean = mx.mean(x, axis=reduction_axes, keepdims=True)
+        var = mx.var(x, axis=reduction_axes, keepdims=True)
+        # Normalize
+        x = (x - mean) * mx.rsqrt(var + self.eps)
+        # Scale and shift if necessary
+        return (self.weight * x + self.bias) if "weight" in self else x
+
+
+class LayerNorm(Module):
+    r"""Applies layer normalization [1] on the inputs.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively.
+
+    [1]: https://arxiv.org/abs/1607.06450
+
+    Args:
+        dims (int): The feature dimension of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+        affine (bool): If True learn an affine transform to apply after the
+            normalization
+    """
+
+    def __init__(self, dims: int, eps: float = 1e-5, affine: bool = True):
+        super().__init__()
+        if affine:
+            self.bias = mx.zeros((dims,))
+            self.weight = mx.ones((dims,))
+        self.eps = eps
+        self.dims = dims
+
+    def _extra_repr(self):
+        return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
+
+    def __call__(self, x):
+        means = mx.mean(x, axis=-1, keepdims=True)
+        var = mx.var(x, axis=-1, keepdims=True)
+        x = (x - means) * mx.rsqrt(var + self.eps)
+        return (self.weight * x + self.bias) if "weight" in self else x
+
+
+class RMSNorm(Module):
+    r"""Applies Root Mean Square normalization [1] to the inputs.
+
+    Computes
+
+    ..  math::
+
+        y = \frac{x}{\sqrt{E[x^2] + \epsilon}} \gamma
+
+    where :math:`\gamma` is a learned per feature dimension parameter initialized at
+    1.
+
+    [1]: https://arxiv.org/abs/1910.07467
+
+    Args:
+        dims (int): The feature dimension of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+    """
+
+    def __init__(self, dims: int, eps: float = 1e-5):
+        super().__init__()
+        self.weight = mx.ones((dims,))
+        self.eps = eps
+
+    def _extra_repr(self):
+        return f"{self.weight.shape[0]}, eps={self.eps}"
+
+    def __call__(self, x):
+        # S is 1/sqrt(N) where N is the size of the features of x and is used
+        # to compute a numerically more stable RMS of x by multiplying with S
+        # first and summing.
+        #
+        # This way we prefer underflow over overflow which is controlled with
+        # the parameter epsilon anyway.
+        S = 1 / x.shape[-1] ** 0.5
+
+        n = (x * S).square().sum(axis=-1, keepdims=True)
+        n = mx.rsqrt(n + self.eps)
+
+        return self.weight * x * n
+
+
+class GroupNorm(Module):
+    r"""Applies Group Normalization [1] to the inputs.
+
+    Computes the same normalization as layer norm, namely
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively. However, the mean and
+    variance are computed over the spatial dimensions and each group of
+    features. In particular, the input is split into num_groups across the
+    feature dimension.
+
+    The feature dimension is assumed to be the last dimension and the dimensions
+    that precede it (except the first) are considered the spatial dimensions.
+
+    [1]: https://arxiv.org/abs/1803.08494
+
+    Args:
+        num_groups (int): Number of groups to separate the features into
+        dims (int): The feature dimensions of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+        affine (bool): If True learn an affine transform to apply after the
+            normalization.
+        pytorch_compatible (bool): If True perform the group normalization in
+            the same order/grouping as PyTorch.
+    """
+
+    def __init__(
+        self,
+        num_groups: int,
+        dims: int,
+        eps: float = 1e-5,
+        affine: bool = True,
+        pytorch_compatible: bool = False,
+    ):
+        super().__init__()
+        if affine:
+            self.bias = mx.zeros((dims,))
+            self.weight = mx.ones((dims,))
+        self.num_groups = num_groups
+        self.dims = dims
+        self.eps = eps
+        self.pytorch_compatible = pytorch_compatible
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_groups}, {self.dims}, eps={self.eps}, "
+            f"affine={'weight' in self}, pytorch_compatible={self.pytorch_compatible}"
+        )
+
+    def _pytorch_compatible_group_norm(self, x):
+        num_groups = self.num_groups
+        batch, *rest, dims = x.shape
+
+        # Split into groups
+        x = x.reshape(batch, -1, num_groups, dims // num_groups)
+        x = x.transpose(0, 1, 3, 2).reshape(batch, -1, num_groups)
+
+        # Normalize
+        means = mx.mean(x, axis=1, keepdims=True)
+        var = mx.var(x, axis=1, keepdims=True)
+        x = (x - means) * mx.rsqrt(var + self.eps)
+        x = x.reshape(batch, -1, dims // num_groups, num_groups)
+        x = x.transpose(0, 1, 3, 2).reshape(batch, *rest, dims)
+
+        return x
+
+    def _group_norm(self, x):
+        num_groups = self.num_groups
+        batch, *rest, dims = x.shape
+
+        # Split into groups
+        x = x.reshape(batch, -1, num_groups)
+
+        # Normalize
+        means = mx.mean(x, axis=1, keepdims=True)
+        var = mx.var(x, axis=1, keepdims=True)
+        x = (x - means) * mx.rsqrt(var + self.eps)
+        x = x.reshape(batch, *rest, dims)
+
+        return x
+
+    def __call__(self, x):
+        group_norm = (
+            self._pytorch_compatible_group_norm
+            if self.pytorch_compatible
+            else self._group_norm
+        )
+        x = group_norm(x)
+        return (self.weight * x + self.bias) if "weight" in self else x
+
+
+class BatchNorm(Module):
+    r"""Applies Batch Normalization over a 2D or 3D input.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively.
+
+    The input shape is specified as ``NC`` or ``NLC``, where ``N`` is the
+    batch, ``C`` is the number of features or channels, and ``L`` is the
+    sequence length. The output has the same shape as the input. For
+    four-dimensional arrays, the shape is ``NHWC``, where ``H`` and ``W`` are
+    the height and width respectively.
+
+    For more information on Batch Normalization, see the original paper `Batch
+    Normalization: Accelerating Deep Network Training by Reducing Internal
+    Covariate Shift <https://arxiv.org/abs/1502.03167>`_.
+
+    Args:
+        num_features (int): The feature dimension to normalize over.
+        eps (float, optional): A small additive constant for numerical
+            stability. Default: ``1e-5``.
+        momentum (float, optional): The momentum for updating the running
+            mean and variance. Default: ``0.1``.
+        affine (bool, optional): If ``True``, apply a learned affine
+            transformation after the normalization. Default: ``True``.
+        track_running_stats (bool, optional): If ``True``, track the
+            running mean and variance. Default: ``True``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.random.normal((5, 4))
+        >>> bn = nn.BatchNorm(num_features=4, affine=True)
+        >>> output = bn(x)
+    """
+
+    def __init__(
+        self,
+        num_features: int,
+        eps: float = 1e-5,
+        momentum: float = 0.1,
+        affine: bool = True,
+        track_running_stats: bool = True,
+    ):
+        super().__init__()
+
+        self.num_features = num_features
+        self.eps = eps
+        self.momentum = momentum
+        self.track_running_stats = track_running_stats
+
+        if affine:
+            self.weight = mx.ones((num_features,))
+            self.bias = mx.zeros((num_features,))
+
+        if self.track_running_stats:
+            self.running_mean = mx.zeros((num_features,))
+            self.running_var = mx.ones((num_features,))
+            self.freeze(keys=["running_mean", "running_var"], recurse=False)
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze to make sure that running_mean and var are always
+        frozen parameters."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(keys=["running_mean", "running_var"], recurse=False)
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_features}, eps={self.eps}, "
+            f"momentum={self.momentum}, affine={'weight' in self}, "
+            f"track_running_stats={self.track_running_stats}"
+        )
+
+    def _calc_stats(self, x: mx.array) -> Tuple[mx.array, mx.array]:
+        """
+        Calculate the mean and variance of the input tensor across the batch
+        and spatial dimensions.
+
+        Args:
+            x (array): Input tensor.
+
+        Returns:
+            tuple: Tuple containing mean and variance.
+        """
+        reduction_axes = tuple(range(0, x.ndim - 1))
+
+        mean = mx.mean(x, axis=reduction_axes, keepdims=True)
+        var = mx.var(x, axis=reduction_axes, keepdims=True)
+
+        return mean, var
+
+    def __call__(self, x: mx.array) -> mx.array:
+        """
+        Forward pass of BatchNorm.
+
+        Args:
+            x (array): Input tensor.
+
+        Returns:
+            array: Normalized output tensor.
+        """
+        if x.ndim < 2 or x.ndim > 4:
+            raise ValueError(
+                f"Expected input tensor to have 2, 3 or 4 dimensions, but got {x.ndim}"
+            )
+
+        # Calculate the mean and variance used to normalize the input x. If we
+        # are in training mode update the running stats if needed.
+        mean, var = self._calc_stats(x)
+        if self.training and self.track_running_stats:
+            mu = self.momentum
+            self.running_mean = (1 - mu) * self.running_mean + mu * mean
+            self.running_var = (1 - mu) * self.running_var + mu * var
+        elif self.track_running_stats:
+            mean = self.running_mean
+            var = self.running_var
+
+        x = (x - mean) * mx.rsqrt(var + self.eps)
+        return (self.weight * x + self.bias) if "weight" in self else x
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/positional_encoding.py b/lib/python3.11/site-packages/mlx/nn/layers/positional_encoding.py
new file mode 100644
index 0000000000000000000000000000000000000000..032fd0f922b3b985c73c9228d53b3f8aa851c4f7
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/positional_encoding.py
@@ -0,0 +1,199 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Optional
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class RoPE(Module):
+    """Implements the rotary positional encoding.
+
+    The traditional implementation rotates consecutive pairs of elements in the
+    feature dimension while the default implementation rotates pairs with
+    stride half the feature dimensions for efficiency.
+
+    For more details see `RoFormer: Enhanced Transformer with Rotary Position
+    Embedding <https://arxiv.org/abs/2104.09864>`_.
+
+    Args:
+        dims (int): The feature dimensions to be rotated. If the input feature
+            is larger than dims then the rest is left unchanged.
+        traditional (bool, optional): If set to True choose the traditional
+            implementation which is slightly less efficient. Default: ``False``.
+        base (float, optional): The base used to compute angular frequency for
+            each dimension in the positional encodings. Default: ``10000``.
+        scale (float, optional): The scale used to scale the positions. Default: ``1.0``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        traditional: bool = False,
+        base: float = 10000,
+        scale: float = 1.0,
+    ):
+        super().__init__()
+        self.dims = dims
+        self.traditional = traditional
+        self.base = base
+        self.scale = scale
+
+    def _extra_repr(self):
+        return f"{self.dims}, traditional={self.traditional}"
+
+    def _compute_rope(self, costheta, sintheta, x):
+        x1 = x[..., : self.dims // 2]
+        x2 = x[..., self.dims // 2 : self.dims]
+        rx1 = x1 * costheta - x2 * sintheta
+        rx2 = x1 * sintheta + x2 * costheta
+
+        if self.dims < x.shape[-1]:
+            rx = mx.concatenate([rx1, rx2, x[..., self.dims :]], axis=-1)
+        else:
+            rx = mx.concatenate([rx1, rx2], axis=-1)
+
+        return rx
+
+    def _compute_traditional_rope(self, costheta, sintheta, x):
+        x1 = x[..., ::2]
+        x2 = x[..., 1::2]
+        rx1 = x1 * costheta - x2 * sintheta
+        rx2 = x1 * sintheta + x2 * costheta
+
+        if self.dims < x.shape[-1]:
+            raise NotImplementedError(
+                "RoPE doesn't implement partial traditional application"
+            )
+
+        rx = mx.concatenate([rx1[..., None], rx2[..., None]], axis=-1)
+
+        return rx
+
+    def __call__(self, x, offset: int = 0):
+        shape = x.shape
+        x = mx.reshape(x, (-1, shape[-2], shape[-1]))
+        N = x.shape[1] + offset
+        costheta, sintheta = RoPE.create_cos_sin_theta(
+            N, self.dims, offset=offset, base=self.base, scale=self.scale, dtype=x.dtype
+        )
+
+        rope = (
+            self._compute_traditional_rope if self.traditional else self._compute_rope
+        )
+        rx = rope(costheta, sintheta, x)
+
+        return mx.reshape(rx, shape)
+
+    @staticmethod
+    def create_cos_sin_theta(
+        N: int,
+        D: int,
+        offset: int = 0,
+        base: float = 10000,
+        scale: float = 1.0,
+        dtype=mx.float32,
+    ):
+        D = D // 2
+        positions = mx.arange(offset, N, dtype=dtype) * scale
+        freqs = mx.exp(-mx.arange(0.0, D, dtype=dtype) * (math.log(base) / D))
+        theta = mx.reshape(positions, (-1, 1)) * mx.reshape(freqs, (1, -1))
+        return mx.cos(theta), mx.sin(theta)
+
+
+class SinusoidalPositionalEncoding(Module):
+    r"""Implements sinusoidal positional encoding.
+
+    For more details see the paper `Attention Is All You Need
+    <https://arxiv.org/abs/1706.03762>`_.
+
+    Args:
+        dims (int): The dimensionality of the resulting positional embeddings.
+        min_freq (float, optional): The minimum frequency expected. Default:
+            ``0.0001``.
+        max_freq (float, optional): The maximum frequency expected. Default:
+            ``1``.
+        scale (float, optional): A multiplicative scale for the embeddings.
+            Default: ``sqrt(dims//2)``.
+        cos_first (bool, optional): If ``True`` embed using ``[cos(x); sin(x)]``
+            instead of the reverse. Default: ``False``.
+        full_turns (bool, optional): If ``True`` multiply the frequencies with
+            :math:`2\pi`. Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        min_freq: float = 0.0001,
+        max_freq: float = 1,
+        scale: Optional[float] = None,
+        cos_first: bool = False,
+        full_turns: bool = False,
+    ):
+        super().__init__()
+
+        one_zero = 1 - mx.arange(0, dims // 2) / (dims // 2 - 1)
+        min_freq = math.log(min_freq)
+        max_freq = math.log(max_freq)
+
+        # Start with underscore so it is not included in the parameters
+        self._sigmas = mx.exp(one_zero * (max_freq - min_freq) + min_freq)
+        if full_turns:
+            self._sigmas = self._sigmas * (2 * math.pi)
+
+        # Save some constants that define the implementation
+        self.scale = scale or (2 / dims) ** 0.5
+        self.cos_first = cos_first
+
+    def __call__(self, x):
+        y = x[..., None] * self._sigmas
+        cosy = mx.cos(y)
+        siny = mx.sin(y)
+
+        if self.cos_first:
+            y = mx.concatenate([cosy, siny], axis=-1)
+        else:
+            y = mx.concatenate([siny, cosy], axis=-1)
+
+        if self.scale != 1:
+            y = y * self.scale
+
+        return y
+
+
+class ALiBi(Module):
+    @staticmethod
+    def create_alibi_matrix(
+        q_sequence_length: int,
+        k_sequence_length: int,
+        num_heads: int,
+        offset: int,
+        dtype=mx.float32,
+    ):
+        x1 = mx.arange(offset, q_sequence_length)
+        x2 = mx.arange(0, k_sequence_length)
+        distance_matrix = -mx.abs(
+            mx.expand_dims(x1[:, None] - x2[None, :], axis=(0, 1))
+        )
+        alibi_slope = ALiBi.create_alibi_slope(num_heads=num_heads)
+        alibi_mask = (distance_matrix * alibi_slope).astype(dtype)
+        return alibi_mask
+
+    @staticmethod
+    def create_alibi_slope(num_heads):
+        x = (2**8) ** (1 / num_heads)
+        out = mx.power(x, -mx.arange(1, num_heads + 1))
+        return mx.expand_dims(out, axis=(-1, -2))
+
+    def __call__(self, attention_scores, offset=0, mask=None):
+        alibi_mask = ALiBi.create_alibi_matrix(
+            q_sequence_length=attention_scores.shape[-2] + offset,
+            k_sequence_length=attention_scores.shape[-1],
+            num_heads=attention_scores.shape[1],
+            offset=offset,
+            dtype=attention_scores.dtype,
+        )
+        if mask is not None:
+            alibi_mask = alibi_mask + mask
+        return attention_scores + alibi_mask
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/quantized.py b/lib/python3.11/site-packages/mlx/nn/layers/quantized.py
new file mode 100644
index 0000000000000000000000000000000000000000..a52285633a9f9e42d76de360bf02d49412a66142
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/quantized.py
@@ -0,0 +1,125 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.linear import Linear
+from mlx.utils import tree_flatten, tree_map
+
+
+class QuantizedLinear(Module):
+    """Applies an affine transformation to the input using a quantized weight matrix.
+
+    It is the quantized equivalent of :class:`mlx.nn.Linear`. For now its
+    parameters are frozen and will not be included in any gradient computation
+    but this will probably change in the future.
+
+    QuantizedLinear also provides two useful classmethods to convert linear
+    layers to QuantizedLinear layers.
+
+    - :meth:`from_linear` returns a QuantizedLinear layer that applies the same
+      linear transformation up to the quantization error.
+    - :meth:`quantize_module` swaps all the linear layers of the passed module
+      with QuantizedLinear ones.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` then the layer will not use
+            a bias. (default: True).
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. (default: 64)
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. (default: 4)
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group_size: int = 64,
+        bits: int = 4,
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1 / input_dims)
+        weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims),
+        )
+        self.weight, self.scales, self.biases = mx.quantize(weight, group_size, bits)
+
+        # And bias if needed
+        if bias:
+            self.bias = mx.zeros((output_dims,))
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze so that we unfreeze any layers we might contain but
+        our parameters will remain frozen."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(recurse=False)
+
+    def _extra_repr(self):
+        out_dims, in_dims = self.weight.shape
+        in_dims *= 32 // self.bits
+        return (
+            f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self},"
+            f"group_size={self.group_size}, bits={self.bits}"
+        )
+
+    def __call__(self, x):
+        x = mx.quantized_matmul(
+            x,
+            self.weight,
+            scales=self.scales,
+            biases=self.biases,
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+        )
+        if "bias" in self:
+            x = x + self.bias
+        return x
+
+    @classmethod
+    def from_linear(cls, linear_layer: Module, group_size: int = 64, bits: int = 4):
+        """Create a QuantizedLinear layer from the parameters of a provided
+        linear layer."""
+        output_dims, input_dims = linear_layer.weight.shape
+        ql = cls(input_dims, output_dims, False, group_size, bits)
+        ql.weight, ql.scales, ql.biases = mx.quantize(
+            linear_layer.weight, group_size, bits
+        )
+        if "bias" in linear_layer:
+            ql.bias = linear_layer.bias
+
+        return ql
+
+    @classmethod
+    def quantize_module(
+        cls,
+        model: Module,
+        group_size: int = 64,
+        bits: int = 4,
+        linear_class_predicate=lambda m: isinstance(m, Linear),
+    ):
+        def _quantize_if_linear(m):
+            if linear_class_predicate(m):
+                return cls.from_linear(m, group_size, bits)
+            else:
+                return m
+
+        leaves = model.leaf_modules()
+        leaves = tree_map(_quantize_if_linear, leaves, is_leaf=Module.is_module)
+        model.update_modules(leaves)
diff --git a/lib/python3.11/site-packages/mlx/nn/layers/transformer.py b/lib/python3.11/site-packages/mlx/nn/layers/transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..c61f5405f2d018c9dcfe03c29ab3caab94f02420
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/layers/transformer.py
@@ -0,0 +1,354 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Any, Callable, Optional
+
+import mlx.core as mx
+from mlx.nn.layers.activations import relu
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.dropout import Dropout
+from mlx.nn.layers.linear import Linear
+from mlx.nn.layers.normalization import LayerNorm
+
+
+class MultiHeadAttention(Module):
+    """Implements the scaled dot product attention with multiple heads.
+
+    Given inputs for queries, keys and values the ``MultiHeadAttention``
+    produces new values by aggregating information from the input values
+    according to the similarities of the input queries and keys.
+
+    All inputs as well as the output are linearly projected without biases by
+    default.
+
+    ``MultiHeadAttention`` also takes an optional additive attention mask that
+    should be broadcastable with ``(batch, num_heads, # queries, # keys)``. The
+    mask should have ``-inf`` or very large negative numbers at the positions
+    that should *not* be attended to.
+
+    Args:
+        dims (int): The model dimensions. This is also the default
+            value for the queries, keys, values, and the output.
+        num_heads (int): The number of attention heads to use.
+        query_input_dims (int, optional): The input dimensions of the queries.
+            Default: ``dims``.
+        key_input_dims (int, optional): The input dimensions of the keys.
+            Default: ``dims``.
+        value_input_dims (int, optional): The input dimensions of the values.
+            Default: ``key_input_dims``.
+        value_dims (int, optional): The dimensions of the values after the
+            projection. Default: ``dims``.
+        value_output_dims (int, optional): The dimensions the new values will
+            be projected to. Default: ``dims``.
+        bias (bool, optional): Whether or not to use a bias in the projections.
+            Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        query_input_dims: Optional[int] = None,
+        key_input_dims: Optional[int] = None,
+        value_input_dims: Optional[int] = None,
+        value_dims: Optional[int] = None,
+        value_output_dims: Optional[int] = None,
+        bias: bool = False,
+    ):
+        super().__init__()
+
+        if (dims % num_heads) != 0:
+            raise ValueError(
+                "The input feature dimensions should be divisible by the "
+                f"number of heads ({dims} % {num_heads}) != 0"
+            )
+
+        query_input_dims = query_input_dims or dims
+        key_input_dims = key_input_dims or dims
+        value_input_dims = value_input_dims or key_input_dims
+        value_dims = value_dims or dims
+        value_output_dims = value_output_dims or dims
+
+        self.num_heads = num_heads
+        self.query_proj = Linear(query_input_dims, dims, bias=bias)
+        self.key_proj = Linear(key_input_dims, dims, bias=bias)
+        self.value_proj = Linear(value_input_dims, value_dims, bias=bias)
+        self.out_proj = Linear(value_dims, value_output_dims, bias=bias)
+
+    def __call__(self, queries, keys, values, mask=None):
+        queries = self.query_proj(queries)
+        keys = self.key_proj(keys)
+        values = self.value_proj(values)
+
+        num_heads = self.num_heads
+        B, L, D = queries.shape
+        _, S, _ = keys.shape
+        queries = queries.reshape(B, L, num_heads, -1).transpose(0, 2, 1, 3)
+        keys = keys.reshape(B, S, num_heads, -1).transpose(0, 2, 3, 1)
+        values = values.reshape(B, S, num_heads, -1).transpose(0, 2, 1, 3)
+
+        # Dimensions are [batch x num heads x sequence x hidden dim]
+        scale = math.sqrt(1 / queries.shape[-1])
+        scores = (queries * scale) @ keys
+        if mask is not None:
+            scores = scores + mask.astype(scores.dtype)
+        scores = mx.softmax(scores, axis=-1)
+        values_hat = (scores @ values).transpose(0, 2, 1, 3).reshape(B, L, -1)
+
+        return self.out_proj(values_hat)
+
+    @staticmethod
+    def create_additive_causal_mask(N: int, dtype: mx.Dtype = mx.float32):
+        indices = mx.arange(N)
+        mask = indices[:, None] < indices[None]
+        # usually inf but 1e9 is as good and softmax(full(1e9)) != nan
+        # TODO: Should replace this with finfo(dtype).min
+        mask = mask.astype(dtype) * -1e9
+        return mask
+
+
+class TransformerEncoderLayer(Module):
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        norm_first: bool = False,
+    ):
+        super().__init__()
+        mlp_dims = mlp_dims or dims * 4
+        self.attention = MultiHeadAttention(dims, num_heads)
+        self.ln1 = LayerNorm(dims)
+        self.ln2 = LayerNorm(dims)
+        self.linear1 = Linear(dims, mlp_dims)
+        self.linear2 = Linear(mlp_dims, dims)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.activation = activation
+        self.norm_first = norm_first
+
+    def __call__(self, x, mask):
+        if self.norm_first:
+            y = self.ln1(x)
+            y = self.attention(y, y, y, mask)
+            y = self.dropout1(y)
+            x = x + y
+
+            y = self.ln2(x)
+            y = self.linear1(y)
+            y = self.activation(y)
+            y = self.dropout2(y)
+            y = self.linear2(y)
+            y = x + y
+
+        else:
+            y = self.attention(x, x, x, mask)
+            y = self.dropout1(y)
+            y = self.ln1(x + y)
+
+            y = self.linear1(y)
+            y = self.activation(y)
+            y = self.dropout2(y)
+            y = self.linear2(y)
+            y = self.ln2(x + y)
+
+        return y
+
+
+class TransformerEncoder(Module):
+    def __init__(
+        self,
+        num_layers: int,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation=relu,
+        norm_first: bool = False,
+    ):
+        super().__init__()
+        self.layers = [
+            TransformerEncoderLayer(
+                dims, num_heads, mlp_dims, dropout, activation, norm_first
+            )
+            for i in range(num_layers)
+        ]
+        self.ln = LayerNorm(dims)
+
+    def __call__(self, x, mask):
+        for l in self.layers:
+            x = l(x, mask)
+        return self.ln(x)
+
+
+class TransformerDecoderLayer(Module):
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        norm_first: bool = False,
+    ):
+        super().__init__()
+        mlp_dims = mlp_dims or dims * 4
+        self.self_attention = MultiHeadAttention(dims, num_heads)
+        self.cross_attention = MultiHeadAttention(dims, num_heads)
+        self.ln1 = LayerNorm(dims)
+        self.ln2 = LayerNorm(dims)
+        self.ln3 = LayerNorm(dims)
+        self.linear1 = Linear(dims, mlp_dims)
+        self.linear2 = Linear(mlp_dims, dims)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.dropout3 = Dropout(dropout)
+        self.activation = activation
+        self.norm_first = norm_first
+
+    def __call__(self, x, memory, x_mask, memory_mask):
+        if self.norm_first:
+            y = self.ln1(x)
+            y = self.self_attention(y, y, y, x_mask)
+            y = self.dropout1(y)
+            x = x + y
+
+            y = self.ln2(x)
+            y = self.cross_attention(y, memory, memory, memory_mask)
+            y = self.dropout2(y)
+            x = x + y
+
+            y = self.ln3(x)
+            y = self.linear1(y)
+            y = self.activation(y)
+            y = self.dropout3(y)
+            y = self.linear2(y)
+            y = x + y
+
+        else:
+            y = self.self_attention(x, x, x, x_mask)
+            y = self.dropout1(y)
+            x = self.ln1(x + y)
+
+            y = self.cross_attention(y, memory, memory, memory_mask)
+            y = self.dropout2(y)
+            x = self.ln1(x + y)
+
+            y = self.linear1(x)
+            y = self.activation(y)
+            y = self.dropout3(y)
+            y = self.linear2(y)
+            y = self.ln3(x + y)
+
+        return y
+
+
+class TransformerDecoder(Module):
+    def __init__(
+        self,
+        num_layers: int,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation=relu,
+        norm_first: bool = False,
+    ):
+        super().__init__()
+        self.layers = [
+            TransformerDecoderLayer(
+                dims, num_heads, mlp_dims, dropout, activation, norm_first
+            )
+            for i in range(num_layers)
+        ]
+        self.ln = LayerNorm(dims)
+
+    def __call__(self, x, memory, x_mask, memory_mask):
+        for l in self.layers:
+            x = l(x, memory, x_mask, memory_mask)
+        return self.ln(x)
+
+
+class Transformer(Module):
+    """
+    Implements a standard Transformer model.
+
+    The implementation is based on `Attention Is All You Need
+    <https://arxiv.org/abs/1706.03762>`_.
+
+    The Transformer model contains an encoder and a decoder. The encoder
+    processes the input sequence and the decoder generates the output sequence.
+    The interaction between encoder and decoder happens through the attention
+    mechanism.
+
+    Args:
+        dims (int, optional): The number of expected features in the
+            encoder/decoder inputs. Default: ``512``.
+        num_heads (int, optional): The number of attention heads. Default:
+            ``8``.
+        num_encoder_layers (int, optional): The number of encoder layers in the
+            Transformer encoder. Default: ``6``.
+        num_decoder_layers (int, optional): The number of decoder layers in the
+            Transformer decoder. Default: ``6``.
+        mlp_dims (int, optional): The hidden dimension of the MLP block in each
+            Transformer layer. Defaults to ``4*dims`` if not provided. Default:
+            ``None``.
+        dropout (float, optional): The dropout value for the Transformer
+            encoder and decoder. Dropout is used after each attention layer and
+            the activation in the MLP layer. Default: ``0.0``.
+        activation (function, optional): the activation function for the MLP
+            hidden layer. Default: :func:`mlx.nn.relu`.
+        custom_encoder (nn.Module, optional): A custom encoder to replace the
+            standard Transformer encoder. Default: ``None``.
+        custom_decoder (nn.Module, optional): A custom decoder to replace the
+            standard Transformer decoder. Default: ``None``.
+        norm_first (bool, optional): if ``True``, encoder and decoder layers
+            will perform layer normalization before attention and MLP
+            operations, otherwise after. Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int = 512,
+        num_heads: int = 8,
+        num_encoder_layers: int = 6,
+        num_decoder_layers: int = 6,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        custom_encoder: Optional[Any] = None,
+        custom_decoder: Optional[Any] = None,
+        norm_first: bool = False,
+    ):
+        super().__init__()
+        if custom_encoder is not None:
+            self.encoder = custom_encoder
+        else:
+            self.encoder = TransformerEncoder(
+                num_encoder_layers,
+                dims,
+                num_heads,
+                mlp_dims,
+                dropout,
+                activation,
+                norm_first,
+            )
+
+        if custom_decoder is not None:
+            self.decoder = custom_decoder
+        else:
+            self.decoder = TransformerDecoder(
+                num_decoder_layers,
+                dims,
+                num_heads,
+                mlp_dims,
+                dropout,
+                activation,
+                norm_first,
+            )
+
+    def __call__(self, src, tgt, src_mask, tgt_mask, memory_mask):
+        memory = self.encoder(src, src_mask)
+        return self.decoder(tgt, memory, tgt_mask, memory_mask)
diff --git a/lib/python3.11/site-packages/mlx/nn/losses.py b/lib/python3.11/site-packages/mlx/nn/losses.py
new file mode 100644
index 0000000000000000000000000000000000000000..91316fd04525827a17c698c451eedd6800266b16
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/losses.py
@@ -0,0 +1,374 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def cross_entropy(
+    logits: mx.array,
+    targets: mx.array,
+    weights: mx.array = None,
+    axis: int = -1,
+    label_smoothing: float = 0.0,
+    reduction: str = "none",
+) -> mx.array:
+    """
+    Computes the cross entropy loss.
+
+    Args:
+        logits (array): The unnormalized predicted logits.
+        targets (array): The target values, as class indices.
+        weights (array, optional): Weights for each target. Default: ``None``.
+        axis (int, optional): The axis over which to compute softmax. Default: ``-1``.
+        label_smoothing (float, optional): Label smoothing factor. Default: ``0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+            ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed cross entropy loss.
+    """
+    if label_smoothing < 0 or label_smoothing >= 1:
+        raise ValueError(f"Label smoothing must in [0, 1), got {label_smoothing}.")
+
+    score = mx.take_along_axis(logits, targets[..., None], axis).squeeze(-1)
+    logsumexp_logits = mx.logsumexp(logits, axis=axis)
+    if label_smoothing > 0:
+        # Adjust the true class score with label smoothing
+        adjusted_score = (1 - label_smoothing) * score
+
+        # Calculate the mean logit across the classes for smoothed loss
+        mean_logits = logits.mean(axis=axis)
+        smoothed_loss = -mean_logits * label_smoothing
+
+        # Combine the adjusted score and smoothed loss with the logsumexp logits
+        loss = logsumexp_logits - adjusted_score + smoothed_loss
+    else:
+        loss = logsumexp_logits - score
+
+    # Apply weights if provided
+    if weights is not None:
+        if weights.shape != targets.shape:
+            raise ValueError(
+                f"Weights with shape {weights.shape} is not the same as "
+                f"targets with shape {targets.shape}."
+            )
+        loss *= weights
+
+    # Apply reduction
+    return _reduce(loss, reduction)
+
+
+def binary_cross_entropy(
+    logits: mx.array, targets: mx.array, reduction: str = "none"
+) -> mx.array:
+    """
+    Computes the binary cross entropy loss.
+
+    Args:
+        logits (array): The unnormalized (pre-sigmoid) predicted logits.
+        targets (array): The binary target values in {0, 1}.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed binary cross entropy loss.
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> inputs = mx.array([0.105361, 0.223144, 1.20397, 0.916291])
+        >>> targets = mx.array([0, 0, 1, 1])
+        >>> loss = nn.losses.binary_cross_entropy(inputs, targets, "mean")
+        >>> loss
+        array([0.612192], dtype=float32)
+    """
+    loss = mx.logaddexp(0.0, logits) - targets * logits
+    return _reduce(loss, reduction)
+
+
+def l1_loss(
+    predictions: mx.array, targets: mx.array, reduction: str = "mean"
+) -> mx.array:
+    """
+    Computes the L1 loss.
+
+    Args:
+        predictions (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed L1 loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+    loss = mx.abs(predictions - targets)
+
+    return _reduce(loss, reduction)
+
+
+def mse_loss(
+    predictions: mx.array, targets: mx.array, reduction: str = "mean"
+) -> mx.array:
+    """
+    Computes the mean squared error loss.
+
+    Args:
+        predictions (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed mean squared error loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+
+    loss = mx.square(predictions - targets)
+    return _reduce(loss, reduction)
+
+
+def nll_loss(
+    inputs: mx.array, targets: mx.array, axis: int = -1, reduction: str = "none"
+) -> mx.array:
+    """
+    Computes the negative log likelihood loss.
+
+    Args:
+        inputs (array): The predicted distribution in log space.
+        targets (array): The target values.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed NLL loss.
+    """
+    loss = -mx.take_along_axis(inputs, targets[..., None], axis).squeeze(-1)
+
+    return _reduce(loss, reduction)
+
+
+def kl_div_loss(
+    inputs: mx.array, targets: mx.array, axis: int = -1, reduction: str = "none"
+) -> mx.array:
+    """
+    Computes the Kullback-Leibler divergence loss.
+
+    Computes the following when ``reduction == 'none'``:
+
+    .. code-block:: python
+
+        mx.exp(targets) * (targets - inputs).sum(axis)
+
+    Args:
+        inputs (array): Log probabilities for the predicted distribution.
+        targets (array): Log probabilities for the target distribution.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed Kullback-Leibler divergence loss.
+    """
+    loss = mx.sum(mx.exp(targets) * (targets - inputs), axis)
+
+    return _reduce(loss, reduction)
+
+
+def smooth_l1_loss(
+    predictions: mx.array, targets: mx.array, beta: float = 1.0, reduction: str = "mean"
+) -> mx.array:
+    r"""
+    Computes the smooth L1 loss.
+
+    The smooth L1 loss is a variant of the L1 loss which replaces the absolute
+    difference with a squared difference when the absolute difference is less
+    than ``beta``.
+
+    The formula for the smooth L1 Loss is:
+
+    .. math::
+
+       l =
+          \begin{cases}
+            0.5 (x - y)^2, & \text{ if } & (x - y) < \beta \\
+            |x - y| - 0.5 \beta, &  & \text{otherwise}
+          \end{cases}
+
+    Args:
+        predictions (array): Predicted values.
+        targets (array): Ground truth values.
+        beta (float, optional): The threshold after which the loss changes
+          from the squared to the absolute difference. Default: ``1.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed smooth L1 loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+
+    diff = predictions - targets
+    loss = mx.where(
+        diff < beta, 0.5 * mx.square(diff) / beta, mx.abs(diff) - 0.5 * beta
+    )
+
+    return _reduce(loss, reduction)
+
+
+def triplet_loss(
+    anchors: mx.array,
+    positives: mx.array,
+    negatives: mx.array,
+    axis: int = -1,
+    p: int = 2,
+    margin: float = 1.0,
+    eps: float = 1e-6,
+    reduction: str = "none",
+) -> mx.array:
+    r"""
+    Computes the triplet loss for a set of anchor, positive, and negative samples.
+    Margin is represented with alpha in the math section.
+
+    .. math::
+
+       L_{\text{triplet}} = \max\left(\|A - P\|_p - \|A - N\|_p + \alpha, 0\right)
+
+    Args:
+        anchors (array): The anchor samples.
+        positives (array): The positive samples.
+        negatives (array): The negative samples.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        p (int, optional): The norm degree for pairwise distance. Default: ``2``.
+        margin (float, optional): Margin for the triplet loss. Defaults to ``1.0``.
+        eps (float, optional): Small positive constant to prevent numerical instability. Defaults to ``1e-6``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: Computed triplet loss. If reduction is "none", returns a tensor of the same shape as input;
+                  if reduction is "mean" or "sum", returns a scalar tensor.
+    """
+    loss = mx.maximum(
+        mx.sqrt(mx.power(anchors - positives, p).sum(axis) + eps)
+        - mx.sqrt(mx.power(anchors - negatives, p).sum(axis) + eps)
+        + margin,
+        0,
+    )
+    return _reduce(loss, reduction)
+
+
+def _reduce(loss: mx.array, reduction: str = "none"):
+    if reduction == "mean":
+        return mx.mean(loss)
+    elif reduction == "sum":
+        return mx.sum(loss)
+    elif reduction == "none":
+        return loss
+    else:
+        raise ValueError("Invalid reduction. Must be 'none', 'mean', or 'sum'.")
+
+
+def hinge_loss(
+    inputs: mx.array, targets: mx.array, reduction: str = "none"
+) -> mx.array:
+    r"""
+    Computes the hinge loss between inputs and targets.
+
+    .. math::
+
+       \text{hinge}(y, y_{\text{pred}}) = \max(0, 1 - y \cdot y_{\text{pred}})
+
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values. They should be -1 or 1.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed hinge loss.
+    """
+    loss = mx.maximum(1 - inputs * targets, 0)
+
+    return _reduce(loss, reduction)
+
+
+def huber_loss(
+    inputs: mx.array, targets: mx.array, delta: float = 1.0, reduction: str = "none"
+) -> mx.array:
+    r"""
+    Computes the Huber loss between inputs and targets.
+
+    .. math::
+
+        L_{\delta}(a) =
+        \left\{ \begin{array}{ll}
+            \frac{1}{2} a^2 & \text{for } |a| \leq \delta, \\
+            \delta \left( |a| - \frac{1}{2} \delta \right) & \text{otherwise.}
+        \end{array} \right.
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values.
+        delta (float, optional): The threshold at which to change between L1 and L2 loss.
+          Default: ``1.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed Huber loss.
+    """
+    errors = inputs - targets
+    abs_errors = mx.abs(errors)
+    quadratic = mx.minimum(abs_errors, delta)
+    linear = abs_errors - quadratic
+    loss = 0.5 * quadratic**2 + delta * linear
+
+    return _reduce(loss, reduction)
+
+
+def log_cosh_loss(
+    inputs: mx.array, targets: mx.array, reduction: str = "none"
+) -> mx.array:
+    r"""
+    Computes the log cosh loss between inputs and targets.
+
+    Logcosh acts like L2 loss for small errors, ensuring stable gradients,
+    and like the L1 loss for large errors, reducing sensitivity to outliers. This
+    dual behavior offers a balanced, robust approach for regression tasks.
+
+    .. math::
+
+       \text{logcosh}(y_{\text{true}}, y_{\text{pred}}) =
+            \frac{1}{n} \sum_{i=1}^{n}
+            \log(\cosh(y_{\text{pred}}^{(i)} - y_{\text{true}}^{(i)}))
+
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed log cosh loss.
+    """
+    errors = inputs - targets
+    loss = mx.logaddexp(errors, -errors) - math.log(2)
+
+    return _reduce(loss, reduction)
diff --git a/lib/python3.11/site-packages/mlx/nn/utils.py b/lib/python3.11/site-packages/mlx/nn/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ab80cb00f30b8e1555fb04c83cb0cbfdecd5e87
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/nn/utils.py
@@ -0,0 +1,33 @@
+# Copyright © 2023 Apple Inc.
+
+from typing import Callable
+
+import mlx.core as mx
+
+
+def value_and_grad(model: "mlx.nn.Module", fn: Callable):
+    """Transform the passed function ``fn`` to a function that computes the
+    gradients of ``fn`` wrt the model's trainable parameters and also its
+    value.
+
+    Args:
+        model (mlx.nn.Module): The model whose trainable parameters to compute
+                               gradients for
+        fn (Callable): The scalar function to compute gradients for
+
+    Returns:
+        A callable that returns the value of ``fn`` and the gradients wrt the
+        trainable parameters of ``model``
+    """
+
+    def inner_fn(params, *args, **kwargs):
+        model.update(params)
+        return fn(*args, **kwargs)
+
+    value_grad_fn = mx.value_and_grad(inner_fn)
+
+    def wrapped_value_grad_fn(*args, **kwargs):
+        value, grad = value_grad_fn(model.trainable_parameters(), *args, **kwargs)
+        return value, grad
+
+    return wrapped_value_grad_fn
diff --git a/lib/python3.11/site-packages/mlx/optimizers.py b/lib/python3.11/site-packages/mlx/optimizers.py
new file mode 100644
index 0000000000000000000000000000000000000000..601d87b03e3295f31ad88b456021932b759a8a85
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/optimizers.py
@@ -0,0 +1,500 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import List
+
+import mlx.core as mx
+from mlx.utils import tree_map
+
+
+class OptimizerState(dict):
+    """The optimizer state implements a recursively defined
+    :class:`collections.defaultdict`, namely a missing key in an optimizer
+    state is an :class:`OptimizerState`.
+
+    .. note::
+       :meth:`OptimizerState.get` in contrast to a normal dictionary also sets
+       the key to the ``default`` value if the ``key`` was not present in the
+       dictionary.
+    """
+
+    def __getitem__(self, key):
+        if key not in self:
+            self[key] = OptimizerState()
+        return super().__getitem__(key)
+
+    def get(self, key, default):
+        """If ``key`` doesn't exist set its value to ``default`` and then return it."""
+        if key not in self:
+            self[key] = default
+        return super().__getitem__(key)
+
+
+class Optimizer:
+    """The base class for all optimizers. It allows us to implement an
+    optimizer on a per-parameter basis and apply it to a parameter tree.
+
+    Attributes:
+        state (OptimizerState): It holds the optimizer's state dictionary.
+    """
+
+    def __init__(self):
+        self.state = OptimizerState()
+
+    def update(self, model: "mlx.nn.Module", gradients: dict):
+        """Apply the gradients to the parameters of the model and update the
+        model with the new parameters.
+
+        Args:
+            model (mlx.nn.Module): An mlx module to be updated.
+            gradients (dict): A Python tree of gradients, most likely computed
+                              via :func:`mlx.nn.value_and_grad`.
+        """
+        model.update(self.apply_gradients(gradients, model))
+
+    def apply_gradients(self, gradients: dict, model: dict):
+        """Apply the gradients to the parameters and return the updated parameters.
+
+        Can be used to update a model via
+        ``model.update(opt.apply_gradients(grads, model))`` which is precisely
+        how :meth:`Optimizer.update` is implemented.
+
+        Args:
+            gradients (dict): A Python tree of gradients.
+            model (dict): A Python tree of parameters. It can be a superset of
+                          the gradients. In that case the returned python tree
+                          will be of the same structure as the gradients.
+        """
+        return tree_map(self.apply_single, gradients, model, self.state)
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """To be extended by the children classes to implement each optimizer's
+        update."""
+        raise NotImplementedError()
+
+
+class SGD(Optimizer):
+    r"""Stochastic gradient descent optimizer.
+
+    Updates a parameter :math:`w` with a gradient :math:`g` as follows
+
+    .. math::
+
+        v_{t+1} &= \mu v_t + (1 - \tau) g_t \\
+        w_{t+1} &= w_t - \lambda v_{t+1}
+
+    Args:
+        learning_rate (float): The learning rate :math:`\lambda`.
+        momentum (float, optional): The momentum strength :math:`\mu`. Default: ``0``
+        weight_decay (float, optional): The weight decay (L2 penalty). Default: ``0``
+        dampening (float, optional): Dampening for momentum :math:`\tau`. Default: ``0``
+        nesterov (bool, optional): Enables Nesterov momentum. Default: ``False``
+    """
+
+    def __init__(
+        self,
+        learning_rate: float,
+        momentum: float = 0.0,
+        weight_decay: float = 0.0,
+        dampening: float = 0.0,
+        nesterov: bool = False,
+    ):
+        if nesterov and (momentum <= 0 or dampening != 0):
+            raise ValueError(
+                "Nesterov momentum requires a momentum and zero dampening."
+            )
+        super().__init__()
+
+        self.learning_rate = learning_rate
+        self.momentum = momentum
+        self.weight_decay = weight_decay
+        self.dampening = dampening
+        self.nesterov = nesterov
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the SGD parameter update and stores :math:`v` in the
+        optimizer state."""
+        if self.momentum <= 0:
+            return parameter - self.learning_rate * gradient
+
+        v = state.get("v", mx.zeros_like(gradient))
+
+        if self.weight_decay != 0:
+            gradient += self.weight_decay * parameter
+
+        v = self.momentum * v
+        if self.dampening > 0:
+            v += (1 - self.dampening) * gradient
+        else:
+            v += gradient
+
+        if self.nesterov:
+            update = gradient + self.momentum * v
+        else:
+            update = v
+        state["v"] = v
+        return parameter - self.learning_rate * update
+
+
+class RMSprop(Optimizer):
+    r"""Implementation of the RMSprop optimizer [1].
+
+    [1]: Tieleman, T. and Hinton, G. 2012. Lecture 6.5-rmsprop, coursera: Neural networks for machine learning
+
+    .. math::
+
+        v_{t+1} &= \alpha v_t + (1 - \alpha) g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{g_t}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float): The learning rate :math:`\lambda`.
+        alpha (float, optional): The smoothing constant :math:`\alpha`.
+          Default: ``0.99``
+        eps (float, optional): The term :math:`\epsilon` added to the denominator
+          to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(self, learning_rate: float, alpha: float = 0.99, eps: float = 1e-8):
+        super().__init__()
+
+        self.learning_rate = learning_rate
+        self.alpha = alpha
+        self.eps = eps
+
+        if self.alpha < 0.0:
+            raise ValueError(
+                f"RMSprop alpha should be >=0, {self.alpha} was provided instead"
+            )
+        if self.eps < 0.0:
+            raise ValueError(
+                f"RMSprop epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the RMSprop parameter update and stores :math:`v` in the optimizer state."""
+        lr = self.learning_rate
+        alpha = self.alpha
+        eps = self.eps
+
+        v = state.get("v", mx.zeros_like(gradient))
+        v = alpha * v + (1 - alpha) * mx.square(gradient)
+        state["v"] = v
+
+        return parameter - lr * gradient / (mx.sqrt(v) + eps)
+
+
+class Adagrad(Optimizer):
+    r"""Implementation of the Adagrad optimizer [1].
+
+    Our Adagrad implementation follows the original paper. In detail,
+
+    [1]: Duchi, J., Hazan, E. and Singer, Y., 2011. Adaptive subgradient methods
+    for online learning and stochastic optimization. JMLR 2011.
+
+    .. math::
+
+        v_{t+1} &= v_t + g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{g_t}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float): The learning rate :math:`\lambda`.
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(self, learning_rate: float, eps: float = 1e-8):
+        super().__init__()
+
+        self.learning_rate = learning_rate
+        self.eps = eps
+
+        if self.eps < 0.0:
+            raise ValueError(
+                f"Adagrad epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the Adagrad parameter update and stores :math:`v` in the
+        optimizer state."""
+        lr = self.learning_rate
+        eps = self.eps
+
+        v = state.get("v", mx.zeros_like(gradient))
+        v = v + mx.square(gradient)
+        state["v"] = v
+
+        return parameter - lr * gradient / (mx.sqrt(v) + eps)
+
+
+class AdaDelta(Optimizer):
+    r"""Implementation of the AdaDelta optimizer with learning rate[1].
+
+    Our AdaDelta implementation follows the original paper. In detail,
+
+    [1]: Zeiler, M.D., 2012. ADADELTA: an adaptive learning rate method. arXiv preprint arXiv:1212.5701.
+
+    .. math::
+
+        v_{t+1} &= \rho v_t + (1 - \rho) g_t^2 \\
+        \Delta w_{t+1} &= \frac{\sqrt{u_t + \epsilon}}{\sqrt{v_{t+1} + \epsilon}} g_t \\
+        u_{t+1} &= \rho u_t + (1 - \rho) \Delta w_{t+1}^2 \\
+        w_{t+1} &= w_t - \lambda \Delta w_{t+1}
+
+    Args:
+        learning_rate (float): The learning rate :math:`\lambda`.
+        rho (float, optional): The coefficient :math:`\rho` used for computing a
+            running average of squared gradients. Default: ``0.9``
+        eps (float, optional): The term :math:`\epsilon` added to the denominator to improve
+          numerical stability. Default: `1e-8`
+    """
+
+    def __init__(self, learning_rate: float, rho: float = 0.9, eps: float = 1e-6):
+        super().__init__()
+
+        self.learning_rate = learning_rate
+        self.rho = rho
+        self.eps = eps
+        if self.rho < 0.0:
+            raise ValueError(
+                f"AdaDelta rho should be >=0, {self.rho} was provided instead"
+            )
+        if self.eps < 0.0:
+            raise ValueError(
+                f"AdaDelta epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the AdaDelta parameter update and stores :math:`v` and
+        :math:`u` in the optimizer state."""
+        lr = self.learning_rate
+        rho = self.rho
+        eps = self.eps
+
+        v = state.get("v", mx.zeros_like(gradient))
+        u = state.get("s", mx.zeros_like(gradient))
+
+        v = rho * v + (1 - rho) * mx.square(gradient)
+        d = mx.sqrt(u + eps) / mx.sqrt(v + eps) * gradient
+        u = rho * u + (1 - rho) * mx.square(d)
+
+        state["v"] = v
+        state["u"] = u
+
+        return parameter - lr * d
+
+
+class Adam(Optimizer):
+    r"""Implementation of the Adam optimizer [1].
+
+    Our Adam implementation follows the original paper and omits the bias
+    correction in the first and second moment estimates. In detail,
+
+    [1]: Kingma, D.P. and Ba, J., 2015. Adam: A method for stochastic
+    optimization. ICLR 2015.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \beta_2 v_t + (1 - \beta_2) g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{m_{t+1}}{\sqrt{v_{t+1} + \epsilon}}
+
+    Args:
+        learning_rate (float): The learning rate :math:`\lambda`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self, learning_rate: float, betas: List[float] = [0.9, 0.999], eps: float = 1e-8
+    ):
+        super().__init__()
+
+        self.learning_rate = learning_rate
+        self.betas = betas
+        self.eps = eps
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the Adam parameter update and stores :math:`v` and
+        :math:`m` in the optimizer state."""
+        lr = self.learning_rate
+        b1, b2 = self.betas
+        eps = self.eps
+
+        m = state.get("m", gradient)
+        v = state.get("v", mx.square(gradient))
+        m = b1 * m + (1 - b1) * gradient
+        v = b2 * v + (1 - b2) * mx.square(gradient)
+        state["m"] = m
+        state["v"] = v
+
+        return parameter - lr * m / (mx.sqrt(v) + eps)
+
+
+class AdamW(Adam):
+    r"""Implementation of the AdamW optimizer [1].
+
+    Following the above convention, in contrast with [1], we do not use bias
+    correction in the first and second moments for AdamW. We update the weights
+    with a weight_decay (:math:`\lambda`) value:
+
+    [1]: Loshchilov, I. and Hutter, F., 2019. Decoupled weight decay
+    regularization. ICLR 2019.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \beta_2 v_t + (1 - \beta_2) g_t^2 \\
+        w_{t+1} &= w_t - \alpha (\frac{m_{t+1}}{\sqrt{v_{t+1} + \epsilon}} + \lambda w_t)
+
+    Args:
+        learning_rate (float): The learning rate :math:`\alpha`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+        weight_decay (float, optional): The weight decay :math:`\lambda`.
+          Default: ``0``.
+    """
+
+    def __init__(
+        self,
+        learning_rate: float,
+        betas: List[float] = [0.9, 0.999],
+        eps: float = 1e-8,
+        weight_decay: float = 0.01,
+    ):
+        super().__init__(learning_rate=learning_rate, betas=betas, eps=eps)
+        self.weight_decay = weight_decay
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the AdamW parameter update by modifying the parameters
+        passed into Adam.
+        """
+
+        return super().apply_single(
+            gradient, parameter * (1 - self.learning_rate * self.weight_decay), state
+        )
+
+
+class Adamax(Adam):
+    r"""Implementation of the Adamax optimizer. It is a variant of Adam based
+    on the infinity norm [1].
+
+    Our Adam implementation follows the original paper and omits the bias
+    correction in the first and second moment estimates. In detail,
+
+    [1]: Kingma, D.P. and Ba, J., 2015. Adam: A method for stochastic
+    optimization. ICLR 2015.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \max(\beta_2 v_t, |g_t|) \\
+        w_{t+1} &= w_t - \lambda \frac{m_{t+1}}{v_{t+1} + \epsilon}
+
+    Args:
+        learning_rate (float): The learning rate :math:`\lambda`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self, learning_rate: float, betas: List[float] = [0.9, 0.999], eps: float = 1e-8
+    ):
+        super().__init__(learning_rate, betas, eps)
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the Adamax parameter update and stores :math:`v` and
+        :math:`m` in the optimizer state."""
+        lr = self.learning_rate
+        b1, b2 = self.betas
+        eps = self.eps
+
+        m = state.get("m", mx.zeros_like(gradient))
+        v = state.get("v", mx.zeros_like(gradient))
+
+        m = b1 * m + (1 - b1) * gradient
+        v = mx.maximum(b2 * v, mx.abs(gradient))
+        state["m"] = m
+        state["v"] = v
+
+        return parameter - lr * m / (v + eps)
+
+
+class Lion(Optimizer):
+    r"""Implementation of the Lion optimizer [1].
+
+    Since updates are computed through the sign operation, they tend to
+    have larger norm than for other optimizers such as SGD and Adam.
+    We recommend a learning rate that is 3-10x smaller than AdamW and a
+    weight decay 3-10x larger than AdamW to maintain the strength
+    (lr * wd). Our Lion implementation follows the original paper. In
+    detail,
+
+    [1]: Chen, X. Symbolic Discovery of Optimization Algorithms. arXiv
+    preprint arXiv:2302.06675.
+
+    .. math::
+
+        c_{t + 1} &= \beta_1 m_t + (1 - \beta_1) g_t
+        m_{t + 1} &= \beta_2 m_t + (1 - \beta_2) g_t
+        w_{t + 1} &= w_t - \eta (\text{sign}(c_t) + \lambda w_t)
+
+    Args:
+        learning_rate (float): The learning rate :math:`\eta`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing the gradient
+          momentum and update direction. Default: ``(0.9, 0.99)``
+        weight_decay (float, optional): The weight decay :math:`\lambda`. Default: ``0.0``
+    """
+
+    def __init__(
+        self,
+        learning_rate: float,
+        betas: List[float] = [0.9, 0.99],
+        weight_decay: float = 0.0,
+    ):
+        super().__init__()
+
+        self.learning_rate = learning_rate
+        self.betas = betas
+        self.weight_decay = weight_decay
+
+    def apply_single(
+        self, gradient: mx.array, parameter: mx.array, state: OptimizerState
+    ):
+        """Performs the Lion parameter update and stores :math:`m`
+        in the optimizer state."""
+        lr = self.learning_rate
+        b1, b2 = self.betas
+        weight_decay = self.weight_decay
+
+        m = state.get("m", gradient)
+        c = b1 * m + (1 - b1) * gradient
+        state["m"] = b2 * m + (1 - b2) * gradient
+        if weight_decay > 0:
+            parameter = (1 - lr * weight_decay) * parameter
+        return parameter - lr * mx.sign(c)
diff --git a/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXConfig.cmake b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b28e667ecaef245bb5e54e8f2a04383d06332d64
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXConfig.cmake
@@ -0,0 +1,57 @@
+# Find MLX
+#
+# Defines the following variables:
+#
+#   MLX_FOUND            : True if MLX is found
+#   MLX_INCLUDE_DIRS     : Include directory
+#   MLX_LIBRARIES        : Libraries to link against
+#   MLX_CXX_FLAGS        : Additional compiler flags
+#   MLX_BUILD_ACCELERATE : True if MLX was built with accelerate 
+#   MLX_BUILD_METAL      : True if MLX was built with metal 
+
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was mlx.pc.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+####################################################################################
+
+include(${PACKAGE_PREFIX_DIR}/share/cmake/MLX/MLXTargets.cmake)
+include(${PACKAGE_PREFIX_DIR}/share/cmake/MLX/extension.cmake)
+
+set_and_check(MLX_LIBRARY_DIRS ${PACKAGE_PREFIX_DIR}/lib)
+set_and_check(MLX_INCLUDE_DIRS ${PACKAGE_PREFIX_DIR}/include)
+set(MLX_LIBRARIES mlx)
+
+find_library(MLX_LIBRARY mlx PATHS ${MLX_LIBRARY_DIRS})
+
+if (ON)
+    set(MLX_BUILD_ACCELERATE ON)
+    set(MLX_CXX_FLAGS ${MLX_CXX_FLAGS} -DACCELERATE_NEW_LAPACK)
+endif()
+
+if (ON)
+    set(MLX_BUILD_METAL ON)
+    set(MLX_CXX_FLAGS ${MLX_CXX_FLAGS} -D_METAL_)
+    set_and_check(MLX_INCLUDE_DIRS 
+        ${MLX_INCLUDE_DIRS} 
+        ${PACKAGE_PREFIX_DIR}/include/metal_cpp
+    )
+endif()
+
+set_target_properties(mlx PROPERTIES
+    CXX_STANDARD 17
+    INTERFACE_COMPILE_OPTIONS "${MLX_CXX_FLAGS}"
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MLX DEFAULT_MSG MLX_LIBRARY MLX_INCLUDE_DIRS)
diff --git a/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXConfigVersion.cmake b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXConfigVersion.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..fc48e608eb26b819f6055d91b4eed997922aa617
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXConfigVersion.cmake
@@ -0,0 +1,65 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version,
+# but only if the requested major version is the same as the current one.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+set(PACKAGE_VERSION "0.0.7")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if("0.0.7" MATCHES "^([0-9]+)\\.")
+    set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+    endif()
+  else()
+    set(CVF_VERSION_MAJOR "0.0.7")
+  endif()
+
+  if(PACKAGE_FIND_VERSION_RANGE)
+    # both endpoints of the range must have the expected major version
+    math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1")
+    if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR)
+          OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT)))
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX)))
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+  else()
+    if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR)
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()
diff --git a/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXTargets-release.cmake b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXTargets-release.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3490abbfc25d318396d089a928e23d6347796976
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXTargets-release.cmake
@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "mlx" for configuration "Release"
+set_property(TARGET mlx APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(mlx PROPERTIES
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libmlx.dylib"
+  IMPORTED_SONAME_RELEASE "@rpath/libmlx.dylib"
+  )
+
+list(APPEND _cmake_import_check_targets mlx )
+list(APPEND _cmake_import_check_files_for_mlx "${_IMPORT_PREFIX}/lib/libmlx.dylib" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXTargets.cmake b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXTargets.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d569c1accf34412e6a8c7920bfff0593863198fd
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/share/cmake/MLX/MLXTargets.cmake
@@ -0,0 +1,107 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 2.8.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.3")
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.3...3.24)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS mlx)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target mlx
+add_library(mlx SHARED IMPORTED)
+
+set_target_properties(mlx PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/metal_cpp;${_IMPORT_PREFIX}/include/json;${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include"
+  INTERFACE_LINK_LIBRARIES "/Applications/Xcode-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Metal.framework;/Applications/Xcode-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Foundation.framework;/Applications/Xcode-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/QuartzCore.framework;/Applications/Xcode-beta.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX14.0.sdk/System/Library/Frameworks/Accelerate.framework"
+)
+
+if(CMAKE_VERSION VERSION_LESS 2.8.12)
+  message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.")
+endif()
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/MLXTargets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+    if(NOT EXISTS "${_cmake_file}")
+      message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+    endif()
+  endforeach()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/lib/python3.11/site-packages/mlx/share/cmake/MLX/extension.cmake b/lib/python3.11/site-packages/mlx/share/cmake/MLX/extension.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ffb02ee418c3e75a435ff1d0e3361774d2aedf4a
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/share/cmake/MLX/extension.cmake
@@ -0,0 +1,56 @@
+include(CMakeParseArguments)
+
+###############################################################################
+# Build metal library
+#
+# Adds a custom target ${TARGET} to build ${OUTPUT_DIRECTORY}/{TITLE}.metallib
+# from list ${SOURCES}, including list ${INCLUDE_DIRS}, depends on list ${DEPS}
+#
+# Args:
+#     TARGET: Custom target to be added for the metal library 
+#     TITLE: Name of the .metallib
+#     OUTPUT_DIRECTORY: Where to place ${TITLE}.metallib
+#     SOURCES: List of source files
+#     INCLUDE_DIRS: List of include dirs
+#     DEPS: List of dependency files (like headers)
+#
+macro(mlx_build_metallib)
+  # Parse args
+  set(oneValueArgs TARGET TITLE OUTPUT_DIRECTORY)
+  set(multiValueArgs SOURCES INCLUDE_DIRS DEPS)
+  cmake_parse_arguments(
+      MTLLIB 
+      ""
+      "${oneValueArgs}"
+      "${multiValueArgs}" 
+      ${ARGN}
+  )
+
+  # Set output
+  set(MTLLIB_BUILD_TARGET "${MTLLIB_OUTPUT_DIRECTORY}/${MTLLIB_TITLE}.metallib")
+
+  # Collect compile options 
+  set(MTLLIB_COMPILE_OPTIONS -Wall -Wextra -fno-fast-math)
+
+  # Prepare metallib build command
+  add_custom_command(
+    OUTPUT ${MTLLIB_BUILD_TARGET}
+    COMMAND xcrun -sdk macosx metal 
+                  "$<LIST:TRANSFORM,${MTLLIB_INCLUDE_DIRS},PREPEND,-I>"
+                  ${MTLLIB_COMPILE_OPTIONS}
+                  ${MTLLIB_SOURCES}
+                  -o ${MTLLIB_BUILD_TARGET}
+    DEPENDS ${MTLLIB_DEPS} ${MTLLIB_SOURCES}
+    COMMAND_EXPAND_LISTS
+    COMMENT "Building ${MTLLIB_TITLE}.metallib"
+    VERBATIM
+  )
+
+  # Add metallib custom target
+  add_custom_target(
+    ${MTLLIB_TARGET}
+    DEPENDS
+    ${MTLLIB_BUILD_TARGET}
+  )
+
+endmacro(mlx_build_metallib)
\ No newline at end of file
diff --git a/lib/python3.11/site-packages/mlx/utils.py b/lib/python3.11/site-packages/mlx/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..137a8aae4cc7c0630bbb20cf573230429aaa6051
--- /dev/null
+++ b/lib/python3.11/site-packages/mlx/utils.py
@@ -0,0 +1,145 @@
+# Copyright © 2023 Apple Inc.
+
+from collections import defaultdict
+
+
+def tree_map(fn, tree, *rest, is_leaf=None):
+    """Applies ``fn`` to the leaves of the python tree ``tree`` and
+    returns a new collection with the results.
+
+    If ``rest`` is provided, every item is assumed to be a superset of ``tree``
+    and the corresponding leaves are provided as extra positional arguments to
+    ``fn``. In that respect, :meth:`tree_map` is closer to :func:`itertools.starmap`
+    than to :func:`map`.
+
+    The keyword argument ``is_leaf`` decides what constitutes a leaf from
+    ``tree`` similar to :func:`tree_flatten`.
+
+    .. code-block:: python
+
+        import mlx.nn as nn
+        from mlx.utils import tree_map
+
+        model = nn.Linear(10, 10)
+        print(model.parameters().keys())
+        # dict_keys(['weight', 'bias'])
+
+        # square the parameters
+        model.update(tree_map(lambda x: x*x, model.parameters()))
+
+    Args:
+        fn (Callable): The function that processes the leaves of the tree
+        tree (Any): The main python tree that will be iterated upon
+        rest (Tuple[Any]): Extra trees to be iterated together with tree
+        is_leaf (Optional[Callable]): An optional callable that returns True if
+            the passed object is considered a leaf or False otherwise.
+
+    Returns:
+        A python tree with the new values returned by ``fn``.
+    """
+    if is_leaf is not None and is_leaf(tree):
+        return fn(tree, *rest)
+    elif isinstance(tree, (list, tuple)):
+        TreeType = type(tree)
+        return TreeType(
+            tree_map(fn, child, *(r[i] for r in rest), is_leaf=is_leaf)
+            for i, child in enumerate(tree)
+        )
+    elif isinstance(tree, dict):
+        return {
+            k: tree_map(fn, child, *(r[k] for r in rest), is_leaf=is_leaf)
+            for k, child in tree.items()
+        }
+    else:
+        return fn(tree, *rest)
+
+
+def tree_flatten(tree, prefix="", is_leaf=None):
+    """Flattens a python tree to a list of key, value tuples.
+
+    The keys are using the dot notation to define trees of arbitrary depth and
+    complexity.
+
+    .. code-block:: python
+
+        from mlx.utils import tree_flatten
+
+        print(tree_flatten([[[0]]]))
+        # [("0.0.0", 0)]
+
+        print(tree_flatten([[[0]]], ".hello"))
+        # [("hello.0.0.0", 0)]
+
+    .. note::
+       Dictionaries should have keys that are valid python identifiers.
+
+    Args:
+        tree (Any): The python tree to be flattened.
+        prefix (str): A prefix to use for the keys. The first character is
+            always discarded.
+        is_leaf (Callable): An optional callable that returns True if the
+            passed object is considered a leaf or False otherwise.
+
+    Returns:
+        List[Tuple[str, Any]]: The flat representation of the python tree.
+    """
+    flat_tree = []
+
+    if is_leaf is None or not is_leaf(tree):
+        if isinstance(tree, (list, tuple)):
+            for i, t in enumerate(tree):
+                flat_tree.extend(tree_flatten(t, f"{prefix}.{i}", is_leaf))
+            return flat_tree
+        if isinstance(tree, dict):
+            for k, t in tree.items():
+                flat_tree.extend(tree_flatten(t, f"{prefix}.{k}", is_leaf))
+            return flat_tree
+
+    return [(prefix[1:], tree)]
+
+
+def tree_unflatten(tree):
+    """Recreate a python tree from its flat representation.
+
+    .. code-block:: python
+
+        from mlx.utils import tree_unflatten
+
+        d = tree_unflatten([("hello.world", 42)])
+        print(d)
+        # {"hello": {"world": 42}}
+
+    Args:
+        tree (List[Tuple[str, Any]]): The flat representation of a python tree.
+                                      For instance as returned by :meth:`tree_flatten`.
+
+    Returns:
+        A python tree.
+    """
+    if len(tree) == 1 and tree[0][0] == "":
+        return tree[0][1]
+
+    try:
+        int(tree[0][0].split(".", maxsplit=1)[0])
+        is_list = True
+    except ValueError:
+        is_list = False
+
+    # collect children
+    children = defaultdict(list)
+    for key, value in tree:
+        current_idx, *next_idx = key.split(".", maxsplit=1)
+        next_idx = "" if not next_idx else next_idx[0]
+        children[current_idx].append((next_idx, value))
+
+    # recursively map them to the original container
+    if is_list:
+        keys = sorted((int(idx), idx) for idx in children.keys())
+        l = []
+        for i, k in keys:
+            # if i <= len(l), no {} will be appended.
+            l.extend([{} for _ in range(i - len(l))])
+            l.append(tree_unflatten(children[k]))
+        return l
+    else:
+        return {k: tree_unflatten(v) for k, v in children.items()}
diff --git a/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/INSTALLER b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/LICENSE b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..0a523bece3e50519653c4d7a38399baa487fefa1
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2012 Erik Rose
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/METADATA b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..6f7dfa18249712ef7f088a2d3fcd26a7c93d51e8
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/METADATA
@@ -0,0 +1,253 @@
+Metadata-Version: 2.1
+Name: more-itertools
+Version: 10.1.0
+Summary: More routines for operating on iterables, beyond itertools
+Keywords: itertools,iterator,iteration,filter,peek,peekable,chunk,chunked
+Author-email: Erik Rose <erikrose@grinchcentral.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries
+Project-URL: Homepage, https://github.com/more-itertools/more-itertools
+
+==============
+More Itertools
+==============
+
+.. image:: https://readthedocs.org/projects/more-itertools/badge/?version=latest
+  :target: https://more-itertools.readthedocs.io/en/stable/
+
+Python's ``itertools`` library is a gem - you can compose elegant solutions
+for a variety of problems with the functions it provides. In ``more-itertools``
+we collect additional building blocks, recipes, and routines for working with
+Python iterables.
+
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Grouping               | `chunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.chunked>`_,                                                                               |
+|                        | `ichunked <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ichunked>`_,                                                                             |
+|                        | `chunked_even <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.chunked_even>`_,                                                                     |
+|                        | `sliced <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sliced>`_,                                                                                 |
+|                        | `constrained_batches <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.constrained_batches>`_,                                                       |
+|                        | `distribute <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distribute>`_,                                                                         |
+|                        | `divide <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.divide>`_,                                                                                 |
+|                        | `split_at <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_at>`_,                                                                             |
+|                        | `split_before <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_before>`_,                                                                     |
+|                        | `split_after <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_after>`_,                                                                       |
+|                        | `split_into <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_into>`_,                                                                         |
+|                        | `split_when <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.split_when>`_,                                                                         |
+|                        | `bucket <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.bucket>`_,                                                                                 |
+|                        | `unzip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unzip>`_,                                                                                   |
+|                        | `batched <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.batched>`_,                                                                               |
+|                        | `grouper <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.grouper>`_,                                                                               |
+|                        | `partition <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partition>`_,                                                                           |
+|                        | `transpose <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.transpose>`_                                                                            |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Lookahead and lookback | `spy <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.spy>`_,                                                                                       |
+|                        | `peekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.peekable>`_,                                                                             |
+|                        | `seekable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.seekable>`_                                                                              |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Windowing              | `windowed <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.windowed>`_,                                                                             |
+|                        | `substrings <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings>`_,                                                                         |
+|                        | `substrings_indexes <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.substrings_indexes>`_,                                                         |
+|                        | `stagger <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.stagger>`_,                                                                               |
+|                        | `windowed_complete <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.windowed_complete>`_,                                                           |
+|                        | `pairwise <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.pairwise>`_,                                                                             |
+|                        | `triplewise <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.triplewise>`_,                                                                         |
+|                        | `sliding_window <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sliding_window>`_,                                                                 |
+|                        | `subslices <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.subslices>`_                                                                            |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Augmenting             | `count_cycle <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.count_cycle>`_,                                                                       |
+|                        | `intersperse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.intersperse>`_,                                                                       |
+|                        | `padded <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.padded>`_,                                                                                 |
+|                        | `repeat_each <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeat_each>`_,                                                                       |
+|                        | `mark_ends <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.mark_ends>`_,                                                                           |
+|                        | `repeat_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeat_last>`_,                                                                       |
+|                        | `adjacent <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.adjacent>`_,                                                                             |
+|                        | `groupby_transform <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.groupby_transform>`_,                                                           |
+|                        | `pad_none <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.pad_none>`_,                                                                             |
+|                        | `ncycles <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ncycles>`_                                                                                |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Combining              | `collapse <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.collapse>`_,                                                                             |
+|                        | `sort_together <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sort_together>`_,                                                                   |
+|                        | `interleave <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave>`_,                                                                         |
+|                        | `interleave_longest <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave_longest>`_,                                                         |
+|                        | `interleave_evenly <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.interleave_evenly>`_,                                                           |
+|                        | `zip_offset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_offset>`_,                                                                         |
+|                        | `zip_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_equal>`_,                                                                           |
+|                        | `zip_broadcast <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.zip_broadcast>`_,                                                                   |
+|                        | `dotproduct <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.dotproduct>`_,                                                                         |
+|                        | `convolve <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.convolve>`_,                                                                             |
+|                        | `flatten <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.flatten>`_,                                                                               |
+|                        | `roundrobin <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.roundrobin>`_,                                                                         |
+|                        | `prepend <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.prepend>`_,                                                                               |
+|                        | `value_chain <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.value_chain>`_,                                                                       |
+|                        | `partial_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partial_product>`_                                                                |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Summarizing            | `ilen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.ilen>`_,                                                                                     |
+|                        | `unique_to_each <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_to_each>`_,                                                                 |
+|                        | `sample <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sample>`_,                                                                                 |
+|                        | `consecutive_groups <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consecutive_groups>`_,                                                         |
+|                        | `run_length <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.run_length>`_,                                                                         |
+|                        | `map_reduce <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_reduce>`_,                                                                         |
+|                        | `exactly_n <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.exactly_n>`_,                                                                           |
+|                        | `is_sorted <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.is_sorted>`_,                                                                           |
+|                        | `all_equal <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.all_equal>`_,                                                                           |
+|                        | `all_unique <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.all_unique>`_,                                                                         |
+|                        | `minmax <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.minmax>`_,                                                                                 |
+|                        | `first_true <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first_true>`_,                                                                         |
+|                        | `quantify <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.quantify>`_,                                                                             |
+|                        | `iequals <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iequals>`_                                                                                |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Selecting              | `islice_extended <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.islice_extended>`_,                                                               |
+|                        | `first <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.first>`_,                                                                                   |
+|                        | `last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.last>`_,                                                                                     |
+|                        | `one <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.one>`_,                                                                                       |
+|                        | `only <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.only>`_,                                                                                     |
+|                        | `strictly_n <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.strictly_n>`_,                                                                         |
+|                        | `strip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.strip>`_,                                                                                   |
+|                        | `lstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.lstrip>`_,                                                                                 |
+|                        | `rstrip <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rstrip>`_,                                                                                 |
+|                        | `filter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.filter_except>`_,                                                                   |
+|                        | `map_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_except>`_,                                                                         |
+|                        | `nth_or_last <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_or_last>`_,                                                                       |
+|                        | `unique_in_window <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_in_window>`_,                                                             |
+|                        | `before_and_after <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.before_and_after>`_,                                                             |
+|                        | `nth <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth>`_,                                                                                       |
+|                        | `take <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.take>`_,                                                                                     |
+|                        | `tail <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tail>`_,                                                                                     |
+|                        | `unique_everseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_everseen>`_,                                                               |
+|                        | `unique_justseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.unique_justseen>`_,                                                               |
+|                        | `duplicates_everseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.duplicates_everseen>`_,                                                       |
+|                        | `duplicates_justseen <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.duplicates_justseen>`_,                                                       |
+|                        | `longest_common_prefix <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.longest_common_prefix>`_,                                                   |
+|                        | `takewhile_inclusive <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.takewhile_inclusive>`_                                                        |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Combinatorics          | `distinct_permutations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_permutations>`_,                                                   |
+|                        | `distinct_combinations <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.distinct_combinations>`_,                                                   |
+|                        | `circular_shifts <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.circular_shifts>`_,                                                               |
+|                        | `partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.partitions>`_,                                                                         |
+|                        | `set_partitions <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.set_partitions>`_,                                                                 |
+|                        | `product_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.product_index>`_,                                                                   |
+|                        | `combination_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.combination_index>`_,                                                           |
+|                        | `permutation_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.permutation_index>`_,                                                           |
+|                        | `combination_with_replacement_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.combination_with_replacement_index>`_,                         |
+|                        | `gray_product  <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.gray_product>`_,                                                                    |
+|                        | `outer_product  <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.outer_product>`_,                                                                  |
+|                        | `powerset <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.powerset>`_,                                                                             |
+|                        | `random_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_product>`_,                                                                 |
+|                        | `random_permutation <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_permutation>`_,                                                         |
+|                        | `random_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination>`_,                                                         |
+|                        | `random_combination_with_replacement <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.random_combination_with_replacement>`_,                       |
+|                        | `nth_product <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_product>`_,                                                                       |
+|                        | `nth_permutation <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_permutation>`_,                                                               |
+|                        | `nth_combination <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_combination>`_,                                                               |
+|                        | `nth_combination_with_replacement <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.nth_combination_with_replacement>`_                              |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Wrapping               | `always_iterable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_iterable>`_,                                                               |
+|                        | `always_reversible <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.always_reversible>`_,                                                           |
+|                        | `countable <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.countable>`_,                                                                           |
+|                        | `consumer <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consumer>`_,                                                                             |
+|                        | `with_iter <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.with_iter>`_,                                                                           |
+|                        | `iter_except <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iter_except>`_                                                                        |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Others                 | `locate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.locate>`_,                                                                                 |
+|                        | `rlocate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.rlocate>`_,                                                                               |
+|                        | `replace <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.replace>`_,                                                                               |
+|                        | `numeric_range <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.numeric_range>`_,                                                                   |
+|                        | `side_effect <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.side_effect>`_,                                                                       |
+|                        | `iterate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iterate>`_,                                                                               |
+|                        | `difference <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.difference>`_,                                                                         |
+|                        | `make_decorator <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.make_decorator>`_,                                                                 |
+|                        | `SequenceView <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.SequenceView>`_,                                                                     |
+|                        | `time_limited <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.time_limited>`_,                                                                     |
+|                        | `map_if <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.map_if>`_,                                                                                 |
+|                        | `iter_index <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.iter_index>`_,                                                                         |
+|                        | `consume <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.consume>`_,                                                                               |
+|                        | `tabulate <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.tabulate>`_,                                                                             |
+|                        | `repeatfunc <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.repeatfunc>`_,                                                                         |
+|                        | `polynomial_from_roots <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.polynomial_from_roots>`_,                                                   |
+|                        | `polynomial_eval <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.polynomial_eval>`_,                                                               |
+|                        | `polynomial_derivative <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.polynomial_derivative>`_,                                                   |
+|                        | `sieve <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sieve>`_,                                                                                   |
+|                        | `factor <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.factor>`_,                                                                                 |
+|                        | `matmul <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.matmul>`_,                                                                                 |
+|                        | `sum_of_squares <https://more-itertools.readthedocs.io/en/stable/api.html#more_itertools.sum_of_squares>`_                                                                  |
++------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+
+Getting started
+===============
+
+To get started, install the library with `pip <https://pip.pypa.io/en/stable/>`_:
+
+.. code-block:: shell
+
+    pip install more-itertools
+
+The recipes from the `itertools docs <https://docs.python.org/3/library/itertools.html#itertools-recipes>`_
+are included in the top-level package:
+
+.. code-block:: python
+
+    >>> from more_itertools import flatten
+    >>> iterable = [(0, 1), (2, 3)]
+    >>> list(flatten(iterable))
+    [0, 1, 2, 3]
+
+Several new recipes are available as well:
+
+.. code-block:: python
+
+    >>> from more_itertools import chunked
+    >>> iterable = [0, 1, 2, 3, 4, 5, 6, 7, 8]
+    >>> list(chunked(iterable, 3))
+    [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+
+    >>> from more_itertools import spy
+    >>> iterable = (x * x for x in range(1, 6))
+    >>> head, iterable = spy(iterable, n=3)
+    >>> list(head)
+    [1, 4, 9]
+    >>> list(iterable)
+    [1, 4, 9, 16, 25]
+
+
+
+For the full listing of functions, see the `API documentation <https://more-itertools.readthedocs.io/en/stable/api.html>`_.
+
+
+Links elsewhere
+===============
+
+Blog posts about ``more-itertools``:
+
+* `Yo, I heard you like decorators <https://www.bbayles.com/index/decorator_factory>`__
+* `Tour of Python Itertools <https://martinheinz.dev/blog/16>`__ (`Alternate <https://dev.to/martinheinz/tour-of-python-itertools-4122>`__)
+* `Real-World Python More Itertools <https://www.gidware.com/real-world-more-itertools/>`_
+
+
+Development
+===========
+
+``more-itertools`` is maintained by `@erikrose <https://github.com/erikrose>`_
+and `@bbayles <https://github.com/bbayles>`_, with help from `many others <https://github.com/more-itertools/more-itertools/graphs/contributors>`_.
+If you have a problem or suggestion, please file a bug or pull request in this
+repository. Thanks for contributing!
+
+
+Version History
+===============
+
+The version history can be found in `documentation <https://more-itertools.readthedocs.io/en/stable/versions.html>`_.
+
diff --git a/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/RECORD b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..4e385deec70004c71e6e59d454e5f455dbe475f9
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/RECORD
@@ -0,0 +1,16 @@
+more_itertools-10.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+more_itertools-10.1.0.dist-info/LICENSE,sha256=CfHIyelBrz5YTVlkHqm4fYPAyw_QB-te85Gn4mQ8GkY,1053
+more_itertools-10.1.0.dist-info/METADATA,sha256=s6T6Rg5Sq9hJE6KhX38MrPxWh8X0d9Fsdld4qdbrQVQ,33830
+more_itertools-10.1.0.dist-info/RECORD,,
+more_itertools-10.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+more_itertools-10.1.0.dist-info/WHEEL,sha256=rSgq_JpHF9fHR1lx53qwg_1-2LypZE_qmcuXbVUq948,81
+more_itertools/__init__.py,sha256=weQyJxnCVH2EuAaoxC8ZEX-ViZmpHm5kLHO05O8LfRM,149
+more_itertools/__init__.pyi,sha256=5B3eTzON1BBuOLob1vCflyEb2lSd6usXQQ-Cv-hXkeA,43
+more_itertools/__pycache__/__init__.cpython-311.pyc,,
+more_itertools/__pycache__/more.cpython-311.pyc,,
+more_itertools/__pycache__/recipes.cpython-311.pyc,,
+more_itertools/more.py,sha256=6XrPO3vvd3miZb6ygQtY5SoJeLk2PAwfEQOlZHwZgXw,140481
+more_itertools/more.pyi,sha256=nbYRtg-0YR0XMnFOGMzRzbgEOtNC_cfkUaOMOmNVWMA,20726
+more_itertools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+more_itertools/recipes.py,sha256=GNzJluz0ZYBZhF_H3bC7YkNCm9fZzOoBiQvh1WNNDOU,26354
+more_itertools/recipes.pyi,sha256=77IGo2ZqPtp9IkRu5MzQBgatLBl52vO3MRrFvPDcHzM,4237
diff --git a/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/REQUESTED b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/WHEEL b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..db4a255f3a271083b66f205eeaa81f74c97bb8ac
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools-10.1.0.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.8.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/lib/python3.11/site-packages/more_itertools/__init__.py b/lib/python3.11/site-packages/more_itertools/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..28ffadcf8dafe5e21b4cfc558f7fec1f071ae54d
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools/__init__.py
@@ -0,0 +1,6 @@
+"""More routines for operating on iterables, beyond itertools"""
+
+from .more import *  # noqa
+from .recipes import *  # noqa
+
+__version__ = '10.1.0'
diff --git a/lib/python3.11/site-packages/more_itertools/__init__.pyi b/lib/python3.11/site-packages/more_itertools/__init__.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..96f6e36c7f4ac9ea0aebdcd9e11b8d1ff092d2ef
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools/__init__.pyi
@@ -0,0 +1,2 @@
+from .more import *
+from .recipes import *
diff --git a/lib/python3.11/site-packages/more_itertools/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/more_itertools/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e3f3825f3444de326a10c4afee56e95771f8143
Binary files /dev/null and b/lib/python3.11/site-packages/more_itertools/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/more_itertools/__pycache__/more.cpython-311.pyc b/lib/python3.11/site-packages/more_itertools/__pycache__/more.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39d1b6b24922ff0f040043625e92df75c4eac0e7
Binary files /dev/null and b/lib/python3.11/site-packages/more_itertools/__pycache__/more.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/more_itertools/__pycache__/recipes.cpython-311.pyc b/lib/python3.11/site-packages/more_itertools/__pycache__/recipes.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fd78d1582fc5eafa6991a25fca8dd43b0e74282
Binary files /dev/null and b/lib/python3.11/site-packages/more_itertools/__pycache__/recipes.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/more_itertools/more.py b/lib/python3.11/site-packages/more_itertools/more.py
new file mode 100644
index 0000000000000000000000000000000000000000..59c2f1a499d2b7e4923ea8f60389fb2f2b8fd342
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools/more.py
@@ -0,0 +1,4569 @@
+import warnings
+
+from collections import Counter, defaultdict, deque, abc
+from collections.abc import Sequence
+from functools import cached_property, partial, reduce, wraps
+from heapq import heapify, heapreplace, heappop
+from itertools import (
+    chain,
+    compress,
+    count,
+    cycle,
+    dropwhile,
+    groupby,
+    islice,
+    repeat,
+    starmap,
+    takewhile,
+    tee,
+    zip_longest,
+    product,
+)
+from math import exp, factorial, floor, log
+from queue import Empty, Queue
+from random import random, randrange, uniform
+from operator import itemgetter, mul, sub, gt, lt, ge, le
+from sys import hexversion, maxsize
+from time import monotonic
+
+from .recipes import (
+    _marker,
+    _zip_equal,
+    UnequalIterablesError,
+    consume,
+    flatten,
+    pairwise,
+    powerset,
+    take,
+    unique_everseen,
+    all_equal,
+    batched,
+)
+
+__all__ = [
+    'AbortThread',
+    'SequenceView',
+    'UnequalIterablesError',
+    'adjacent',
+    'all_unique',
+    'always_iterable',
+    'always_reversible',
+    'bucket',
+    'callback_iter',
+    'chunked',
+    'chunked_even',
+    'circular_shifts',
+    'collapse',
+    'combination_index',
+    'combination_with_replacement_index',
+    'consecutive_groups',
+    'constrained_batches',
+    'consumer',
+    'count_cycle',
+    'countable',
+    'difference',
+    'distinct_combinations',
+    'distinct_permutations',
+    'distribute',
+    'divide',
+    'duplicates_everseen',
+    'duplicates_justseen',
+    'exactly_n',
+    'filter_except',
+    'first',
+    'gray_product',
+    'groupby_transform',
+    'ichunked',
+    'iequals',
+    'ilen',
+    'interleave',
+    'interleave_evenly',
+    'interleave_longest',
+    'intersperse',
+    'is_sorted',
+    'islice_extended',
+    'iterate',
+    'last',
+    'locate',
+    'longest_common_prefix',
+    'lstrip',
+    'make_decorator',
+    'map_except',
+    'map_if',
+    'map_reduce',
+    'mark_ends',
+    'minmax',
+    'nth_or_last',
+    'nth_permutation',
+    'nth_product',
+    'nth_combination_with_replacement',
+    'numeric_range',
+    'one',
+    'only',
+    'outer_product',
+    'padded',
+    'partial_product',
+    'partitions',
+    'peekable',
+    'permutation_index',
+    'product_index',
+    'raise_',
+    'repeat_each',
+    'repeat_last',
+    'replace',
+    'rlocate',
+    'rstrip',
+    'run_length',
+    'sample',
+    'seekable',
+    'set_partitions',
+    'side_effect',
+    'sliced',
+    'sort_together',
+    'split_after',
+    'split_at',
+    'split_before',
+    'split_into',
+    'split_when',
+    'spy',
+    'stagger',
+    'strip',
+    'strictly_n',
+    'substrings',
+    'substrings_indexes',
+    'takewhile_inclusive',
+    'time_limited',
+    'unique_in_window',
+    'unique_to_each',
+    'unzip',
+    'value_chain',
+    'windowed',
+    'windowed_complete',
+    'with_iter',
+    'zip_broadcast',
+    'zip_equal',
+    'zip_offset',
+]
+
+
+def chunked(iterable, n, strict=False):
+    """Break *iterable* into lists of length *n*:
+
+        >>> list(chunked([1, 2, 3, 4, 5, 6], 3))
+        [[1, 2, 3], [4, 5, 6]]
+
+    By the default, the last yielded list will have fewer than *n* elements
+    if the length of *iterable* is not divisible by *n*:
+
+        >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3))
+        [[1, 2, 3], [4, 5, 6], [7, 8]]
+
+    To use a fill-in value instead, see the :func:`grouper` recipe.
+
+    If the length of *iterable* is not divisible by *n* and *strict* is
+    ``True``, then ``ValueError`` will be raised before the last
+    list is yielded.
+
+    """
+    iterator = iter(partial(take, n, iter(iterable)), [])
+    if strict:
+        if n is None:
+            raise ValueError('n must not be None when using strict mode.')
+
+        def ret():
+            for chunk in iterator:
+                if len(chunk) != n:
+                    raise ValueError('iterable is not divisible by n.')
+                yield chunk
+
+        return iter(ret())
+    else:
+        return iterator
+
+
+def first(iterable, default=_marker):
+    """Return the first item of *iterable*, or *default* if *iterable* is
+    empty.
+
+        >>> first([0, 1, 2, 3])
+        0
+        >>> first([], 'some default')
+        'some default'
+
+    If *default* is not provided and there are no items in the iterable,
+    raise ``ValueError``.
+
+    :func:`first` is useful when you have a generator of expensive-to-retrieve
+    values and want any arbitrary one. It is marginally shorter than
+    ``next(iter(iterable), default)``.
+
+    """
+    try:
+        return next(iter(iterable))
+    except StopIteration as e:
+        if default is _marker:
+            raise ValueError(
+                'first() was called on an empty iterable, and no '
+                'default value was provided.'
+            ) from e
+        return default
+
+
+def last(iterable, default=_marker):
+    """Return the last item of *iterable*, or *default* if *iterable* is
+    empty.
+
+        >>> last([0, 1, 2, 3])
+        3
+        >>> last([], 'some default')
+        'some default'
+
+    If *default* is not provided and there are no items in the iterable,
+    raise ``ValueError``.
+    """
+    try:
+        if isinstance(iterable, Sequence):
+            return iterable[-1]
+        # Work around https://bugs.python.org/issue38525
+        elif hasattr(iterable, '__reversed__') and (hexversion != 0x030800F0):
+            return next(reversed(iterable))
+        else:
+            return deque(iterable, maxlen=1)[-1]
+    except (IndexError, TypeError, StopIteration):
+        if default is _marker:
+            raise ValueError(
+                'last() was called on an empty iterable, and no default was '
+                'provided.'
+            )
+        return default
+
+
+def nth_or_last(iterable, n, default=_marker):
+    """Return the nth or the last item of *iterable*,
+    or *default* if *iterable* is empty.
+
+        >>> nth_or_last([0, 1, 2, 3], 2)
+        2
+        >>> nth_or_last([0, 1], 2)
+        1
+        >>> nth_or_last([], 0, 'some default')
+        'some default'
+
+    If *default* is not provided and there are no items in the iterable,
+    raise ``ValueError``.
+    """
+    return last(islice(iterable, n + 1), default=default)
+
+
+class peekable:
+    """Wrap an iterator to allow lookahead and prepending elements.
+
+    Call :meth:`peek` on the result to get the value that will be returned
+    by :func:`next`. This won't advance the iterator:
+
+        >>> p = peekable(['a', 'b'])
+        >>> p.peek()
+        'a'
+        >>> next(p)
+        'a'
+
+    Pass :meth:`peek` a default value to return that instead of raising
+    ``StopIteration`` when the iterator is exhausted.
+
+        >>> p = peekable([])
+        >>> p.peek('hi')
+        'hi'
+
+    peekables also offer a :meth:`prepend` method, which "inserts" items
+    at the head of the iterable:
+
+        >>> p = peekable([1, 2, 3])
+        >>> p.prepend(10, 11, 12)
+        >>> next(p)
+        10
+        >>> p.peek()
+        11
+        >>> list(p)
+        [11, 12, 1, 2, 3]
+
+    peekables can be indexed. Index 0 is the item that will be returned by
+    :func:`next`, index 1 is the item after that, and so on:
+    The values up to the given index will be cached.
+
+        >>> p = peekable(['a', 'b', 'c', 'd'])
+        >>> p[0]
+        'a'
+        >>> p[1]
+        'b'
+        >>> next(p)
+        'a'
+
+    Negative indexes are supported, but be aware that they will cache the
+    remaining items in the source iterator, which may require significant
+    storage.
+
+    To check whether a peekable is exhausted, check its truth value:
+
+        >>> p = peekable(['a', 'b'])
+        >>> if p:  # peekable has items
+        ...     list(p)
+        ['a', 'b']
+        >>> if not p:  # peekable is exhausted
+        ...     list(p)
+        []
+
+    """
+
+    def __init__(self, iterable):
+        self._it = iter(iterable)
+        self._cache = deque()
+
+    def __iter__(self):
+        return self
+
+    def __bool__(self):
+        try:
+            self.peek()
+        except StopIteration:
+            return False
+        return True
+
+    def peek(self, default=_marker):
+        """Return the item that will be next returned from ``next()``.
+
+        Return ``default`` if there are no items left. If ``default`` is not
+        provided, raise ``StopIteration``.
+
+        """
+        if not self._cache:
+            try:
+                self._cache.append(next(self._it))
+            except StopIteration:
+                if default is _marker:
+                    raise
+                return default
+        return self._cache[0]
+
+    def prepend(self, *items):
+        """Stack up items to be the next ones returned from ``next()`` or
+        ``self.peek()``. The items will be returned in
+        first in, first out order::
+
+            >>> p = peekable([1, 2, 3])
+            >>> p.prepend(10, 11, 12)
+            >>> next(p)
+            10
+            >>> list(p)
+            [11, 12, 1, 2, 3]
+
+        It is possible, by prepending items, to "resurrect" a peekable that
+        previously raised ``StopIteration``.
+
+            >>> p = peekable([])
+            >>> next(p)
+            Traceback (most recent call last):
+              ...
+            StopIteration
+            >>> p.prepend(1)
+            >>> next(p)
+            1
+            >>> next(p)
+            Traceback (most recent call last):
+              ...
+            StopIteration
+
+        """
+        self._cache.extendleft(reversed(items))
+
+    def __next__(self):
+        if self._cache:
+            return self._cache.popleft()
+
+        return next(self._it)
+
+    def _get_slice(self, index):
+        # Normalize the slice's arguments
+        step = 1 if (index.step is None) else index.step
+        if step > 0:
+            start = 0 if (index.start is None) else index.start
+            stop = maxsize if (index.stop is None) else index.stop
+        elif step < 0:
+            start = -1 if (index.start is None) else index.start
+            stop = (-maxsize - 1) if (index.stop is None) else index.stop
+        else:
+            raise ValueError('slice step cannot be zero')
+
+        # If either the start or stop index is negative, we'll need to cache
+        # the rest of the iterable in order to slice from the right side.
+        if (start < 0) or (stop < 0):
+            self._cache.extend(self._it)
+        # Otherwise we'll need to find the rightmost index and cache to that
+        # point.
+        else:
+            n = min(max(start, stop) + 1, maxsize)
+            cache_len = len(self._cache)
+            if n >= cache_len:
+                self._cache.extend(islice(self._it, n - cache_len))
+
+        return list(self._cache)[index]
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            return self._get_slice(index)
+
+        cache_len = len(self._cache)
+        if index < 0:
+            self._cache.extend(self._it)
+        elif index >= cache_len:
+            self._cache.extend(islice(self._it, index + 1 - cache_len))
+
+        return self._cache[index]
+
+
+def consumer(func):
+    """Decorator that automatically advances a PEP-342-style "reverse iterator"
+    to its first yield point so you don't have to call ``next()`` on it
+    manually.
+
+        >>> @consumer
+        ... def tally():
+        ...     i = 0
+        ...     while True:
+        ...         print('Thing number %s is %s.' % (i, (yield)))
+        ...         i += 1
+        ...
+        >>> t = tally()
+        >>> t.send('red')
+        Thing number 0 is red.
+        >>> t.send('fish')
+        Thing number 1 is fish.
+
+    Without the decorator, you would have to call ``next(t)`` before
+    ``t.send()`` could be used.
+
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        gen = func(*args, **kwargs)
+        next(gen)
+        return gen
+
+    return wrapper
+
+
+def ilen(iterable):
+    """Return the number of items in *iterable*.
+
+        >>> ilen(x for x in range(1000000) if x % 3 == 0)
+        333334
+
+    This consumes the iterable, so handle with care.
+
+    """
+    # This approach was selected because benchmarks showed it's likely the
+    # fastest of the known implementations at the time of writing.
+    # See GitHub tracker: #236, #230.
+    counter = count()
+    deque(zip(iterable, counter), maxlen=0)
+    return next(counter)
+
+
+def iterate(func, start):
+    """Return ``start``, ``func(start)``, ``func(func(start))``, ...
+
+    >>> from itertools import islice
+    >>> list(islice(iterate(lambda x: 2*x, 1), 10))
+    [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+
+    """
+    while True:
+        yield start
+        try:
+            start = func(start)
+        except StopIteration:
+            break
+
+
+def with_iter(context_manager):
+    """Wrap an iterable in a ``with`` statement, so it closes once exhausted.
+
+    For example, this will close the file when the iterator is exhausted::
+
+        upper_lines = (line.upper() for line in with_iter(open('foo')))
+
+    Any context manager which returns an iterable is a candidate for
+    ``with_iter``.
+
+    """
+    with context_manager as iterable:
+        yield from iterable
+
+
+def one(iterable, too_short=None, too_long=None):
+    """Return the first item from *iterable*, which is expected to contain only
+    that item. Raise an exception if *iterable* is empty or has more than one
+    item.
+
+    :func:`one` is useful for ensuring that an iterable contains only one item.
+    For example, it can be used to retrieve the result of a database query
+    that is expected to return a single row.
+
+    If *iterable* is empty, ``ValueError`` will be raised. You may specify a
+    different exception with the *too_short* keyword:
+
+        >>> it = []
+        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        ValueError: too many items in iterable (expected 1)'
+        >>> too_short = IndexError('too few items')
+        >>> one(it, too_short=too_short)  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        IndexError: too few items
+
+    Similarly, if *iterable* contains more than one item, ``ValueError`` will
+    be raised. You may specify a different exception with the *too_long*
+    keyword:
+
+        >>> it = ['too', 'many']
+        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        ValueError: Expected exactly one item in iterable, but got 'too',
+        'many', and perhaps more.
+        >>> too_long = RuntimeError
+        >>> one(it, too_long=too_long)  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        RuntimeError
+
+    Note that :func:`one` attempts to advance *iterable* twice to ensure there
+    is only one item. See :func:`spy` or :func:`peekable` to check iterable
+    contents less destructively.
+
+    """
+    it = iter(iterable)
+
+    try:
+        first_value = next(it)
+    except StopIteration as e:
+        raise (
+            too_short or ValueError('too few items in iterable (expected 1)')
+        ) from e
+
+    try:
+        second_value = next(it)
+    except StopIteration:
+        pass
+    else:
+        msg = (
+            'Expected exactly one item in iterable, but got {!r}, {!r}, '
+            'and perhaps more.'.format(first_value, second_value)
+        )
+        raise too_long or ValueError(msg)
+
+    return first_value
+
+
+def raise_(exception, *args):
+    raise exception(*args)
+
+
+def strictly_n(iterable, n, too_short=None, too_long=None):
+    """Validate that *iterable* has exactly *n* items and return them if
+    it does. If it has fewer than *n* items, call function *too_short*
+    with those items. If it has more than *n* items, call function
+    *too_long* with the first ``n + 1`` items.
+
+        >>> iterable = ['a', 'b', 'c', 'd']
+        >>> n = 4
+        >>> list(strictly_n(iterable, n))
+        ['a', 'b', 'c', 'd']
+
+    By default, *too_short* and *too_long* are functions that raise
+    ``ValueError``.
+
+        >>> list(strictly_n('ab', 3))  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        ValueError: too few items in iterable (got 2)
+
+        >>> list(strictly_n('abc', 2))  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        ValueError: too many items in iterable (got at least 3)
+
+    You can instead supply functions that do something else.
+    *too_short* will be called with the number of items in *iterable*.
+    *too_long* will be called with `n + 1`.
+
+        >>> def too_short(item_count):
+        ...     raise RuntimeError
+        >>> it = strictly_n('abcd', 6, too_short=too_short)
+        >>> list(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        RuntimeError
+
+        >>> def too_long(item_count):
+        ...     print('The boss is going to hear about this')
+        >>> it = strictly_n('abcdef', 4, too_long=too_long)
+        >>> list(it)
+        The boss is going to hear about this
+        ['a', 'b', 'c', 'd']
+
+    """
+    if too_short is None:
+        too_short = lambda item_count: raise_(
+            ValueError,
+            'Too few items in iterable (got {})'.format(item_count),
+        )
+
+    if too_long is None:
+        too_long = lambda item_count: raise_(
+            ValueError,
+            'Too many items in iterable (got at least {})'.format(item_count),
+        )
+
+    it = iter(iterable)
+    for i in range(n):
+        try:
+            item = next(it)
+        except StopIteration:
+            too_short(i)
+            return
+        else:
+            yield item
+
+    try:
+        next(it)
+    except StopIteration:
+        pass
+    else:
+        too_long(n + 1)
+
+
+def distinct_permutations(iterable, r=None):
+    """Yield successive distinct permutations of the elements in *iterable*.
+
+        >>> sorted(distinct_permutations([1, 0, 1]))
+        [(0, 1, 1), (1, 0, 1), (1, 1, 0)]
+
+    Equivalent to ``set(permutations(iterable))``, except duplicates are not
+    generated and thrown away. For larger input sequences this is much more
+    efficient.
+
+    Duplicate permutations arise when there are duplicated elements in the
+    input iterable. The number of items returned is
+    `n! / (x_1! * x_2! * ... * x_n!)`, where `n` is the total number of
+    items input, and each `x_i` is the count of a distinct item in the input
+    sequence.
+
+    If *r* is given, only the *r*-length permutations are yielded.
+
+        >>> sorted(distinct_permutations([1, 0, 1], r=2))
+        [(0, 1), (1, 0), (1, 1)]
+        >>> sorted(distinct_permutations(range(3), r=2))
+        [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
+
+    """
+
+    # Algorithm: https://w.wiki/Qai
+    def _full(A):
+        while True:
+            # Yield the permutation we have
+            yield tuple(A)
+
+            # Find the largest index i such that A[i] < A[i + 1]
+            for i in range(size - 2, -1, -1):
+                if A[i] < A[i + 1]:
+                    break
+            #  If no such index exists, this permutation is the last one
+            else:
+                return
+
+            # Find the largest index j greater than j such that A[i] < A[j]
+            for j in range(size - 1, i, -1):
+                if A[i] < A[j]:
+                    break
+
+            # Swap the value of A[i] with that of A[j], then reverse the
+            # sequence from A[i + 1] to form the new permutation
+            A[i], A[j] = A[j], A[i]
+            A[i + 1 :] = A[: i - size : -1]  # A[i + 1:][::-1]
+
+    # Algorithm: modified from the above
+    def _partial(A, r):
+        # Split A into the first r items and the last r items
+        head, tail = A[:r], A[r:]
+        right_head_indexes = range(r - 1, -1, -1)
+        left_tail_indexes = range(len(tail))
+
+        while True:
+            # Yield the permutation we have
+            yield tuple(head)
+
+            # Starting from the right, find the first index of the head with
+            # value smaller than the maximum value of the tail - call it i.
+            pivot = tail[-1]
+            for i in right_head_indexes:
+                if head[i] < pivot:
+                    break
+                pivot = head[i]
+            else:
+                return
+
+            # Starting from the left, find the first value of the tail
+            # with a value greater than head[i] and swap.
+            for j in left_tail_indexes:
+                if tail[j] > head[i]:
+                    head[i], tail[j] = tail[j], head[i]
+                    break
+            # If we didn't find one, start from the right and find the first
+            # index of the head with a value greater than head[i] and swap.
+            else:
+                for j in right_head_indexes:
+                    if head[j] > head[i]:
+                        head[i], head[j] = head[j], head[i]
+                        break
+
+            # Reverse head[i + 1:] and swap it with tail[:r - (i + 1)]
+            tail += head[: i - r : -1]  # head[i + 1:][::-1]
+            i += 1
+            head[i:], tail[:] = tail[: r - i], tail[r - i :]
+
+    items = sorted(iterable)
+
+    size = len(items)
+    if r is None:
+        r = size
+
+    if 0 < r <= size:
+        return _full(items) if (r == size) else _partial(items, r)
+
+    return iter(() if r else ((),))
+
+
+def intersperse(e, iterable, n=1):
+    """Intersperse filler element *e* among the items in *iterable*, leaving
+    *n* items between each filler element.
+
+        >>> list(intersperse('!', [1, 2, 3, 4, 5]))
+        [1, '!', 2, '!', 3, '!', 4, '!', 5]
+
+        >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2))
+        [1, 2, None, 3, 4, None, 5]
+
+    """
+    if n == 0:
+        raise ValueError('n must be > 0')
+    elif n == 1:
+        # interleave(repeat(e), iterable) -> e, x_0, e, x_1, e, x_2...
+        # islice(..., 1, None) -> x_0, e, x_1, e, x_2...
+        return islice(interleave(repeat(e), iterable), 1, None)
+    else:
+        # interleave(filler, chunks) -> [e], [x_0, x_1], [e], [x_2, x_3]...
+        # islice(..., 1, None) -> [x_0, x_1], [e], [x_2, x_3]...
+        # flatten(...) -> x_0, x_1, e, x_2, x_3...
+        filler = repeat([e])
+        chunks = chunked(iterable, n)
+        return flatten(islice(interleave(filler, chunks), 1, None))
+
+
+def unique_to_each(*iterables):
+    """Return the elements from each of the input iterables that aren't in the
+    other input iterables.
+
+    For example, suppose you have a set of packages, each with a set of
+    dependencies::
+
+        {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}}
+
+    If you remove one package, which dependencies can also be removed?
+
+    If ``pkg_1`` is removed, then ``A`` is no longer necessary - it is not
+    associated with ``pkg_2`` or ``pkg_3``. Similarly, ``C`` is only needed for
+    ``pkg_2``, and ``D`` is only needed for ``pkg_3``::
+
+        >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'})
+        [['A'], ['C'], ['D']]
+
+    If there are duplicates in one input iterable that aren't in the others
+    they will be duplicated in the output. Input order is preserved::
+
+        >>> unique_to_each("mississippi", "missouri")
+        [['p', 'p'], ['o', 'u', 'r']]
+
+    It is assumed that the elements of each iterable are hashable.
+
+    """
+    pool = [list(it) for it in iterables]
+    counts = Counter(chain.from_iterable(map(set, pool)))
+    uniques = {element for element in counts if counts[element] == 1}
+    return [list(filter(uniques.__contains__, it)) for it in pool]
+
+
+def windowed(seq, n, fillvalue=None, step=1):
+    """Return a sliding window of width *n* over the given iterable.
+
+        >>> all_windows = windowed([1, 2, 3, 4, 5], 3)
+        >>> list(all_windows)
+        [(1, 2, 3), (2, 3, 4), (3, 4, 5)]
+
+    When the window is larger than the iterable, *fillvalue* is used in place
+    of missing values:
+
+        >>> list(windowed([1, 2, 3], 4))
+        [(1, 2, 3, None)]
+
+    Each window will advance in increments of *step*:
+
+        >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2))
+        [(1, 2, 3), (3, 4, 5), (5, 6, '!')]
+
+    To slide into the iterable's items, use :func:`chain` to add filler items
+    to the left:
+
+        >>> iterable = [1, 2, 3, 4]
+        >>> n = 3
+        >>> padding = [None] * (n - 1)
+        >>> list(windowed(chain(padding, iterable), 3))
+        [(None, None, 1), (None, 1, 2), (1, 2, 3), (2, 3, 4)]
+    """
+    if n < 0:
+        raise ValueError('n must be >= 0')
+    if n == 0:
+        yield tuple()
+        return
+    if step < 1:
+        raise ValueError('step must be >= 1')
+
+    window = deque(maxlen=n)
+    i = n
+    for _ in map(window.append, seq):
+        i -= 1
+        if not i:
+            i = step
+            yield tuple(window)
+
+    size = len(window)
+    if size == 0:
+        return
+    elif size < n:
+        yield tuple(chain(window, repeat(fillvalue, n - size)))
+    elif 0 < i < min(step, n):
+        window += (fillvalue,) * i
+        yield tuple(window)
+
+
+def substrings(iterable):
+    """Yield all of the substrings of *iterable*.
+
+        >>> [''.join(s) for s in substrings('more')]
+        ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more']
+
+    Note that non-string iterables can also be subdivided.
+
+        >>> list(substrings([0, 1, 2]))
+        [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)]
+
+    """
+    # The length-1 substrings
+    seq = []
+    for item in iter(iterable):
+        seq.append(item)
+        yield (item,)
+    seq = tuple(seq)
+    item_count = len(seq)
+
+    # And the rest
+    for n in range(2, item_count + 1):
+        for i in range(item_count - n + 1):
+            yield seq[i : i + n]
+
+
+def substrings_indexes(seq, reverse=False):
+    """Yield all substrings and their positions in *seq*
+
+    The items yielded will be a tuple of the form ``(substr, i, j)``, where
+    ``substr == seq[i:j]``.
+
+    This function only works for iterables that support slicing, such as
+    ``str`` objects.
+
+    >>> for item in substrings_indexes('more'):
+    ...    print(item)
+    ('m', 0, 1)
+    ('o', 1, 2)
+    ('r', 2, 3)
+    ('e', 3, 4)
+    ('mo', 0, 2)
+    ('or', 1, 3)
+    ('re', 2, 4)
+    ('mor', 0, 3)
+    ('ore', 1, 4)
+    ('more', 0, 4)
+
+    Set *reverse* to ``True`` to yield the same items in the opposite order.
+
+
+    """
+    r = range(1, len(seq) + 1)
+    if reverse:
+        r = reversed(r)
+    return (
+        (seq[i : i + L], i, i + L) for L in r for i in range(len(seq) - L + 1)
+    )
+
+
+class bucket:
+    """Wrap *iterable* and return an object that buckets it iterable into
+    child iterables based on a *key* function.
+
+        >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3']
+        >>> s = bucket(iterable, key=lambda x: x[0])  # Bucket by 1st character
+        >>> sorted(list(s))  # Get the keys
+        ['a', 'b', 'c']
+        >>> a_iterable = s['a']
+        >>> next(a_iterable)
+        'a1'
+        >>> next(a_iterable)
+        'a2'
+        >>> list(s['b'])
+        ['b1', 'b2', 'b3']
+
+    The original iterable will be advanced and its items will be cached until
+    they are used by the child iterables. This may require significant storage.
+
+    By default, attempting to select a bucket to which no items belong  will
+    exhaust the iterable and cache all values.
+    If you specify a *validator* function, selected buckets will instead be
+    checked against it.
+
+        >>> from itertools import count
+        >>> it = count(1, 2)  # Infinite sequence of odd numbers
+        >>> key = lambda x: x % 10  # Bucket by last digit
+        >>> validator = lambda x: x in {1, 3, 5, 7, 9}  # Odd digits only
+        >>> s = bucket(it, key=key, validator=validator)
+        >>> 2 in s
+        False
+        >>> list(s[2])
+        []
+
+    """
+
+    def __init__(self, iterable, key, validator=None):
+        self._it = iter(iterable)
+        self._key = key
+        self._cache = defaultdict(deque)
+        self._validator = validator or (lambda x: True)
+
+    def __contains__(self, value):
+        if not self._validator(value):
+            return False
+
+        try:
+            item = next(self[value])
+        except StopIteration:
+            return False
+        else:
+            self._cache[value].appendleft(item)
+
+        return True
+
+    def _get_values(self, value):
+        """
+        Helper to yield items from the parent iterator that match *value*.
+        Items that don't match are stored in the local cache as they
+        are encountered.
+        """
+        while True:
+            # If we've cached some items that match the target value, emit
+            # the first one and evict it from the cache.
+            if self._cache[value]:
+                yield self._cache[value].popleft()
+            # Otherwise we need to advance the parent iterator to search for
+            # a matching item, caching the rest.
+            else:
+                while True:
+                    try:
+                        item = next(self._it)
+                    except StopIteration:
+                        return
+                    item_value = self._key(item)
+                    if item_value == value:
+                        yield item
+                        break
+                    elif self._validator(item_value):
+                        self._cache[item_value].append(item)
+
+    def __iter__(self):
+        for item in self._it:
+            item_value = self._key(item)
+            if self._validator(item_value):
+                self._cache[item_value].append(item)
+
+        yield from self._cache.keys()
+
+    def __getitem__(self, value):
+        if not self._validator(value):
+            return iter(())
+
+        return self._get_values(value)
+
+
+def spy(iterable, n=1):
+    """Return a 2-tuple with a list containing the first *n* elements of
+    *iterable*, and an iterator with the same items as *iterable*.
+    This allows you to "look ahead" at the items in the iterable without
+    advancing it.
+
+    There is one item in the list by default:
+
+        >>> iterable = 'abcdefg'
+        >>> head, iterable = spy(iterable)
+        >>> head
+        ['a']
+        >>> list(iterable)
+        ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+
+    You may use unpacking to retrieve items instead of lists:
+
+        >>> (head,), iterable = spy('abcdefg')
+        >>> head
+        'a'
+        >>> (first, second), iterable = spy('abcdefg', 2)
+        >>> first
+        'a'
+        >>> second
+        'b'
+
+    The number of items requested can be larger than the number of items in
+    the iterable:
+
+        >>> iterable = [1, 2, 3, 4, 5]
+        >>> head, iterable = spy(iterable, 10)
+        >>> head
+        [1, 2, 3, 4, 5]
+        >>> list(iterable)
+        [1, 2, 3, 4, 5]
+
+    """
+    it = iter(iterable)
+    head = take(n, it)
+
+    return head.copy(), chain(head, it)
+
+
+def interleave(*iterables):
+    """Return a new iterable yielding from each iterable in turn,
+    until the shortest is exhausted.
+
+        >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8]))
+        [1, 4, 6, 2, 5, 7]
+
+    For a version that doesn't terminate after the shortest iterable is
+    exhausted, see :func:`interleave_longest`.
+
+    """
+    return chain.from_iterable(zip(*iterables))
+
+
+def interleave_longest(*iterables):
+    """Return a new iterable yielding from each iterable in turn,
+    skipping any that are exhausted.
+
+        >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8]))
+        [1, 4, 6, 2, 5, 7, 3, 8]
+
+    This function produces the same output as :func:`roundrobin`, but may
+    perform better for some inputs (in particular when the number of iterables
+    is large).
+
+    """
+    i = chain.from_iterable(zip_longest(*iterables, fillvalue=_marker))
+    return (x for x in i if x is not _marker)
+
+
+def interleave_evenly(iterables, lengths=None):
+    """
+    Interleave multiple iterables so that their elements are evenly distributed
+    throughout the output sequence.
+
+    >>> iterables = [1, 2, 3, 4, 5], ['a', 'b']
+    >>> list(interleave_evenly(iterables))
+    [1, 2, 'a', 3, 4, 'b', 5]
+
+    >>> iterables = [[1, 2, 3], [4, 5], [6, 7, 8]]
+    >>> list(interleave_evenly(iterables))
+    [1, 6, 4, 2, 7, 3, 8, 5]
+
+    This function requires iterables of known length. Iterables without
+    ``__len__()`` can be used by manually specifying lengths with *lengths*:
+
+    >>> from itertools import combinations, repeat
+    >>> iterables = [combinations(range(4), 2), ['a', 'b', 'c']]
+    >>> lengths = [4 * (4 - 1) // 2, 3]
+    >>> list(interleave_evenly(iterables, lengths=lengths))
+    [(0, 1), (0, 2), 'a', (0, 3), (1, 2), 'b', (1, 3), (2, 3), 'c']
+
+    Based on Bresenham's algorithm.
+    """
+    if lengths is None:
+        try:
+            lengths = [len(it) for it in iterables]
+        except TypeError:
+            raise ValueError(
+                'Iterable lengths could not be determined automatically. '
+                'Specify them with the lengths keyword.'
+            )
+    elif len(iterables) != len(lengths):
+        raise ValueError('Mismatching number of iterables and lengths.')
+
+    dims = len(lengths)
+
+    # sort iterables by length, descending
+    lengths_permute = sorted(
+        range(dims), key=lambda i: lengths[i], reverse=True
+    )
+    lengths_desc = [lengths[i] for i in lengths_permute]
+    iters_desc = [iter(iterables[i]) for i in lengths_permute]
+
+    # the longest iterable is the primary one (Bresenham: the longest
+    # distance along an axis)
+    delta_primary, deltas_secondary = lengths_desc[0], lengths_desc[1:]
+    iter_primary, iters_secondary = iters_desc[0], iters_desc[1:]
+    errors = [delta_primary // dims] * len(deltas_secondary)
+
+    to_yield = sum(lengths)
+    while to_yield:
+        yield next(iter_primary)
+        to_yield -= 1
+        # update errors for each secondary iterable
+        errors = [e - delta for e, delta in zip(errors, deltas_secondary)]
+
+        # those iterables for which the error is negative are yielded
+        # ("diagonal step" in Bresenham)
+        for i, e in enumerate(errors):
+            if e < 0:
+                yield next(iters_secondary[i])
+                to_yield -= 1
+                errors[i] += delta_primary
+
+
+def collapse(iterable, base_type=None, levels=None):
+    """Flatten an iterable with multiple levels of nesting (e.g., a list of
+    lists of tuples) into non-iterable types.
+
+        >>> iterable = [(1, 2), ([3, 4], [[5], [6]])]
+        >>> list(collapse(iterable))
+        [1, 2, 3, 4, 5, 6]
+
+    Binary and text strings are not considered iterable and
+    will not be collapsed.
+
+    To avoid collapsing other types, specify *base_type*:
+
+        >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']]
+        >>> list(collapse(iterable, base_type=tuple))
+        ['ab', ('cd', 'ef'), 'gh', 'ij']
+
+    Specify *levels* to stop flattening after a certain level:
+
+    >>> iterable = [('a', ['b']), ('c', ['d'])]
+    >>> list(collapse(iterable))  # Fully flattened
+    ['a', 'b', 'c', 'd']
+    >>> list(collapse(iterable, levels=1))  # Only one level flattened
+    ['a', ['b'], 'c', ['d']]
+
+    """
+
+    def walk(node, level):
+        if (
+            ((levels is not None) and (level > levels))
+            or isinstance(node, (str, bytes))
+            or ((base_type is not None) and isinstance(node, base_type))
+        ):
+            yield node
+            return
+
+        try:
+            tree = iter(node)
+        except TypeError:
+            yield node
+            return
+        else:
+            for child in tree:
+                yield from walk(child, level + 1)
+
+    yield from walk(iterable, 0)
+
+
+def side_effect(func, iterable, chunk_size=None, before=None, after=None):
+    """Invoke *func* on each item in *iterable* (or on each *chunk_size* group
+    of items) before yielding the item.
+
+    `func` must be a function that takes a single argument. Its return value
+    will be discarded.
+
+    *before* and *after* are optional functions that take no arguments. They
+    will be executed before iteration starts and after it ends, respectively.
+
+    `side_effect` can be used for logging, updating progress bars, or anything
+    that is not functionally "pure."
+
+    Emitting a status message:
+
+        >>> from more_itertools import consume
+        >>> func = lambda item: print('Received {}'.format(item))
+        >>> consume(side_effect(func, range(2)))
+        Received 0
+        Received 1
+
+    Operating on chunks of items:
+
+        >>> pair_sums = []
+        >>> func = lambda chunk: pair_sums.append(sum(chunk))
+        >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2))
+        [0, 1, 2, 3, 4, 5]
+        >>> list(pair_sums)
+        [1, 5, 9]
+
+    Writing to a file-like object:
+
+        >>> from io import StringIO
+        >>> from more_itertools import consume
+        >>> f = StringIO()
+        >>> func = lambda x: print(x, file=f)
+        >>> before = lambda: print(u'HEADER', file=f)
+        >>> after = f.close
+        >>> it = [u'a', u'b', u'c']
+        >>> consume(side_effect(func, it, before=before, after=after))
+        >>> f.closed
+        True
+
+    """
+    try:
+        if before is not None:
+            before()
+
+        if chunk_size is None:
+            for item in iterable:
+                func(item)
+                yield item
+        else:
+            for chunk in chunked(iterable, chunk_size):
+                func(chunk)
+                yield from chunk
+    finally:
+        if after is not None:
+            after()
+
+
+def sliced(seq, n, strict=False):
+    """Yield slices of length *n* from the sequence *seq*.
+
+    >>> list(sliced((1, 2, 3, 4, 5, 6), 3))
+    [(1, 2, 3), (4, 5, 6)]
+
+    By the default, the last yielded slice will have fewer than *n* elements
+    if the length of *seq* is not divisible by *n*:
+
+    >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3))
+    [(1, 2, 3), (4, 5, 6), (7, 8)]
+
+    If the length of *seq* is not divisible by *n* and *strict* is
+    ``True``, then ``ValueError`` will be raised before the last
+    slice is yielded.
+
+    This function will only work for iterables that support slicing.
+    For non-sliceable iterables, see :func:`chunked`.
+
+    """
+    iterator = takewhile(len, (seq[i : i + n] for i in count(0, n)))
+    if strict:
+
+        def ret():
+            for _slice in iterator:
+                if len(_slice) != n:
+                    raise ValueError("seq is not divisible by n.")
+                yield _slice
+
+        return iter(ret())
+    else:
+        return iterator
+
+
+def split_at(iterable, pred, maxsplit=-1, keep_separator=False):
+    """Yield lists of items from *iterable*, where each list is delimited by
+    an item where callable *pred* returns ``True``.
+
+        >>> list(split_at('abcdcba', lambda x: x == 'b'))
+        [['a'], ['c', 'd', 'c'], ['a']]
+
+        >>> list(split_at(range(10), lambda n: n % 2 == 1))
+        [[0], [2], [4], [6], [8], []]
+
+    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
+    then there is no limit on the number of splits:
+
+        >>> list(split_at(range(10), lambda n: n % 2 == 1, maxsplit=2))
+        [[0], [2], [4, 5, 6, 7, 8, 9]]
+
+    By default, the delimiting items are not included in the output.
+    To include them, set *keep_separator* to ``True``.
+
+        >>> list(split_at('abcdcba', lambda x: x == 'b', keep_separator=True))
+        [['a'], ['b'], ['c', 'd', 'c'], ['b'], ['a']]
+
+    """
+    if maxsplit == 0:
+        yield list(iterable)
+        return
+
+    buf = []
+    it = iter(iterable)
+    for item in it:
+        if pred(item):
+            yield buf
+            if keep_separator:
+                yield [item]
+            if maxsplit == 1:
+                yield list(it)
+                return
+            buf = []
+            maxsplit -= 1
+        else:
+            buf.append(item)
+    yield buf
+
+
+def split_before(iterable, pred, maxsplit=-1):
+    """Yield lists of items from *iterable*, where each list ends just before
+    an item for which callable *pred* returns ``True``:
+
+        >>> list(split_before('OneTwo', lambda s: s.isupper()))
+        [['O', 'n', 'e'], ['T', 'w', 'o']]
+
+        >>> list(split_before(range(10), lambda n: n % 3 == 0))
+        [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
+
+    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
+    then there is no limit on the number of splits:
+
+        >>> list(split_before(range(10), lambda n: n % 3 == 0, maxsplit=2))
+        [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
+    """
+    if maxsplit == 0:
+        yield list(iterable)
+        return
+
+    buf = []
+    it = iter(iterable)
+    for item in it:
+        if pred(item) and buf:
+            yield buf
+            if maxsplit == 1:
+                yield [item] + list(it)
+                return
+            buf = []
+            maxsplit -= 1
+        buf.append(item)
+    if buf:
+        yield buf
+
+
+def split_after(iterable, pred, maxsplit=-1):
+    """Yield lists of items from *iterable*, where each list ends with an
+    item where callable *pred* returns ``True``:
+
+        >>> list(split_after('one1two2', lambda s: s.isdigit()))
+        [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']]
+
+        >>> list(split_after(range(10), lambda n: n % 3 == 0))
+        [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]]
+
+    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
+    then there is no limit on the number of splits:
+
+        >>> list(split_after(range(10), lambda n: n % 3 == 0, maxsplit=2))
+        [[0], [1, 2, 3], [4, 5, 6, 7, 8, 9]]
+
+    """
+    if maxsplit == 0:
+        yield list(iterable)
+        return
+
+    buf = []
+    it = iter(iterable)
+    for item in it:
+        buf.append(item)
+        if pred(item) and buf:
+            yield buf
+            if maxsplit == 1:
+                buf = list(it)
+                if buf:
+                    yield buf
+                return
+            buf = []
+            maxsplit -= 1
+    if buf:
+        yield buf
+
+
+def split_when(iterable, pred, maxsplit=-1):
+    """Split *iterable* into pieces based on the output of *pred*.
+    *pred* should be a function that takes successive pairs of items and
+    returns ``True`` if the iterable should be split in between them.
+
+    For example, to find runs of increasing numbers, split the iterable when
+    element ``i`` is larger than element ``i + 1``:
+
+        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], lambda x, y: x > y))
+        [[1, 2, 3, 3], [2, 5], [2, 4], [2]]
+
+    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
+    then there is no limit on the number of splits:
+
+        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2],
+        ...                 lambda x, y: x > y, maxsplit=2))
+        [[1, 2, 3, 3], [2, 5], [2, 4, 2]]
+
+    """
+    if maxsplit == 0:
+        yield list(iterable)
+        return
+
+    it = iter(iterable)
+    try:
+        cur_item = next(it)
+    except StopIteration:
+        return
+
+    buf = [cur_item]
+    for next_item in it:
+        if pred(cur_item, next_item):
+            yield buf
+            if maxsplit == 1:
+                yield [next_item] + list(it)
+                return
+            buf = []
+            maxsplit -= 1
+
+        buf.append(next_item)
+        cur_item = next_item
+
+    yield buf
+
+
+def split_into(iterable, sizes):
+    """Yield a list of sequential items from *iterable* of length 'n' for each
+    integer 'n' in *sizes*.
+
+        >>> list(split_into([1,2,3,4,5,6], [1,2,3]))
+        [[1], [2, 3], [4, 5, 6]]
+
+    If the sum of *sizes* is smaller than the length of *iterable*, then the
+    remaining items of *iterable* will not be returned.
+
+        >>> list(split_into([1,2,3,4,5,6], [2,3]))
+        [[1, 2], [3, 4, 5]]
+
+    If the sum of *sizes* is larger than the length of *iterable*, fewer items
+    will be returned in the iteration that overruns *iterable* and further
+    lists will be empty:
+
+        >>> list(split_into([1,2,3,4], [1,2,3,4]))
+        [[1], [2, 3], [4], []]
+
+    When a ``None`` object is encountered in *sizes*, the returned list will
+    contain items up to the end of *iterable* the same way that itertools.slice
+    does:
+
+        >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None]))
+        [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]]
+
+    :func:`split_into` can be useful for grouping a series of items where the
+    sizes of the groups are not uniform. An example would be where in a row
+    from a table, multiple columns represent elements of the same feature
+    (e.g. a point represented by x,y,z) but, the format is not the same for
+    all columns.
+    """
+    # convert the iterable argument into an iterator so its contents can
+    # be consumed by islice in case it is a generator
+    it = iter(iterable)
+
+    for size in sizes:
+        if size is None:
+            yield list(it)
+            return
+        else:
+            yield list(islice(it, size))
+
+
+def padded(iterable, fillvalue=None, n=None, next_multiple=False):
+    """Yield the elements from *iterable*, followed by *fillvalue*, such that
+    at least *n* items are emitted.
+
+        >>> list(padded([1, 2, 3], '?', 5))
+        [1, 2, 3, '?', '?']
+
+    If *next_multiple* is ``True``, *fillvalue* will be emitted until the
+    number of items emitted is a multiple of *n*::
+
+        >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True))
+        [1, 2, 3, 4, None, None]
+
+    If *n* is ``None``, *fillvalue* will be emitted indefinitely.
+
+    """
+    it = iter(iterable)
+    if n is None:
+        yield from chain(it, repeat(fillvalue))
+    elif n < 1:
+        raise ValueError('n must be at least 1')
+    else:
+        item_count = 0
+        for item in it:
+            yield item
+            item_count += 1
+
+        remaining = (n - item_count) % n if next_multiple else n - item_count
+        for _ in range(remaining):
+            yield fillvalue
+
+
+def repeat_each(iterable, n=2):
+    """Repeat each element in *iterable* *n* times.
+
+    >>> list(repeat_each('ABC', 3))
+    ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']
+    """
+    return chain.from_iterable(map(repeat, iterable, repeat(n)))
+
+
+def repeat_last(iterable, default=None):
+    """After the *iterable* is exhausted, keep yielding its last element.
+
+        >>> list(islice(repeat_last(range(3)), 5))
+        [0, 1, 2, 2, 2]
+
+    If the iterable is empty, yield *default* forever::
+
+        >>> list(islice(repeat_last(range(0), 42), 5))
+        [42, 42, 42, 42, 42]
+
+    """
+    item = _marker
+    for item in iterable:
+        yield item
+    final = default if item is _marker else item
+    yield from repeat(final)
+
+
+def distribute(n, iterable):
+    """Distribute the items from *iterable* among *n* smaller iterables.
+
+        >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
+        >>> list(group_1)
+        [1, 3, 5]
+        >>> list(group_2)
+        [2, 4, 6]
+
+    If the length of *iterable* is not evenly divisible by *n*, then the
+    length of the returned iterables will not be identical:
+
+        >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
+        >>> [list(c) for c in children]
+        [[1, 4, 7], [2, 5], [3, 6]]
+
+    If the length of *iterable* is smaller than *n*, then the last returned
+    iterables will be empty:
+
+        >>> children = distribute(5, [1, 2, 3])
+        >>> [list(c) for c in children]
+        [[1], [2], [3], [], []]
+
+    This function uses :func:`itertools.tee` and may require significant
+    storage. If you need the order items in the smaller iterables to match the
+    original iterable, see :func:`divide`.
+
+    """
+    if n < 1:
+        raise ValueError('n must be at least 1')
+
+    children = tee(iterable, n)
+    return [islice(it, index, None, n) for index, it in enumerate(children)]
+
+
+def stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None):
+    """Yield tuples whose elements are offset from *iterable*.
+    The amount by which the `i`-th item in each tuple is offset is given by
+    the `i`-th item in *offsets*.
+
+        >>> list(stagger([0, 1, 2, 3]))
+        [(None, 0, 1), (0, 1, 2), (1, 2, 3)]
+        >>> list(stagger(range(8), offsets=(0, 2, 4)))
+        [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)]
+
+    By default, the sequence will end when the final element of a tuple is the
+    last item in the iterable. To continue until the first element of a tuple
+    is the last item in the iterable, set *longest* to ``True``::
+
+        >>> list(stagger([0, 1, 2, 3], longest=True))
+        [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)]
+
+    By default, ``None`` will be used to replace offsets beyond the end of the
+    sequence. Specify *fillvalue* to use some other value.
+
+    """
+    children = tee(iterable, len(offsets))
+
+    return zip_offset(
+        *children, offsets=offsets, longest=longest, fillvalue=fillvalue
+    )
+
+
+def zip_equal(*iterables):
+    """``zip`` the input *iterables* together, but raise
+    ``UnequalIterablesError`` if they aren't all the same length.
+
+        >>> it_1 = range(3)
+        >>> it_2 = iter('abc')
+        >>> list(zip_equal(it_1, it_2))
+        [(0, 'a'), (1, 'b'), (2, 'c')]
+
+        >>> it_1 = range(3)
+        >>> it_2 = iter('abcd')
+        >>> list(zip_equal(it_1, it_2)) # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+        ...
+        more_itertools.more.UnequalIterablesError: Iterables have different
+        lengths
+
+    """
+    if hexversion >= 0x30A00A6:
+        warnings.warn(
+            (
+                'zip_equal will be removed in a future version of '
+                'more-itertools. Use the builtin zip function with '
+                'strict=True instead.'
+            ),
+            DeprecationWarning,
+        )
+
+    return _zip_equal(*iterables)
+
+
+def zip_offset(*iterables, offsets, longest=False, fillvalue=None):
+    """``zip`` the input *iterables* together, but offset the `i`-th iterable
+    by the `i`-th item in *offsets*.
+
+        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1)))
+        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')]
+
+    This can be used as a lightweight alternative to SciPy or pandas to analyze
+    data sets in which some series have a lead or lag relationship.
+
+    By default, the sequence will end when the shortest iterable is exhausted.
+    To continue until the longest iterable is exhausted, set *longest* to
+    ``True``.
+
+        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True))
+        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')]
+
+    By default, ``None`` will be used to replace offsets beyond the end of the
+    sequence. Specify *fillvalue* to use some other value.
+
+    """
+    if len(iterables) != len(offsets):
+        raise ValueError("Number of iterables and offsets didn't match")
+
+    staggered = []
+    for it, n in zip(iterables, offsets):
+        if n < 0:
+            staggered.append(chain(repeat(fillvalue, -n), it))
+        elif n > 0:
+            staggered.append(islice(it, n, None))
+        else:
+            staggered.append(it)
+
+    if longest:
+        return zip_longest(*staggered, fillvalue=fillvalue)
+
+    return zip(*staggered)
+
+
+def sort_together(iterables, key_list=(0,), key=None, reverse=False):
+    """Return the input iterables sorted together, with *key_list* as the
+    priority for sorting. All iterables are trimmed to the length of the
+    shortest one.
+
+    This can be used like the sorting function in a spreadsheet. If each
+    iterable represents a column of data, the key list determines which
+    columns are used for sorting.
+
+    By default, all iterables are sorted using the ``0``-th iterable::
+
+        >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')]
+        >>> sort_together(iterables)
+        [(1, 2, 3, 4), ('d', 'c', 'b', 'a')]
+
+    Set a different key list to sort according to another iterable.
+    Specifying multiple keys dictates how ties are broken::
+
+        >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')]
+        >>> sort_together(iterables, key_list=(1, 2))
+        [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')]
+
+    To sort by a function of the elements of the iterable, pass a *key*
+    function. Its arguments are the elements of the iterables corresponding to
+    the key list::
+
+        >>> names = ('a', 'b', 'c')
+        >>> lengths = (1, 2, 3)
+        >>> widths = (5, 2, 1)
+        >>> def area(length, width):
+        ...     return length * width
+        >>> sort_together([names, lengths, widths], key_list=(1, 2), key=area)
+        [('c', 'b', 'a'), (3, 2, 1), (1, 2, 5)]
+
+    Set *reverse* to ``True`` to sort in descending order.
+
+        >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True)
+        [(3, 2, 1), ('a', 'b', 'c')]
+
+    """
+    if key is None:
+        # if there is no key function, the key argument to sorted is an
+        # itemgetter
+        key_argument = itemgetter(*key_list)
+    else:
+        # if there is a key function, call it with the items at the offsets
+        # specified by the key function as arguments
+        key_list = list(key_list)
+        if len(key_list) == 1:
+            # if key_list contains a single item, pass the item at that offset
+            # as the only argument to the key function
+            key_offset = key_list[0]
+            key_argument = lambda zipped_items: key(zipped_items[key_offset])
+        else:
+            # if key_list contains multiple items, use itemgetter to return a
+            # tuple of items, which we pass as *args to the key function
+            get_key_items = itemgetter(*key_list)
+            key_argument = lambda zipped_items: key(
+                *get_key_items(zipped_items)
+            )
+
+    return list(
+        zip(*sorted(zip(*iterables), key=key_argument, reverse=reverse))
+    )
+
+
+def unzip(iterable):
+    """The inverse of :func:`zip`, this function disaggregates the elements
+    of the zipped *iterable*.
+
+    The ``i``-th iterable contains the ``i``-th element from each element
+    of the zipped iterable. The first element is used to determine the
+    length of the remaining elements.
+
+        >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+        >>> letters, numbers = unzip(iterable)
+        >>> list(letters)
+        ['a', 'b', 'c', 'd']
+        >>> list(numbers)
+        [1, 2, 3, 4]
+
+    This is similar to using ``zip(*iterable)``, but it avoids reading
+    *iterable* into memory. Note, however, that this function uses
+    :func:`itertools.tee` and thus may require significant storage.
+
+    """
+    head, iterable = spy(iter(iterable))
+    if not head:
+        # empty iterable, e.g. zip([], [], [])
+        return ()
+    # spy returns a one-length iterable as head
+    head = head[0]
+    iterables = tee(iterable, len(head))
+
+    def itemgetter(i):
+        def getter(obj):
+            try:
+                return obj[i]
+            except IndexError:
+                # basically if we have an iterable like
+                # iter([(1, 2, 3), (4, 5), (6,)])
+                # the second unzipped iterable would fail at the third tuple
+                # since it would try to access tup[1]
+                # same with the third unzipped iterable and the second tuple
+                # to support these "improperly zipped" iterables,
+                # we create a custom itemgetter
+                # which just stops the unzipped iterables
+                # at first length mismatch
+                raise StopIteration
+
+        return getter
+
+    return tuple(map(itemgetter(i), it) for i, it in enumerate(iterables))
+
+
+def divide(n, iterable):
+    """Divide the elements from *iterable* into *n* parts, maintaining
+    order.
+
+        >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6])
+        >>> list(group_1)
+        [1, 2, 3]
+        >>> list(group_2)
+        [4, 5, 6]
+
+    If the length of *iterable* is not evenly divisible by *n*, then the
+    length of the returned iterables will not be identical:
+
+        >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7])
+        >>> [list(c) for c in children]
+        [[1, 2, 3], [4, 5], [6, 7]]
+
+    If the length of the iterable is smaller than n, then the last returned
+    iterables will be empty:
+
+        >>> children = divide(5, [1, 2, 3])
+        >>> [list(c) for c in children]
+        [[1], [2], [3], [], []]
+
+    This function will exhaust the iterable before returning and may require
+    significant storage. If order is not important, see :func:`distribute`,
+    which does not first pull the iterable into memory.
+
+    """
+    if n < 1:
+        raise ValueError('n must be at least 1')
+
+    try:
+        iterable[:0]
+    except TypeError:
+        seq = tuple(iterable)
+    else:
+        seq = iterable
+
+    q, r = divmod(len(seq), n)
+
+    ret = []
+    stop = 0
+    for i in range(1, n + 1):
+        start = stop
+        stop += q + 1 if i <= r else q
+        ret.append(iter(seq[start:stop]))
+
+    return ret
+
+
+def always_iterable(obj, base_type=(str, bytes)):
+    """If *obj* is iterable, return an iterator over its items::
+
+        >>> obj = (1, 2, 3)
+        >>> list(always_iterable(obj))
+        [1, 2, 3]
+
+    If *obj* is not iterable, return a one-item iterable containing *obj*::
+
+        >>> obj = 1
+        >>> list(always_iterable(obj))
+        [1]
+
+    If *obj* is ``None``, return an empty iterable:
+
+        >>> obj = None
+        >>> list(always_iterable(None))
+        []
+
+    By default, binary and text strings are not considered iterable::
+
+        >>> obj = 'foo'
+        >>> list(always_iterable(obj))
+        ['foo']
+
+    If *base_type* is set, objects for which ``isinstance(obj, base_type)``
+    returns ``True`` won't be considered iterable.
+
+        >>> obj = {'a': 1}
+        >>> list(always_iterable(obj))  # Iterate over the dict's keys
+        ['a']
+        >>> list(always_iterable(obj, base_type=dict))  # Treat dicts as a unit
+        [{'a': 1}]
+
+    Set *base_type* to ``None`` to avoid any special handling and treat objects
+    Python considers iterable as iterable:
+
+        >>> obj = 'foo'
+        >>> list(always_iterable(obj, base_type=None))
+        ['f', 'o', 'o']
+    """
+    if obj is None:
+        return iter(())
+
+    if (base_type is not None) and isinstance(obj, base_type):
+        return iter((obj,))
+
+    try:
+        return iter(obj)
+    except TypeError:
+        return iter((obj,))
+
+
+def adjacent(predicate, iterable, distance=1):
+    """Return an iterable over `(bool, item)` tuples where the `item` is
+    drawn from *iterable* and the `bool` indicates whether
+    that item satisfies the *predicate* or is adjacent to an item that does.
+
+    For example, to find whether items are adjacent to a ``3``::
+
+        >>> list(adjacent(lambda x: x == 3, range(6)))
+        [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)]
+
+    Set *distance* to change what counts as adjacent. For example, to find
+    whether items are two places away from a ``3``:
+
+        >>> list(adjacent(lambda x: x == 3, range(6), distance=2))
+        [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)]
+
+    This is useful for contextualizing the results of a search function.
+    For example, a code comparison tool might want to identify lines that
+    have changed, but also surrounding lines to give the viewer of the diff
+    context.
+
+    The predicate function will only be called once for each item in the
+    iterable.
+
+    See also :func:`groupby_transform`, which can be used with this function
+    to group ranges of items with the same `bool` value.
+
+    """
+    # Allow distance=0 mainly for testing that it reproduces results with map()
+    if distance < 0:
+        raise ValueError('distance must be at least 0')
+
+    i1, i2 = tee(iterable)
+    padding = [False] * distance
+    selected = chain(padding, map(predicate, i1), padding)
+    adjacent_to_selected = map(any, windowed(selected, 2 * distance + 1))
+    return zip(adjacent_to_selected, i2)
+
+
+def groupby_transform(iterable, keyfunc=None, valuefunc=None, reducefunc=None):
+    """An extension of :func:`itertools.groupby` that can apply transformations
+    to the grouped data.
+
+    * *keyfunc* is a function computing a key value for each item in *iterable*
+    * *valuefunc* is a function that transforms the individual items from
+      *iterable* after grouping
+    * *reducefunc* is a function that transforms each group of items
+
+    >>> iterable = 'aAAbBBcCC'
+    >>> keyfunc = lambda k: k.upper()
+    >>> valuefunc = lambda v: v.lower()
+    >>> reducefunc = lambda g: ''.join(g)
+    >>> list(groupby_transform(iterable, keyfunc, valuefunc, reducefunc))
+    [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')]
+
+    Each optional argument defaults to an identity function if not specified.
+
+    :func:`groupby_transform` is useful when grouping elements of an iterable
+    using a separate iterable as the key. To do this, :func:`zip` the iterables
+    and pass a *keyfunc* that extracts the first element and a *valuefunc*
+    that extracts the second element::
+
+        >>> from operator import itemgetter
+        >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3]
+        >>> values = 'abcdefghi'
+        >>> iterable = zip(keys, values)
+        >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1))
+        >>> [(k, ''.join(g)) for k, g in grouper]
+        [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')]
+
+    Note that the order of items in the iterable is significant.
+    Only adjacent items are grouped together, so if you don't want any
+    duplicate groups, you should sort the iterable by the key function.
+
+    """
+    ret = groupby(iterable, keyfunc)
+    if valuefunc:
+        ret = ((k, map(valuefunc, g)) for k, g in ret)
+    if reducefunc:
+        ret = ((k, reducefunc(g)) for k, g in ret)
+
+    return ret
+
+
+class numeric_range(abc.Sequence, abc.Hashable):
+    """An extension of the built-in ``range()`` function whose arguments can
+    be any orderable numeric type.
+
+    With only *stop* specified, *start* defaults to ``0`` and *step*
+    defaults to ``1``. The output items will match the type of *stop*:
+
+        >>> list(numeric_range(3.5))
+        [0.0, 1.0, 2.0, 3.0]
+
+    With only *start* and *stop* specified, *step* defaults to ``1``. The
+    output items will match the type of *start*:
+
+        >>> from decimal import Decimal
+        >>> start = Decimal('2.1')
+        >>> stop = Decimal('5.1')
+        >>> list(numeric_range(start, stop))
+        [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')]
+
+    With *start*, *stop*, and *step*  specified the output items will match
+    the type of ``start + step``:
+
+        >>> from fractions import Fraction
+        >>> start = Fraction(1, 2)  # Start at 1/2
+        >>> stop = Fraction(5, 2)  # End at 5/2
+        >>> step = Fraction(1, 2)  # Count by 1/2
+        >>> list(numeric_range(start, stop, step))
+        [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)]
+
+    If *step* is zero, ``ValueError`` is raised. Negative steps are supported:
+
+        >>> list(numeric_range(3, -1, -1.0))
+        [3.0, 2.0, 1.0, 0.0]
+
+    Be aware of the limitations of floating point numbers; the representation
+    of the yielded numbers may be surprising.
+
+    ``datetime.datetime`` objects can be used for *start* and *stop*, if *step*
+    is a ``datetime.timedelta`` object:
+
+        >>> import datetime
+        >>> start = datetime.datetime(2019, 1, 1)
+        >>> stop = datetime.datetime(2019, 1, 3)
+        >>> step = datetime.timedelta(days=1)
+        >>> items = iter(numeric_range(start, stop, step))
+        >>> next(items)
+        datetime.datetime(2019, 1, 1, 0, 0)
+        >>> next(items)
+        datetime.datetime(2019, 1, 2, 0, 0)
+
+    """
+
+    _EMPTY_HASH = hash(range(0, 0))
+
+    def __init__(self, *args):
+        argc = len(args)
+        if argc == 1:
+            (self._stop,) = args
+            self._start = type(self._stop)(0)
+            self._step = type(self._stop - self._start)(1)
+        elif argc == 2:
+            self._start, self._stop = args
+            self._step = type(self._stop - self._start)(1)
+        elif argc == 3:
+            self._start, self._stop, self._step = args
+        elif argc == 0:
+            raise TypeError(
+                'numeric_range expected at least '
+                '1 argument, got {}'.format(argc)
+            )
+        else:
+            raise TypeError(
+                'numeric_range expected at most '
+                '3 arguments, got {}'.format(argc)
+            )
+
+        self._zero = type(self._step)(0)
+        if self._step == self._zero:
+            raise ValueError('numeric_range() arg 3 must not be zero')
+        self._growing = self._step > self._zero
+
+    def __bool__(self):
+        if self._growing:
+            return self._start < self._stop
+        else:
+            return self._start > self._stop
+
+    def __contains__(self, elem):
+        if self._growing:
+            if self._start <= elem < self._stop:
+                return (elem - self._start) % self._step == self._zero
+        else:
+            if self._start >= elem > self._stop:
+                return (self._start - elem) % (-self._step) == self._zero
+
+        return False
+
+    def __eq__(self, other):
+        if isinstance(other, numeric_range):
+            empty_self = not bool(self)
+            empty_other = not bool(other)
+            if empty_self or empty_other:
+                return empty_self and empty_other  # True if both empty
+            else:
+                return (
+                    self._start == other._start
+                    and self._step == other._step
+                    and self._get_by_index(-1) == other._get_by_index(-1)
+                )
+        else:
+            return False
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self._get_by_index(key)
+        elif isinstance(key, slice):
+            step = self._step if key.step is None else key.step * self._step
+
+            if key.start is None or key.start <= -self._len:
+                start = self._start
+            elif key.start >= self._len:
+                start = self._stop
+            else:  # -self._len < key.start < self._len
+                start = self._get_by_index(key.start)
+
+            if key.stop is None or key.stop >= self._len:
+                stop = self._stop
+            elif key.stop <= -self._len:
+                stop = self._start
+            else:  # -self._len < key.stop < self._len
+                stop = self._get_by_index(key.stop)
+
+            return numeric_range(start, stop, step)
+        else:
+            raise TypeError(
+                'numeric range indices must be '
+                'integers or slices, not {}'.format(type(key).__name__)
+            )
+
+    def __hash__(self):
+        if self:
+            return hash((self._start, self._get_by_index(-1), self._step))
+        else:
+            return self._EMPTY_HASH
+
+    def __iter__(self):
+        values = (self._start + (n * self._step) for n in count())
+        if self._growing:
+            return takewhile(partial(gt, self._stop), values)
+        else:
+            return takewhile(partial(lt, self._stop), values)
+
+    def __len__(self):
+        return self._len
+
+    @cached_property
+    def _len(self):
+        if self._growing:
+            start = self._start
+            stop = self._stop
+            step = self._step
+        else:
+            start = self._stop
+            stop = self._start
+            step = -self._step
+        distance = stop - start
+        if distance <= self._zero:
+            return 0
+        else:  # distance > 0 and step > 0: regular euclidean division
+            q, r = divmod(distance, step)
+            return int(q) + int(r != self._zero)
+
+    def __reduce__(self):
+        return numeric_range, (self._start, self._stop, self._step)
+
+    def __repr__(self):
+        if self._step == 1:
+            return "numeric_range({}, {})".format(
+                repr(self._start), repr(self._stop)
+            )
+        else:
+            return "numeric_range({}, {}, {})".format(
+                repr(self._start), repr(self._stop), repr(self._step)
+            )
+
+    def __reversed__(self):
+        return iter(
+            numeric_range(
+                self._get_by_index(-1), self._start - self._step, -self._step
+            )
+        )
+
+    def count(self, value):
+        return int(value in self)
+
+    def index(self, value):
+        if self._growing:
+            if self._start <= value < self._stop:
+                q, r = divmod(value - self._start, self._step)
+                if r == self._zero:
+                    return int(q)
+        else:
+            if self._start >= value > self._stop:
+                q, r = divmod(self._start - value, -self._step)
+                if r == self._zero:
+                    return int(q)
+
+        raise ValueError("{} is not in numeric range".format(value))
+
+    def _get_by_index(self, i):
+        if i < 0:
+            i += self._len
+        if i < 0 or i >= self._len:
+            raise IndexError("numeric range object index out of range")
+        return self._start + i * self._step
+
+
+def count_cycle(iterable, n=None):
+    """Cycle through the items from *iterable* up to *n* times, yielding
+    the number of completed cycles along with each item. If *n* is omitted the
+    process repeats indefinitely.
+
+    >>> list(count_cycle('AB', 3))
+    [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')]
+
+    """
+    iterable = tuple(iterable)
+    if not iterable:
+        return iter(())
+    counter = count() if n is None else range(n)
+    return ((i, item) for i in counter for item in iterable)
+
+
+def mark_ends(iterable):
+    """Yield 3-tuples of the form ``(is_first, is_last, item)``.
+
+    >>> list(mark_ends('ABC'))
+    [(True, False, 'A'), (False, False, 'B'), (False, True, 'C')]
+
+    Use this when looping over an iterable to take special action on its first
+    and/or last items:
+
+    >>> iterable = ['Header', 100, 200, 'Footer']
+    >>> total = 0
+    >>> for is_first, is_last, item in mark_ends(iterable):
+    ...     if is_first:
+    ...         continue  # Skip the header
+    ...     if is_last:
+    ...         continue  # Skip the footer
+    ...     total += item
+    >>> print(total)
+    300
+    """
+    it = iter(iterable)
+
+    try:
+        b = next(it)
+    except StopIteration:
+        return
+
+    try:
+        for i in count():
+            a = b
+            b = next(it)
+            yield i == 0, False, a
+
+    except StopIteration:
+        yield i == 0, True, a
+
+
+def locate(iterable, pred=bool, window_size=None):
+    """Yield the index of each item in *iterable* for which *pred* returns
+    ``True``.
+
+    *pred* defaults to :func:`bool`, which will select truthy items:
+
+        >>> list(locate([0, 1, 1, 0, 1, 0, 0]))
+        [1, 2, 4]
+
+    Set *pred* to a custom function to, e.g., find the indexes for a particular
+    item.
+
+        >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b'))
+        [1, 3]
+
+    If *window_size* is given, then the *pred* function will be called with
+    that many items. This enables searching for sub-sequences:
+
+        >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
+        >>> pred = lambda *args: args == (1, 2, 3)
+        >>> list(locate(iterable, pred=pred, window_size=3))
+        [1, 5, 9]
+
+    Use with :func:`seekable` to find indexes and then retrieve the associated
+    items:
+
+        >>> from itertools import count
+        >>> from more_itertools import seekable
+        >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count())
+        >>> it = seekable(source)
+        >>> pred = lambda x: x > 100
+        >>> indexes = locate(it, pred=pred)
+        >>> i = next(indexes)
+        >>> it.seek(i)
+        >>> next(it)
+        106
+
+    """
+    if window_size is None:
+        return compress(count(), map(pred, iterable))
+
+    if window_size < 1:
+        raise ValueError('window size must be at least 1')
+
+    it = windowed(iterable, window_size, fillvalue=_marker)
+    return compress(count(), starmap(pred, it))
+
+
+def longest_common_prefix(iterables):
+    """Yield elements of the longest common prefix amongst given *iterables*.
+
+    >>> ''.join(longest_common_prefix(['abcd', 'abc', 'abf']))
+    'ab'
+
+    """
+    return (c[0] for c in takewhile(all_equal, zip(*iterables)))
+
+
+def lstrip(iterable, pred):
+    """Yield the items from *iterable*, but strip any from the beginning
+    for which *pred* returns ``True``.
+
+    For example, to remove a set of items from the start of an iterable:
+
+        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
+        >>> pred = lambda x: x in {None, False, ''}
+        >>> list(lstrip(iterable, pred))
+        [1, 2, None, 3, False, None]
+
+    This function is analogous to to :func:`str.lstrip`, and is essentially
+    an wrapper for :func:`itertools.dropwhile`.
+
+    """
+    return dropwhile(pred, iterable)
+
+
+def rstrip(iterable, pred):
+    """Yield the items from *iterable*, but strip any from the end
+    for which *pred* returns ``True``.
+
+    For example, to remove a set of items from the end of an iterable:
+
+        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
+        >>> pred = lambda x: x in {None, False, ''}
+        >>> list(rstrip(iterable, pred))
+        [None, False, None, 1, 2, None, 3]
+
+    This function is analogous to :func:`str.rstrip`.
+
+    """
+    cache = []
+    cache_append = cache.append
+    cache_clear = cache.clear
+    for x in iterable:
+        if pred(x):
+            cache_append(x)
+        else:
+            yield from cache
+            cache_clear()
+            yield x
+
+
+def strip(iterable, pred):
+    """Yield the items from *iterable*, but strip any from the
+    beginning and end for which *pred* returns ``True``.
+
+    For example, to remove a set of items from both ends of an iterable:
+
+        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
+        >>> pred = lambda x: x in {None, False, ''}
+        >>> list(strip(iterable, pred))
+        [1, 2, None, 3]
+
+    This function is analogous to :func:`str.strip`.
+
+    """
+    return rstrip(lstrip(iterable, pred), pred)
+
+
+class islice_extended:
+    """An extension of :func:`itertools.islice` that supports negative values
+    for *stop*, *start*, and *step*.
+
+        >>> iterable = iter('abcdefgh')
+        >>> list(islice_extended(iterable, -4, -1))
+        ['e', 'f', 'g']
+
+    Slices with negative values require some caching of *iterable*, but this
+    function takes care to minimize the amount of memory required.
+
+    For example, you can use a negative step with an infinite iterator:
+
+        >>> from itertools import count
+        >>> list(islice_extended(count(), 110, 99, -2))
+        [110, 108, 106, 104, 102, 100]
+
+    You can also use slice notation directly:
+
+        >>> iterable = map(str, count())
+        >>> it = islice_extended(iterable)[10:20:2]
+        >>> list(it)
+        ['10', '12', '14', '16', '18']
+
+    """
+
+    def __init__(self, iterable, *args):
+        it = iter(iterable)
+        if args:
+            self._iterable = _islice_helper(it, slice(*args))
+        else:
+            self._iterable = it
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self._iterable)
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            return islice_extended(_islice_helper(self._iterable, key))
+
+        raise TypeError('islice_extended.__getitem__ argument must be a slice')
+
+
+def _islice_helper(it, s):
+    start = s.start
+    stop = s.stop
+    if s.step == 0:
+        raise ValueError('step argument must be a non-zero integer or None.')
+    step = s.step or 1
+
+    if step > 0:
+        start = 0 if (start is None) else start
+
+        if start < 0:
+            # Consume all but the last -start items
+            cache = deque(enumerate(it, 1), maxlen=-start)
+            len_iter = cache[-1][0] if cache else 0
+
+            # Adjust start to be positive
+            i = max(len_iter + start, 0)
+
+            # Adjust stop to be positive
+            if stop is None:
+                j = len_iter
+            elif stop >= 0:
+                j = min(stop, len_iter)
+            else:
+                j = max(len_iter + stop, 0)
+
+            # Slice the cache
+            n = j - i
+            if n <= 0:
+                return
+
+            for index, item in islice(cache, 0, n, step):
+                yield item
+        elif (stop is not None) and (stop < 0):
+            # Advance to the start position
+            next(islice(it, start, start), None)
+
+            # When stop is negative, we have to carry -stop items while
+            # iterating
+            cache = deque(islice(it, -stop), maxlen=-stop)
+
+            for index, item in enumerate(it):
+                cached_item = cache.popleft()
+                if index % step == 0:
+                    yield cached_item
+                cache.append(item)
+        else:
+            # When both start and stop are positive we have the normal case
+            yield from islice(it, start, stop, step)
+    else:
+        start = -1 if (start is None) else start
+
+        if (stop is not None) and (stop < 0):
+            # Consume all but the last items
+            n = -stop - 1
+            cache = deque(enumerate(it, 1), maxlen=n)
+            len_iter = cache[-1][0] if cache else 0
+
+            # If start and stop are both negative they are comparable and
+            # we can just slice. Otherwise we can adjust start to be negative
+            # and then slice.
+            if start < 0:
+                i, j = start, stop
+            else:
+                i, j = min(start - len_iter, -1), None
+
+            for index, item in list(cache)[i:j:step]:
+                yield item
+        else:
+            # Advance to the stop position
+            if stop is not None:
+                m = stop + 1
+                next(islice(it, m, m), None)
+
+            # stop is positive, so if start is negative they are not comparable
+            # and we need the rest of the items.
+            if start < 0:
+                i = start
+                n = None
+            # stop is None and start is positive, so we just need items up to
+            # the start index.
+            elif stop is None:
+                i = None
+                n = start + 1
+            # Both stop and start are positive, so they are comparable.
+            else:
+                i = None
+                n = start - stop
+                if n <= 0:
+                    return
+
+            cache = list(islice(it, n))
+
+            yield from cache[i::step]
+
+
+def always_reversible(iterable):
+    """An extension of :func:`reversed` that supports all iterables, not
+    just those which implement the ``Reversible`` or ``Sequence`` protocols.
+
+        >>> print(*always_reversible(x for x in range(3)))
+        2 1 0
+
+    If the iterable is already reversible, this function returns the
+    result of :func:`reversed()`. If the iterable is not reversible,
+    this function will cache the remaining items in the iterable and
+    yield them in reverse order, which may require significant storage.
+    """
+    try:
+        return reversed(iterable)
+    except TypeError:
+        return reversed(list(iterable))
+
+
+def consecutive_groups(iterable, ordering=lambda x: x):
+    """Yield groups of consecutive items using :func:`itertools.groupby`.
+    The *ordering* function determines whether two items are adjacent by
+    returning their position.
+
+    By default, the ordering function is the identity function. This is
+    suitable for finding runs of numbers:
+
+        >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40]
+        >>> for group in consecutive_groups(iterable):
+        ...     print(list(group))
+        [1]
+        [10, 11, 12]
+        [20]
+        [30, 31, 32, 33]
+        [40]
+
+    For finding runs of adjacent letters, try using the :meth:`index` method
+    of a string of letters:
+
+        >>> from string import ascii_lowercase
+        >>> iterable = 'abcdfgilmnop'
+        >>> ordering = ascii_lowercase.index
+        >>> for group in consecutive_groups(iterable, ordering):
+        ...     print(list(group))
+        ['a', 'b', 'c', 'd']
+        ['f', 'g']
+        ['i']
+        ['l', 'm', 'n', 'o', 'p']
+
+    Each group of consecutive items is an iterator that shares it source with
+    *iterable*. When an an output group is advanced, the previous group is
+    no longer available unless its elements are copied (e.g., into a ``list``).
+
+        >>> iterable = [1, 2, 11, 12, 21, 22]
+        >>> saved_groups = []
+        >>> for group in consecutive_groups(iterable):
+        ...     saved_groups.append(list(group))  # Copy group elements
+        >>> saved_groups
+        [[1, 2], [11, 12], [21, 22]]
+
+    """
+    for k, g in groupby(
+        enumerate(iterable), key=lambda x: x[0] - ordering(x[1])
+    ):
+        yield map(itemgetter(1), g)
+
+
+def difference(iterable, func=sub, *, initial=None):
+    """This function is the inverse of :func:`itertools.accumulate`. By default
+    it will compute the first difference of *iterable* using
+    :func:`operator.sub`:
+
+        >>> from itertools import accumulate
+        >>> iterable = accumulate([0, 1, 2, 3, 4])  # produces 0, 1, 3, 6, 10
+        >>> list(difference(iterable))
+        [0, 1, 2, 3, 4]
+
+    *func* defaults to :func:`operator.sub`, but other functions can be
+    specified. They will be applied as follows::
+
+        A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ...
+
+    For example, to do progressive division:
+
+        >>> iterable = [1, 2, 6, 24, 120]
+        >>> func = lambda x, y: x // y
+        >>> list(difference(iterable, func))
+        [1, 2, 3, 4, 5]
+
+    If the *initial* keyword is set, the first element will be skipped when
+    computing successive differences.
+
+        >>> it = [10, 11, 13, 16]  # from accumulate([1, 2, 3], initial=10)
+        >>> list(difference(it, initial=10))
+        [1, 2, 3]
+
+    """
+    a, b = tee(iterable)
+    try:
+        first = [next(b)]
+    except StopIteration:
+        return iter([])
+
+    if initial is not None:
+        first = []
+
+    return chain(first, map(func, b, a))
+
+
+class SequenceView(Sequence):
+    """Return a read-only view of the sequence object *target*.
+
+    :class:`SequenceView` objects are analogous to Python's built-in
+    "dictionary view" types. They provide a dynamic view of a sequence's items,
+    meaning that when the sequence updates, so does the view.
+
+        >>> seq = ['0', '1', '2']
+        >>> view = SequenceView(seq)
+        >>> view
+        SequenceView(['0', '1', '2'])
+        >>> seq.append('3')
+        >>> view
+        SequenceView(['0', '1', '2', '3'])
+
+    Sequence views support indexing, slicing, and length queries. They act
+    like the underlying sequence, except they don't allow assignment:
+
+        >>> view[1]
+        '1'
+        >>> view[1:-1]
+        ['1', '2']
+        >>> len(view)
+        4
+
+    Sequence views are useful as an alternative to copying, as they don't
+    require (much) extra storage.
+
+    """
+
+    def __init__(self, target):
+        if not isinstance(target, Sequence):
+            raise TypeError
+        self._target = target
+
+    def __getitem__(self, index):
+        return self._target[index]
+
+    def __len__(self):
+        return len(self._target)
+
+    def __repr__(self):
+        return '{}({})'.format(self.__class__.__name__, repr(self._target))
+
+
+class seekable:
+    """Wrap an iterator to allow for seeking backward and forward. This
+    progressively caches the items in the source iterable so they can be
+    re-visited.
+
+    Call :meth:`seek` with an index to seek to that position in the source
+    iterable.
+
+    To "reset" an iterator, seek to ``0``:
+
+        >>> from itertools import count
+        >>> it = seekable((str(n) for n in count()))
+        >>> next(it), next(it), next(it)
+        ('0', '1', '2')
+        >>> it.seek(0)
+        >>> next(it), next(it), next(it)
+        ('0', '1', '2')
+        >>> next(it)
+        '3'
+
+    You can also seek forward:
+
+        >>> it = seekable((str(n) for n in range(20)))
+        >>> it.seek(10)
+        >>> next(it)
+        '10'
+        >>> it.relative_seek(-2)  # Seeking relative to the current position
+        >>> next(it)
+        '9'
+        >>> it.seek(20)  # Seeking past the end of the source isn't a problem
+        >>> list(it)
+        []
+        >>> it.seek(0)  # Resetting works even after hitting the end
+        >>> next(it), next(it), next(it)
+        ('0', '1', '2')
+
+    Call :meth:`peek` to look ahead one item without advancing the iterator:
+
+        >>> it = seekable('1234')
+        >>> it.peek()
+        '1'
+        >>> list(it)
+        ['1', '2', '3', '4']
+        >>> it.peek(default='empty')
+        'empty'
+
+    Before the iterator is at its end, calling :func:`bool` on it will return
+    ``True``. After it will return ``False``:
+
+        >>> it = seekable('5678')
+        >>> bool(it)
+        True
+        >>> list(it)
+        ['5', '6', '7', '8']
+        >>> bool(it)
+        False
+
+    You may view the contents of the cache with the :meth:`elements` method.
+    That returns a :class:`SequenceView`, a view that updates automatically:
+
+        >>> it = seekable((str(n) for n in range(10)))
+        >>> next(it), next(it), next(it)
+        ('0', '1', '2')
+        >>> elements = it.elements()
+        >>> elements
+        SequenceView(['0', '1', '2'])
+        >>> next(it)
+        '3'
+        >>> elements
+        SequenceView(['0', '1', '2', '3'])
+
+    By default, the cache grows as the source iterable progresses, so beware of
+    wrapping very large or infinite iterables. Supply *maxlen* to limit the
+    size of the cache (this of course limits how far back you can seek).
+
+        >>> from itertools import count
+        >>> it = seekable((str(n) for n in count()), maxlen=2)
+        >>> next(it), next(it), next(it), next(it)
+        ('0', '1', '2', '3')
+        >>> list(it.elements())
+        ['2', '3']
+        >>> it.seek(0)
+        >>> next(it), next(it), next(it), next(it)
+        ('2', '3', '4', '5')
+        >>> next(it)
+        '6'
+
+    """
+
+    def __init__(self, iterable, maxlen=None):
+        self._source = iter(iterable)
+        if maxlen is None:
+            self._cache = []
+        else:
+            self._cache = deque([], maxlen)
+        self._index = None
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self._index is not None:
+            try:
+                item = self._cache[self._index]
+            except IndexError:
+                self._index = None
+            else:
+                self._index += 1
+                return item
+
+        item = next(self._source)
+        self._cache.append(item)
+        return item
+
+    def __bool__(self):
+        try:
+            self.peek()
+        except StopIteration:
+            return False
+        return True
+
+    def peek(self, default=_marker):
+        try:
+            peeked = next(self)
+        except StopIteration:
+            if default is _marker:
+                raise
+            return default
+        if self._index is None:
+            self._index = len(self._cache)
+        self._index -= 1
+        return peeked
+
+    def elements(self):
+        return SequenceView(self._cache)
+
+    def seek(self, index):
+        self._index = index
+        remainder = index - len(self._cache)
+        if remainder > 0:
+            consume(self, remainder)
+
+    def relative_seek(self, count):
+        index = len(self._cache)
+        self.seek(max(index + count, 0))
+
+
+class run_length:
+    """
+    :func:`run_length.encode` compresses an iterable with run-length encoding.
+    It yields groups of repeated items with the count of how many times they
+    were repeated:
+
+        >>> uncompressed = 'abbcccdddd'
+        >>> list(run_length.encode(uncompressed))
+        [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+
+    :func:`run_length.decode` decompresses an iterable that was previously
+    compressed with run-length encoding. It yields the items of the
+    decompressed iterable:
+
+        >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+        >>> list(run_length.decode(compressed))
+        ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd']
+
+    """
+
+    @staticmethod
+    def encode(iterable):
+        return ((k, ilen(g)) for k, g in groupby(iterable))
+
+    @staticmethod
+    def decode(iterable):
+        return chain.from_iterable(repeat(k, n) for k, n in iterable)
+
+
+def exactly_n(iterable, n, predicate=bool):
+    """Return ``True`` if exactly ``n`` items in the iterable are ``True``
+    according to the *predicate* function.
+
+        >>> exactly_n([True, True, False], 2)
+        True
+        >>> exactly_n([True, True, False], 1)
+        False
+        >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3)
+        True
+
+    The iterable will be advanced until ``n + 1`` truthy items are encountered,
+    so avoid calling it on infinite iterables.
+
+    """
+    return len(take(n + 1, filter(predicate, iterable))) == n
+
+
+def circular_shifts(iterable):
+    """Return a list of circular shifts of *iterable*.
+
+    >>> circular_shifts(range(4))
+    [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)]
+    """
+    lst = list(iterable)
+    return take(len(lst), windowed(cycle(lst), len(lst)))
+
+
+def make_decorator(wrapping_func, result_index=0):
+    """Return a decorator version of *wrapping_func*, which is a function that
+    modifies an iterable. *result_index* is the position in that function's
+    signature where the iterable goes.
+
+    This lets you use itertools on the "production end," i.e. at function
+    definition. This can augment what the function returns without changing the
+    function's code.
+
+    For example, to produce a decorator version of :func:`chunked`:
+
+        >>> from more_itertools import chunked
+        >>> chunker = make_decorator(chunked, result_index=0)
+        >>> @chunker(3)
+        ... def iter_range(n):
+        ...     return iter(range(n))
+        ...
+        >>> list(iter_range(9))
+        [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+
+    To only allow truthy items to be returned:
+
+        >>> truth_serum = make_decorator(filter, result_index=1)
+        >>> @truth_serum(bool)
+        ... def boolean_test():
+        ...     return [0, 1, '', ' ', False, True]
+        ...
+        >>> list(boolean_test())
+        [1, ' ', True]
+
+    The :func:`peekable` and :func:`seekable` wrappers make for practical
+    decorators:
+
+        >>> from more_itertools import peekable
+        >>> peekable_function = make_decorator(peekable)
+        >>> @peekable_function()
+        ... def str_range(*args):
+        ...     return (str(x) for x in range(*args))
+        ...
+        >>> it = str_range(1, 20, 2)
+        >>> next(it), next(it), next(it)
+        ('1', '3', '5')
+        >>> it.peek()
+        '7'
+        >>> next(it)
+        '7'
+
+    """
+
+    # See https://sites.google.com/site/bbayles/index/decorator_factory for
+    # notes on how this works.
+    def decorator(*wrapping_args, **wrapping_kwargs):
+        def outer_wrapper(f):
+            def inner_wrapper(*args, **kwargs):
+                result = f(*args, **kwargs)
+                wrapping_args_ = list(wrapping_args)
+                wrapping_args_.insert(result_index, result)
+                return wrapping_func(*wrapping_args_, **wrapping_kwargs)
+
+            return inner_wrapper
+
+        return outer_wrapper
+
+    return decorator
+
+
+def map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None):
+    """Return a dictionary that maps the items in *iterable* to categories
+    defined by *keyfunc*, transforms them with *valuefunc*, and
+    then summarizes them by category with *reducefunc*.
+
+    *valuefunc* defaults to the identity function if it is unspecified.
+    If *reducefunc* is unspecified, no summarization takes place:
+
+        >>> keyfunc = lambda x: x.upper()
+        >>> result = map_reduce('abbccc', keyfunc)
+        >>> sorted(result.items())
+        [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])]
+
+    Specifying *valuefunc* transforms the categorized items:
+
+        >>> keyfunc = lambda x: x.upper()
+        >>> valuefunc = lambda x: 1
+        >>> result = map_reduce('abbccc', keyfunc, valuefunc)
+        >>> sorted(result.items())
+        [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])]
+
+    Specifying *reducefunc* summarizes the categorized items:
+
+        >>> keyfunc = lambda x: x.upper()
+        >>> valuefunc = lambda x: 1
+        >>> reducefunc = sum
+        >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc)
+        >>> sorted(result.items())
+        [('A', 1), ('B', 2), ('C', 3)]
+
+    You may want to filter the input iterable before applying the map/reduce
+    procedure:
+
+        >>> all_items = range(30)
+        >>> items = [x for x in all_items if 10 <= x <= 20]  # Filter
+        >>> keyfunc = lambda x: x % 2  # Evens map to 0; odds to 1
+        >>> categories = map_reduce(items, keyfunc=keyfunc)
+        >>> sorted(categories.items())
+        [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])]
+        >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum)
+        >>> sorted(summaries.items())
+        [(0, 90), (1, 75)]
+
+    Note that all items in the iterable are gathered into a list before the
+    summarization step, which may require significant storage.
+
+    The returned object is a :obj:`collections.defaultdict` with the
+    ``default_factory`` set to ``None``, such that it behaves like a normal
+    dictionary.
+
+    """
+    valuefunc = (lambda x: x) if (valuefunc is None) else valuefunc
+
+    ret = defaultdict(list)
+    for item in iterable:
+        key = keyfunc(item)
+        value = valuefunc(item)
+        ret[key].append(value)
+
+    if reducefunc is not None:
+        for key, value_list in ret.items():
+            ret[key] = reducefunc(value_list)
+
+    ret.default_factory = None
+    return ret
+
+
+def rlocate(iterable, pred=bool, window_size=None):
+    """Yield the index of each item in *iterable* for which *pred* returns
+    ``True``, starting from the right and moving left.
+
+    *pred* defaults to :func:`bool`, which will select truthy items:
+
+        >>> list(rlocate([0, 1, 1, 0, 1, 0, 0]))  # Truthy at 1, 2, and 4
+        [4, 2, 1]
+
+    Set *pred* to a custom function to, e.g., find the indexes for a particular
+    item:
+
+        >>> iterable = iter('abcb')
+        >>> pred = lambda x: x == 'b'
+        >>> list(rlocate(iterable, pred))
+        [3, 1]
+
+    If *window_size* is given, then the *pred* function will be called with
+    that many items. This enables searching for sub-sequences:
+
+        >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
+        >>> pred = lambda *args: args == (1, 2, 3)
+        >>> list(rlocate(iterable, pred=pred, window_size=3))
+        [9, 5, 1]
+
+    Beware, this function won't return anything for infinite iterables.
+    If *iterable* is reversible, ``rlocate`` will reverse it and search from
+    the right. Otherwise, it will search from the left and return the results
+    in reverse order.
+
+    See :func:`locate` to for other example applications.
+
+    """
+    if window_size is None:
+        try:
+            len_iter = len(iterable)
+            return (len_iter - i - 1 for i in locate(reversed(iterable), pred))
+        except TypeError:
+            pass
+
+    return reversed(list(locate(iterable, pred, window_size)))
+
+
+def replace(iterable, pred, substitutes, count=None, window_size=1):
+    """Yield the items from *iterable*, replacing the items for which *pred*
+    returns ``True`` with the items from the iterable *substitutes*.
+
+        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1]
+        >>> pred = lambda x: x == 0
+        >>> substitutes = (2, 3)
+        >>> list(replace(iterable, pred, substitutes))
+        [1, 1, 2, 3, 1, 1, 2, 3, 1, 1]
+
+    If *count* is given, the number of replacements will be limited:
+
+        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0]
+        >>> pred = lambda x: x == 0
+        >>> substitutes = [None]
+        >>> list(replace(iterable, pred, substitutes, count=2))
+        [1, 1, None, 1, 1, None, 1, 1, 0]
+
+    Use *window_size* to control the number of items passed as arguments to
+    *pred*. This allows for locating and replacing subsequences.
+
+        >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5]
+        >>> window_size = 3
+        >>> pred = lambda *args: args == (0, 1, 2)  # 3 items passed to pred
+        >>> substitutes = [3, 4] # Splice in these items
+        >>> list(replace(iterable, pred, substitutes, window_size=window_size))
+        [3, 4, 5, 3, 4, 5]
+
+    """
+    if window_size < 1:
+        raise ValueError('window_size must be at least 1')
+
+    # Save the substitutes iterable, since it's used more than once
+    substitutes = tuple(substitutes)
+
+    # Add padding such that the number of windows matches the length of the
+    # iterable
+    it = chain(iterable, [_marker] * (window_size - 1))
+    windows = windowed(it, window_size)
+
+    n = 0
+    for w in windows:
+        # If the current window matches our predicate (and we haven't hit
+        # our maximum number of replacements), splice in the substitutes
+        # and then consume the following windows that overlap with this one.
+        # For example, if the iterable is (0, 1, 2, 3, 4...)
+        # and the window size is 2, we have (0, 1), (1, 2), (2, 3)...
+        # If the predicate matches on (0, 1), we need to zap (0, 1) and (1, 2)
+        if pred(*w):
+            if (count is None) or (n < count):
+                n += 1
+                yield from substitutes
+                consume(windows, window_size - 1)
+                continue
+
+        # If there was no match (or we've reached the replacement limit),
+        # yield the first item from the window.
+        if w and (w[0] is not _marker):
+            yield w[0]
+
+
+def partitions(iterable):
+    """Yield all possible order-preserving partitions of *iterable*.
+
+    >>> iterable = 'abc'
+    >>> for part in partitions(iterable):
+    ...     print([''.join(p) for p in part])
+    ['abc']
+    ['a', 'bc']
+    ['ab', 'c']
+    ['a', 'b', 'c']
+
+    This is unrelated to :func:`partition`.
+
+    """
+    sequence = list(iterable)
+    n = len(sequence)
+    for i in powerset(range(1, n)):
+        yield [sequence[i:j] for i, j in zip((0,) + i, i + (n,))]
+
+
+def set_partitions(iterable, k=None):
+    """
+    Yield the set partitions of *iterable* into *k* parts. Set partitions are
+    not order-preserving.
+
+    >>> iterable = 'abc'
+    >>> for part in set_partitions(iterable, 2):
+    ...     print([''.join(p) for p in part])
+    ['a', 'bc']
+    ['ab', 'c']
+    ['b', 'ac']
+
+
+    If *k* is not given, every set partition is generated.
+
+    >>> iterable = 'abc'
+    >>> for part in set_partitions(iterable):
+    ...     print([''.join(p) for p in part])
+    ['abc']
+    ['a', 'bc']
+    ['ab', 'c']
+    ['b', 'ac']
+    ['a', 'b', 'c']
+
+    """
+    L = list(iterable)
+    n = len(L)
+    if k is not None:
+        if k < 1:
+            raise ValueError(
+                "Can't partition in a negative or zero number of groups"
+            )
+        elif k > n:
+            return
+
+    def set_partitions_helper(L, k):
+        n = len(L)
+        if k == 1:
+            yield [L]
+        elif n == k:
+            yield [[s] for s in L]
+        else:
+            e, *M = L
+            for p in set_partitions_helper(M, k - 1):
+                yield [[e], *p]
+            for p in set_partitions_helper(M, k):
+                for i in range(len(p)):
+                    yield p[:i] + [[e] + p[i]] + p[i + 1 :]
+
+    if k is None:
+        for k in range(1, n + 1):
+            yield from set_partitions_helper(L, k)
+    else:
+        yield from set_partitions_helper(L, k)
+
+
+class time_limited:
+    """
+    Yield items from *iterable* until *limit_seconds* have passed.
+    If the time limit expires before all items have been yielded, the
+    ``timed_out`` parameter will be set to ``True``.
+
+    >>> from time import sleep
+    >>> def generator():
+    ...     yield 1
+    ...     yield 2
+    ...     sleep(0.2)
+    ...     yield 3
+    >>> iterable = time_limited(0.1, generator())
+    >>> list(iterable)
+    [1, 2]
+    >>> iterable.timed_out
+    True
+
+    Note that the time is checked before each item is yielded, and iteration
+    stops if  the time elapsed is greater than *limit_seconds*. If your time
+    limit is 1 second, but it takes 2 seconds to generate the first item from
+    the iterable, the function will run for 2 seconds and not yield anything.
+
+    """
+
+    def __init__(self, limit_seconds, iterable):
+        if limit_seconds < 0:
+            raise ValueError('limit_seconds must be positive')
+        self.limit_seconds = limit_seconds
+        self._iterable = iter(iterable)
+        self._start_time = monotonic()
+        self.timed_out = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        item = next(self._iterable)
+        if monotonic() - self._start_time > self.limit_seconds:
+            self.timed_out = True
+            raise StopIteration
+
+        return item
+
+
+def only(iterable, default=None, too_long=None):
+    """If *iterable* has only one item, return it.
+    If it has zero items, return *default*.
+    If it has more than one item, raise the exception given by *too_long*,
+    which is ``ValueError`` by default.
+
+    >>> only([], default='missing')
+    'missing'
+    >>> only([1])
+    1
+    >>> only([1, 2])  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    ...
+    ValueError: Expected exactly one item in iterable, but got 1, 2,
+     and perhaps more.'
+    >>> only([1, 2], too_long=TypeError)  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    ...
+    TypeError
+
+    Note that :func:`only` attempts to advance *iterable* twice to ensure there
+    is only one item.  See :func:`spy` or :func:`peekable` to check
+    iterable contents less destructively.
+    """
+    it = iter(iterable)
+    first_value = next(it, default)
+
+    try:
+        second_value = next(it)
+    except StopIteration:
+        pass
+    else:
+        msg = (
+            'Expected exactly one item in iterable, but got {!r}, {!r}, '
+            'and perhaps more.'.format(first_value, second_value)
+        )
+        raise too_long or ValueError(msg)
+
+    return first_value
+
+
+class _IChunk:
+    def __init__(self, iterable, n):
+        self._it = islice(iterable, n)
+        self._cache = deque()
+
+    def fill_cache(self):
+        self._cache.extend(self._it)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            return next(self._it)
+        except StopIteration:
+            if self._cache:
+                return self._cache.popleft()
+            else:
+                raise
+
+
+def ichunked(iterable, n):
+    """Break *iterable* into sub-iterables with *n* elements each.
+    :func:`ichunked` is like :func:`chunked`, but it yields iterables
+    instead of lists.
+
+    If the sub-iterables are read in order, the elements of *iterable*
+    won't be stored in memory.
+    If they are read out of order, :func:`itertools.tee` is used to cache
+    elements as necessary.
+
+    >>> from itertools import count
+    >>> all_chunks = ichunked(count(), 4)
+    >>> c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks)
+    >>> list(c_2)  # c_1's elements have been cached; c_3's haven't been
+    [4, 5, 6, 7]
+    >>> list(c_1)
+    [0, 1, 2, 3]
+    >>> list(c_3)
+    [8, 9, 10, 11]
+
+    """
+    source = peekable(iter(iterable))
+    ichunk_marker = object()
+    while True:
+        # Check to see whether we're at the end of the source iterable
+        item = source.peek(ichunk_marker)
+        if item is ichunk_marker:
+            return
+
+        chunk = _IChunk(source, n)
+        yield chunk
+
+        # Advance the source iterable and fill previous chunk's cache
+        chunk.fill_cache()
+
+
+def iequals(*iterables):
+    """Return ``True`` if all given *iterables* are equal to each other,
+    which means that they contain the same elements in the same order.
+
+    The function is useful for comparing iterables of different data types
+    or iterables that do not support equality checks.
+
+    >>> iequals("abc", ['a', 'b', 'c'], ('a', 'b', 'c'), iter("abc"))
+    True
+
+    >>> iequals("abc", "acb")
+    False
+
+    Not to be confused with :func:`all_equals`, which checks whether all
+    elements of iterable are equal to each other.
+
+    """
+    return all(map(all_equal, zip_longest(*iterables, fillvalue=object())))
+
+
+def distinct_combinations(iterable, r):
+    """Yield the distinct combinations of *r* items taken from *iterable*.
+
+        >>> list(distinct_combinations([0, 0, 1], 2))
+        [(0, 0), (0, 1)]
+
+    Equivalent to ``set(combinations(iterable))``, except duplicates are not
+    generated and thrown away. For larger input sequences this is much more
+    efficient.
+
+    """
+    if r < 0:
+        raise ValueError('r must be non-negative')
+    elif r == 0:
+        yield ()
+        return
+    pool = tuple(iterable)
+    generators = [unique_everseen(enumerate(pool), key=itemgetter(1))]
+    current_combo = [None] * r
+    level = 0
+    while generators:
+        try:
+            cur_idx, p = next(generators[-1])
+        except StopIteration:
+            generators.pop()
+            level -= 1
+            continue
+        current_combo[level] = p
+        if level + 1 == r:
+            yield tuple(current_combo)
+        else:
+            generators.append(
+                unique_everseen(
+                    enumerate(pool[cur_idx + 1 :], cur_idx + 1),
+                    key=itemgetter(1),
+                )
+            )
+            level += 1
+
+
+def filter_except(validator, iterable, *exceptions):
+    """Yield the items from *iterable* for which the *validator* function does
+    not raise one of the specified *exceptions*.
+
+    *validator* is called for each item in *iterable*.
+    It should be a function that accepts one argument and raises an exception
+    if that item is not valid.
+
+    >>> iterable = ['1', '2', 'three', '4', None]
+    >>> list(filter_except(int, iterable, ValueError, TypeError))
+    ['1', '2', '4']
+
+    If an exception other than one given by *exceptions* is raised by
+    *validator*, it is raised like normal.
+    """
+    for item in iterable:
+        try:
+            validator(item)
+        except exceptions:
+            pass
+        else:
+            yield item
+
+
+def map_except(function, iterable, *exceptions):
+    """Transform each item from *iterable* with *function* and yield the
+    result, unless *function* raises one of the specified *exceptions*.
+
+    *function* is called to transform each item in *iterable*.
+    It should accept one argument.
+
+    >>> iterable = ['1', '2', 'three', '4', None]
+    >>> list(map_except(int, iterable, ValueError, TypeError))
+    [1, 2, 4]
+
+    If an exception other than one given by *exceptions* is raised by
+    *function*, it is raised like normal.
+    """
+    for item in iterable:
+        try:
+            yield function(item)
+        except exceptions:
+            pass
+
+
+def map_if(iterable, pred, func, func_else=lambda x: x):
+    """Evaluate each item from *iterable* using *pred*. If the result is
+    equivalent to ``True``, transform the item with *func* and yield it.
+    Otherwise, transform the item with *func_else* and yield it.
+
+    *pred*, *func*, and *func_else* should each be functions that accept
+    one argument. By default, *func_else* is the identity function.
+
+    >>> from math import sqrt
+    >>> iterable = list(range(-5, 5))
+    >>> iterable
+    [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
+    >>> list(map_if(iterable, lambda x: x > 3, lambda x: 'toobig'))
+    [-5, -4, -3, -2, -1, 0, 1, 2, 3, 'toobig']
+    >>> list(map_if(iterable, lambda x: x >= 0,
+    ... lambda x: f'{sqrt(x):.2f}', lambda x: None))
+    [None, None, None, None, None, '0.00', '1.00', '1.41', '1.73', '2.00']
+    """
+    for item in iterable:
+        yield func(item) if pred(item) else func_else(item)
+
+
+def _sample_unweighted(iterable, k):
+    # Implementation of "Algorithm L" from the 1994 paper by Kim-Hung Li:
+    # "Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))".
+
+    # Fill up the reservoir (collection of samples) with the first `k` samples
+    reservoir = take(k, iterable)
+
+    # Generate random number that's the largest in a sample of k U(0,1) numbers
+    # Largest order statistic: https://en.wikipedia.org/wiki/Order_statistic
+    W = exp(log(random()) / k)
+
+    # The number of elements to skip before changing the reservoir is a random
+    # number with a geometric distribution. Sample it using random() and logs.
+    next_index = k + floor(log(random()) / log(1 - W))
+
+    for index, element in enumerate(iterable, k):
+        if index == next_index:
+            reservoir[randrange(k)] = element
+            # The new W is the largest in a sample of k U(0, `old_W`) numbers
+            W *= exp(log(random()) / k)
+            next_index += floor(log(random()) / log(1 - W)) + 1
+
+    return reservoir
+
+
+def _sample_weighted(iterable, k, weights):
+    # Implementation of "A-ExpJ" from the 2006 paper by Efraimidis et al. :
+    # "Weighted random sampling with a reservoir".
+
+    # Log-transform for numerical stability for weights that are small/large
+    weight_keys = (log(random()) / weight for weight in weights)
+
+    # Fill up the reservoir (collection of samples) with the first `k`
+    # weight-keys and elements, then heapify the list.
+    reservoir = take(k, zip(weight_keys, iterable))
+    heapify(reservoir)
+
+    # The number of jumps before changing the reservoir is a random variable
+    # with an exponential distribution. Sample it using random() and logs.
+    smallest_weight_key, _ = reservoir[0]
+    weights_to_skip = log(random()) / smallest_weight_key
+
+    for weight, element in zip(weights, iterable):
+        if weight >= weights_to_skip:
+            # The notation here is consistent with the paper, but we store
+            # the weight-keys in log-space for better numerical stability.
+            smallest_weight_key, _ = reservoir[0]
+            t_w = exp(weight * smallest_weight_key)
+            r_2 = uniform(t_w, 1)  # generate U(t_w, 1)
+            weight_key = log(r_2) / weight
+            heapreplace(reservoir, (weight_key, element))
+            smallest_weight_key, _ = reservoir[0]
+            weights_to_skip = log(random()) / smallest_weight_key
+        else:
+            weights_to_skip -= weight
+
+    # Equivalent to [element for weight_key, element in sorted(reservoir)]
+    return [heappop(reservoir)[1] for _ in range(k)]
+
+
+def sample(iterable, k, weights=None):
+    """Return a *k*-length list of elements chosen (without replacement)
+    from the *iterable*. Like :func:`random.sample`, but works on iterables
+    of unknown length.
+
+    >>> iterable = range(100)
+    >>> sample(iterable, 5)  # doctest: +SKIP
+    [81, 60, 96, 16, 4]
+
+    An iterable with *weights* may also be given:
+
+    >>> iterable = range(100)
+    >>> weights = (i * i + 1 for i in range(100))
+    >>> sampled = sample(iterable, 5, weights=weights)  # doctest: +SKIP
+    [79, 67, 74, 66, 78]
+
+    The algorithm can also be used to generate weighted random permutations.
+    The relative weight of each item determines the probability that it
+    appears late in the permutation.
+
+    >>> data = "abcdefgh"
+    >>> weights = range(1, len(data) + 1)
+    >>> sample(data, k=len(data), weights=weights)  # doctest: +SKIP
+    ['c', 'a', 'b', 'e', 'g', 'd', 'h', 'f']
+    """
+    if k == 0:
+        return []
+
+    iterable = iter(iterable)
+    if weights is None:
+        return _sample_unweighted(iterable, k)
+    else:
+        weights = iter(weights)
+        return _sample_weighted(iterable, k, weights)
+
+
+def is_sorted(iterable, key=None, reverse=False, strict=False):
+    """Returns ``True`` if the items of iterable are in sorted order, and
+    ``False`` otherwise. *key* and *reverse* have the same meaning that they do
+    in the built-in :func:`sorted` function.
+
+    >>> is_sorted(['1', '2', '3', '4', '5'], key=int)
+    True
+    >>> is_sorted([5, 4, 3, 1, 2], reverse=True)
+    False
+
+    If *strict*, tests for strict sorting, that is, returns ``False`` if equal
+    elements are found:
+
+    >>> is_sorted([1, 2, 2])
+    True
+    >>> is_sorted([1, 2, 2], strict=True)
+    False
+
+    The function returns ``False`` after encountering the first out-of-order
+    item. If there are no out-of-order items, the iterable is exhausted.
+    """
+
+    compare = (le if reverse else ge) if strict else (lt if reverse else gt)
+    it = iterable if key is None else map(key, iterable)
+    return not any(starmap(compare, pairwise(it)))
+
+
+class AbortThread(BaseException):
+    pass
+
+
+class callback_iter:
+    """Convert a function that uses callbacks to an iterator.
+
+    Let *func* be a function that takes a `callback` keyword argument.
+    For example:
+
+    >>> def func(callback=None):
+    ...     for i, c in [(1, 'a'), (2, 'b'), (3, 'c')]:
+    ...         if callback:
+    ...             callback(i, c)
+    ...     return 4
+
+
+    Use ``with callback_iter(func)`` to get an iterator over the parameters
+    that are delivered to the callback.
+
+    >>> with callback_iter(func) as it:
+    ...     for args, kwargs in it:
+    ...         print(args)
+    (1, 'a')
+    (2, 'b')
+    (3, 'c')
+
+    The function will be called in a background thread. The ``done`` property
+    indicates whether it has completed execution.
+
+    >>> it.done
+    True
+
+    If it completes successfully, its return value will be available
+    in the ``result`` property.
+
+    >>> it.result
+    4
+
+    Notes:
+
+    * If the function uses some keyword argument besides ``callback``, supply
+      *callback_kwd*.
+    * If it finished executing, but raised an exception, accessing the
+      ``result`` property will raise the same exception.
+    * If it hasn't finished executing, accessing the ``result``
+      property from within the ``with`` block will raise ``RuntimeError``.
+    * If it hasn't finished executing, accessing the ``result`` property from
+      outside the ``with`` block will raise a
+      ``more_itertools.AbortThread`` exception.
+    * Provide *wait_seconds* to adjust how frequently the it is polled for
+      output.
+
+    """
+
+    def __init__(self, func, callback_kwd='callback', wait_seconds=0.1):
+        self._func = func
+        self._callback_kwd = callback_kwd
+        self._aborted = False
+        self._future = None
+        self._wait_seconds = wait_seconds
+        # Lazily import concurrent.future
+        self._executor = __import__(
+            'concurrent.futures'
+        ).futures.ThreadPoolExecutor(max_workers=1)
+        self._iterator = self._reader()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._aborted = True
+        self._executor.shutdown()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self._iterator)
+
+    @property
+    def done(self):
+        if self._future is None:
+            return False
+        return self._future.done()
+
+    @property
+    def result(self):
+        if not self.done:
+            raise RuntimeError('Function has not yet completed')
+
+        return self._future.result()
+
+    def _reader(self):
+        q = Queue()
+
+        def callback(*args, **kwargs):
+            if self._aborted:
+                raise AbortThread('canceled by user')
+
+            q.put((args, kwargs))
+
+        self._future = self._executor.submit(
+            self._func, **{self._callback_kwd: callback}
+        )
+
+        while True:
+            try:
+                item = q.get(timeout=self._wait_seconds)
+            except Empty:
+                pass
+            else:
+                q.task_done()
+                yield item
+
+            if self._future.done():
+                break
+
+        remaining = []
+        while True:
+            try:
+                item = q.get_nowait()
+            except Empty:
+                break
+            else:
+                q.task_done()
+                remaining.append(item)
+        q.join()
+        yield from remaining
+
+
+def windowed_complete(iterable, n):
+    """
+    Yield ``(beginning, middle, end)`` tuples, where:
+
+    * Each ``middle`` has *n* items from *iterable*
+    * Each ``beginning`` has the items before the ones in ``middle``
+    * Each ``end`` has the items after the ones in ``middle``
+
+    >>> iterable = range(7)
+    >>> n = 3
+    >>> for beginning, middle, end in windowed_complete(iterable, n):
+    ...     print(beginning, middle, end)
+    () (0, 1, 2) (3, 4, 5, 6)
+    (0,) (1, 2, 3) (4, 5, 6)
+    (0, 1) (2, 3, 4) (5, 6)
+    (0, 1, 2) (3, 4, 5) (6,)
+    (0, 1, 2, 3) (4, 5, 6) ()
+
+    Note that *n* must be at least 0 and most equal to the length of
+    *iterable*.
+
+    This function will exhaust the iterable and may require significant
+    storage.
+    """
+    if n < 0:
+        raise ValueError('n must be >= 0')
+
+    seq = tuple(iterable)
+    size = len(seq)
+
+    if n > size:
+        raise ValueError('n must be <= len(seq)')
+
+    for i in range(size - n + 1):
+        beginning = seq[:i]
+        middle = seq[i : i + n]
+        end = seq[i + n :]
+        yield beginning, middle, end
+
+
+def all_unique(iterable, key=None):
+    """
+    Returns ``True`` if all the elements of *iterable* are unique (no two
+    elements are equal).
+
+        >>> all_unique('ABCB')
+        False
+
+    If a *key* function is specified, it will be used to make comparisons.
+
+        >>> all_unique('ABCb')
+        True
+        >>> all_unique('ABCb', str.lower)
+        False
+
+    The function returns as soon as the first non-unique element is
+    encountered. Iterables with a mix of hashable and unhashable items can
+    be used, but the function will be slower for unhashable items.
+    """
+    seenset = set()
+    seenset_add = seenset.add
+    seenlist = []
+    seenlist_add = seenlist.append
+    for element in map(key, iterable) if key else iterable:
+        try:
+            if element in seenset:
+                return False
+            seenset_add(element)
+        except TypeError:
+            if element in seenlist:
+                return False
+            seenlist_add(element)
+    return True
+
+
+def nth_product(index, *args):
+    """Equivalent to ``list(product(*args))[index]``.
+
+    The products of *args* can be ordered lexicographically.
+    :func:`nth_product` computes the product at sort position *index* without
+    computing the previous products.
+
+        >>> nth_product(8, range(2), range(2), range(2), range(2))
+        (1, 0, 0, 0)
+
+    ``IndexError`` will be raised if the given *index* is invalid.
+    """
+    pools = list(map(tuple, reversed(args)))
+    ns = list(map(len, pools))
+
+    c = reduce(mul, ns)
+
+    if index < 0:
+        index += c
+
+    if not 0 <= index < c:
+        raise IndexError
+
+    result = []
+    for pool, n in zip(pools, ns):
+        result.append(pool[index % n])
+        index //= n
+
+    return tuple(reversed(result))
+
+
+def nth_permutation(iterable, r, index):
+    """Equivalent to ``list(permutations(iterable, r))[index]```
+
+    The subsequences of *iterable* that are of length *r* where order is
+    important can be ordered lexicographically. :func:`nth_permutation`
+    computes the subsequence at sort position *index* directly, without
+    computing the previous subsequences.
+
+        >>> nth_permutation('ghijk', 2, 5)
+        ('h', 'i')
+
+    ``ValueError`` will be raised If *r* is negative or greater than the length
+    of *iterable*.
+    ``IndexError`` will be raised if the given *index* is invalid.
+    """
+    pool = list(iterable)
+    n = len(pool)
+
+    if r is None or r == n:
+        r, c = n, factorial(n)
+    elif not 0 <= r < n:
+        raise ValueError
+    else:
+        c = factorial(n) // factorial(n - r)
+
+    if index < 0:
+        index += c
+
+    if not 0 <= index < c:
+        raise IndexError
+
+    if c == 0:
+        return tuple()
+
+    result = [0] * r
+    q = index * factorial(n) // c if r < n else index
+    for d in range(1, n + 1):
+        q, i = divmod(q, d)
+        if 0 <= n - d < r:
+            result[n - d] = i
+        if q == 0:
+            break
+
+    return tuple(map(pool.pop, result))
+
+
+def nth_combination_with_replacement(iterable, r, index):
+    """Equivalent to
+    ``list(combinations_with_replacement(iterable, r))[index]``.
+
+
+    The subsequences with repetition of *iterable* that are of length *r* can
+    be ordered lexicographically. :func:`nth_combination_with_replacement`
+    computes the subsequence at sort position *index* directly, without
+    computing the previous subsequences with replacement.
+
+        >>> nth_combination_with_replacement(range(5), 3, 5)
+        (0, 1, 1)
+
+    ``ValueError`` will be raised If *r* is negative or greater than the length
+    of *iterable*.
+    ``IndexError`` will be raised if the given *index* is invalid.
+    """
+    pool = tuple(iterable)
+    n = len(pool)
+    if (r < 0) or (r > n):
+        raise ValueError
+
+    c = factorial(n + r - 1) // (factorial(r) * factorial(n - 1))
+
+    if index < 0:
+        index += c
+
+    if (index < 0) or (index >= c):
+        raise IndexError
+
+    result = []
+    i = 0
+    while r:
+        r -= 1
+        while n >= 0:
+            num_combs = factorial(n + r - 1) // (
+                factorial(r) * factorial(n - 1)
+            )
+            if index < num_combs:
+                break
+            n -= 1
+            i += 1
+            index -= num_combs
+        result.append(pool[i])
+
+    return tuple(result)
+
+
+def value_chain(*args):
+    """Yield all arguments passed to the function in the same order in which
+    they were passed. If an argument itself is iterable then iterate over its
+    values.
+
+        >>> list(value_chain(1, 2, 3, [4, 5, 6]))
+        [1, 2, 3, 4, 5, 6]
+
+    Binary and text strings are not considered iterable and are emitted
+    as-is:
+
+        >>> list(value_chain('12', '34', ['56', '78']))
+        ['12', '34', '56', '78']
+
+
+    Multiple levels of nesting are not flattened.
+
+    """
+    for value in args:
+        if isinstance(value, (str, bytes)):
+            yield value
+            continue
+        try:
+            yield from value
+        except TypeError:
+            yield value
+
+
+def product_index(element, *args):
+    """Equivalent to ``list(product(*args)).index(element)``
+
+    The products of *args* can be ordered lexicographically.
+    :func:`product_index` computes the first index of *element* without
+    computing the previous products.
+
+        >>> product_index([8, 2], range(10), range(5))
+        42
+
+    ``ValueError`` will be raised if the given *element* isn't in the product
+    of *args*.
+    """
+    index = 0
+
+    for x, pool in zip_longest(element, args, fillvalue=_marker):
+        if x is _marker or pool is _marker:
+            raise ValueError('element is not a product of args')
+
+        pool = tuple(pool)
+        index = index * len(pool) + pool.index(x)
+
+    return index
+
+
+def combination_index(element, iterable):
+    """Equivalent to ``list(combinations(iterable, r)).index(element)``
+
+    The subsequences of *iterable* that are of length *r* can be ordered
+    lexicographically. :func:`combination_index` computes the index of the
+    first *element*, without computing the previous combinations.
+
+        >>> combination_index('adf', 'abcdefg')
+        10
+
+    ``ValueError`` will be raised if the given *element* isn't one of the
+    combinations of *iterable*.
+    """
+    element = enumerate(element)
+    k, y = next(element, (None, None))
+    if k is None:
+        return 0
+
+    indexes = []
+    pool = enumerate(iterable)
+    for n, x in pool:
+        if x == y:
+            indexes.append(n)
+            tmp, y = next(element, (None, None))
+            if tmp is None:
+                break
+            else:
+                k = tmp
+    else:
+        raise ValueError('element is not a combination of iterable')
+
+    n, _ = last(pool, default=(n, None))
+
+    # Python versions below 3.8 don't have math.comb
+    index = 1
+    for i, j in enumerate(reversed(indexes), start=1):
+        j = n - j
+        if i <= j:
+            index += factorial(j) // (factorial(i) * factorial(j - i))
+
+    return factorial(n + 1) // (factorial(k + 1) * factorial(n - k)) - index
+
+
+def combination_with_replacement_index(element, iterable):
+    """Equivalent to
+    ``list(combinations_with_replacement(iterable, r)).index(element)``
+
+    The subsequences with repetition of *iterable* that are of length *r* can
+    be ordered lexicographically. :func:`combination_with_replacement_index`
+    computes the index of the first *element*, without computing the previous
+    combinations with replacement.
+
+        >>> combination_with_replacement_index('adf', 'abcdefg')
+        20
+
+    ``ValueError`` will be raised if the given *element* isn't one of the
+    combinations with replacement of *iterable*.
+    """
+    element = tuple(element)
+    l = len(element)
+    element = enumerate(element)
+
+    k, y = next(element, (None, None))
+    if k is None:
+        return 0
+
+    indexes = []
+    pool = tuple(iterable)
+    for n, x in enumerate(pool):
+        while x == y:
+            indexes.append(n)
+            tmp, y = next(element, (None, None))
+            if tmp is None:
+                break
+            else:
+                k = tmp
+        if y is None:
+            break
+    else:
+        raise ValueError(
+            'element is not a combination with replacment of iterable'
+        )
+
+    n = len(pool)
+    occupations = [0] * n
+    for p in indexes:
+        occupations[p] += 1
+
+    index = 0
+    for k in range(1, n):
+        j = l + n - 1 - k - sum(occupations[:k])
+        i = n - k
+        if i <= j:
+            index += factorial(j) // (factorial(i) * factorial(j - i))
+
+    return index
+
+
+def permutation_index(element, iterable):
+    """Equivalent to ``list(permutations(iterable, r)).index(element)```
+
+    The subsequences of *iterable* that are of length *r* where order is
+    important can be ordered lexicographically. :func:`permutation_index`
+    computes the index of the first *element* directly, without computing
+    the previous permutations.
+
+        >>> permutation_index([1, 3, 2], range(5))
+        19
+
+    ``ValueError`` will be raised if the given *element* isn't one of the
+    permutations of *iterable*.
+    """
+    index = 0
+    pool = list(iterable)
+    for i, x in zip(range(len(pool), -1, -1), element):
+        r = pool.index(x)
+        index = index * i + r
+        del pool[r]
+
+    return index
+
+
+class countable:
+    """Wrap *iterable* and keep a count of how many items have been consumed.
+
+    The ``items_seen`` attribute starts at ``0`` and increments as the iterable
+    is consumed:
+
+        >>> iterable = map(str, range(10))
+        >>> it = countable(iterable)
+        >>> it.items_seen
+        0
+        >>> next(it), next(it)
+        ('0', '1')
+        >>> list(it)
+        ['2', '3', '4', '5', '6', '7', '8', '9']
+        >>> it.items_seen
+        10
+    """
+
+    def __init__(self, iterable):
+        self._it = iter(iterable)
+        self.items_seen = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        item = next(self._it)
+        self.items_seen += 1
+
+        return item
+
+
+def chunked_even(iterable, n):
+    """Break *iterable* into lists of approximately length *n*.
+    Items are distributed such the lengths of the lists differ by at most
+    1 item.
+
+    >>> iterable = [1, 2, 3, 4, 5, 6, 7]
+    >>> n = 3
+    >>> list(chunked_even(iterable, n))  # List lengths: 3, 2, 2
+    [[1, 2, 3], [4, 5], [6, 7]]
+    >>> list(chunked(iterable, n))  # List lengths: 3, 3, 1
+    [[1, 2, 3], [4, 5, 6], [7]]
+
+    """
+
+    len_method = getattr(iterable, '__len__', None)
+
+    if len_method is None:
+        return _chunked_even_online(iterable, n)
+    else:
+        return _chunked_even_finite(iterable, len_method(), n)
+
+
+def _chunked_even_online(iterable, n):
+    buffer = []
+    maxbuf = n + (n - 2) * (n - 1)
+    for x in iterable:
+        buffer.append(x)
+        if len(buffer) == maxbuf:
+            yield buffer[:n]
+            buffer = buffer[n:]
+    yield from _chunked_even_finite(buffer, len(buffer), n)
+
+
+def _chunked_even_finite(iterable, N, n):
+    if N < 1:
+        return
+
+    # Lists are either size `full_size <= n` or `partial_size = full_size - 1`
+    q, r = divmod(N, n)
+    num_lists = q + (1 if r > 0 else 0)
+    q, r = divmod(N, num_lists)
+    full_size = q + (1 if r > 0 else 0)
+    partial_size = full_size - 1
+    num_full = N - partial_size * num_lists
+    num_partial = num_lists - num_full
+
+    # Yield num_full lists of full_size
+    partial_start_idx = num_full * full_size
+    if full_size > 0:
+        for i in range(0, partial_start_idx, full_size):
+            yield list(islice(iterable, i, i + full_size))
+
+    # Yield num_partial lists of partial_size
+    if partial_size > 0:
+        for i in range(
+            partial_start_idx,
+            partial_start_idx + (num_partial * partial_size),
+            partial_size,
+        ):
+            yield list(islice(iterable, i, i + partial_size))
+
+
+def zip_broadcast(*objects, scalar_types=(str, bytes), strict=False):
+    """A version of :func:`zip` that "broadcasts" any scalar
+    (i.e., non-iterable) items into output tuples.
+
+    >>> iterable_1 = [1, 2, 3]
+    >>> iterable_2 = ['a', 'b', 'c']
+    >>> scalar = '_'
+    >>> list(zip_broadcast(iterable_1, iterable_2, scalar))
+    [(1, 'a', '_'), (2, 'b', '_'), (3, 'c', '_')]
+
+    The *scalar_types* keyword argument determines what types are considered
+    scalar. It is set to ``(str, bytes)`` by default. Set it to ``None`` to
+    treat strings and byte strings as iterable:
+
+    >>> list(zip_broadcast('abc', 0, 'xyz', scalar_types=None))
+    [('a', 0, 'x'), ('b', 0, 'y'), ('c', 0, 'z')]
+
+    If the *strict* keyword argument is ``True``, then
+    ``UnequalIterablesError`` will be raised if any of the iterables have
+    different lengths.
+    """
+
+    def is_scalar(obj):
+        if scalar_types and isinstance(obj, scalar_types):
+            return True
+        try:
+            iter(obj)
+        except TypeError:
+            return True
+        else:
+            return False
+
+    size = len(objects)
+    if not size:
+        return
+
+    new_item = [None] * size
+    iterables, iterable_positions = [], []
+    for i, obj in enumerate(objects):
+        if is_scalar(obj):
+            new_item[i] = obj
+        else:
+            iterables.append(iter(obj))
+            iterable_positions.append(i)
+
+    if not iterables:
+        yield tuple(objects)
+        return
+
+    zipper = _zip_equal if strict else zip
+    for item in zipper(*iterables):
+        for i, new_item[i] in zip(iterable_positions, item):
+            pass
+        yield tuple(new_item)
+
+
+def unique_in_window(iterable, n, key=None):
+    """Yield the items from *iterable* that haven't been seen recently.
+    *n* is the size of the lookback window.
+
+        >>> iterable = [0, 1, 0, 2, 3, 0]
+        >>> n = 3
+        >>> list(unique_in_window(iterable, n))
+        [0, 1, 2, 3, 0]
+
+    The *key* function, if provided, will be used to determine uniqueness:
+
+        >>> list(unique_in_window('abAcda', 3, key=lambda x: x.lower()))
+        ['a', 'b', 'c', 'd', 'a']
+
+    The items in *iterable* must be hashable.
+
+    """
+    if n <= 0:
+        raise ValueError('n must be greater than 0')
+
+    window = deque(maxlen=n)
+    counts = defaultdict(int)
+    use_key = key is not None
+
+    for item in iterable:
+        if len(window) == n:
+            to_discard = window[0]
+            if counts[to_discard] == 1:
+                del counts[to_discard]
+            else:
+                counts[to_discard] -= 1
+
+        k = key(item) if use_key else item
+        if k not in counts:
+            yield item
+        counts[k] += 1
+        window.append(k)
+
+
+def duplicates_everseen(iterable, key=None):
+    """Yield duplicate elements after their first appearance.
+
+    >>> list(duplicates_everseen('mississippi'))
+    ['s', 'i', 's', 's', 'i', 'p', 'i']
+    >>> list(duplicates_everseen('AaaBbbCccAaa', str.lower))
+    ['a', 'a', 'b', 'b', 'c', 'c', 'A', 'a', 'a']
+
+    This function is analagous to :func:`unique_everseen` and is subject to
+    the same performance considerations.
+
+    """
+    seen_set = set()
+    seen_list = []
+    use_key = key is not None
+
+    for element in iterable:
+        k = key(element) if use_key else element
+        try:
+            if k not in seen_set:
+                seen_set.add(k)
+            else:
+                yield element
+        except TypeError:
+            if k not in seen_list:
+                seen_list.append(k)
+            else:
+                yield element
+
+
+def duplicates_justseen(iterable, key=None):
+    """Yields serially-duplicate elements after their first appearance.
+
+    >>> list(duplicates_justseen('mississippi'))
+    ['s', 's', 'p']
+    >>> list(duplicates_justseen('AaaBbbCccAaa', str.lower))
+    ['a', 'a', 'b', 'b', 'c', 'c', 'a', 'a']
+
+    This function is analagous to :func:`unique_justseen`.
+
+    """
+    return flatten(g for _, g in groupby(iterable, key) for _ in g)
+
+
+def minmax(iterable_or_value, *others, key=None, default=_marker):
+    """Returns both the smallest and largest items in an iterable
+    or the largest of two or more arguments.
+
+        >>> minmax([3, 1, 5])
+        (1, 5)
+
+        >>> minmax(4, 2, 6)
+        (2, 6)
+
+    If a *key* function is provided, it will be used to transform the input
+    items for comparison.
+
+        >>> minmax([5, 30], key=str)  # '30' sorts before '5'
+        (30, 5)
+
+    If a *default* value is provided, it will be returned if there are no
+    input items.
+
+        >>> minmax([], default=(0, 0))
+        (0, 0)
+
+    Otherwise ``ValueError`` is raised.
+
+    This function is based on the
+    `recipe <http://code.activestate.com/recipes/577916/>`__ by
+    Raymond Hettinger and takes care to minimize the number of comparisons
+    performed.
+    """
+    iterable = (iterable_or_value, *others) if others else iterable_or_value
+
+    it = iter(iterable)
+
+    try:
+        lo = hi = next(it)
+    except StopIteration as e:
+        if default is _marker:
+            raise ValueError(
+                '`minmax()` argument is an empty iterable. '
+                'Provide a `default` value to suppress this error.'
+            ) from e
+        return default
+
+    # Different branches depending on the presence of key. This saves a lot
+    # of unimportant copies which would slow the "key=None" branch
+    # significantly down.
+    if key is None:
+        for x, y in zip_longest(it, it, fillvalue=lo):
+            if y < x:
+                x, y = y, x
+            if x < lo:
+                lo = x
+            if hi < y:
+                hi = y
+
+    else:
+        lo_key = hi_key = key(lo)
+
+        for x, y in zip_longest(it, it, fillvalue=lo):
+            x_key, y_key = key(x), key(y)
+
+            if y_key < x_key:
+                x, y, x_key, y_key = y, x, y_key, x_key
+            if x_key < lo_key:
+                lo, lo_key = x, x_key
+            if hi_key < y_key:
+                hi, hi_key = y, y_key
+
+    return lo, hi
+
+
+def constrained_batches(
+    iterable, max_size, max_count=None, get_len=len, strict=True
+):
+    """Yield batches of items from *iterable* with a combined size limited by
+    *max_size*.
+
+    >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1']
+    >>> list(constrained_batches(iterable, 10))
+    [(b'12345', b'123'), (b'12345678', b'1', b'1'), (b'12', b'1')]
+
+    If a *max_count* is supplied, the number of items per batch is also
+    limited:
+
+    >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1']
+    >>> list(constrained_batches(iterable, 10, max_count = 2))
+    [(b'12345', b'123'), (b'12345678', b'1'), (b'1', b'12'), (b'1',)]
+
+    If a *get_len* function is supplied, use that instead of :func:`len` to
+    determine item size.
+
+    If *strict* is ``True``, raise ``ValueError`` if any single item is bigger
+    than *max_size*. Otherwise, allow single items to exceed *max_size*.
+    """
+    if max_size <= 0:
+        raise ValueError('maximum size must be greater than zero')
+
+    batch = []
+    batch_size = 0
+    batch_count = 0
+    for item in iterable:
+        item_len = get_len(item)
+        if strict and item_len > max_size:
+            raise ValueError('item size exceeds maximum size')
+
+        reached_count = batch_count == max_count
+        reached_size = item_len + batch_size > max_size
+        if batch_count and (reached_size or reached_count):
+            yield tuple(batch)
+            batch.clear()
+            batch_size = 0
+            batch_count = 0
+
+        batch.append(item)
+        batch_size += item_len
+        batch_count += 1
+
+    if batch:
+        yield tuple(batch)
+
+
+def gray_product(*iterables):
+    """Like :func:`itertools.product`, but return tuples in an order such
+    that only one element in the generated tuple changes from one iteration
+    to the next.
+
+        >>> list(gray_product('AB','CD'))
+        [('A', 'C'), ('B', 'C'), ('B', 'D'), ('A', 'D')]
+
+    This function consumes all of the input iterables before producing output.
+    If any of the input iterables have fewer than two items, ``ValueError``
+    is raised.
+
+    For information on the algorithm, see
+    `this section <https://www-cs-faculty.stanford.edu/~knuth/fasc2a.ps.gz>`__
+    of Donald Knuth's *The Art of Computer Programming*.
+    """
+    all_iterables = tuple(tuple(x) for x in iterables)
+    iterable_count = len(all_iterables)
+    for iterable in all_iterables:
+        if len(iterable) < 2:
+            raise ValueError("each iterable must have two or more items")
+
+    # This is based on "Algorithm H" from section 7.2.1.1, page 20.
+    # a holds the indexes of the source iterables for the n-tuple to be yielded
+    # f is the array of "focus pointers"
+    # o is the array of "directions"
+    a = [0] * iterable_count
+    f = list(range(iterable_count + 1))
+    o = [1] * iterable_count
+    while True:
+        yield tuple(all_iterables[i][a[i]] for i in range(iterable_count))
+        j = f[0]
+        f[0] = 0
+        if j == iterable_count:
+            break
+        a[j] = a[j] + o[j]
+        if a[j] == 0 or a[j] == len(all_iterables[j]) - 1:
+            o[j] = -o[j]
+            f[j] = f[j + 1]
+            f[j + 1] = j + 1
+
+
+def partial_product(*iterables):
+    """Yields tuples containing one item from each iterator, with subsequent
+    tuples changing a single item at a time by advancing each iterator until it
+    is exhausted. This sequence guarantees every value in each iterable is
+    output at least once without generating all possible combinations.
+
+    This may be useful, for example, when testing an expensive function.
+
+        >>> list(partial_product('AB', 'C', 'DEF'))
+        [('A', 'C', 'D'), ('B', 'C', 'D'), ('B', 'C', 'E'), ('B', 'C', 'F')]
+    """
+
+    iterators = list(map(iter, iterables))
+
+    try:
+        prod = [next(it) for it in iterators]
+    except StopIteration:
+        return
+    yield tuple(prod)
+
+    for i, it in enumerate(iterators):
+        for prod[i] in it:
+            yield tuple(prod)
+
+
+def takewhile_inclusive(predicate, iterable):
+    """A variant of :func:`takewhile` that yields one additional element.
+
+        >>> list(takewhile_inclusive(lambda x: x < 5, [1, 4, 6, 4, 1]))
+        [1, 4, 6]
+
+    :func:`takewhile` would return ``[1, 4]``.
+    """
+    for x in iterable:
+        if predicate(x):
+            yield x
+        else:
+            yield x
+            break
+
+
+def outer_product(func, xs, ys, *args, **kwargs):
+    """A generalized outer product that applies a binary function to all
+    pairs of items. Returns a 2D matrix with ``len(xs)`` rows and ``len(ys)``
+    columns.
+    Also accepts ``*args`` and ``**kwargs`` that are passed to ``func``.
+
+    Multiplication table:
+
+    >>> list(outer_product(mul, range(1, 4), range(1, 6)))
+    [(1, 2, 3, 4, 5), (2, 4, 6, 8, 10), (3, 6, 9, 12, 15)]
+
+    Cross tabulation:
+
+    >>> xs = ['A', 'B', 'A', 'A', 'B', 'B', 'A', 'A', 'B', 'B']
+    >>> ys = ['X', 'X', 'X', 'Y', 'Z', 'Z', 'Y', 'Y', 'Z', 'Z']
+    >>> rows = list(zip(xs, ys))
+    >>> count_rows = lambda x, y: rows.count((x, y))
+    >>> list(outer_product(count_rows, sorted(set(xs)), sorted(set(ys))))
+    [(2, 3, 0), (1, 0, 4)]
+
+    Usage with ``*args`` and ``**kwargs``:
+
+    >>> animals = ['cat', 'wolf', 'mouse']
+    >>> list(outer_product(min, animals, animals, key=len))
+    [('cat', 'cat', 'cat'), ('cat', 'wolf', 'wolf'), ('cat', 'wolf', 'mouse')]
+    """
+    ys = tuple(ys)
+    return batched(
+        starmap(lambda x, y: func(x, y, *args, **kwargs), product(xs, ys)),
+        n=len(ys),
+    )
diff --git a/lib/python3.11/site-packages/more_itertools/more.pyi b/lib/python3.11/site-packages/more_itertools/more.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..07bfc15513962cce01d11b6a4854d736a926ded3
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools/more.pyi
@@ -0,0 +1,684 @@
+"""Stubs for more_itertools.more"""
+from __future__ import annotations
+
+from types import TracebackType
+from typing import (
+    Any,
+    Callable,
+    Container,
+    ContextManager,
+    Generic,
+    Hashable,
+    Iterable,
+    Iterator,
+    overload,
+    Reversible,
+    Sequence,
+    Sized,
+    Type,
+    TypeVar,
+    type_check_only,
+)
+from typing_extensions import Protocol
+
+# Type and type variable definitions
+_T = TypeVar('_T')
+_T1 = TypeVar('_T1')
+_T2 = TypeVar('_T2')
+_U = TypeVar('_U')
+_V = TypeVar('_V')
+_W = TypeVar('_W')
+_T_co = TypeVar('_T_co', covariant=True)
+_GenFn = TypeVar('_GenFn', bound=Callable[..., Iterator[object]])
+_Raisable = BaseException | Type[BaseException]
+
+@type_check_only
+class _SizedIterable(Protocol[_T_co], Sized, Iterable[_T_co]): ...
+
+@type_check_only
+class _SizedReversible(Protocol[_T_co], Sized, Reversible[_T_co]): ...
+
+@type_check_only
+class _SupportsSlicing(Protocol[_T_co]):
+    def __getitem__(self, __k: slice) -> _T_co: ...
+
+def chunked(
+    iterable: Iterable[_T], n: int | None, strict: bool = ...
+) -> Iterator[list[_T]]: ...
+@overload
+def first(iterable: Iterable[_T]) -> _T: ...
+@overload
+def first(iterable: Iterable[_T], default: _U) -> _T | _U: ...
+@overload
+def last(iterable: Iterable[_T]) -> _T: ...
+@overload
+def last(iterable: Iterable[_T], default: _U) -> _T | _U: ...
+@overload
+def nth_or_last(iterable: Iterable[_T], n: int) -> _T: ...
+@overload
+def nth_or_last(iterable: Iterable[_T], n: int, default: _U) -> _T | _U: ...
+
+class peekable(Generic[_T], Iterator[_T]):
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    def __iter__(self) -> peekable[_T]: ...
+    def __bool__(self) -> bool: ...
+    @overload
+    def peek(self) -> _T: ...
+    @overload
+    def peek(self, default: _U) -> _T | _U: ...
+    def prepend(self, *items: _T) -> None: ...
+    def __next__(self) -> _T: ...
+    @overload
+    def __getitem__(self, index: int) -> _T: ...
+    @overload
+    def __getitem__(self, index: slice) -> list[_T]: ...
+
+def consumer(func: _GenFn) -> _GenFn: ...
+def ilen(iterable: Iterable[object]) -> int: ...
+def iterate(func: Callable[[_T], _T], start: _T) -> Iterator[_T]: ...
+def with_iter(
+    context_manager: ContextManager[Iterable[_T]],
+) -> Iterator[_T]: ...
+def one(
+    iterable: Iterable[_T],
+    too_short: _Raisable | None = ...,
+    too_long: _Raisable | None = ...,
+) -> _T: ...
+def raise_(exception: _Raisable, *args: Any) -> None: ...
+def strictly_n(
+    iterable: Iterable[_T],
+    n: int,
+    too_short: _GenFn | None = ...,
+    too_long: _GenFn | None = ...,
+) -> list[_T]: ...
+def distinct_permutations(
+    iterable: Iterable[_T], r: int | None = ...
+) -> Iterator[tuple[_T, ...]]: ...
+def intersperse(
+    e: _U, iterable: Iterable[_T], n: int = ...
+) -> Iterator[_T | _U]: ...
+def unique_to_each(*iterables: Iterable[_T]) -> list[list[_T]]: ...
+@overload
+def windowed(
+    seq: Iterable[_T], n: int, *, step: int = ...
+) -> Iterator[tuple[_T | None, ...]]: ...
+@overload
+def windowed(
+    seq: Iterable[_T], n: int, fillvalue: _U, step: int = ...
+) -> Iterator[tuple[_T | _U, ...]]: ...
+def substrings(iterable: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...
+def substrings_indexes(
+    seq: Sequence[_T], reverse: bool = ...
+) -> Iterator[tuple[Sequence[_T], int, int]]: ...
+
+class bucket(Generic[_T, _U], Container[_U]):
+    def __init__(
+        self,
+        iterable: Iterable[_T],
+        key: Callable[[_T], _U],
+        validator: Callable[[object], object] | None = ...,
+    ) -> None: ...
+    def __contains__(self, value: object) -> bool: ...
+    def __iter__(self) -> Iterator[_U]: ...
+    def __getitem__(self, value: object) -> Iterator[_T]: ...
+
+def spy(
+    iterable: Iterable[_T], n: int = ...
+) -> tuple[list[_T], Iterator[_T]]: ...
+def interleave(*iterables: Iterable[_T]) -> Iterator[_T]: ...
+def interleave_longest(*iterables: Iterable[_T]) -> Iterator[_T]: ...
+def interleave_evenly(
+    iterables: list[Iterable[_T]], lengths: list[int] | None = ...
+) -> Iterator[_T]: ...
+def collapse(
+    iterable: Iterable[Any],
+    base_type: type | None = ...,
+    levels: int | None = ...,
+) -> Iterator[Any]: ...
+@overload
+def side_effect(
+    func: Callable[[_T], object],
+    iterable: Iterable[_T],
+    chunk_size: None = ...,
+    before: Callable[[], object] | None = ...,
+    after: Callable[[], object] | None = ...,
+) -> Iterator[_T]: ...
+@overload
+def side_effect(
+    func: Callable[[list[_T]], object],
+    iterable: Iterable[_T],
+    chunk_size: int,
+    before: Callable[[], object] | None = ...,
+    after: Callable[[], object] | None = ...,
+) -> Iterator[_T]: ...
+def sliced(
+    seq: _SupportsSlicing[_T], n: int, strict: bool = ...
+) -> Iterator[_T]: ...
+def split_at(
+    iterable: Iterable[_T],
+    pred: Callable[[_T], object],
+    maxsplit: int = ...,
+    keep_separator: bool = ...,
+) -> Iterator[list[_T]]: ...
+def split_before(
+    iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ...
+) -> Iterator[list[_T]]: ...
+def split_after(
+    iterable: Iterable[_T], pred: Callable[[_T], object], maxsplit: int = ...
+) -> Iterator[list[_T]]: ...
+def split_when(
+    iterable: Iterable[_T],
+    pred: Callable[[_T, _T], object],
+    maxsplit: int = ...,
+) -> Iterator[list[_T]]: ...
+def split_into(
+    iterable: Iterable[_T], sizes: Iterable[int | None]
+) -> Iterator[list[_T]]: ...
+@overload
+def padded(
+    iterable: Iterable[_T],
+    *,
+    n: int | None = ...,
+    next_multiple: bool = ...,
+) -> Iterator[_T | None]: ...
+@overload
+def padded(
+    iterable: Iterable[_T],
+    fillvalue: _U,
+    n: int | None = ...,
+    next_multiple: bool = ...,
+) -> Iterator[_T | _U]: ...
+@overload
+def repeat_last(iterable: Iterable[_T]) -> Iterator[_T]: ...
+@overload
+def repeat_last(iterable: Iterable[_T], default: _U) -> Iterator[_T | _U]: ...
+def distribute(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ...
+@overload
+def stagger(
+    iterable: Iterable[_T],
+    offsets: _SizedIterable[int] = ...,
+    longest: bool = ...,
+) -> Iterator[tuple[_T | None, ...]]: ...
+@overload
+def stagger(
+    iterable: Iterable[_T],
+    offsets: _SizedIterable[int] = ...,
+    longest: bool = ...,
+    fillvalue: _U = ...,
+) -> Iterator[tuple[_T | _U, ...]]: ...
+
+class UnequalIterablesError(ValueError):
+    def __init__(self, details: tuple[int, int, int] | None = ...) -> None: ...
+
+@overload
+def zip_equal(__iter1: Iterable[_T1]) -> Iterator[tuple[_T1]]: ...
+@overload
+def zip_equal(
+    __iter1: Iterable[_T1], __iter2: Iterable[_T2]
+) -> Iterator[tuple[_T1, _T2]]: ...
+@overload
+def zip_equal(
+    __iter1: Iterable[_T],
+    __iter2: Iterable[_T],
+    __iter3: Iterable[_T],
+    *iterables: Iterable[_T],
+) -> Iterator[tuple[_T, ...]]: ...
+@overload
+def zip_offset(
+    __iter1: Iterable[_T1],
+    *,
+    offsets: _SizedIterable[int],
+    longest: bool = ...,
+    fillvalue: None = None,
+) -> Iterator[tuple[_T1 | None]]: ...
+@overload
+def zip_offset(
+    __iter1: Iterable[_T1],
+    __iter2: Iterable[_T2],
+    *,
+    offsets: _SizedIterable[int],
+    longest: bool = ...,
+    fillvalue: None = None,
+) -> Iterator[tuple[_T1 | None, _T2 | None]]: ...
+@overload
+def zip_offset(
+    __iter1: Iterable[_T],
+    __iter2: Iterable[_T],
+    __iter3: Iterable[_T],
+    *iterables: Iterable[_T],
+    offsets: _SizedIterable[int],
+    longest: bool = ...,
+    fillvalue: None = None,
+) -> Iterator[tuple[_T | None, ...]]: ...
+@overload
+def zip_offset(
+    __iter1: Iterable[_T1],
+    *,
+    offsets: _SizedIterable[int],
+    longest: bool = ...,
+    fillvalue: _U,
+) -> Iterator[tuple[_T1 | _U]]: ...
+@overload
+def zip_offset(
+    __iter1: Iterable[_T1],
+    __iter2: Iterable[_T2],
+    *,
+    offsets: _SizedIterable[int],
+    longest: bool = ...,
+    fillvalue: _U,
+) -> Iterator[tuple[_T1 | _U, _T2 | _U]]: ...
+@overload
+def zip_offset(
+    __iter1: Iterable[_T],
+    __iter2: Iterable[_T],
+    __iter3: Iterable[_T],
+    *iterables: Iterable[_T],
+    offsets: _SizedIterable[int],
+    longest: bool = ...,
+    fillvalue: _U,
+) -> Iterator[tuple[_T | _U, ...]]: ...
+def sort_together(
+    iterables: Iterable[Iterable[_T]],
+    key_list: Iterable[int] = ...,
+    key: Callable[..., Any] | None = ...,
+    reverse: bool = ...,
+) -> list[tuple[_T, ...]]: ...
+def unzip(iterable: Iterable[Sequence[_T]]) -> tuple[Iterator[_T], ...]: ...
+def divide(n: int, iterable: Iterable[_T]) -> list[Iterator[_T]]: ...
+def always_iterable(
+    obj: object,
+    base_type: type | tuple[type | tuple[Any, ...], ...] | None = ...,
+) -> Iterator[Any]: ...
+def adjacent(
+    predicate: Callable[[_T], bool],
+    iterable: Iterable[_T],
+    distance: int = ...,
+) -> Iterator[tuple[bool, _T]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: None = None,
+    valuefunc: None = None,
+    reducefunc: None = None,
+) -> Iterator[tuple[_T, Iterator[_T]]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: None,
+    reducefunc: None,
+) -> Iterator[tuple[_U, Iterator[_T]]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: None,
+    valuefunc: Callable[[_T], _V],
+    reducefunc: None,
+) -> Iterable[tuple[_T, Iterable[_V]]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: Callable[[_T], _V],
+    reducefunc: None,
+) -> Iterable[tuple[_U, Iterator[_V]]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: None,
+    valuefunc: None,
+    reducefunc: Callable[[Iterator[_T]], _W],
+) -> Iterable[tuple[_T, _W]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: None,
+    reducefunc: Callable[[Iterator[_T]], _W],
+) -> Iterable[tuple[_U, _W]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: None,
+    valuefunc: Callable[[_T], _V],
+    reducefunc: Callable[[Iterable[_V]], _W],
+) -> Iterable[tuple[_T, _W]]: ...
+@overload
+def groupby_transform(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: Callable[[_T], _V],
+    reducefunc: Callable[[Iterable[_V]], _W],
+) -> Iterable[tuple[_U, _W]]: ...
+
+class numeric_range(Generic[_T, _U], Sequence[_T], Hashable, Reversible[_T]):
+    @overload
+    def __init__(self, __stop: _T) -> None: ...
+    @overload
+    def __init__(self, __start: _T, __stop: _T) -> None: ...
+    @overload
+    def __init__(self, __start: _T, __stop: _T, __step: _U) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __contains__(self, elem: object) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+    @overload
+    def __getitem__(self, key: int) -> _T: ...
+    @overload
+    def __getitem__(self, key: slice) -> numeric_range[_T, _U]: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __len__(self) -> int: ...
+    def __reduce__(
+        self,
+    ) -> tuple[Type[numeric_range[_T, _U]], tuple[_T, _T, _U]]: ...
+    def __repr__(self) -> str: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def count(self, value: _T) -> int: ...
+    def index(self, value: _T) -> int: ...  # type: ignore
+
+def count_cycle(
+    iterable: Iterable[_T], n: int | None = ...
+) -> Iterable[tuple[int, _T]]: ...
+def mark_ends(
+    iterable: Iterable[_T],
+) -> Iterable[tuple[bool, bool, _T]]: ...
+def locate(
+    iterable: Iterable[object],
+    pred: Callable[..., Any] = ...,
+    window_size: int | None = ...,
+) -> Iterator[int]: ...
+def lstrip(
+    iterable: Iterable[_T], pred: Callable[[_T], object]
+) -> Iterator[_T]: ...
+def rstrip(
+    iterable: Iterable[_T], pred: Callable[[_T], object]
+) -> Iterator[_T]: ...
+def strip(
+    iterable: Iterable[_T], pred: Callable[[_T], object]
+) -> Iterator[_T]: ...
+
+class islice_extended(Generic[_T], Iterator[_T]):
+    def __init__(self, iterable: Iterable[_T], *args: int | None) -> None: ...
+    def __iter__(self) -> islice_extended[_T]: ...
+    def __next__(self) -> _T: ...
+    def __getitem__(self, index: slice) -> islice_extended[_T]: ...
+
+def always_reversible(iterable: Iterable[_T]) -> Iterator[_T]: ...
+def consecutive_groups(
+    iterable: Iterable[_T], ordering: Callable[[_T], int] = ...
+) -> Iterator[Iterator[_T]]: ...
+@overload
+def difference(
+    iterable: Iterable[_T],
+    func: Callable[[_T, _T], _U] = ...,
+    *,
+    initial: None = ...,
+) -> Iterator[_T | _U]: ...
+@overload
+def difference(
+    iterable: Iterable[_T], func: Callable[[_T, _T], _U] = ..., *, initial: _U
+) -> Iterator[_U]: ...
+
+class SequenceView(Generic[_T], Sequence[_T]):
+    def __init__(self, target: Sequence[_T]) -> None: ...
+    @overload
+    def __getitem__(self, index: int) -> _T: ...
+    @overload
+    def __getitem__(self, index: slice) -> Sequence[_T]: ...
+    def __len__(self) -> int: ...
+
+class seekable(Generic[_T], Iterator[_T]):
+    def __init__(
+        self, iterable: Iterable[_T], maxlen: int | None = ...
+    ) -> None: ...
+    def __iter__(self) -> seekable[_T]: ...
+    def __next__(self) -> _T: ...
+    def __bool__(self) -> bool: ...
+    @overload
+    def peek(self) -> _T: ...
+    @overload
+    def peek(self, default: _U) -> _T | _U: ...
+    def elements(self) -> SequenceView[_T]: ...
+    def seek(self, index: int) -> None: ...
+    def relative_seek(self, count: int) -> None: ...
+
+class run_length:
+    @staticmethod
+    def encode(iterable: Iterable[_T]) -> Iterator[tuple[_T, int]]: ...
+    @staticmethod
+    def decode(iterable: Iterable[tuple[_T, int]]) -> Iterator[_T]: ...
+
+def exactly_n(
+    iterable: Iterable[_T], n: int, predicate: Callable[[_T], object] = ...
+) -> bool: ...
+def circular_shifts(iterable: Iterable[_T]) -> list[tuple[_T, ...]]: ...
+def make_decorator(
+    wrapping_func: Callable[..., _U], result_index: int = ...
+) -> Callable[..., Callable[[Callable[..., Any]], Callable[..., _U]]]: ...
+@overload
+def map_reduce(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: None = ...,
+    reducefunc: None = ...,
+) -> dict[_U, list[_T]]: ...
+@overload
+def map_reduce(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: Callable[[_T], _V],
+    reducefunc: None = ...,
+) -> dict[_U, list[_V]]: ...
+@overload
+def map_reduce(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: None = ...,
+    reducefunc: Callable[[list[_T]], _W] = ...,
+) -> dict[_U, _W]: ...
+@overload
+def map_reduce(
+    iterable: Iterable[_T],
+    keyfunc: Callable[[_T], _U],
+    valuefunc: Callable[[_T], _V],
+    reducefunc: Callable[[list[_V]], _W],
+) -> dict[_U, _W]: ...
+def rlocate(
+    iterable: Iterable[_T],
+    pred: Callable[..., object] = ...,
+    window_size: int | None = ...,
+) -> Iterator[int]: ...
+def replace(
+    iterable: Iterable[_T],
+    pred: Callable[..., object],
+    substitutes: Iterable[_U],
+    count: int | None = ...,
+    window_size: int = ...,
+) -> Iterator[_T | _U]: ...
+def partitions(iterable: Iterable[_T]) -> Iterator[list[list[_T]]]: ...
+def set_partitions(
+    iterable: Iterable[_T], k: int | None = ...
+) -> Iterator[list[list[_T]]]: ...
+
+class time_limited(Generic[_T], Iterator[_T]):
+    def __init__(
+        self, limit_seconds: float, iterable: Iterable[_T]
+    ) -> None: ...
+    def __iter__(self) -> islice_extended[_T]: ...
+    def __next__(self) -> _T: ...
+
+@overload
+def only(
+    iterable: Iterable[_T], *, too_long: _Raisable | None = ...
+) -> _T | None: ...
+@overload
+def only(
+    iterable: Iterable[_T], default: _U, too_long: _Raisable | None = ...
+) -> _T | _U: ...
+def ichunked(iterable: Iterable[_T], n: int) -> Iterator[Iterator[_T]]: ...
+def distinct_combinations(
+    iterable: Iterable[_T], r: int
+) -> Iterator[tuple[_T, ...]]: ...
+def filter_except(
+    validator: Callable[[Any], object],
+    iterable: Iterable[_T],
+    *exceptions: Type[BaseException],
+) -> Iterator[_T]: ...
+def map_except(
+    function: Callable[[Any], _U],
+    iterable: Iterable[_T],
+    *exceptions: Type[BaseException],
+) -> Iterator[_U]: ...
+def map_if(
+    iterable: Iterable[Any],
+    pred: Callable[[Any], bool],
+    func: Callable[[Any], Any],
+    func_else: Callable[[Any], Any] | None = ...,
+) -> Iterator[Any]: ...
+def sample(
+    iterable: Iterable[_T],
+    k: int,
+    weights: Iterable[float] | None = ...,
+) -> list[_T]: ...
+def is_sorted(
+    iterable: Iterable[_T],
+    key: Callable[[_T], _U] | None = ...,
+    reverse: bool = False,
+    strict: bool = False,
+) -> bool: ...
+
+class AbortThread(BaseException):
+    pass
+
+class callback_iter(Generic[_T], Iterator[_T]):
+    def __init__(
+        self,
+        func: Callable[..., Any],
+        callback_kwd: str = ...,
+        wait_seconds: float = ...,
+    ) -> None: ...
+    def __enter__(self) -> callback_iter[_T]: ...
+    def __exit__(
+        self,
+        exc_type: Type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None: ...
+    def __iter__(self) -> callback_iter[_T]: ...
+    def __next__(self) -> _T: ...
+    def _reader(self) -> Iterator[_T]: ...
+    @property
+    def done(self) -> bool: ...
+    @property
+    def result(self) -> Any: ...
+
+def windowed_complete(
+    iterable: Iterable[_T], n: int
+) -> Iterator[tuple[_T, ...]]: ...
+def all_unique(
+    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...
+) -> bool: ...
+def nth_product(index: int, *args: Iterable[_T]) -> tuple[_T, ...]: ...
+def nth_combination_with_replacement(
+    iterable: Iterable[_T], r: int, index: int
+) -> tuple[_T, ...]: ...
+def nth_permutation(
+    iterable: Iterable[_T], r: int, index: int
+) -> tuple[_T, ...]: ...
+def value_chain(*args: _T | Iterable[_T]) -> Iterable[_T]: ...
+def product_index(element: Iterable[_T], *args: Iterable[_T]) -> int: ...
+def combination_index(
+    element: Iterable[_T], iterable: Iterable[_T]
+) -> int: ...
+def combination_with_replacement_index(
+    element: Iterable[_T], iterable: Iterable[_T]
+) -> int: ...
+def permutation_index(
+    element: Iterable[_T], iterable: Iterable[_T]
+) -> int: ...
+def repeat_each(iterable: Iterable[_T], n: int = ...) -> Iterator[_T]: ...
+
+class countable(Generic[_T], Iterator[_T]):
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    def __iter__(self) -> countable[_T]: ...
+    def __next__(self) -> _T: ...
+
+def chunked_even(iterable: Iterable[_T], n: int) -> Iterator[list[_T]]: ...
+def zip_broadcast(
+    *objects: _T | Iterable[_T],
+    scalar_types: type | tuple[type | tuple[Any, ...], ...] | None = ...,
+    strict: bool = ...,
+) -> Iterable[tuple[_T, ...]]: ...
+def unique_in_window(
+    iterable: Iterable[_T], n: int, key: Callable[[_T], _U] | None = ...
+) -> Iterator[_T]: ...
+def duplicates_everseen(
+    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...
+) -> Iterator[_T]: ...
+def duplicates_justseen(
+    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...
+) -> Iterator[_T]: ...
+
+class _SupportsLessThan(Protocol):
+    def __lt__(self, __other: Any) -> bool: ...
+
+_SupportsLessThanT = TypeVar("_SupportsLessThanT", bound=_SupportsLessThan)
+
+@overload
+def minmax(
+    iterable_or_value: Iterable[_SupportsLessThanT], *, key: None = None
+) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ...
+@overload
+def minmax(
+    iterable_or_value: Iterable[_T], *, key: Callable[[_T], _SupportsLessThan]
+) -> tuple[_T, _T]: ...
+@overload
+def minmax(
+    iterable_or_value: Iterable[_SupportsLessThanT],
+    *,
+    key: None = None,
+    default: _U,
+) -> _U | tuple[_SupportsLessThanT, _SupportsLessThanT]: ...
+@overload
+def minmax(
+    iterable_or_value: Iterable[_T],
+    *,
+    key: Callable[[_T], _SupportsLessThan],
+    default: _U,
+) -> _U | tuple[_T, _T]: ...
+@overload
+def minmax(
+    iterable_or_value: _SupportsLessThanT,
+    __other: _SupportsLessThanT,
+    *others: _SupportsLessThanT,
+) -> tuple[_SupportsLessThanT, _SupportsLessThanT]: ...
+@overload
+def minmax(
+    iterable_or_value: _T,
+    __other: _T,
+    *others: _T,
+    key: Callable[[_T], _SupportsLessThan],
+) -> tuple[_T, _T]: ...
+def longest_common_prefix(
+    iterables: Iterable[Iterable[_T]],
+) -> Iterator[_T]: ...
+def iequals(*iterables: Iterable[object]) -> bool: ...
+def constrained_batches(
+    iterable: Iterable[object],
+    max_size: int,
+    max_count: int | None = ...,
+    get_len: Callable[[_T], object] = ...,
+    strict: bool = ...,
+) -> Iterator[tuple[_T]]: ...
+def gray_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...
+def partial_product(*iterables: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...
+def takewhile_inclusive(
+    predicate: Callable[[_T], bool], iterable: Iterable[_T]
+) -> Iterator[_T]: ...
+def outer_product(
+    func: Callable[[_T, _U], _V],
+    xs: Iterable[_T],
+    ys: Iterable[_U],
+    *args: Any,
+    **kwargs: Any,
+) -> Iterator[tuple[_V, ...]]: ...
diff --git a/lib/python3.11/site-packages/more_itertools/py.typed b/lib/python3.11/site-packages/more_itertools/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/more_itertools/recipes.py b/lib/python3.11/site-packages/more_itertools/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0bdbecec6981e2c5b8d0a64a5450caba581cdc1
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools/recipes.py
@@ -0,0 +1,977 @@
+"""Imported from the recipes section of the itertools documentation.
+
+All functions taken from the recipes section of the itertools library docs
+[1]_.
+Some backward-compatible usability improvements have been made.
+
+.. [1] http://docs.python.org/library/itertools.html#recipes
+
+"""
+import math
+import operator
+
+from collections import deque
+from collections.abc import Sized
+from functools import partial, reduce
+from itertools import (
+    chain,
+    combinations,
+    compress,
+    count,
+    cycle,
+    groupby,
+    islice,
+    product,
+    repeat,
+    starmap,
+    tee,
+    zip_longest,
+)
+from random import randrange, sample, choice
+
+__all__ = [
+    'all_equal',
+    'batched',
+    'before_and_after',
+    'consume',
+    'convolve',
+    'dotproduct',
+    'first_true',
+    'factor',
+    'flatten',
+    'grouper',
+    'iter_except',
+    'iter_index',
+    'matmul',
+    'ncycles',
+    'nth',
+    'nth_combination',
+    'padnone',
+    'pad_none',
+    'pairwise',
+    'partition',
+    'polynomial_eval',
+    'polynomial_from_roots',
+    'polynomial_derivative',
+    'powerset',
+    'prepend',
+    'quantify',
+    'random_combination_with_replacement',
+    'random_combination',
+    'random_permutation',
+    'random_product',
+    'repeatfunc',
+    'roundrobin',
+    'sieve',
+    'sliding_window',
+    'subslices',
+    'sum_of_squares',
+    'tabulate',
+    'tail',
+    'take',
+    'transpose',
+    'triplewise',
+    'unique_everseen',
+    'unique_justseen',
+]
+
+_marker = object()
+
+
+# zip with strict is available for Python 3.10+
+try:
+    zip(strict=True)
+except TypeError:
+    _zip_strict = zip
+else:
+    _zip_strict = partial(zip, strict=True)
+
+# math.sumprod is available for Python 3.12+
+_sumprod = getattr(math, 'sumprod', lambda x, y: dotproduct(x, y))
+
+
+def take(n, iterable):
+    """Return first *n* items of the iterable as a list.
+
+        >>> take(3, range(10))
+        [0, 1, 2]
+
+    If there are fewer than *n* items in the iterable, all of them are
+    returned.
+
+        >>> take(10, range(3))
+        [0, 1, 2]
+
+    """
+    return list(islice(iterable, n))
+
+
+def tabulate(function, start=0):
+    """Return an iterator over the results of ``func(start)``,
+    ``func(start + 1)``, ``func(start + 2)``...
+
+    *func* should be a function that accepts one integer argument.
+
+    If *start* is not specified it defaults to 0. It will be incremented each
+    time the iterator is advanced.
+
+        >>> square = lambda x: x ** 2
+        >>> iterator = tabulate(square, -3)
+        >>> take(4, iterator)
+        [9, 4, 1, 0]
+
+    """
+    return map(function, count(start))
+
+
+def tail(n, iterable):
+    """Return an iterator over the last *n* items of *iterable*.
+
+    >>> t = tail(3, 'ABCDEFG')
+    >>> list(t)
+    ['E', 'F', 'G']
+
+    """
+    # If the given iterable has a length, then we can use islice to get its
+    # final elements. Note that if the iterable is not actually Iterable,
+    # either islice or deque will throw a TypeError. This is why we don't
+    # check if it is Iterable.
+    if isinstance(iterable, Sized):
+        yield from islice(iterable, max(0, len(iterable) - n), None)
+    else:
+        yield from iter(deque(iterable, maxlen=n))
+
+
+def consume(iterator, n=None):
+    """Advance *iterable* by *n* steps. If *n* is ``None``, consume it
+    entirely.
+
+    Efficiently exhausts an iterator without returning values. Defaults to
+    consuming the whole iterator, but an optional second argument may be
+    provided to limit consumption.
+
+        >>> i = (x for x in range(10))
+        >>> next(i)
+        0
+        >>> consume(i, 3)
+        >>> next(i)
+        4
+        >>> consume(i)
+        >>> next(i)
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+        StopIteration
+
+    If the iterator has fewer items remaining than the provided limit, the
+    whole iterator will be consumed.
+
+        >>> i = (x for x in range(3))
+        >>> consume(i, 5)
+        >>> next(i)
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+        StopIteration
+
+    """
+    # Use functions that consume iterators at C speed.
+    if n is None:
+        # feed the entire iterator into a zero-length deque
+        deque(iterator, maxlen=0)
+    else:
+        # advance to the empty slice starting at position n
+        next(islice(iterator, n, n), None)
+
+
+def nth(iterable, n, default=None):
+    """Returns the nth item or a default value.
+
+    >>> l = range(10)
+    >>> nth(l, 3)
+    3
+    >>> nth(l, 20, "zebra")
+    'zebra'
+
+    """
+    return next(islice(iterable, n, None), default)
+
+
+def all_equal(iterable):
+    """
+    Returns ``True`` if all the elements are equal to each other.
+
+        >>> all_equal('aaaa')
+        True
+        >>> all_equal('aaab')
+        False
+
+    """
+    g = groupby(iterable)
+    return next(g, True) and not next(g, False)
+
+
+def quantify(iterable, pred=bool):
+    """Return the how many times the predicate is true.
+
+    >>> quantify([True, False, True])
+    2
+
+    """
+    return sum(map(pred, iterable))
+
+
+def pad_none(iterable):
+    """Returns the sequence of elements and then returns ``None`` indefinitely.
+
+        >>> take(5, pad_none(range(3)))
+        [0, 1, 2, None, None]
+
+    Useful for emulating the behavior of the built-in :func:`map` function.
+
+    See also :func:`padded`.
+
+    """
+    return chain(iterable, repeat(None))
+
+
+padnone = pad_none
+
+
+def ncycles(iterable, n):
+    """Returns the sequence elements *n* times
+
+    >>> list(ncycles(["a", "b"], 3))
+    ['a', 'b', 'a', 'b', 'a', 'b']
+
+    """
+    return chain.from_iterable(repeat(tuple(iterable), n))
+
+
+def dotproduct(vec1, vec2):
+    """Returns the dot product of the two iterables.
+
+    >>> dotproduct([10, 10], [20, 20])
+    400
+
+    """
+    return sum(map(operator.mul, vec1, vec2))
+
+
+def flatten(listOfLists):
+    """Return an iterator flattening one level of nesting in a list of lists.
+
+        >>> list(flatten([[0, 1], [2, 3]]))
+        [0, 1, 2, 3]
+
+    See also :func:`collapse`, which can flatten multiple levels of nesting.
+
+    """
+    return chain.from_iterable(listOfLists)
+
+
+def repeatfunc(func, times=None, *args):
+    """Call *func* with *args* repeatedly, returning an iterable over the
+    results.
+
+    If *times* is specified, the iterable will terminate after that many
+    repetitions:
+
+        >>> from operator import add
+        >>> times = 4
+        >>> args = 3, 5
+        >>> list(repeatfunc(add, times, *args))
+        [8, 8, 8, 8]
+
+    If *times* is ``None`` the iterable will not terminate:
+
+        >>> from random import randrange
+        >>> times = None
+        >>> args = 1, 11
+        >>> take(6, repeatfunc(randrange, times, *args))  # doctest:+SKIP
+        [2, 4, 8, 1, 8, 4]
+
+    """
+    if times is None:
+        return starmap(func, repeat(args))
+    return starmap(func, repeat(args, times))
+
+
+def _pairwise(iterable):
+    """Returns an iterator of paired items, overlapping, from the original
+
+    >>> take(4, pairwise(count()))
+    [(0, 1), (1, 2), (2, 3), (3, 4)]
+
+    On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`.
+
+    """
+    a, b = tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+try:
+    from itertools import pairwise as itertools_pairwise
+except ImportError:
+    pairwise = _pairwise
+else:
+
+    def pairwise(iterable):
+        return itertools_pairwise(iterable)
+
+    pairwise.__doc__ = _pairwise.__doc__
+
+
+class UnequalIterablesError(ValueError):
+    def __init__(self, details=None):
+        msg = 'Iterables have different lengths'
+        if details is not None:
+            msg += (': index 0 has length {}; index {} has length {}').format(
+                *details
+            )
+
+        super().__init__(msg)
+
+
+def _zip_equal_generator(iterables):
+    for combo in zip_longest(*iterables, fillvalue=_marker):
+        for val in combo:
+            if val is _marker:
+                raise UnequalIterablesError()
+        yield combo
+
+
+def _zip_equal(*iterables):
+    # Check whether the iterables are all the same size.
+    try:
+        first_size = len(iterables[0])
+        for i, it in enumerate(iterables[1:], 1):
+            size = len(it)
+            if size != first_size:
+                raise UnequalIterablesError(details=(first_size, i, size))
+        # All sizes are equal, we can use the built-in zip.
+        return zip(*iterables)
+    # If any one of the iterables didn't have a length, start reading
+    # them until one runs out.
+    except TypeError:
+        return _zip_equal_generator(iterables)
+
+
+def grouper(iterable, n, incomplete='fill', fillvalue=None):
+    """Group elements from *iterable* into fixed-length groups of length *n*.
+
+    >>> list(grouper('ABCDEF', 3))
+    [('A', 'B', 'C'), ('D', 'E', 'F')]
+
+    The keyword arguments *incomplete* and *fillvalue* control what happens for
+    iterables whose length is not a multiple of *n*.
+
+    When *incomplete* is `'fill'`, the last group will contain instances of
+    *fillvalue*.
+
+    >>> list(grouper('ABCDEFG', 3, incomplete='fill', fillvalue='x'))
+    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]
+
+    When *incomplete* is `'ignore'`, the last group will not be emitted.
+
+    >>> list(grouper('ABCDEFG', 3, incomplete='ignore', fillvalue='x'))
+    [('A', 'B', 'C'), ('D', 'E', 'F')]
+
+    When *incomplete* is `'strict'`, a subclass of `ValueError` will be raised.
+
+    >>> it = grouper('ABCDEFG', 3, incomplete='strict')
+    >>> list(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+    ...
+    UnequalIterablesError
+
+    """
+    args = [iter(iterable)] * n
+    if incomplete == 'fill':
+        return zip_longest(*args, fillvalue=fillvalue)
+    if incomplete == 'strict':
+        return _zip_equal(*args)
+    if incomplete == 'ignore':
+        return zip(*args)
+    else:
+        raise ValueError('Expected fill, strict, or ignore')
+
+
+def roundrobin(*iterables):
+    """Yields an item from each iterable, alternating between them.
+
+        >>> list(roundrobin('ABC', 'D', 'EF'))
+        ['A', 'D', 'E', 'B', 'F', 'C']
+
+    This function produces the same output as :func:`interleave_longest`, but
+    may perform better for some inputs (in particular when the number of
+    iterables is small).
+
+    """
+    # Recipe credited to George Sakkis
+    pending = len(iterables)
+    nexts = cycle(iter(it).__next__ for it in iterables)
+    while pending:
+        try:
+            for next in nexts:
+                yield next()
+        except StopIteration:
+            pending -= 1
+            nexts = cycle(islice(nexts, pending))
+
+
+def partition(pred, iterable):
+    """
+    Returns a 2-tuple of iterables derived from the input iterable.
+    The first yields the items that have ``pred(item) == False``.
+    The second yields the items that have ``pred(item) == True``.
+
+        >>> is_odd = lambda x: x % 2 != 0
+        >>> iterable = range(10)
+        >>> even_items, odd_items = partition(is_odd, iterable)
+        >>> list(even_items), list(odd_items)
+        ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])
+
+    If *pred* is None, :func:`bool` is used.
+
+        >>> iterable = [0, 1, False, True, '', ' ']
+        >>> false_items, true_items = partition(None, iterable)
+        >>> list(false_items), list(true_items)
+        ([0, False, ''], [1, True, ' '])
+
+    """
+    if pred is None:
+        pred = bool
+
+    t1, t2, p = tee(iterable, 3)
+    p1, p2 = tee(map(pred, p))
+    return (compress(t1, map(operator.not_, p1)), compress(t2, p2))
+
+
+def powerset(iterable):
+    """Yields all possible subsets of the iterable.
+
+        >>> list(powerset([1, 2, 3]))
+        [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
+
+    :func:`powerset` will operate on iterables that aren't :class:`set`
+    instances, so repeated elements in the input will produce repeated elements
+    in the output. Use :func:`unique_everseen` on the input to avoid generating
+    duplicates:
+
+        >>> seq = [1, 1, 0]
+        >>> list(powerset(seq))
+        [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
+        >>> from more_itertools import unique_everseen
+        >>> list(powerset(unique_everseen(seq)))
+        [(), (1,), (0,), (1, 0)]
+
+    """
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))
+
+
+def unique_everseen(iterable, key=None):
+    """
+    Yield unique elements, preserving order.
+
+        >>> list(unique_everseen('AAAABBBCCDAABBB'))
+        ['A', 'B', 'C', 'D']
+        >>> list(unique_everseen('ABBCcAD', str.lower))
+        ['A', 'B', 'C', 'D']
+
+    Sequences with a mix of hashable and unhashable items can be used.
+    The function will be slower (i.e., `O(n^2)`) for unhashable items.
+
+    Remember that ``list`` objects are unhashable - you can use the *key*
+    parameter to transform the list to a tuple (which is hashable) to
+    avoid a slowdown.
+
+        >>> iterable = ([1, 2], [2, 3], [1, 2])
+        >>> list(unique_everseen(iterable))  # Slow
+        [[1, 2], [2, 3]]
+        >>> list(unique_everseen(iterable, key=tuple))  # Faster
+        [[1, 2], [2, 3]]
+
+    Similary, you may want to convert unhashable ``set`` objects with
+    ``key=frozenset``. For ``dict`` objects,
+    ``key=lambda x: frozenset(x.items())`` can be used.
+
+    """
+    seenset = set()
+    seenset_add = seenset.add
+    seenlist = []
+    seenlist_add = seenlist.append
+    use_key = key is not None
+
+    for element in iterable:
+        k = key(element) if use_key else element
+        try:
+            if k not in seenset:
+                seenset_add(k)
+                yield element
+        except TypeError:
+            if k not in seenlist:
+                seenlist_add(k)
+                yield element
+
+
+def unique_justseen(iterable, key=None):
+    """Yields elements in order, ignoring serial duplicates
+
+    >>> list(unique_justseen('AAAABBBCCDAABBB'))
+    ['A', 'B', 'C', 'D', 'A', 'B']
+    >>> list(unique_justseen('ABBCcAD', str.lower))
+    ['A', 'B', 'C', 'A', 'D']
+
+    """
+    return map(next, map(operator.itemgetter(1), groupby(iterable, key)))
+
+
+def iter_except(func, exception, first=None):
+    """Yields results from a function repeatedly until an exception is raised.
+
+    Converts a call-until-exception interface to an iterator interface.
+    Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel
+    to end the loop.
+
+        >>> l = [0, 1, 2]
+        >>> list(iter_except(l.pop, IndexError))
+        [2, 1, 0]
+
+    Multiple exceptions can be specified as a stopping condition:
+
+        >>> l = [1, 2, 3, '...', 4, 5, 6]
+        >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
+        [7, 6, 5]
+        >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
+        [4, 3, 2]
+        >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
+        []
+
+    """
+    try:
+        if first is not None:
+            yield first()
+        while 1:
+            yield func()
+    except exception:
+        pass
+
+
+def first_true(iterable, default=None, pred=None):
+    """
+    Returns the first true value in the iterable.
+
+    If no true value is found, returns *default*
+
+    If *pred* is not None, returns the first item for which
+    ``pred(item) == True`` .
+
+        >>> first_true(range(10))
+        1
+        >>> first_true(range(10), pred=lambda x: x > 5)
+        6
+        >>> first_true(range(10), default='missing', pred=lambda x: x > 9)
+        'missing'
+
+    """
+    return next(filter(pred, iterable), default)
+
+
+def random_product(*args, repeat=1):
+    """Draw an item at random from each of the input iterables.
+
+        >>> random_product('abc', range(4), 'XYZ')  # doctest:+SKIP
+        ('c', 3, 'Z')
+
+    If *repeat* is provided as a keyword argument, that many items will be
+    drawn from each iterable.
+
+        >>> random_product('abcd', range(4), repeat=2)  # doctest:+SKIP
+        ('a', 2, 'd', 3)
+
+    This equivalent to taking a random selection from
+    ``itertools.product(*args, **kwarg)``.
+
+    """
+    pools = [tuple(pool) for pool in args] * repeat
+    return tuple(choice(pool) for pool in pools)
+
+
+def random_permutation(iterable, r=None):
+    """Return a random *r* length permutation of the elements in *iterable*.
+
+    If *r* is not specified or is ``None``, then *r* defaults to the length of
+    *iterable*.
+
+        >>> random_permutation(range(5))  # doctest:+SKIP
+        (3, 4, 0, 1, 2)
+
+    This equivalent to taking a random selection from
+    ``itertools.permutations(iterable, r)``.
+
+    """
+    pool = tuple(iterable)
+    r = len(pool) if r is None else r
+    return tuple(sample(pool, r))
+
+
+def random_combination(iterable, r):
+    """Return a random *r* length subsequence of the elements in *iterable*.
+
+        >>> random_combination(range(5), 3)  # doctest:+SKIP
+        (2, 3, 4)
+
+    This equivalent to taking a random selection from
+    ``itertools.combinations(iterable, r)``.
+
+    """
+    pool = tuple(iterable)
+    n = len(pool)
+    indices = sorted(sample(range(n), r))
+    return tuple(pool[i] for i in indices)
+
+
+def random_combination_with_replacement(iterable, r):
+    """Return a random *r* length subsequence of elements in *iterable*,
+    allowing individual elements to be repeated.
+
+        >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
+        (0, 0, 1, 2, 2)
+
+    This equivalent to taking a random selection from
+    ``itertools.combinations_with_replacement(iterable, r)``.
+
+    """
+    pool = tuple(iterable)
+    n = len(pool)
+    indices = sorted(randrange(n) for i in range(r))
+    return tuple(pool[i] for i in indices)
+
+
+def nth_combination(iterable, r, index):
+    """Equivalent to ``list(combinations(iterable, r))[index]``.
+
+    The subsequences of *iterable* that are of length *r* can be ordered
+    lexicographically. :func:`nth_combination` computes the subsequence at
+    sort position *index* directly, without computing the previous
+    subsequences.
+
+        >>> nth_combination(range(5), 3, 5)
+        (0, 3, 4)
+
+    ``ValueError`` will be raised If *r* is negative or greater than the length
+    of *iterable*.
+    ``IndexError`` will be raised if the given *index* is invalid.
+    """
+    pool = tuple(iterable)
+    n = len(pool)
+    if (r < 0) or (r > n):
+        raise ValueError
+
+    c = 1
+    k = min(r, n - r)
+    for i in range(1, k + 1):
+        c = c * (n - k + i) // i
+
+    if index < 0:
+        index += c
+
+    if (index < 0) or (index >= c):
+        raise IndexError
+
+    result = []
+    while r:
+        c, n, r = c * r // n, n - 1, r - 1
+        while index >= c:
+            index -= c
+            c, n = c * (n - r) // n, n - 1
+        result.append(pool[-1 - n])
+
+    return tuple(result)
+
+
+def prepend(value, iterator):
+    """Yield *value*, followed by the elements in *iterator*.
+
+        >>> value = '0'
+        >>> iterator = ['1', '2', '3']
+        >>> list(prepend(value, iterator))
+        ['0', '1', '2', '3']
+
+    To prepend multiple values, see :func:`itertools.chain`
+    or :func:`value_chain`.
+
+    """
+    return chain([value], iterator)
+
+
+def convolve(signal, kernel):
+    """Convolve the iterable *signal* with the iterable *kernel*.
+
+        >>> signal = (1, 2, 3, 4, 5)
+        >>> kernel = [3, 2, 1]
+        >>> list(convolve(signal, kernel))
+        [3, 8, 14, 20, 26, 14, 5]
+
+    Note: the input arguments are not interchangeable, as the *kernel*
+    is immediately consumed and stored.
+
+    """
+    # This implementation intentionally doesn't match the one in the itertools
+    # documentation.
+    kernel = tuple(kernel)[::-1]
+    n = len(kernel)
+    window = deque([0], maxlen=n) * n
+    for x in chain(signal, repeat(0, n - 1)):
+        window.append(x)
+        yield _sumprod(kernel, window)
+
+
+def before_and_after(predicate, it):
+    """A variant of :func:`takewhile` that allows complete access to the
+    remainder of the iterator.
+
+         >>> it = iter('ABCdEfGhI')
+         >>> all_upper, remainder = before_and_after(str.isupper, it)
+         >>> ''.join(all_upper)
+         'ABC'
+         >>> ''.join(remainder) # takewhile() would lose the 'd'
+         'dEfGhI'
+
+    Note that the first iterator must be fully consumed before the second
+    iterator can generate valid results.
+    """
+    it = iter(it)
+    transition = []
+
+    def true_iterator():
+        for elem in it:
+            if predicate(elem):
+                yield elem
+            else:
+                transition.append(elem)
+                return
+
+    # Note: this is different from itertools recipes to allow nesting
+    # before_and_after remainders into before_and_after again. See tests
+    # for an example.
+    remainder_iterator = chain(transition, it)
+
+    return true_iterator(), remainder_iterator
+
+
+def triplewise(iterable):
+    """Return overlapping triplets from *iterable*.
+
+    >>> list(triplewise('ABCDE'))
+    [('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')]
+
+    """
+    for (a, _), (b, c) in pairwise(pairwise(iterable)):
+        yield a, b, c
+
+
+def sliding_window(iterable, n):
+    """Return a sliding window of width *n* over *iterable*.
+
+        >>> list(sliding_window(range(6), 4))
+        [(0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)]
+
+    If *iterable* has fewer than *n* items, then nothing is yielded:
+
+        >>> list(sliding_window(range(3), 4))
+        []
+
+    For a variant with more features, see :func:`windowed`.
+    """
+    it = iter(iterable)
+    window = deque(islice(it, n - 1), maxlen=n)
+    for x in it:
+        window.append(x)
+        yield tuple(window)
+
+
+def subslices(iterable):
+    """Return all contiguous non-empty subslices of *iterable*.
+
+        >>> list(subslices('ABC'))
+        [['A'], ['A', 'B'], ['A', 'B', 'C'], ['B'], ['B', 'C'], ['C']]
+
+    This is similar to :func:`substrings`, but emits items in a different
+    order.
+    """
+    seq = list(iterable)
+    slices = starmap(slice, combinations(range(len(seq) + 1), 2))
+    return map(operator.getitem, repeat(seq), slices)
+
+
+def polynomial_from_roots(roots):
+    """Compute a polynomial's coefficients from its roots.
+
+    >>> roots = [5, -4, 3]  # (x - 5) * (x + 4) * (x - 3)
+    >>> polynomial_from_roots(roots)  # x^3 - 4 * x^2 - 17 * x + 60
+    [1, -4, -17, 60]
+    """
+    factors = zip(repeat(1), map(operator.neg, roots))
+    return list(reduce(convolve, factors, [1]))
+
+
+def iter_index(iterable, value, start=0):
+    """Yield the index of each place in *iterable* that *value* occurs,
+    beginning with index *start*.
+
+    See :func:`locate` for a more general means of finding the indexes
+    associated with particular values.
+
+    >>> list(iter_index('AABCADEAF', 'A'))
+    [0, 1, 4, 7]
+    """
+    try:
+        seq_index = iterable.index
+    except AttributeError:
+        # Slow path for general iterables
+        it = islice(iterable, start, None)
+        i = start - 1
+        try:
+            while True:
+                i = i + operator.indexOf(it, value) + 1
+                yield i
+        except ValueError:
+            pass
+    else:
+        # Fast path for sequences
+        i = start - 1
+        try:
+            while True:
+                i = seq_index(value, i + 1)
+                yield i
+        except ValueError:
+            pass
+
+
+def sieve(n):
+    """Yield the primes less than n.
+
+    >>> list(sieve(30))
+    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+    """
+    data = bytearray((0, 1)) * (n // 2)
+    data[:3] = 0, 0, 0
+    limit = math.isqrt(n) + 1
+    for p in compress(range(limit), data):
+        data[p * p : n : p + p] = bytes(len(range(p * p, n, p + p)))
+    data[2] = 1
+    return iter_index(data, 1) if n > 2 else iter([])
+
+
+def _batched(iterable, n):
+    """Batch data into lists of length *n*. The last batch may be shorter.
+
+    >>> list(batched('ABCDEFG', 3))
+    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]
+
+    On Python 3.12 and above, this is an alias for :func:`itertools.batched`.
+    """
+    if n < 1:
+        raise ValueError('n must be at least one')
+    it = iter(iterable)
+    while True:
+        batch = tuple(islice(it, n))
+        if not batch:
+            break
+        yield batch
+
+
+try:
+    from itertools import batched as itertools_batched
+except ImportError:
+    batched = _batched
+else:
+
+    def batched(iterable, n):
+        return itertools_batched(iterable, n)
+
+    batched.__doc__ = _batched.__doc__
+
+
+def transpose(it):
+    """Swap the rows and columns of the input.
+
+    >>> list(transpose([(1, 2, 3), (11, 22, 33)]))
+    [(1, 11), (2, 22), (3, 33)]
+
+    The caller should ensure that the dimensions of the input are compatible.
+    If the input is empty, no output will be produced.
+    """
+    return _zip_strict(*it)
+
+
+def matmul(m1, m2):
+    """Multiply two matrices.
+    >>> list(matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)]))
+    [(49, 80), (41, 60)]
+
+    The caller should ensure that the dimensions of the input matrices are
+    compatible with each other.
+    """
+    n = len(m2[0])
+    return batched(starmap(_sumprod, product(m1, transpose(m2))), n)
+
+
+def factor(n):
+    """Yield the prime factors of n.
+    >>> list(factor(360))
+    [2, 2, 2, 3, 3, 5]
+    """
+    for prime in sieve(math.isqrt(n) + 1):
+        while True:
+            if n % prime:
+                break
+            yield prime
+            n //= prime
+            if n == 1:
+                return
+    if n > 1:
+        yield n
+
+
+def polynomial_eval(coefficients, x):
+    """Evaluate a polynomial at a specific value.
+
+    Example: evaluating x^3 - 4 * x^2 - 17 * x + 60 at x = 2.5:
+
+    >>> coefficients = [1, -4, -17, 60]
+    >>> x = 2.5
+    >>> polynomial_eval(coefficients, x)
+    8.125
+    """
+    n = len(coefficients)
+    if n == 0:
+        return x * 0  # coerce zero to the type of x
+    powers = map(pow, repeat(x), reversed(range(n)))
+    return _sumprod(coefficients, powers)
+
+
+def sum_of_squares(it):
+    """Return the sum of the squares of the input values.
+
+    >>> sum_of_squares([10, 20, 30])
+    1400
+    """
+    return _sumprod(*tee(it))
+
+
+def polynomial_derivative(coefficients):
+    """Compute the first derivative of a polynomial.
+
+    Example: evaluating the derivative of x^3 - 4 * x^2 - 17 * x + 60
+
+    >>> coefficients = [1, -4, -17, 60]
+    >>> derivative_coefficients = polynomial_derivative(coefficients)
+    >>> derivative_coefficients
+    [3, -8, -17]
+    """
+    n = len(coefficients)
+    powers = reversed(range(1, n))
+    return list(map(operator.mul, coefficients, powers))
diff --git a/lib/python3.11/site-packages/more_itertools/recipes.pyi b/lib/python3.11/site-packages/more_itertools/recipes.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..ef8838649104f93b6dfd0213379480f9a56f75b0
--- /dev/null
+++ b/lib/python3.11/site-packages/more_itertools/recipes.pyi
@@ -0,0 +1,122 @@
+"""Stubs for more_itertools.recipes"""
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    overload,
+    Sequence,
+    Type,
+    TypeVar,
+)
+
+# Type and type variable definitions
+_T = TypeVar('_T')
+_U = TypeVar('_U')
+
+def take(n: int, iterable: Iterable[_T]) -> list[_T]: ...
+def tabulate(
+    function: Callable[[int], _T], start: int = ...
+) -> Iterator[_T]: ...
+def tail(n: int, iterable: Iterable[_T]) -> Iterator[_T]: ...
+def consume(iterator: Iterable[_T], n: int | None = ...) -> None: ...
+@overload
+def nth(iterable: Iterable[_T], n: int) -> _T | None: ...
+@overload
+def nth(iterable: Iterable[_T], n: int, default: _U) -> _T | _U: ...
+def all_equal(iterable: Iterable[object]) -> bool: ...
+def quantify(
+    iterable: Iterable[_T], pred: Callable[[_T], bool] = ...
+) -> int: ...
+def pad_none(iterable: Iterable[_T]) -> Iterator[_T | None]: ...
+def padnone(iterable: Iterable[_T]) -> Iterator[_T | None]: ...
+def ncycles(iterable: Iterable[_T], n: int) -> Iterator[_T]: ...
+def dotproduct(vec1: Iterable[object], vec2: Iterable[object]) -> object: ...
+def flatten(listOfLists: Iterable[Iterable[_T]]) -> Iterator[_T]: ...
+def repeatfunc(
+    func: Callable[..., _U], times: int | None = ..., *args: Any
+) -> Iterator[_U]: ...
+def pairwise(iterable: Iterable[_T]) -> Iterator[tuple[_T, _T]]: ...
+def grouper(
+    iterable: Iterable[_T],
+    n: int,
+    incomplete: str = ...,
+    fillvalue: _U = ...,
+) -> Iterator[tuple[_T | _U, ...]]: ...
+def roundrobin(*iterables: Iterable[_T]) -> Iterator[_T]: ...
+def partition(
+    pred: Callable[[_T], object] | None, iterable: Iterable[_T]
+) -> tuple[Iterator[_T], Iterator[_T]]: ...
+def powerset(iterable: Iterable[_T]) -> Iterator[tuple[_T, ...]]: ...
+def unique_everseen(
+    iterable: Iterable[_T], key: Callable[[_T], _U] | None = ...
+) -> Iterator[_T]: ...
+def unique_justseen(
+    iterable: Iterable[_T], key: Callable[[_T], object] | None = ...
+) -> Iterator[_T]: ...
+@overload
+def iter_except(
+    func: Callable[[], _T],
+    exception: Type[BaseException] | tuple[Type[BaseException], ...],
+    first: None = ...,
+) -> Iterator[_T]: ...
+@overload
+def iter_except(
+    func: Callable[[], _T],
+    exception: Type[BaseException] | tuple[Type[BaseException], ...],
+    first: Callable[[], _U],
+) -> Iterator[_T | _U]: ...
+@overload
+def first_true(
+    iterable: Iterable[_T], *, pred: Callable[[_T], object] | None = ...
+) -> _T | None: ...
+@overload
+def first_true(
+    iterable: Iterable[_T],
+    default: _U,
+    pred: Callable[[_T], object] | None = ...,
+) -> _T | _U: ...
+def random_product(
+    *args: Iterable[_T], repeat: int = ...
+) -> tuple[_T, ...]: ...
+def random_permutation(
+    iterable: Iterable[_T], r: int | None = ...
+) -> tuple[_T, ...]: ...
+def random_combination(iterable: Iterable[_T], r: int) -> tuple[_T, ...]: ...
+def random_combination_with_replacement(
+    iterable: Iterable[_T], r: int
+) -> tuple[_T, ...]: ...
+def nth_combination(
+    iterable: Iterable[_T], r: int, index: int
+) -> tuple[_T, ...]: ...
+def prepend(value: _T, iterator: Iterable[_U]) -> Iterator[_T | _U]: ...
+def convolve(signal: Iterable[_T], kernel: Iterable[_T]) -> Iterator[_T]: ...
+def before_and_after(
+    predicate: Callable[[_T], bool], it: Iterable[_T]
+) -> tuple[Iterator[_T], Iterator[_T]]: ...
+def triplewise(iterable: Iterable[_T]) -> Iterator[tuple[_T, _T, _T]]: ...
+def sliding_window(
+    iterable: Iterable[_T], n: int
+) -> Iterator[tuple[_T, ...]]: ...
+def subslices(iterable: Iterable[_T]) -> Iterator[list[_T]]: ...
+def polynomial_from_roots(roots: Sequence[_T]) -> list[_T]: ...
+def iter_index(
+    iterable: Iterable[object],
+    value: Any,
+    start: int | None = ...,
+) -> Iterator[int]: ...
+def sieve(n: int) -> Iterator[int]: ...
+def batched(
+    iterable: Iterable[_T],
+    n: int,
+) -> Iterator[tuple[_T]]: ...
+def transpose(
+    it: Iterable[Iterable[_T]],
+) -> Iterator[tuple[_T, ...]]: ...
+def matmul(m1: Sequence[_T], m2: Sequence[_T]) -> Iterator[tuple[_T]]: ...
+def factor(n: int) -> Iterator[int]: ...
+def polynomial_eval(coefficients: Sequence[_T], x: _U) -> _U: ...
+def sum_of_squares(it: Iterable[_T]) -> _T: ...
+def polynomial_derivative(coefficients: Sequence[_T]) -> list[_T]: ...
diff --git a/lib/python3.11/site-packages/mpmath/__init__.py b/lib/python3.11/site-packages/mpmath/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..46a7c6f7c0875548f264612b604a9e1574b00a84
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/__init__.py
@@ -0,0 +1,468 @@
+__version__ = '1.3.0'
+
+from .usertools import monitor, timing
+
+from .ctx_fp import FPContext
+from .ctx_mp import MPContext
+from .ctx_iv import MPIntervalContext
+
+fp = FPContext()
+mp = MPContext()
+iv = MPIntervalContext()
+
+fp._mp = mp
+mp._mp = mp
+iv._mp = mp
+mp._fp = fp
+fp._fp = fp
+mp._iv = iv
+fp._iv = iv
+iv._iv = iv
+
+# XXX: extremely bad pickle hack
+from . import ctx_mp as _ctx_mp
+_ctx_mp._mpf_module.mpf = mp.mpf
+_ctx_mp._mpf_module.mpc = mp.mpc
+
+make_mpf = mp.make_mpf
+make_mpc = mp.make_mpc
+
+extraprec = mp.extraprec
+extradps = mp.extradps
+workprec = mp.workprec
+workdps = mp.workdps
+autoprec = mp.autoprec
+maxcalls = mp.maxcalls
+memoize = mp.memoize
+
+mag = mp.mag
+
+bernfrac = mp.bernfrac
+
+qfrom = mp.qfrom
+mfrom = mp.mfrom
+kfrom = mp.kfrom
+taufrom = mp.taufrom
+qbarfrom = mp.qbarfrom
+ellipfun = mp.ellipfun
+jtheta = mp.jtheta
+kleinj = mp.kleinj
+eta = mp.eta
+
+qp = mp.qp
+qhyper = mp.qhyper
+qgamma = mp.qgamma
+qfac = mp.qfac
+
+nint_distance = mp.nint_distance
+
+plot = mp.plot
+cplot = mp.cplot
+splot = mp.splot
+
+odefun = mp.odefun
+
+jacobian = mp.jacobian
+findroot = mp.findroot
+multiplicity = mp.multiplicity
+
+isinf = mp.isinf
+isnan = mp.isnan
+isnormal = mp.isnormal
+isint = mp.isint
+isfinite = mp.isfinite
+almosteq = mp.almosteq
+nan = mp.nan
+rand = mp.rand
+
+absmin = mp.absmin
+absmax = mp.absmax
+
+fraction = mp.fraction
+
+linspace = mp.linspace
+arange = mp.arange
+
+mpmathify = convert = mp.convert
+mpc = mp.mpc
+
+mpi = iv._mpi
+
+nstr = mp.nstr
+nprint = mp.nprint
+chop = mp.chop
+
+fneg = mp.fneg
+fadd = mp.fadd
+fsub = mp.fsub
+fmul = mp.fmul
+fdiv = mp.fdiv
+fprod = mp.fprod
+
+quad = mp.quad
+quadgl = mp.quadgl
+quadts = mp.quadts
+quadosc = mp.quadosc
+quadsubdiv = mp.quadsubdiv
+
+invertlaplace = mp.invertlaplace
+invlaptalbot = mp.invlaptalbot
+invlapstehfest = mp.invlapstehfest
+invlapdehoog = mp.invlapdehoog
+
+pslq = mp.pslq
+identify = mp.identify
+findpoly = mp.findpoly
+
+richardson = mp.richardson
+shanks = mp.shanks
+levin = mp.levin
+cohen_alt = mp.cohen_alt
+nsum = mp.nsum
+nprod = mp.nprod
+difference = mp.difference
+diff = mp.diff
+diffs = mp.diffs
+diffs_prod = mp.diffs_prod
+diffs_exp = mp.diffs_exp
+diffun = mp.diffun
+differint = mp.differint
+taylor = mp.taylor
+pade = mp.pade
+polyval = mp.polyval
+polyroots = mp.polyroots
+fourier = mp.fourier
+fourierval = mp.fourierval
+sumem = mp.sumem
+sumap = mp.sumap
+chebyfit = mp.chebyfit
+limit = mp.limit
+
+matrix = mp.matrix
+eye = mp.eye
+diag = mp.diag
+zeros = mp.zeros
+ones = mp.ones
+hilbert = mp.hilbert
+randmatrix = mp.randmatrix
+swap_row = mp.swap_row
+extend = mp.extend
+norm = mp.norm
+mnorm = mp.mnorm
+
+lu_solve = mp.lu_solve
+lu = mp.lu
+qr = mp.qr
+unitvector = mp.unitvector
+inverse = mp.inverse
+residual = mp.residual
+qr_solve = mp.qr_solve
+cholesky = mp.cholesky
+cholesky_solve = mp.cholesky_solve
+det = mp.det
+cond = mp.cond
+hessenberg = mp.hessenberg
+schur = mp.schur
+eig = mp.eig
+eig_sort = mp.eig_sort
+eigsy = mp.eigsy
+eighe = mp.eighe
+eigh = mp.eigh
+svd_r = mp.svd_r
+svd_c = mp.svd_c
+svd = mp.svd
+gauss_quadrature = mp.gauss_quadrature
+
+expm = mp.expm
+sqrtm = mp.sqrtm
+powm = mp.powm
+logm = mp.logm
+sinm = mp.sinm
+cosm = mp.cosm
+
+mpf = mp.mpf
+j = mp.j
+exp = mp.exp
+expj = mp.expj
+expjpi = mp.expjpi
+ln = mp.ln
+im = mp.im
+re = mp.re
+inf = mp.inf
+ninf = mp.ninf
+sign = mp.sign
+
+eps = mp.eps
+pi = mp.pi
+ln2 = mp.ln2
+ln10 = mp.ln10
+phi = mp.phi
+e = mp.e
+euler = mp.euler
+catalan = mp.catalan
+khinchin = mp.khinchin
+glaisher = mp.glaisher
+apery = mp.apery
+degree = mp.degree
+twinprime = mp.twinprime
+mertens = mp.mertens
+
+ldexp = mp.ldexp
+frexp = mp.frexp
+
+fsum = mp.fsum
+fdot = mp.fdot
+
+sqrt = mp.sqrt
+cbrt = mp.cbrt
+exp = mp.exp
+ln = mp.ln
+log = mp.log
+log10 = mp.log10
+power = mp.power
+cos = mp.cos
+sin = mp.sin
+tan = mp.tan
+cosh = mp.cosh
+sinh = mp.sinh
+tanh = mp.tanh
+acos = mp.acos
+asin = mp.asin
+atan = mp.atan
+asinh = mp.asinh
+acosh = mp.acosh
+atanh = mp.atanh
+sec = mp.sec
+csc = mp.csc
+cot = mp.cot
+sech = mp.sech
+csch = mp.csch
+coth = mp.coth
+asec = mp.asec
+acsc = mp.acsc
+acot = mp.acot
+asech = mp.asech
+acsch = mp.acsch
+acoth = mp.acoth
+cospi = mp.cospi
+sinpi = mp.sinpi
+sinc = mp.sinc
+sincpi = mp.sincpi
+cos_sin = mp.cos_sin
+cospi_sinpi = mp.cospi_sinpi
+fabs = mp.fabs
+re = mp.re
+im = mp.im
+conj = mp.conj
+floor = mp.floor
+ceil = mp.ceil
+nint = mp.nint
+frac = mp.frac
+root = mp.root
+nthroot = mp.nthroot
+hypot = mp.hypot
+fmod = mp.fmod
+ldexp = mp.ldexp
+frexp = mp.frexp
+sign = mp.sign
+arg = mp.arg
+phase = mp.phase
+polar = mp.polar
+rect = mp.rect
+degrees = mp.degrees
+radians = mp.radians
+atan2 = mp.atan2
+fib = mp.fib
+fibonacci = mp.fibonacci
+lambertw = mp.lambertw
+zeta = mp.zeta
+altzeta = mp.altzeta
+gamma = mp.gamma
+rgamma = mp.rgamma
+factorial = mp.factorial
+fac = mp.fac
+fac2 = mp.fac2
+beta = mp.beta
+betainc = mp.betainc
+psi = mp.psi
+#psi0 = mp.psi0
+#psi1 = mp.psi1
+#psi2 = mp.psi2
+#psi3 = mp.psi3
+polygamma = mp.polygamma
+digamma = mp.digamma
+#trigamma = mp.trigamma
+#tetragamma = mp.tetragamma
+#pentagamma = mp.pentagamma
+harmonic = mp.harmonic
+bernoulli = mp.bernoulli
+bernfrac = mp.bernfrac
+stieltjes = mp.stieltjes
+hurwitz = mp.hurwitz
+dirichlet = mp.dirichlet
+bernpoly = mp.bernpoly
+eulerpoly = mp.eulerpoly
+eulernum = mp.eulernum
+polylog = mp.polylog
+clsin = mp.clsin
+clcos = mp.clcos
+gammainc = mp.gammainc
+gammaprod = mp.gammaprod
+binomial = mp.binomial
+rf = mp.rf
+ff = mp.ff
+hyper = mp.hyper
+hyp0f1 = mp.hyp0f1
+hyp1f1 = mp.hyp1f1
+hyp1f2 = mp.hyp1f2
+hyp2f1 = mp.hyp2f1
+hyp2f2 = mp.hyp2f2
+hyp2f0 = mp.hyp2f0
+hyp2f3 = mp.hyp2f3
+hyp3f2 = mp.hyp3f2
+hyperu = mp.hyperu
+hypercomb = mp.hypercomb
+meijerg = mp.meijerg
+appellf1 = mp.appellf1
+appellf2 = mp.appellf2
+appellf3 = mp.appellf3
+appellf4 = mp.appellf4
+hyper2d = mp.hyper2d
+bihyper = mp.bihyper
+erf = mp.erf
+erfc = mp.erfc
+erfi = mp.erfi
+erfinv = mp.erfinv
+npdf = mp.npdf
+ncdf = mp.ncdf
+expint = mp.expint
+e1 = mp.e1
+ei = mp.ei
+li = mp.li
+ci = mp.ci
+si = mp.si
+chi = mp.chi
+shi = mp.shi
+fresnels = mp.fresnels
+fresnelc = mp.fresnelc
+airyai = mp.airyai
+airybi = mp.airybi
+airyaizero = mp.airyaizero
+airybizero = mp.airybizero
+scorergi = mp.scorergi
+scorerhi = mp.scorerhi
+ellipk = mp.ellipk
+ellipe = mp.ellipe
+ellipf = mp.ellipf
+ellippi = mp.ellippi
+elliprc = mp.elliprc
+elliprj = mp.elliprj
+elliprf = mp.elliprf
+elliprd = mp.elliprd
+elliprg = mp.elliprg
+agm = mp.agm
+jacobi = mp.jacobi
+chebyt = mp.chebyt
+chebyu = mp.chebyu
+legendre = mp.legendre
+legenp = mp.legenp
+legenq = mp.legenq
+hermite = mp.hermite
+pcfd = mp.pcfd
+pcfu = mp.pcfu
+pcfv = mp.pcfv
+pcfw = mp.pcfw
+gegenbauer = mp.gegenbauer
+laguerre = mp.laguerre
+spherharm = mp.spherharm
+besselj = mp.besselj
+j0 = mp.j0
+j1 = mp.j1
+besseli = mp.besseli
+bessely = mp.bessely
+besselk = mp.besselk
+besseljzero = mp.besseljzero
+besselyzero = mp.besselyzero
+hankel1 = mp.hankel1
+hankel2 = mp.hankel2
+struveh = mp.struveh
+struvel = mp.struvel
+angerj = mp.angerj
+webere = mp.webere
+lommels1 = mp.lommels1
+lommels2 = mp.lommels2
+whitm = mp.whitm
+whitw = mp.whitw
+ber = mp.ber
+bei = mp.bei
+ker = mp.ker
+kei = mp.kei
+coulombc = mp.coulombc
+coulombf = mp.coulombf
+coulombg = mp.coulombg
+barnesg = mp.barnesg
+superfac = mp.superfac
+hyperfac = mp.hyperfac
+loggamma = mp.loggamma
+siegeltheta = mp.siegeltheta
+siegelz = mp.siegelz
+grampoint = mp.grampoint
+zetazero = mp.zetazero
+riemannr = mp.riemannr
+primepi = mp.primepi
+primepi2 = mp.primepi2
+primezeta = mp.primezeta
+bell = mp.bell
+polyexp = mp.polyexp
+expm1 = mp.expm1
+log1p = mp.log1p
+powm1 = mp.powm1
+unitroots = mp.unitroots
+cyclotomic = mp.cyclotomic
+mangoldt = mp.mangoldt
+secondzeta = mp.secondzeta
+nzeros = mp.nzeros
+backlunds = mp.backlunds
+lerchphi = mp.lerchphi
+stirling1 = mp.stirling1
+stirling2 = mp.stirling2
+squarew = mp.squarew
+trianglew = mp.trianglew
+sawtoothw = mp.sawtoothw
+unit_triangle = mp.unit_triangle
+sigmoid = mp.sigmoid
+
+# be careful when changing this name, don't use test*!
+def runtests():
+    """
+    Run all mpmath tests and print output.
+    """
+    import os.path
+    from inspect import getsourcefile
+    from .tests import runtests as tests
+    testdir = os.path.dirname(os.path.abspath(getsourcefile(tests)))
+    importdir = os.path.abspath(testdir + '/../..')
+    tests.testit(importdir, testdir)
+
+def doctests(filter=[]):
+    import sys
+    from timeit import default_timer as clock
+    for i, arg in enumerate(sys.argv):
+        if '__init__.py' in arg:
+            filter = [sn for sn in sys.argv[i+1:] if not sn.startswith("-")]
+            break
+    import doctest
+    globs = globals().copy()
+    for obj in globs: #sorted(globs.keys()):
+        if filter:
+            if not sum([pat in obj for pat in filter]):
+                continue
+        sys.stdout.write(str(obj) + " ")
+        sys.stdout.flush()
+        t1 = clock()
+        doctest.run_docstring_examples(globs[obj], {}, verbose=("-v" in sys.argv))
+        t2 = clock()
+        print(round(t2-t1, 3))
+
+if __name__ == '__main__':
+    doctests()
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..35bbc2ea6a8d43c59429730b37bf77a1802893cb
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/ctx_base.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_base.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba7ec99a9b7ba8a4d7ea3dd139ad658a49a245cb
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_base.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/ctx_fp.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_fp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7736d81b4ec07fe9c7317a8e7feb91c61befefb
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_fp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/ctx_iv.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_iv.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..04adf523c0a6f1cfcba147daebb6725fc9ffdfd1
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_iv.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/ctx_mp.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_mp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a06436dd34b7b4aabc68be3b46f27f14262906bb
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_mp.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/ctx_mp_python.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_mp_python.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e617ea558e9907901f5159a57c0964f7b8f6845
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/ctx_mp_python.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/function_docs.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/function_docs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7acedeb7b8c61a8f9233cc42e35e9ff8d5d6bc2
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/function_docs.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/identification.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/identification.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..721334634527c201a455fbfc0cff5cc8615e08e2
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/identification.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/math2.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/math2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..48205a0a5fafcacc620c83fa97bcfc78d496bcc1
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/math2.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/rational.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/rational.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed93f8dbda7d0b7f2e5a10ee58772fff7423e44e
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/rational.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/usertools.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/usertools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4e43e7ad68d1ee2138c6ad80c0bf0c8fdac4751
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/usertools.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/__pycache__/visualization.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/__pycache__/visualization.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..874b6c60820b7e6823756d2d97d3622081a62ae7
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/__pycache__/visualization.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__init__.py b/lib/python3.11/site-packages/mpmath/calculus/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..040a3806b968f75b8d1a88ae37a4979fe83d466a
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/__init__.py
@@ -0,0 +1,6 @@
+from . import calculus
+# XXX: hack to set methods
+from . import approximation
+from . import differentiation
+from . import extrapolation
+from . import polynomials
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb29142d963d59092ff1899c752c6d3fa4ca308e
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/approximation.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/approximation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76b48b036b5211504bc3429dd348459a206445d8
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/approximation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/calculus.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/calculus.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..de23748cef51e371affbacc4fa92d80068c975a6
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/calculus.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/differentiation.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/differentiation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a2c95b171356c2adf40a66bbdd4dba65cd447348
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/differentiation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/extrapolation.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/extrapolation.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42278a3489738766842ce2f86e41cd2896898b8c
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/extrapolation.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/inverselaplace.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/inverselaplace.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e7fe0c16d138ea81f9e57682d26e0b7cc757408
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/inverselaplace.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/odes.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/odes.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cfcf95436c7663fbd075fc93ac6adda2ed9fba6d
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/odes.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/optimization.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/optimization.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a756f447e5f32ae49472a1b892cd0e3f3bd504b
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/optimization.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/polynomials.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/polynomials.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c71e4f97b8cd6e6cc8ac33baef81991f98a54f3f
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/polynomials.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/__pycache__/quadrature.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/quadrature.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3c5ea0b4d7364aea59c23b6961d454ed236d48a6
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/calculus/__pycache__/quadrature.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/calculus/approximation.py b/lib/python3.11/site-packages/mpmath/calculus/approximation.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ca5cc598fb53491cb6ae4a41a40477c58544d53
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/approximation.py
@@ -0,0 +1,246 @@
+from ..libmp.backend import xrange
+from .calculus import defun
+
+#----------------------------------------------------------------------------#
+#                              Approximation methods                         #
+#----------------------------------------------------------------------------#
+
+# The Chebyshev approximation formula is given at:
+# http://mathworld.wolfram.com/ChebyshevApproximationFormula.html
+
+# The only major changes in the following code is that we return the
+# expanded polynomial coefficients instead of Chebyshev coefficients,
+# and that we automatically transform [a,b] -> [-1,1] and back
+# for convenience.
+
+# Coefficient in Chebyshev approximation
+def chebcoeff(ctx,f,a,b,j,N):
+    s = ctx.mpf(0)
+    h = ctx.mpf(0.5)
+    for k in range(1, N+1):
+        t = ctx.cospi((k-h)/N)
+        s += f(t*(b-a)*h + (b+a)*h) * ctx.cospi(j*(k-h)/N)
+    return 2*s/N
+
+# Generate Chebyshev polynomials T_n(ax+b) in expanded form
+def chebT(ctx, a=1, b=0):
+    Tb = [1]
+    yield Tb
+    Ta = [b, a]
+    while 1:
+        yield Ta
+        # Recurrence: T[n+1](ax+b) = 2*(ax+b)*T[n](ax+b) - T[n-1](ax+b)
+        Tmp = [0] + [2*a*t for t in Ta]
+        for i, c in enumerate(Ta): Tmp[i] += 2*b*c
+        for i, c in enumerate(Tb): Tmp[i] -= c
+        Ta, Tb = Tmp, Ta
+
+@defun
+def chebyfit(ctx, f, interval, N, error=False):
+    r"""
+    Computes a polynomial of degree `N-1` that approximates the
+    given function `f` on the interval `[a, b]`. With ``error=True``,
+    :func:`~mpmath.chebyfit` also returns an accurate estimate of the
+    maximum absolute error; that is, the maximum value of
+    `|f(x) - P(x)|` for `x \in [a, b]`.
+
+    :func:`~mpmath.chebyfit` uses the Chebyshev approximation formula,
+    which gives a nearly optimal solution: that is, the maximum
+    error of the approximating polynomial is very close to
+    the smallest possible for any polynomial of the same degree.
+
+    Chebyshev approximation is very useful if one needs repeated
+    evaluation of an expensive function, such as function defined
+    implicitly by an integral or a differential equation. (For
+    example, it could be used to turn a slow mpmath function
+    into a fast machine-precision version of the same.)
+
+    **Examples**
+
+    Here we use :func:`~mpmath.chebyfit` to generate a low-degree approximation
+    of `f(x) = \cos(x)`, valid on the interval `[1, 2]`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> poly, err = chebyfit(cos, [1, 2], 5, error=True)
+        >>> nprint(poly)
+        [0.00291682, 0.146166, -0.732491, 0.174141, 0.949553]
+        >>> nprint(err, 12)
+        1.61351758081e-5
+
+    The polynomial can be evaluated using ``polyval``::
+
+        >>> nprint(polyval(poly, 1.6), 12)
+        -0.0291858904138
+        >>> nprint(cos(1.6), 12)
+        -0.0291995223013
+
+    Sampling the true error at 1000 points shows that the error
+    estimate generated by ``chebyfit`` is remarkably good::
+
+        >>> error = lambda x: abs(cos(x) - polyval(poly, x))
+        >>> nprint(max([error(1+n/1000.) for n in range(1000)]), 12)
+        1.61349954245e-5
+
+    **Choice of degree**
+
+    The degree `N` can be set arbitrarily high, to obtain an
+    arbitrarily good approximation. As a rule of thumb, an
+    `N`-term Chebyshev approximation is good to `N/(b-a)` decimal
+    places on a unit interval (although this depends on how
+    well-behaved `f` is). The cost grows accordingly: ``chebyfit``
+    evaluates the function `(N^2)/2` times to compute the
+    coefficients and an additional `N` times to estimate the error.
+
+    **Possible issues**
+
+    One should be careful to use a sufficiently high working
+    precision both when calling ``chebyfit`` and when evaluating
+    the resulting polynomial, as the polynomial is sometimes
+    ill-conditioned. It is for example difficult to reach
+    15-digit accuracy when evaluating the polynomial using
+    machine precision floats, no matter the theoretical
+    accuracy of the polynomial. (The option to return the
+    coefficients in Chebyshev form should be made available
+    in the future.)
+
+    It is important to note the Chebyshev approximation works
+    poorly if `f` is not smooth. A function containing singularities,
+    rapid oscillation, etc can be approximated more effectively by
+    multiplying it by a weight function that cancels out the
+    nonsmooth features, or by dividing the interval into several
+    segments.
+    """
+    a, b = ctx._as_points(interval)
+    orig = ctx.prec
+    try:
+        ctx.prec = orig + int(N**0.5) + 20
+        c = [chebcoeff(ctx,f,a,b,k,N) for k in range(N)]
+        d = [ctx.zero] * N
+        d[0] = -c[0]/2
+        h = ctx.mpf(0.5)
+        T = chebT(ctx, ctx.mpf(2)/(b-a), ctx.mpf(-1)*(b+a)/(b-a))
+        for (k, Tk) in zip(range(N), T):
+            for i in range(len(Tk)):
+                d[i] += c[k]*Tk[i]
+        d = d[::-1]
+        # Estimate maximum error
+        err = ctx.zero
+        for k in range(N):
+            x = ctx.cos(ctx.pi*k/N) * (b-a)*h + (b+a)*h
+            err = max(err, abs(f(x) - ctx.polyval(d, x)))
+    finally:
+        ctx.prec = orig
+    if error:
+        return d, +err
+    else:
+        return d
+
+@defun
+def fourier(ctx, f, interval, N):
+    r"""
+    Computes the Fourier series of degree `N` of the given function
+    on the interval `[a, b]`. More precisely, :func:`~mpmath.fourier` returns
+    two lists `(c, s)` of coefficients (the cosine series and sine
+    series, respectively), such that
+
+    .. math ::
+
+        f(x) \sim \sum_{k=0}^N
+            c_k \cos(k m x) + s_k \sin(k m x)
+
+    where `m = 2 \pi / (b-a)`.
+
+    Note that many texts define the first coefficient as `2 c_0` instead
+    of `c_0`. The easiest way to evaluate the computed series correctly
+    is to pass it to :func:`~mpmath.fourierval`.
+
+    **Examples**
+
+    The function `f(x) = x` has a simple Fourier series on the standard
+    interval `[-\pi, \pi]`. The cosine coefficients are all zero (because
+    the function has odd symmetry), and the sine coefficients are
+    rational numbers::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> c, s = fourier(lambda x: x, [-pi, pi], 5)
+        >>> nprint(c)
+        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+        >>> nprint(s)
+        [0.0, 2.0, -1.0, 0.666667, -0.5, 0.4]
+
+    This computes a Fourier series of a nonsymmetric function on
+    a nonstandard interval::
+
+        >>> I = [-1, 1.5]
+        >>> f = lambda x: x**2 - 4*x + 1
+        >>> cs = fourier(f, I, 4)
+        >>> nprint(cs[0])
+        [0.583333, 1.12479, -1.27552, 0.904708, -0.441296]
+        >>> nprint(cs[1])
+        [0.0, -2.6255, 0.580905, 0.219974, -0.540057]
+
+    It is instructive to plot a function along with its truncated
+    Fourier series::
+
+        >>> plot([f, lambda x: fourierval(cs, I, x)], I) #doctest: +SKIP
+
+    Fourier series generally converge slowly (and may not converge
+    pointwise). For example, if `f(x) = \cosh(x)`, a 10-term Fourier
+    series gives an `L^2` error corresponding to 2-digit accuracy::
+
+        >>> I = [-1, 1]
+        >>> cs = fourier(cosh, I, 9)
+        >>> g = lambda x: (cosh(x) - fourierval(cs, I, x))**2
+        >>> nprint(sqrt(quad(g, I)))
+        0.00467963
+
+    :func:`~mpmath.fourier` uses numerical quadrature. For nonsmooth functions,
+    the accuracy (and speed) can be improved by including all singular
+    points in the interval specification::
+
+        >>> nprint(fourier(abs, [-1, 1], 0), 10)
+        ([0.5000441648], [0.0])
+        >>> nprint(fourier(abs, [-1, 0, 1], 0), 10)
+        ([0.5], [0.0])
+
+    """
+    interval = ctx._as_points(interval)
+    a = interval[0]
+    b = interval[-1]
+    L = b-a
+    cos_series = []
+    sin_series = []
+    cutoff = ctx.eps*10
+    for n in xrange(N+1):
+        m = 2*n*ctx.pi/L
+        an = 2*ctx.quadgl(lambda t: f(t)*ctx.cos(m*t), interval)/L
+        bn = 2*ctx.quadgl(lambda t: f(t)*ctx.sin(m*t), interval)/L
+        if n == 0:
+            an /= 2
+        if abs(an) < cutoff: an = ctx.zero
+        if abs(bn) < cutoff: bn = ctx.zero
+        cos_series.append(an)
+        sin_series.append(bn)
+    return cos_series, sin_series
+
+@defun
+def fourierval(ctx, series, interval, x):
+    """
+    Evaluates a Fourier series (in the format computed by
+    by :func:`~mpmath.fourier` for the given interval) at the point `x`.
+
+    The series should be a pair `(c, s)` where `c` is the
+    cosine series and `s` is the sine series. The two lists
+    need not have the same length.
+    """
+    cs, ss = series
+    ab = ctx._as_points(interval)
+    a = interval[0]
+    b = interval[-1]
+    m = 2*ctx.pi/(ab[-1]-ab[0])
+    s = ctx.zero
+    s += ctx.fsum(cs[n]*ctx.cos(m*n*x) for n in xrange(len(cs)) if cs[n])
+    s += ctx.fsum(ss[n]*ctx.sin(m*n*x) for n in xrange(len(ss)) if ss[n])
+    return s
diff --git a/lib/python3.11/site-packages/mpmath/calculus/calculus.py b/lib/python3.11/site-packages/mpmath/calculus/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..24256f121d6c07e5ce954f2a5f5024f156f64016
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/calculus.py
@@ -0,0 +1,6 @@
+class CalculusMethods(object):
+    pass
+
+def defun(f):
+    setattr(CalculusMethods, f.__name__, f)
+    return f
diff --git a/lib/python3.11/site-packages/mpmath/calculus/differentiation.py b/lib/python3.11/site-packages/mpmath/calculus/differentiation.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8186bebd4476476eded9e4b2f8dc3eb23ef5ff9
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/differentiation.py
@@ -0,0 +1,647 @@
+from ..libmp.backend import xrange
+from .calculus import defun
+
+try:
+    iteritems = dict.iteritems
+except AttributeError:
+    iteritems = dict.items
+
+#----------------------------------------------------------------------------#
+#                                Differentiation                             #
+#----------------------------------------------------------------------------#
+
+@defun
+def difference(ctx, s, n):
+    r"""
+    Given a sequence `(s_k)` containing at least `n+1` items, returns the
+    `n`-th forward difference,
+
+    .. math ::
+
+        \Delta^n = \sum_{k=0}^{\infty} (-1)^{k+n} {n \choose k} s_k.
+    """
+    n = int(n)
+    d = ctx.zero
+    b = (-1) ** (n & 1)
+    for k in xrange(n+1):
+        d += b * s[k]
+        b = (b * (k-n)) // (k+1)
+    return d
+
+def hsteps(ctx, f, x, n, prec, **options):
+    singular = options.get('singular')
+    addprec = options.get('addprec', 10)
+    direction = options.get('direction', 0)
+    workprec = (prec+2*addprec) * (n+1)
+    orig = ctx.prec
+    try:
+        ctx.prec = workprec
+        h = options.get('h')
+        if h is None:
+            if options.get('relative'):
+                hextramag = int(ctx.mag(x))
+            else:
+                hextramag = 0
+            h = ctx.ldexp(1, -prec-addprec-hextramag)
+        else:
+            h = ctx.convert(h)
+        # Directed: steps x, x+h, ... x+n*h
+        direction = options.get('direction', 0)
+        if direction:
+            h *= ctx.sign(direction)
+            steps = xrange(n+1)
+            norm = h
+        # Central: steps x-n*h, x-(n-2)*h ..., x, ..., x+(n-2)*h, x+n*h
+        else:
+            steps = xrange(-n, n+1, 2)
+            norm = (2*h)
+        # Perturb
+        if singular:
+            x += 0.5*h
+        values = [f(x+k*h) for k in steps]
+        return values, norm, workprec
+    finally:
+        ctx.prec = orig
+
+
+@defun
+def diff(ctx, f, x, n=1, **options):
+    r"""
+    Numerically computes the derivative of `f`, `f'(x)`, or generally for
+    an integer `n \ge 0`, the `n`-th derivative `f^{(n)}(x)`.
+    A few basic examples are::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> diff(lambda x: x**2 + x, 1.0)
+        3.0
+        >>> diff(lambda x: x**2 + x, 1.0, 2)
+        2.0
+        >>> diff(lambda x: x**2 + x, 1.0, 3)
+        0.0
+        >>> nprint([diff(exp, 3, n) for n in range(5)])   # exp'(x) = exp(x)
+        [20.0855, 20.0855, 20.0855, 20.0855, 20.0855]
+
+    Even more generally, given a tuple of arguments `(x_1, \ldots, x_k)`
+    and order `(n_1, \ldots, n_k)`, the partial derivative
+    `f^{(n_1,\ldots,n_k)}(x_1,\ldots,x_k)` is evaluated. For example::
+
+        >>> diff(lambda x,y: 3*x*y + 2*y - x, (0.25, 0.5), (0,1))
+        2.75
+        >>> diff(lambda x,y: 3*x*y + 2*y - x, (0.25, 0.5), (1,1))
+        3.0
+
+    **Options**
+
+    The following optional keyword arguments are recognized:
+
+    ``method``
+        Supported methods are ``'step'`` or ``'quad'``: derivatives may be
+        computed using either a finite difference with a small step
+        size `h` (default), or numerical quadrature.
+    ``direction``
+        Direction of finite difference: can be -1 for a left
+        difference, 0 for a central difference (default), or +1
+        for a right difference; more generally can be any complex number.
+    ``addprec``
+        Extra precision for `h` used to account for the function's
+        sensitivity to perturbations (default = 10).
+    ``relative``
+        Choose `h` relative to the magnitude of `x`, rather than an
+        absolute value; useful for large or tiny `x` (default = False).
+    ``h``
+        As an alternative to ``addprec`` and ``relative``, manually
+        select the step size `h`.
+    ``singular``
+        If True, evaluation exactly at the point `x` is avoided; this is
+        useful for differentiating functions with removable singularities.
+        Default = False.
+    ``radius``
+        Radius of integration contour (with ``method = 'quad'``).
+        Default = 0.25. A larger radius typically is faster and more
+        accurate, but it must be chosen so that `f` has no
+        singularities within the radius from the evaluation point.
+
+    A finite difference requires `n+1` function evaluations and must be
+    performed at `(n+1)` times the target precision. Accordingly, `f` must
+    support fast evaluation at high precision.
+
+    With integration, a larger number of function evaluations is
+    required, but not much extra precision is required. For high order
+    derivatives, this method may thus be faster if f is very expensive to
+    evaluate at high precision.
+
+    **Further examples**
+
+    The direction option is useful for computing left- or right-sided
+    derivatives of nonsmooth functions::
+
+        >>> diff(abs, 0, direction=0)
+        0.0
+        >>> diff(abs, 0, direction=1)
+        1.0
+        >>> diff(abs, 0, direction=-1)
+        -1.0
+
+    More generally, if the direction is nonzero, a right difference
+    is computed where the step size is multiplied by sign(direction).
+    For example, with direction=+j, the derivative from the positive
+    imaginary direction will be computed::
+
+        >>> diff(abs, 0, direction=j)
+        (0.0 - 1.0j)
+
+    With integration, the result may have a small imaginary part
+    even even if the result is purely real::
+
+        >>> diff(sqrt, 1, method='quad')    # doctest:+ELLIPSIS
+        (0.5 - 4.59...e-26j)
+        >>> chop(_)
+        0.5
+
+    Adding precision to obtain an accurate value::
+
+        >>> diff(cos, 1e-30)
+        0.0
+        >>> diff(cos, 1e-30, h=0.0001)
+        -9.99999998328279e-31
+        >>> diff(cos, 1e-30, addprec=100)
+        -1.0e-30
+
+    """
+    partial = False
+    try:
+        orders = list(n)
+        x = list(x)
+        partial = True
+    except TypeError:
+        pass
+    if partial:
+        x = [ctx.convert(_) for _ in x]
+        return _partial_diff(ctx, f, x, orders, options)
+    method = options.get('method', 'step')
+    if n == 0 and method != 'quad' and not options.get('singular'):
+        return f(ctx.convert(x))
+    prec = ctx.prec
+    try:
+        if method == 'step':
+            values, norm, workprec = hsteps(ctx, f, x, n, prec, **options)
+            ctx.prec = workprec
+            v = ctx.difference(values, n) / norm**n
+        elif method == 'quad':
+            ctx.prec += 10
+            radius = ctx.convert(options.get('radius', 0.25))
+            def g(t):
+                rei = radius*ctx.expj(t)
+                z = x + rei
+                return f(z) / rei**n
+            d = ctx.quadts(g, [0, 2*ctx.pi])
+            v = d * ctx.factorial(n) / (2*ctx.pi)
+        else:
+            raise ValueError("unknown method: %r" % method)
+    finally:
+        ctx.prec = prec
+    return +v
+
+def _partial_diff(ctx, f, xs, orders, options):
+    if not orders:
+        return f()
+    if not sum(orders):
+        return f(*xs)
+    i = 0
+    for i in range(len(orders)):
+        if orders[i]:
+            break
+    order = orders[i]
+    def fdiff_inner(*f_args):
+        def inner(t):
+            return f(*(f_args[:i] + (t,) + f_args[i+1:]))
+        return ctx.diff(inner, f_args[i], order, **options)
+    orders[i] = 0
+    return _partial_diff(ctx, fdiff_inner, xs, orders, options)
+
+@defun
+def diffs(ctx, f, x, n=None, **options):
+    r"""
+    Returns a generator that yields the sequence of derivatives
+
+    .. math ::
+
+        f(x), f'(x), f''(x), \ldots, f^{(k)}(x), \ldots
+
+    With ``method='step'``, :func:`~mpmath.diffs` uses only `O(k)`
+    function evaluations to generate the first `k` derivatives,
+    rather than the roughly `O(k^2)` evaluations
+    required if one calls :func:`~mpmath.diff` `k` separate times.
+
+    With `n < \infty`, the generator stops as soon as the
+    `n`-th derivative has been generated. If the exact number of
+    needed derivatives is known in advance, this is further
+    slightly more efficient.
+
+    Options are the same as for :func:`~mpmath.diff`.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 15
+        >>> nprint(list(diffs(cos, 1, 5)))
+        [0.540302, -0.841471, -0.540302, 0.841471, 0.540302, -0.841471]
+        >>> for i, d in zip(range(6), diffs(cos, 1)):
+        ...     print("%s %s" % (i, d))
+        ...
+        0 0.54030230586814
+        1 -0.841470984807897
+        2 -0.54030230586814
+        3 0.841470984807897
+        4 0.54030230586814
+        5 -0.841470984807897
+
+    """
+    if n is None:
+        n = ctx.inf
+    else:
+        n = int(n)
+    if options.get('method', 'step') != 'step':
+        k = 0
+        while k < n + 1:
+            yield ctx.diff(f, x, k, **options)
+            k += 1
+        return
+    singular = options.get('singular')
+    if singular:
+        yield ctx.diff(f, x, 0, singular=True)
+    else:
+        yield f(ctx.convert(x))
+    if n < 1:
+        return
+    if n == ctx.inf:
+        A, B = 1, 2
+    else:
+        A, B = 1, n+1
+    while 1:
+        callprec = ctx.prec
+        y, norm, workprec = hsteps(ctx, f, x, B, callprec, **options)
+        for k in xrange(A, B):
+            try:
+                ctx.prec = workprec
+                d = ctx.difference(y, k) / norm**k
+            finally:
+                ctx.prec = callprec
+            yield +d
+            if k >= n:
+                return
+        A, B = B, int(A*1.4+1)
+        B = min(B, n)
+
+def iterable_to_function(gen):
+    gen = iter(gen)
+    data = []
+    def f(k):
+        for i in xrange(len(data), k+1):
+            data.append(next(gen))
+        return data[k]
+    return f
+
+@defun
+def diffs_prod(ctx, factors):
+    r"""
+    Given a list of `N` iterables or generators yielding
+    `f_k(x), f'_k(x), f''_k(x), \ldots` for `k = 1, \ldots, N`,
+    generate `g(x), g'(x), g''(x), \ldots` where
+    `g(x) = f_1(x) f_2(x) \cdots f_N(x)`.
+
+    At high precision and for large orders, this is typically more efficient
+    than numerical differentiation if the derivatives of each `f_k(x)`
+    admit direct computation.
+
+    Note: This function does not increase the working precision internally,
+    so guard digits may have to be added externally for full accuracy.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> f = lambda x: exp(x)*cos(x)*sin(x)
+        >>> u = diffs(f, 1)
+        >>> v = mp.diffs_prod([diffs(exp,1), diffs(cos,1), diffs(sin,1)])
+        >>> next(u); next(v)
+        1.23586333600241
+        1.23586333600241
+        >>> next(u); next(v)
+        0.104658952245596
+        0.104658952245596
+        >>> next(u); next(v)
+        -5.96999877552086
+        -5.96999877552086
+        >>> next(u); next(v)
+        -12.4632923122697
+        -12.4632923122697
+
+    """
+    N = len(factors)
+    if N == 1:
+        for c in factors[0]:
+            yield c
+    else:
+        u = iterable_to_function(ctx.diffs_prod(factors[:N//2]))
+        v = iterable_to_function(ctx.diffs_prod(factors[N//2:]))
+        n = 0
+        while 1:
+            #yield sum(binomial(n,k)*u(n-k)*v(k) for k in xrange(n+1))
+            s = u(n) * v(0)
+            a = 1
+            for k in xrange(1,n+1):
+                a = a * (n-k+1) // k
+                s += a * u(n-k) * v(k)
+            yield s
+            n += 1
+
+def dpoly(n, _cache={}):
+    """
+    nth differentiation polynomial for exp (Faa di Bruno's formula).
+
+    TODO: most exponents are zero, so maybe a sparse representation
+    would be better.
+    """
+    if n in _cache:
+        return _cache[n]
+    if not _cache:
+        _cache[0] = {(0,):1}
+    R = dpoly(n-1)
+    R = dict((c+(0,),v) for (c,v) in iteritems(R))
+    Ra = {}
+    for powers, count in iteritems(R):
+        powers1 = (powers[0]+1,) + powers[1:]
+        if powers1 in Ra:
+            Ra[powers1] += count
+        else:
+            Ra[powers1] = count
+    for powers, count in iteritems(R):
+        if not sum(powers):
+            continue
+        for k,p in enumerate(powers):
+            if p:
+                powers2 = powers[:k] + (p-1,powers[k+1]+1) + powers[k+2:]
+                if powers2 in Ra:
+                    Ra[powers2] += p*count
+                else:
+                    Ra[powers2] = p*count
+    _cache[n] = Ra
+    return _cache[n]
+
+@defun
+def diffs_exp(ctx, fdiffs):
+    r"""
+    Given an iterable or generator yielding `f(x), f'(x), f''(x), \ldots`
+    generate `g(x), g'(x), g''(x), \ldots` where `g(x) = \exp(f(x))`.
+
+    At high precision and for large orders, this is typically more efficient
+    than numerical differentiation if the derivatives of `f(x)`
+    admit direct computation.
+
+    Note: This function does not increase the working precision internally,
+    so guard digits may have to be added externally for full accuracy.
+
+    **Examples**
+
+    The derivatives of the gamma function can be computed using
+    logarithmic differentiation::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>>
+        >>> def diffs_loggamma(x):
+        ...     yield loggamma(x)
+        ...     i = 0
+        ...     while 1:
+        ...         yield psi(i,x)
+        ...         i += 1
+        ...
+        >>> u = diffs_exp(diffs_loggamma(3))
+        >>> v = diffs(gamma, 3)
+        >>> next(u); next(v)
+        2.0
+        2.0
+        >>> next(u); next(v)
+        1.84556867019693
+        1.84556867019693
+        >>> next(u); next(v)
+        2.49292999190269
+        2.49292999190269
+        >>> next(u); next(v)
+        3.44996501352367
+        3.44996501352367
+
+    """
+    fn = iterable_to_function(fdiffs)
+    f0 = ctx.exp(fn(0))
+    yield f0
+    i = 1
+    while 1:
+        s = ctx.mpf(0)
+        for powers, c in iteritems(dpoly(i)):
+            s += c*ctx.fprod(fn(k+1)**p for (k,p) in enumerate(powers) if p)
+        yield s * f0
+        i += 1
+
+@defun
+def differint(ctx, f, x, n=1, x0=0):
+    r"""
+    Calculates the Riemann-Liouville differintegral, or fractional
+    derivative, defined by
+
+    .. math ::
+
+        \,_{x_0}{\mathbb{D}}^n_xf(x) = \frac{1}{\Gamma(m-n)} \frac{d^m}{dx^m}
+        \int_{x_0}^{x}(x-t)^{m-n-1}f(t)dt
+
+    where `f` is a given (presumably well-behaved) function,
+    `x` is the evaluation point, `n` is the order, and `x_0` is
+    the reference point of integration (`m` is an arbitrary
+    parameter selected automatically).
+
+    With `n = 1`, this is just the standard derivative `f'(x)`; with `n = 2`,
+    the second derivative `f''(x)`, etc. With `n = -1`, it gives
+    `\int_{x_0}^x f(t) dt`, with `n = -2`
+    it gives `\int_{x_0}^x \left( \int_{x_0}^t f(u) du \right) dt`, etc.
+
+    As `n` is permitted to be any number, this operator generalizes
+    iterated differentiation and iterated integration to a single
+    operator with a continuous order parameter.
+
+    **Examples**
+
+    There is an exact formula for the fractional derivative of a
+    monomial `x^p`, which may be used as a reference. For example,
+    the following gives a half-derivative (order 0.5)::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> x = mpf(3); p = 2; n = 0.5
+        >>> differint(lambda t: t**p, x, n)
+        7.81764019044672
+        >>> gamma(p+1)/gamma(p-n+1) * x**(p-n)
+        7.81764019044672
+
+    Another useful test function is the exponential function, whose
+    integration / differentiation formula easy generalizes
+    to arbitrary order. Here we first compute a third derivative,
+    and then a triply nested integral. (The reference point `x_0`
+    is set to `-\infty` to avoid nonzero endpoint terms.)::
+
+        >>> differint(lambda x: exp(pi*x), -1.5, 3)
+        0.278538406900792
+        >>> exp(pi*-1.5) * pi**3
+        0.278538406900792
+        >>> differint(lambda x: exp(pi*x), 3.5, -3, -inf)
+        1922.50563031149
+        >>> exp(pi*3.5) / pi**3
+        1922.50563031149
+
+    However, for noninteger `n`, the differentiation formula for the
+    exponential function must be modified to give the same result as the
+    Riemann-Liouville differintegral::
+
+        >>> x = mpf(3.5)
+        >>> c = pi
+        >>> n = 1+2*j
+        >>> differint(lambda x: exp(c*x), x, n)
+        (-123295.005390743 + 140955.117867654j)
+        >>> x**(-n) * exp(c)**x * (x*c)**n * gammainc(-n, 0, x*c) / gamma(-n)
+        (-123295.005390743 + 140955.117867654j)
+
+
+    """
+    m = max(int(ctx.ceil(ctx.re(n)))+1, 1)
+    r = m-n-1
+    g = lambda x: ctx.quad(lambda t: (x-t)**r * f(t), [x0, x])
+    return ctx.diff(g, x, m) / ctx.gamma(m-n)
+
+@defun
+def diffun(ctx, f, n=1, **options):
+    r"""
+    Given a function `f`, returns a function `g(x)` that evaluates the nth
+    derivative `f^{(n)}(x)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> cos2 = diffun(sin)
+        >>> sin2 = diffun(sin, 4)
+        >>> cos(1.3), cos2(1.3)
+        (0.267498828624587, 0.267498828624587)
+        >>> sin(1.3), sin2(1.3)
+        (0.963558185417193, 0.963558185417193)
+
+    The function `f` must support arbitrary precision evaluation.
+    See :func:`~mpmath.diff` for additional details and supported
+    keyword options.
+    """
+    if n == 0:
+        return f
+    def g(x):
+        return ctx.diff(f, x, n, **options)
+    return g
+
+@defun
+def taylor(ctx, f, x, n, **options):
+    r"""
+    Produces a degree-`n` Taylor polynomial around the point `x` of the
+    given function `f`. The coefficients are returned as a list.
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nprint(chop(taylor(sin, 0, 5)))
+        [0.0, 1.0, 0.0, -0.166667, 0.0, 0.00833333]
+
+    The coefficients are computed using high-order numerical
+    differentiation. The function must be possible to evaluate
+    to arbitrary precision. See :func:`~mpmath.diff` for additional details
+    and supported keyword options.
+
+    Note that to evaluate the Taylor polynomial as an approximation
+    of `f`, e.g. with :func:`~mpmath.polyval`, the coefficients must be reversed,
+    and the point of the Taylor expansion must be subtracted from
+    the argument:
+
+        >>> p = taylor(exp, 2.0, 10)
+        >>> polyval(p[::-1], 2.5 - 2.0)
+        12.1824939606092
+        >>> exp(2.5)
+        12.1824939607035
+
+    """
+    gen = enumerate(ctx.diffs(f, x, n, **options))
+    if options.get("chop", True):
+        return [ctx.chop(d)/ctx.factorial(i) for i, d in gen]
+    else:
+        return [d/ctx.factorial(i) for i, d in gen]
+
+@defun
+def pade(ctx, a, L, M):
+    r"""
+    Computes a Pade approximation of degree `(L, M)` to a function.
+    Given at least `L+M+1` Taylor coefficients `a` approximating
+    a function `A(x)`, :func:`~mpmath.pade` returns coefficients of
+    polynomials `P, Q` satisfying
+
+    .. math ::
+
+        P = \sum_{k=0}^L p_k x^k
+
+        Q = \sum_{k=0}^M q_k x^k
+
+        Q_0 = 1
+
+        A(x) Q(x) = P(x) + O(x^{L+M+1})
+
+    `P(x)/Q(x)` can provide a good approximation to an analytic function
+    beyond the radius of convergence of its Taylor series (example
+    from G.A. Baker 'Essentials of Pade Approximants' Academic Press,
+    Ch.1A)::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> one = mpf(1)
+        >>> def f(x):
+        ...     return sqrt((one + 2*x)/(one + x))
+        ...
+        >>> a = taylor(f, 0, 6)
+        >>> p, q = pade(a, 3, 3)
+        >>> x = 10
+        >>> polyval(p[::-1], x)/polyval(q[::-1], x)
+        1.38169105566806
+        >>> f(x)
+        1.38169855941551
+
+    """
+    # To determine L+1 coefficients of P and M coefficients of Q
+    # L+M+1 coefficients of A must be provided
+    if len(a) < L+M+1:
+        raise ValueError("L+M+1 Coefficients should be provided")
+
+    if M == 0:
+        if L == 0:
+            return [ctx.one], [ctx.one]
+        else:
+            return a[:L+1], [ctx.one]
+
+    # Solve first
+    # a[L]*q[1] + ... + a[L-M+1]*q[M] = -a[L+1]
+    # ...
+    # a[L+M-1]*q[1] + ... + a[L]*q[M] = -a[L+M]
+    A = ctx.matrix(M)
+    for j in range(M):
+        for i in range(min(M, L+j+1)):
+            A[j, i] = a[L+j-i]
+    v = -ctx.matrix(a[(L+1):(L+M+1)])
+    x = ctx.lu_solve(A, v)
+    q = [ctx.one] + list(x)
+    # compute p
+    p = [0]*(L+1)
+    for i in range(L+1):
+        s = a[i]
+        for j in range(1, min(M,i) + 1):
+            s += q[j]*a[i-j]
+        p[i] = s
+    return p, q
diff --git a/lib/python3.11/site-packages/mpmath/calculus/extrapolation.py b/lib/python3.11/site-packages/mpmath/calculus/extrapolation.py
new file mode 100644
index 0000000000000000000000000000000000000000..7df0fea3c62c9b71ee24d3f39fd9b7fd3318ed23
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/extrapolation.py
@@ -0,0 +1,2115 @@
+try:
+    from itertools import izip
+except ImportError:
+    izip = zip
+
+from ..libmp.backend import xrange
+from .calculus import defun
+
+try:
+    next = next
+except NameError:
+    next = lambda _: _.next()
+
+@defun
+def richardson(ctx, seq):
+    r"""
+    Given a list ``seq`` of the first `N` elements of a slowly convergent
+    infinite sequence, :func:`~mpmath.richardson` computes the `N`-term
+    Richardson extrapolate for the limit.
+
+    :func:`~mpmath.richardson` returns `(v, c)` where `v` is the estimated
+    limit and `c` is the magnitude of the largest weight used during the
+    computation. The weight provides an estimate of the precision
+    lost to cancellation. Due to cancellation effects, the sequence must
+    be typically be computed at a much higher precision than the target
+    accuracy of the extrapolation.
+
+    **Applicability and issues**
+
+    The `N`-step Richardson extrapolation algorithm used by
+    :func:`~mpmath.richardson` is described in [1].
+
+    Richardson extrapolation only works for a specific type of sequence,
+    namely one converging like partial sums of
+    `P(1)/Q(1) + P(2)/Q(2) + \ldots` where `P` and `Q` are polynomials.
+    When the sequence does not convergence at such a rate
+    :func:`~mpmath.richardson` generally produces garbage.
+
+    Richardson extrapolation has the advantage of being fast: the `N`-term
+    extrapolate requires only `O(N)` arithmetic operations, and usually
+    produces an estimate that is accurate to `O(N)` digits. Contrast with
+    the Shanks transformation (see :func:`~mpmath.shanks`), which requires
+    `O(N^2)` operations.
+
+    :func:`~mpmath.richardson` is unable to produce an estimate for the
+    approximation error. One way to estimate the error is to perform
+    two extrapolations with slightly different `N` and comparing the
+    results.
+
+    Richardson extrapolation does not work for oscillating sequences.
+    As a simple workaround, :func:`~mpmath.richardson` detects if the last
+    three elements do not differ monotonically, and in that case
+    applies extrapolation only to the even-index elements.
+
+    **Example**
+
+    Applying Richardson extrapolation to the Leibniz series for `\pi`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 30; mp.pretty = True
+        >>> S = [4*sum(mpf(-1)**n/(2*n+1) for n in range(m))
+        ...     for m in range(1,30)]
+        >>> v, c = richardson(S[:10])
+        >>> v
+        3.2126984126984126984126984127
+        >>> nprint([v-pi, c])
+        [0.0711058, 2.0]
+
+        >>> v, c = richardson(S[:30])
+        >>> v
+        3.14159265468624052829954206226
+        >>> nprint([v-pi, c])
+        [1.09645e-9, 20833.3]
+
+    **References**
+
+    1. [BenderOrszag]_ pp. 375-376
+
+    """
+    if len(seq) < 3:
+        raise ValueError("seq should be of minimum length 3")
+    if ctx.sign(seq[-1]-seq[-2]) != ctx.sign(seq[-2]-seq[-3]):
+        seq = seq[::2]
+    N = len(seq)//2-1
+    s = ctx.zero
+    # The general weight is c[k] = (N+k)**N * (-1)**(k+N) / k! / (N-k)!
+    # To avoid repeated factorials, we simplify the quotient
+    # of successive weights to obtain a recurrence relation
+    c = (-1)**N * N**N / ctx.mpf(ctx._ifac(N))
+    maxc = 1
+    for k in xrange(N+1):
+        s += c * seq[N+k]
+        maxc = max(abs(c), maxc)
+        c *= (k-N)*ctx.mpf(k+N+1)**N
+        c /= ((1+k)*ctx.mpf(k+N)**N)
+    return s, maxc
+
+@defun
+def shanks(ctx, seq, table=None, randomized=False):
+    r"""
+    Given a list ``seq`` of the first `N` elements of a slowly
+    convergent infinite sequence `(A_k)`, :func:`~mpmath.shanks` computes the iterated
+    Shanks transformation `S(A), S(S(A)), \ldots, S^{N/2}(A)`. The Shanks
+    transformation often provides strong convergence acceleration,
+    especially if the sequence is oscillating.
+
+    The iterated Shanks transformation is computed using the Wynn
+    epsilon algorithm (see [1]). :func:`~mpmath.shanks` returns the full
+    epsilon table generated by Wynn's algorithm, which can be read
+    off as follows:
+
+    * The table is a list of lists forming a lower triangular matrix,
+      where higher row and column indices correspond to more accurate
+      values.
+    * The columns with even index hold dummy entries (required for the
+      computation) and the columns with odd index hold the actual
+      extrapolates.
+    * The last element in the last row is typically the most
+      accurate estimate of the limit.
+    * The difference to the third last element in the last row
+      provides an estimate of the approximation error.
+    * The magnitude of the second last element provides an estimate
+      of the numerical accuracy lost to cancellation.
+
+    For convenience, so the extrapolation is stopped at an odd index
+    so that ``shanks(seq)[-1][-1]`` always gives an estimate of the
+    limit.
+
+    Optionally, an existing table can be passed to :func:`~mpmath.shanks`.
+    This can be used to efficiently extend a previous computation after
+    new elements have been appended to the sequence. The table will
+    then be updated in-place.
+
+    **The Shanks transformation**
+
+    The Shanks transformation is defined as follows (see [2]): given
+    the input sequence `(A_0, A_1, \ldots)`, the transformed sequence is
+    given by
+
+    .. math ::
+
+        S(A_k) = \frac{A_{k+1}A_{k-1}-A_k^2}{A_{k+1}+A_{k-1}-2 A_k}
+
+    The Shanks transformation gives the exact limit `A_{\infty}` in a
+    single step if `A_k = A + a q^k`. Note in particular that it
+    extrapolates the exact sum of a geometric series in a single step.
+
+    Applying the Shanks transformation once often improves convergence
+    substantially for an arbitrary sequence, but the optimal effect is
+    obtained by applying it iteratively:
+    `S(S(A_k)), S(S(S(A_k))), \ldots`.
+
+    Wynn's epsilon algorithm provides an efficient way to generate
+    the table of iterated Shanks transformations. It reduces the
+    computation of each element to essentially a single division, at
+    the cost of requiring dummy elements in the table. See [1] for
+    details.
+
+    **Precision issues**
+
+    Due to cancellation effects, the sequence must be typically be
+    computed at a much higher precision than the target accuracy
+    of the extrapolation.
+
+    If the Shanks transformation converges to the exact limit (such
+    as if the sequence is a geometric series), then a division by
+    zero occurs. By default, :func:`~mpmath.shanks` handles this case by
+    terminating the iteration and returning the table it has
+    generated so far. With *randomized=True*, it will instead
+    replace the zero by a pseudorandom number close to zero.
+    (TODO: find a better solution to this problem.)
+
+    **Examples**
+
+    We illustrate by applying Shanks transformation to the Leibniz
+    series for `\pi`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 50
+        >>> S = [4*sum(mpf(-1)**n/(2*n+1) for n in range(m))
+        ...     for m in range(1,30)]
+        >>>
+        >>> T = shanks(S[:7])
+        >>> for row in T:
+        ...     nprint(row)
+        ...
+        [-0.75]
+        [1.25, 3.16667]
+        [-1.75, 3.13333, -28.75]
+        [2.25, 3.14524, 82.25, 3.14234]
+        [-2.75, 3.13968, -177.75, 3.14139, -969.937]
+        [3.25, 3.14271, 327.25, 3.14166, 3515.06, 3.14161]
+
+    The extrapolated accuracy is about 4 digits, and about 4 digits
+    may have been lost due to cancellation::
+
+        >>> L = T[-1]
+        >>> nprint([abs(L[-1] - pi), abs(L[-1] - L[-3]), abs(L[-2])])
+        [2.22532e-5, 4.78309e-5, 3515.06]
+
+    Now we extend the computation::
+
+        >>> T = shanks(S[:25], T)
+        >>> L = T[-1]
+        >>> nprint([abs(L[-1] - pi), abs(L[-1] - L[-3]), abs(L[-2])])
+        [3.75527e-19, 1.48478e-19, 2.96014e+17]
+
+    The value for pi is now accurate to 18 digits. About 18 digits may
+    also have been lost to cancellation.
+
+    Here is an example with a geometric series, where the convergence
+    is immediate (the sum is exactly 1)::
+
+        >>> mp.dps = 15
+        >>> for row in shanks([0.5, 0.75, 0.875, 0.9375, 0.96875]):
+        ...     nprint(row)
+        [4.0]
+        [8.0, 1.0]
+
+    **References**
+
+    1. [GravesMorris]_
+
+    2. [BenderOrszag]_ pp. 368-375
+
+    """
+    if len(seq) < 2:
+        raise ValueError("seq should be of minimum length 2")
+    if table:
+        START = len(table)
+    else:
+        START = 0
+        table = []
+    STOP = len(seq) - 1
+    if STOP & 1:
+        STOP -= 1
+    one = ctx.one
+    eps = +ctx.eps
+    if randomized:
+        from random import Random
+        rnd = Random()
+        rnd.seed(START)
+    for i in xrange(START, STOP):
+        row = []
+        for j in xrange(i+1):
+            if j == 0:
+                a, b = 0, seq[i+1]-seq[i]
+            else:
+                if j == 1:
+                    a = seq[i]
+                else:
+                    a = table[i-1][j-2]
+                b = row[j-1] - table[i-1][j-1]
+            if not b:
+                if randomized:
+                    b = (1 + rnd.getrandbits(10))*eps
+                elif i & 1:
+                    return table[:-1]
+                else:
+                    return table
+            row.append(a + one/b)
+        table.append(row)
+    return table
+
+
+class levin_class:
+    # levin: Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+    r"""
+    This interface implements Levin's (nonlinear) sequence transformation for
+    convergence acceleration and summation of divergent series. It performs
+    better than the Shanks/Wynn-epsilon algorithm for logarithmic convergent
+    or alternating divergent series.
+
+    Let *A* be the series we want to sum:
+
+    .. math ::
+
+        A = \sum_{k=0}^{\infty} a_k
+
+    Attention: all `a_k` must be non-zero!
+
+    Let `s_n` be the partial sums of this series:
+
+    .. math ::
+
+        s_n = \sum_{k=0}^n a_k.
+
+    **Methods**
+
+    Calling ``levin`` returns an object with the following methods.
+
+    ``update(...)`` works with the list of individual terms `a_k` of *A*, and
+    ``update_step(...)`` works with the list of partial sums `s_k` of *A*:
+
+    .. code ::
+
+        v, e = ...update([a_0, a_1,..., a_k])
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+    ``step(...)`` works with the individual terms `a_k` and ``step_psum(...)``
+    works with the partial sums `s_k`:
+
+    .. code ::
+
+        v, e = ...step(a_k)
+        v, e = ...step_psum(s_k)
+
+    *v* is the current estimate for *A*, and *e* is an error estimate which is
+    simply the difference between the current estimate and the last estimate.
+    One should not mix ``update``, ``update_psum``, ``step`` and ``step_psum``.
+
+    **A word of caution**
+
+    One can only hope for good results (i.e. convergence acceleration or
+    resummation) if the `s_n` have some well defind asymptotic behavior for
+    large `n` and are not erratic or random. Furthermore one usually needs very
+    high working precision because of the numerical cancellation. If the working
+    precision is insufficient, levin may produce silently numerical garbage.
+    Furthermore even if the Levin-transformation converges, in the general case
+    there is no proof that the result is mathematically sound. Only for very
+    special classes of problems one can prove that the Levin-transformation
+    converges to the expected result (for example Stieltjes-type integrals).
+    Furthermore the Levin-transform is quite expensive (i.e. slow) in comparison
+    to Shanks/Wynn-epsilon, Richardson & co.
+    In summary one can say that the Levin-transformation is powerful but
+    unreliable and that it may need a copious amount of working precision.
+
+    The Levin transform has several variants differing in the choice of weights.
+    Some variants are better suited for the possible flavours of convergence
+    behaviour of *A* than other variants:
+
+    .. code ::
+
+       convergence behaviour   levin-u   levin-t   levin-v   shanks/wynn-epsilon
+
+       logarithmic               +         -         +           -
+       linear                    +         +         +           +
+       alternating divergent     +         +         +           +
+
+         "+" means the variant is suitable,"-" means the variant is not suitable;
+         for comparison the Shanks/Wynn-epsilon transform is listed, too.
+
+    The variant is controlled though the variant keyword (i.e. ``variant="u"``,
+    ``variant="t"`` or ``variant="v"``). Overall "u" is probably the best choice.
+
+    Finally it is possible to use the Sidi-S transform instead of the Levin transform
+    by using the keyword ``method='sidi'``. The Sidi-S transform works better than the
+    Levin transformation for some divergent series (see the examples).
+
+    Parameters:
+
+    .. code ::
+
+       method      "levin" or "sidi" chooses either the Levin or the Sidi-S transformation
+       variant     "u","t" or "v" chooses the weight variant.
+
+    The Levin transform is also accessible through the nsum interface.
+    ``method="l"`` or ``method="levin"`` select the normal Levin transform while
+    ``method="sidi"``
+    selects the Sidi-S transform. The variant is in both cases selected through the
+    levin_variant keyword. The stepsize in :func:`~mpmath.nsum` must not be chosen too large, otherwise
+    it will miss the point where the Levin transform converges resulting in numerical
+    overflow/garbage. For highly divergent series a copious amount of working precision
+    must be chosen.
+
+    **Examples**
+
+    First we sum the zeta function::
+
+        >>> from mpmath import mp
+        >>> mp.prec = 53
+        >>> eps = mp.mpf(mp.eps)
+        >>> with mp.extraprec(2 * mp.prec): # levin needs a high working precision
+        ...     L = mp.levin(method = "levin", variant = "u")
+        ...     S, s, n = [], 0, 1
+        ...     while 1:
+        ...         s += mp.one / (n * n)
+        ...         n += 1
+        ...         S.append(s)
+        ...         v, e = L.update_psum(S)
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - mp.pi ** 2 / 6))
+        0.0
+        >>> w = mp.nsum(lambda n: 1 / (n*n), [1, mp.inf], method = "levin", levin_variant = "u")
+        >>> print(mp.chop(v - w))
+        0.0
+
+    Now we sum the zeta function outside its range of convergence
+    (attention: This does not work at the negative integers!)::
+
+        >>> eps = mp.mpf(mp.eps)
+        >>> with mp.extraprec(2 * mp.prec): # levin needs a high working precision
+        ...     L = mp.levin(method = "levin", variant = "v")
+        ...     A, n = [], 1
+        ...     while 1:
+        ...         s = mp.mpf(n) ** (2 + 3j)
+        ...         n += 1
+        ...         A.append(s)
+        ...         v, e = L.update(A)
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - mp.zeta(-2-3j)))
+        0.0
+        >>> w = mp.nsum(lambda n: n ** (2 + 3j), [1, mp.inf], method = "levin", levin_variant = "v")
+        >>> print(mp.chop(v - w))
+        0.0
+
+    Now we sum the divergent asymptotic expansion of an integral related to the
+    exponential integral (see also [2] p.373). The Sidi-S transform works best here::
+
+        >>> z = mp.mpf(10)
+        >>> exact = mp.quad(lambda x: mp.exp(-x)/(1+x/z),[0,mp.inf])
+        >>> # exact = z * mp.exp(z) * mp.expint(1,z) # this is the symbolic expression for the integral
+        >>> eps = mp.mpf(mp.eps)
+        >>> with mp.extraprec(2 * mp.prec): # high working precisions are mandatory for divergent resummation
+        ...     L = mp.levin(method = "sidi", variant = "t")
+        ...     n = 0
+        ...     while 1:
+        ...         s = (-1)**n * mp.fac(n) * z ** (-n)
+        ...         v, e = L.step(s)
+        ...         n += 1
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - exact))
+        0.0
+        >>> w = mp.nsum(lambda n: (-1) ** n * mp.fac(n) * z ** (-n), [0, mp.inf], method = "sidi", levin_variant = "t")
+        >>> print(mp.chop(v - w))
+        0.0
+
+    Another highly divergent integral is also summable::
+
+        >>> z = mp.mpf(2)
+        >>> eps = mp.mpf(mp.eps)
+        >>> exact = mp.quad(lambda x: mp.exp( -x * x / 2 - z * x ** 4), [0,mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
+        >>> # exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi)) # this is the symbolic expression for the integral
+        >>> with mp.extraprec(7 * mp.prec):  # we need copious amount of precision to sum this highly divergent series
+        ...     L = mp.levin(method = "levin", variant = "t")
+        ...     n, s = 0, 0
+        ...     while 1:
+        ...         s += (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n))
+        ...         n += 1
+        ...         v, e = L.step_psum(s)
+        ...         if e < eps:
+        ...             break
+        ...         if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - exact))
+        0.0
+        >>> w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n)),
+        ...   [0, mp.inf], method = "levin", levin_variant = "t", workprec = 8*mp.prec, steps = [2] + [1 for x in xrange(1000)])
+        >>> print(mp.chop(v - w))
+        0.0
+
+    These examples run with 15-20 decimal digits precision. For higher precision the
+    working precision must be raised.
+
+    **Examples for nsum**
+
+    Here we calculate Euler's constant as the constant term in the Laurent
+    expansion of `\zeta(s)` at `s=1`. This sum converges extremly slowly because of
+    the logarithmic convergence behaviour of the Dirichlet series for zeta::
+
+        >>> mp.dps = 30
+        >>> z = mp.mpf(10) ** (-10)
+        >>> a = mp.nsum(lambda n: n**(-(1+z)), [1, mp.inf], method = "l") - 1 / z
+        >>> print(mp.chop(a - mp.euler, tol = 1e-10))
+        0.0
+
+    The Sidi-S transform performs excellently for the alternating series of `\log(2)`::
+
+        >>> a = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "sidi")
+        >>> print(mp.chop(a - mp.log(2)))
+        0.0
+
+    Hypergeometric series can also be summed outside their range of convergence.
+    The stepsize in :func:`~mpmath.nsum` must not be chosen too large, otherwise it will miss the
+    point where the Levin transform converges resulting in numerical overflow/garbage::
+
+        >>> z = 2 + 1j
+        >>> exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
+        >>> f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
+        >>> v = mp.nsum(f, [0, mp.inf], method = "levin", steps = [10 for x in xrange(1000)])
+        >>> print(mp.chop(exact-v))
+        0.0
+
+    References:
+
+      [1] E.J. Weniger - "Nonlinear Sequence Transformations for the Acceleration of
+          Convergence and the Summation of Divergent Series" arXiv:math/0306302
+
+      [2] A. Sidi - "Pratical Extrapolation Methods"
+
+      [3] H.H.H. Homeier - "Scalar Levin-Type Sequence Transformations" arXiv:math/0005209
+
+    """
+
+    def __init__(self, method = "levin", variant = "u"):
+        self.variant = variant
+        self.n = 0
+        self.a0 = 0
+        self.theta = 1
+        self.A = []
+        self.B = []
+        self.last = 0
+        self.last_s = False
+
+        if method == "levin":
+            self.factor = self.factor_levin
+        elif method == "sidi":
+            self.factor = self.factor_sidi
+        else:
+            raise ValueError("levin: unknown method \"%s\"" % method)
+
+    def factor_levin(self, i):
+        # original levin
+        # [1] p.50,e.7.5-7 (with n-j replaced by i)
+        return (self.theta + i) * (self.theta + self.n - 1) ** (self.n - i - 2) / self.ctx.mpf(self.theta + self.n) ** (self.n - i - 1)
+
+    def factor_sidi(self, i):
+        # sidi analogon to levin (factorial series)
+        # [1] p.59,e.8.3-16 (with n-j replaced by i)
+        return (self.theta + self.n - 1) * (self.theta + self.n - 2) / self.ctx.mpf((self.theta + 2 * self.n - i - 2) * (self.theta + 2 * self.n - i - 3))
+
+    def run(self, s, a0, a1 = 0):
+        if self.variant=="t":
+            # levin t
+            w=a0
+        elif self.variant=="u":
+            # levin u
+            w=a0*(self.theta+self.n)
+        elif self.variant=="v":
+            # levin v
+            w=a0*a1/(a0-a1)
+        else:
+            assert False, "unknown variant"
+
+        if w==0:
+            raise ValueError("levin: zero weight")
+
+        self.A.append(s/w)
+        self.B.append(1/w)
+
+        for i in range(self.n-1,-1,-1):
+            if i==self.n-1:
+                f=1
+            else:
+                f=self.factor(i)
+
+            self.A[i]=self.A[i+1]-f*self.A[i]
+            self.B[i]=self.B[i+1]-f*self.B[i]
+
+        self.n+=1
+
+    ###########################################################################
+
+    def update_psum(self,S):
+        """
+        This routine applies the convergence acceleration to the list of partial sums.
+
+        A   = sum(a_k, k = 0..infinity)
+        s_n = sum(a_k, k = 0..n)
+
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.run(S[0],S[0])
+            while self.n<len(S):
+                self.run(S[self.n],S[self.n]-S[self.n-1])
+        else:
+            if len(S)==1:
+                self.last=0
+                return S[0],abs(S[0])
+
+            if self.n==0:
+                self.a1=S[1]-S[0]
+                self.run(S[0],S[0],self.a1)
+
+            while self.n<len(S)-1:
+                na1=S[self.n+1]-S[self.n]
+                self.run(S[self.n],self.a1,na1)
+                self.a1=na1
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+    def update(self,X):
+        """
+        This routine applies the convergence acceleration to the list of individual terms.
+
+        A = sum(a_k, k = 0..infinity)
+
+        v, e = ...update([a_0, a_1,..., a_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.s=X[0]
+                self.run(self.s,X[0])
+            while self.n<len(X):
+                self.s+=X[self.n]
+                self.run(self.s,X[self.n])
+        else:
+            if len(X)==1:
+                self.last=0
+                return X[0],abs(X[0])
+
+            if self.n==0:
+                self.s=X[0]
+                self.run(self.s,X[0],X[1])
+
+            while self.n<len(X)-1:
+                self.s+=X[self.n]
+                self.run(self.s,X[self.n],X[self.n+1])
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+    ###########################################################################
+
+    def step_psum(self,s):
+        """
+        This routine applies the convergence acceleration to the partial sums.
+
+        A   = sum(a_k, k = 0..infinity)
+        s_n = sum(a_k, k = 0..n)
+
+        v, e = ...step_psum(s_k)
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.last_s=s
+                self.run(s,s)
+            else:
+                self.run(s,s-self.last_s)
+                self.last_s=s
+        else:
+            if isinstance(self.last_s,bool):
+                self.last_s=s
+                self.last_w=s
+                self.last=0
+                return s,abs(s)
+
+            na1=s-self.last_s
+            self.run(self.last_s,self.last_w,na1)
+            self.last_w=na1
+            self.last_s=s
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+    def step(self,x):
+        """
+        This routine applies the convergence acceleration to the individual terms.
+
+        A = sum(a_k, k = 0..infinity)
+
+        v, e = ...step(a_k)
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        if self.variant!="v":
+            if self.n==0:
+                self.s=x
+                self.run(self.s,x)
+            else:
+                self.s+=x
+                self.run(self.s,x)
+        else:
+            if isinstance(self.last_s,bool):
+                self.last_s=x
+                self.s=0
+                self.last=0
+                return x,abs(x)
+
+            self.s+=self.last_s
+            self.run(self.s,self.last_s,x)
+            self.last_s=x
+
+        value=self.A[0]/self.B[0]
+        err=abs(value-self.last)
+        self.last=value
+
+        return value,err
+
+def levin(ctx, method = "levin", variant = "u"):
+    L = levin_class(method = method, variant = variant)
+    L.ctx = ctx
+    return L
+
+levin.__doc__ = levin_class.__doc__
+defun(levin)
+
+
+class cohen_alt_class:
+    # cohen_alt: Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+    r"""
+    This interface implements the convergence acceleration of alternating series
+    as described in H. Cohen, F.R. Villegas, D. Zagier - "Convergence Acceleration
+    of Alternating Series". This series transformation works only well if the
+    individual terms of the series have an alternating sign. It belongs to the
+    class of linear series transformations (in contrast to the Shanks/Wynn-epsilon
+    or Levin transform). This series transformation is also able to sum some types
+    of divergent series. See the paper under which conditions this resummation is
+    mathematical sound.
+
+    Let *A* be the series we want to sum:
+
+    .. math ::
+
+        A = \sum_{k=0}^{\infty} a_k
+
+    Let `s_n` be the partial sums of this series:
+
+    .. math ::
+
+        s_n = \sum_{k=0}^n a_k.
+
+
+    **Interface**
+
+    Calling ``cohen_alt`` returns an object with the following methods.
+
+    Then ``update(...)`` works with the list of individual terms `a_k` and
+    ``update_psum(...)`` works with the list of partial sums `s_k`:
+
+    .. code ::
+
+        v, e = ...update([a_0, a_1,..., a_k])
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+    *v* is the current estimate for *A*, and *e* is an error estimate which is
+    simply the difference between the current estimate and the last estimate.
+
+    **Examples**
+
+    Here we compute the alternating zeta function using ``update_psum``::
+
+        >>> from mpmath import mp
+        >>> AC = mp.cohen_alt()
+        >>> S, s, n = [], 0, 1
+        >>> while 1:
+        ...     s += -((-1) ** n) * mp.one / (n * n)
+        ...     n += 1
+        ...     S.append(s)
+        ...     v, e = AC.update_psum(S)
+        ...     if e < mp.eps:
+        ...         break
+        ...     if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> print(mp.chop(v - mp.pi ** 2 / 12))
+        0.0
+
+    Here we compute the product `\prod_{n=1}^{\infty} \Gamma(1+1/(2n-1)) / \Gamma(1+1/(2n))`::
+
+        >>> A = []
+        >>> AC = mp.cohen_alt()
+        >>> n = 1
+        >>> while 1:
+        ...     A.append( mp.loggamma(1 + mp.one / (2 * n - 1)))
+        ...     A.append(-mp.loggamma(1 + mp.one / (2 * n)))
+        ...     n += 1
+        ...     v, e = AC.update(A)
+        ...     if e < mp.eps:
+        ...         break
+        ...     if n > 1000: raise RuntimeError("iteration limit exceeded")
+        >>> v = mp.exp(v)
+        >>> print(mp.chop(v - 1.06215090557106, tol = 1e-12))
+        0.0
+
+    ``cohen_alt`` is also accessible through the :func:`~mpmath.nsum` interface::
+
+        >>> v = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "a")
+        >>> print(mp.chop(v - mp.log(2)))
+        0.0
+        >>> v = mp.nsum(lambda n: (-1)**n / (2 * n + 1), [0, mp.inf], method = "a")
+        >>> print(mp.chop(v - mp.pi / 4))
+        0.0
+        >>> v = mp.nsum(lambda n: (-1)**n * mp.log(n) * n, [1, mp.inf], method = "a")
+        >>> print(mp.chop(v - mp.diff(lambda s: mp.altzeta(s), -1)))
+        0.0
+
+    """
+
+    def __init__(self):
+        self.last=0
+
+    def update(self, A):
+        """
+        This routine applies the convergence acceleration to the list of individual terms.
+
+        A    = sum(a_k, k = 0..infinity)
+
+        v, e = ...update([a_0, a_1,..., a_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        n = len(A)
+        d = (3 + self.ctx.sqrt(8)) ** n
+        d = (d + 1 / d) / 2
+        b = -self.ctx.one
+        c = -d
+        s = 0
+
+        for k in xrange(n):
+            c = b - c
+            if k % 2 == 0:
+                s = s + c * A[k]
+            else:
+                s = s - c * A[k]
+            b = 2 * (k + n) * (k - n) * b / ((2 * k + 1) * (k + self.ctx.one))
+
+        value = s / d
+
+        err = abs(value - self.last)
+        self.last = value
+
+        return value, err
+
+    def update_psum(self, S):
+        """
+        This routine applies the convergence acceleration to the list of partial sums.
+
+        A   = sum(a_k, k = 0..infinity)
+        s_n = sum(a_k ,k = 0..n)
+
+        v, e = ...update_psum([s_0, s_1,..., s_k])
+
+        output:
+          v      current estimate of the series A
+          e      an error estimate which is simply the difference between the current
+                 estimate and the last estimate.
+        """
+
+        n = len(S)
+        d = (3 + self.ctx.sqrt(8)) ** n
+        d = (d + 1 / d) / 2
+        b = self.ctx.one
+        s = 0
+
+        for k in xrange(n):
+            b = 2 * (n + k) * (n - k) * b / ((2 * k + 1) * (k + self.ctx.one))
+            s += b * S[k]
+
+        value = s / d
+
+        err = abs(value - self.last)
+        self.last = value
+
+        return value, err
+
+def cohen_alt(ctx):
+    L = cohen_alt_class()
+    L.ctx = ctx
+    return L
+
+cohen_alt.__doc__ = cohen_alt_class.__doc__
+defun(cohen_alt)
+
+
+@defun
+def sumap(ctx, f, interval, integral=None, error=False):
+    r"""
+    Evaluates an infinite series of an analytic summand *f* using the
+    Abel-Plana formula
+
+    .. math ::
+
+        \sum_{k=0}^{\infty} f(k) = \int_0^{\infty} f(t) dt + \frac{1}{2} f(0) +
+            i \int_0^{\infty} \frac{f(it)-f(-it)}{e^{2\pi t}-1} dt.
+
+    Unlike the Euler-Maclaurin formula (see :func:`~mpmath.sumem`),
+    the Abel-Plana formula does not require derivatives. However,
+    it only works when `|f(it)-f(-it)|` does not
+    increase too rapidly with `t`.
+
+    **Examples**
+
+    The Abel-Plana formula is particularly useful when the summand
+    decreases like a power of `k`; for example when the sum is a pure
+    zeta function::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> sumap(lambda k: 1/k**2.5, [1,inf])
+        1.34148725725091717975677
+        >>> zeta(2.5)
+        1.34148725725091717975677
+        >>> sumap(lambda k: 1/(k+1j)**(2.5+2.5j), [1,inf])
+        (-3.385361068546473342286084 - 0.7432082105196321803869551j)
+        >>> zeta(2.5+2.5j, 1+1j)
+        (-3.385361068546473342286084 - 0.7432082105196321803869551j)
+
+    If the series is alternating, numerical quadrature along the real
+    line is likely to give poor results, so it is better to evaluate
+    the first term symbolically whenever possible:
+
+        >>> n=3; z=-0.75
+        >>> I = expint(n,-log(z))
+        >>> chop(sumap(lambda k: z**k / k**n, [1,inf], integral=I))
+        -0.6917036036904594510141448
+        >>> polylog(n,z)
+        -0.6917036036904594510141448
+
+    """
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        a, b = interval
+        if  b != ctx.inf:
+            raise ValueError("b should be equal to ctx.inf")
+        g = lambda x: f(x+a)
+        if integral is None:
+            i1, err1 = ctx.quad(g, [0,ctx.inf], error=True)
+        else:
+            i1, err1 = integral, 0
+        j = ctx.j
+        p = ctx.pi * 2
+        if ctx._is_real_type(i1):
+            h = lambda t: -2 * ctx.im(g(j*t)) / ctx.expm1(p*t)
+        else:
+            h = lambda t: j*(g(j*t)-g(-j*t)) / ctx.expm1(p*t)
+        i2, err2 = ctx.quad(h, [0,ctx.inf], error=True)
+        err = err1+err2
+        v = i1+i2+0.5*g(ctx.mpf(0))
+    finally:
+        ctx.prec = prec
+    if error:
+        return +v, err
+    return +v
+
+
+@defun
+def sumem(ctx, f, interval, tol=None, reject=10, integral=None,
+    adiffs=None, bdiffs=None, verbose=False, error=False,
+    _fast_abort=False):
+    r"""
+    Uses the Euler-Maclaurin formula to compute an approximation accurate
+    to within ``tol`` (which defaults to the present epsilon) of the sum
+
+    .. math ::
+
+        S = \sum_{k=a}^b f(k)
+
+    where `(a,b)` are given by ``interval`` and `a` or `b` may be
+    infinite. The approximation is
+
+    .. math ::
+
+        S \sim \int_a^b f(x) \,dx + \frac{f(a)+f(b)}{2} +
+        \sum_{k=1}^{\infty} \frac{B_{2k}}{(2k)!}
+        \left(f^{(2k-1)}(b)-f^{(2k-1)}(a)\right).
+
+    The last sum in the Euler-Maclaurin formula is not generally
+    convergent (a notable exception is if `f` is a polynomial, in
+    which case Euler-Maclaurin actually gives an exact result).
+
+    The summation is stopped as soon as the quotient between two
+    consecutive terms falls below *reject*. That is, by default
+    (*reject* = 10), the summation is continued as long as each
+    term adds at least one decimal.
+
+    Although not convergent, convergence to a given tolerance can
+    often be "forced" if `b = \infty` by summing up to `a+N` and then
+    applying the Euler-Maclaurin formula to the sum over the range
+    `(a+N+1, \ldots, \infty)`. This procedure is implemented by
+    :func:`~mpmath.nsum`.
+
+    By default numerical quadrature and differentiation is used.
+    If the symbolic values of the integral and endpoint derivatives
+    are known, it is more efficient to pass the value of the
+    integral explicitly as ``integral`` and the derivatives
+    explicitly as ``adiffs`` and ``bdiffs``. The derivatives
+    should be given as iterables that yield
+    `f(a), f'(a), f''(a), \ldots` (and the equivalent for `b`).
+
+    **Examples**
+
+    Summation of an infinite series, with automatic and symbolic
+    integral and derivative values (the second should be much faster)::
+
+        >>> from mpmath import *
+        >>> mp.dps = 50; mp.pretty = True
+        >>> sumem(lambda n: 1/n**2, [32, inf])
+        0.03174336652030209012658168043874142714132886413417
+        >>> I = mpf(1)/32
+        >>> D = adiffs=((-1)**n*fac(n+1)*32**(-2-n) for n in range(999))
+        >>> sumem(lambda n: 1/n**2, [32, inf], integral=I, adiffs=D)
+        0.03174336652030209012658168043874142714132886413417
+
+    An exact evaluation of a finite polynomial sum::
+
+        >>> sumem(lambda n: n**5-12*n**2+3*n, [-100000, 200000])
+        10500155000624963999742499550000.0
+        >>> print(sum(n**5-12*n**2+3*n for n in range(-100000, 200001)))
+        10500155000624963999742499550000
+
+    """
+    tol = tol or +ctx.eps
+    interval = ctx._as_points(interval)
+    a = ctx.convert(interval[0])
+    b = ctx.convert(interval[-1])
+    err = ctx.zero
+    prev = 0
+    M = 10000
+    if a == ctx.ninf: adiffs = (0 for n in xrange(M))
+    else:             adiffs = adiffs or ctx.diffs(f, a)
+    if b == ctx.inf:  bdiffs = (0 for n in xrange(M))
+    else:             bdiffs = bdiffs or ctx.diffs(f, b)
+    orig = ctx.prec
+    #verbose = 1
+    try:
+        ctx.prec += 10
+        s = ctx.zero
+        for k, (da, db) in enumerate(izip(adiffs, bdiffs)):
+            if k & 1:
+                term = (db-da) * ctx.bernoulli(k+1) / ctx.factorial(k+1)
+                mag = abs(term)
+                if verbose:
+                    print("term", k, "magnitude =", ctx.nstr(mag))
+                if k > 4 and mag < tol:
+                    s += term
+                    break
+                elif k > 4 and abs(prev) / mag < reject:
+                    err += mag
+                    if _fast_abort:
+                        return [s, (s, err)][error]
+                    if verbose:
+                        print("Failed to converge")
+                    break
+                else:
+                    s += term
+                prev = term
+        # Endpoint correction
+        if a != ctx.ninf: s += f(a)/2
+        if b != ctx.inf: s += f(b)/2
+        # Tail integral
+        if verbose:
+            print("Integrating f(x) from x = %s to %s" % (ctx.nstr(a), ctx.nstr(b)))
+        if integral:
+            s += integral
+        else:
+            integral, ierr = ctx.quad(f, interval, error=True)
+            if verbose:
+                print("Integration error:", ierr)
+            s += integral
+            err += ierr
+    finally:
+        ctx.prec = orig
+    if error:
+        return s, err
+    else:
+        return s
+
+@defun
+def adaptive_extrapolation(ctx, update, emfun, kwargs):
+    option = kwargs.get
+    if ctx._fixed_precision:
+        tol = option('tol', ctx.eps*2**10)
+    else:
+        tol = option('tol', ctx.eps/2**10)
+    verbose = option('verbose', False)
+    maxterms = option('maxterms', ctx.dps*10)
+    method = set(option('method', 'r+s').split('+'))
+    skip = option('skip', 0)
+    steps = iter(option('steps', xrange(10, 10**9, 10)))
+    strict = option('strict')
+    #steps = (10 for i in xrange(1000))
+    summer=[]
+    if 'd' in method or 'direct' in method:
+        TRY_RICHARDSON = TRY_SHANKS = TRY_EULER_MACLAURIN = False
+    else:
+        TRY_RICHARDSON = ('r' in method) or ('richardson' in method)
+        TRY_SHANKS = ('s' in method) or ('shanks' in method)
+        TRY_EULER_MACLAURIN = ('e' in method) or \
+            ('euler-maclaurin' in method)
+
+        def init_levin(m):
+            variant = kwargs.get("levin_variant", "u")
+            if isinstance(variant, str):
+                if variant == "all":
+                    variant = ["u", "v", "t"]
+                else:
+                    variant = [variant]
+            for s in variant:
+                L = levin_class(method = m, variant = s)
+                L.ctx = ctx
+                L.name = m + "(" + s + ")"
+                summer.append(L)
+
+        if ('l' in method) or ('levin' in method):
+            init_levin("levin")
+
+        if ('sidi' in method):
+            init_levin("sidi")
+
+        if ('a' in method) or ('alternating' in method):
+            L = cohen_alt_class()
+            L.ctx = ctx
+            L.name = "alternating"
+            summer.append(L)
+
+    last_richardson_value = 0
+    shanks_table = []
+    index = 0
+    step = 10
+    partial = []
+    best = ctx.zero
+    orig = ctx.prec
+    try:
+        if 'workprec' in kwargs:
+            ctx.prec = kwargs['workprec']
+        elif TRY_RICHARDSON or TRY_SHANKS or len(summer)!=0:
+            ctx.prec = (ctx.prec+10) * 4
+        else:
+            ctx.prec += 30
+        while 1:
+            if index >= maxterms:
+                break
+
+            # Get new batch of terms
+            try:
+                step = next(steps)
+            except StopIteration:
+                pass
+            if verbose:
+                print("-"*70)
+                print("Adding terms #%i-#%i" % (index, index+step))
+            update(partial, xrange(index, index+step))
+            index += step
+
+            # Check direct error
+            best = partial[-1]
+            error = abs(best - partial[-2])
+            if verbose:
+                print("Direct error: %s" % ctx.nstr(error))
+            if error <= tol:
+                return best
+
+            # Check each extrapolation method
+            if TRY_RICHARDSON:
+                value, maxc = ctx.richardson(partial)
+                # Convergence
+                richardson_error = abs(value - last_richardson_value)
+                if verbose:
+                    print("Richardson error: %s" % ctx.nstr(richardson_error))
+                # Convergence
+                if richardson_error <= tol:
+                    return value
+                last_richardson_value = value
+                # Unreliable due to cancellation
+                if ctx.eps*maxc > tol:
+                    if verbose:
+                        print("Ran out of precision for Richardson")
+                    TRY_RICHARDSON = False
+                if richardson_error < error:
+                    error = richardson_error
+                    best = value
+            if TRY_SHANKS:
+                shanks_table = ctx.shanks(partial, shanks_table, randomized=True)
+                row = shanks_table[-1]
+                if len(row) == 2:
+                    est1 = row[-1]
+                    shanks_error = 0
+                else:
+                    est1, maxc, est2 = row[-1], abs(row[-2]), row[-3]
+                    shanks_error = abs(est1-est2)
+                if verbose:
+                    print("Shanks error: %s" % ctx.nstr(shanks_error))
+                if shanks_error <= tol:
+                    return est1
+                if ctx.eps*maxc > tol:
+                    if verbose:
+                        print("Ran out of precision for Shanks")
+                    TRY_SHANKS = False
+                if shanks_error < error:
+                    error = shanks_error
+                    best = est1
+            for L in summer:
+                est, lerror = L.update_psum(partial)
+                if verbose:
+                    print("%s error: %s" % (L.name, ctx.nstr(lerror)))
+                if lerror <= tol:
+                    return est
+                if lerror < error:
+                    error = lerror
+                    best = est
+            if TRY_EULER_MACLAURIN:
+                if ctx.almosteq(ctx.mpc(ctx.sign(partial[-1]) / ctx.sign(partial[-2])), -1):
+                    if verbose:
+                        print ("NOT using Euler-Maclaurin: the series appears"
+                            " to be alternating, so numerical\n quadrature"
+                            " will most likely fail")
+                    TRY_EULER_MACLAURIN = False
+                else:
+                    value, em_error = emfun(index, tol)
+                    value += partial[-1]
+                    if verbose:
+                        print("Euler-Maclaurin error: %s" % ctx.nstr(em_error))
+                    if em_error <= tol:
+                        return value
+                    if em_error < error:
+                        best = value
+    finally:
+        ctx.prec = orig
+    if strict:
+        raise ctx.NoConvergence
+    if verbose:
+        print("Warning: failed to converge to target accuracy")
+    return best
+
+@defun
+def nsum(ctx, f, *intervals, **options):
+    r"""
+    Computes the sum
+
+    .. math :: S = \sum_{k=a}^b f(k)
+
+    where `(a, b)` = *interval*, and where `a = -\infty` and/or
+    `b = \infty` are allowed, or more generally
+
+    .. math :: S = \sum_{k_1=a_1}^{b_1} \cdots
+                   \sum_{k_n=a_n}^{b_n} f(k_1,\ldots,k_n)
+
+    if multiple intervals are given.
+
+    Two examples of infinite series that can be summed by :func:`~mpmath.nsum`,
+    where the first converges rapidly and the second converges slowly,
+    are::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nsum(lambda n: 1/fac(n), [0, inf])
+        2.71828182845905
+        >>> nsum(lambda n: 1/n**2, [1, inf])
+        1.64493406684823
+
+    When appropriate, :func:`~mpmath.nsum` applies convergence acceleration to
+    accurately estimate the sums of slowly convergent series. If the series is
+    finite, :func:`~mpmath.nsum` currently does not attempt to perform any
+    extrapolation, and simply calls :func:`~mpmath.fsum`.
+
+    Multidimensional infinite series are reduced to a single-dimensional
+    series over expanding hypercubes; if both infinite and finite dimensions
+    are present, the finite ranges are moved innermost. For more advanced
+    control over the summation order, use nested calls to :func:`~mpmath.nsum`,
+    or manually rewrite the sum as a single-dimensional series.
+
+    **Options**
+
+    *tol*
+        Desired maximum final error. Defaults roughly to the
+        epsilon of the working precision.
+
+    *method*
+        Which summation algorithm to use (described below).
+        Default: ``'richardson+shanks'``.
+
+    *maxterms*
+        Cancel after at most this many terms. Default: 10*dps.
+
+    *steps*
+        An iterable giving the number of terms to add between
+        each extrapolation attempt. The default sequence is
+        [10, 20, 30, 40, ...]. For example, if you know that
+        approximately 100 terms will be required, efficiency might be
+        improved by setting this to [100, 10]. Then the first
+        extrapolation will be performed after 100 terms, the second
+        after 110, etc.
+
+    *verbose*
+        Print details about progress.
+
+    *ignore*
+        If enabled, any term that raises ``ArithmeticError``
+        or ``ValueError`` (e.g. through division by zero) is replaced
+        by a zero. This is convenient for lattice sums with
+        a singular term near the origin.
+
+    **Methods**
+
+    Unfortunately, an algorithm that can efficiently sum any infinite
+    series does not exist. :func:`~mpmath.nsum` implements several different
+    algorithms that each work well in different cases. The *method*
+    keyword argument selects a method.
+
+    The default method is ``'r+s'``, i.e. both Richardson extrapolation
+    and Shanks transformation is attempted. A slower method that
+    handles more cases is ``'r+s+e'``. For very high precision
+    summation, or if the summation needs to be fast (for example if
+    multiple sums need to be evaluated), it is a good idea to
+    investigate which one method works best and only use that.
+
+    ``'richardson'`` / ``'r'``:
+        Uses Richardson extrapolation. Provides useful extrapolation
+        when `f(k) \sim P(k)/Q(k)` or when `f(k) \sim (-1)^k P(k)/Q(k)`
+        for polynomials `P` and `Q`. See :func:`~mpmath.richardson` for
+        additional information.
+
+    ``'shanks'`` / ``'s'``:
+        Uses Shanks transformation. Typically provides useful
+        extrapolation when `f(k) \sim c^k` or when successive terms
+        alternate signs. Is able to sum some divergent series.
+        See :func:`~mpmath.shanks` for additional information.
+
+    ``'levin'`` / ``'l'``:
+        Uses the Levin transformation. It performs better than the Shanks
+        transformation for logarithmic convergent or alternating divergent
+        series. The ``'levin_variant'``-keyword selects the variant. Valid
+        choices are "u", "t", "v" and "all" whereby "all" uses all three
+        u,t and v simultanously (This is good for performance comparison in
+        conjunction with "verbose=True"). Instead of the Levin transform one can
+        also use the Sidi-S transform by selecting the method ``'sidi'``.
+        See :func:`~mpmath.levin` for additional details.
+
+    ``'alternating'`` / ``'a'``:
+        This is the convergence acceleration of alternating series developped
+        by Cohen, Villegras and Zagier.
+        See :func:`~mpmath.cohen_alt` for additional details.
+
+    ``'euler-maclaurin'`` / ``'e'``:
+        Uses the Euler-Maclaurin summation formula to approximate
+        the remainder sum by an integral. This requires high-order
+        numerical derivatives and numerical integration. The advantage
+        of this algorithm is that it works regardless of the
+        decay rate of `f`, as long as `f` is sufficiently smooth.
+        See :func:`~mpmath.sumem` for additional information.
+
+    ``'direct'`` / ``'d'``:
+        Does not perform any extrapolation. This can be used
+        (and should only be used for) rapidly convergent series.
+        The summation automatically stops when the terms
+        decrease below the target tolerance.
+
+    **Basic examples**
+
+    A finite sum::
+
+        >>> nsum(lambda k: 1/k, [1, 6])
+        2.45
+
+    Summation of a series going to negative infinity and a doubly
+    infinite series::
+
+        >>> nsum(lambda k: 1/k**2, [-inf, -1])
+        1.64493406684823
+        >>> nsum(lambda k: 1/(1+k**2), [-inf, inf])
+        3.15334809493716
+
+    :func:`~mpmath.nsum` handles sums of complex numbers::
+
+        >>> nsum(lambda k: (0.5+0.25j)**k, [0, inf])
+        (1.6 + 0.8j)
+
+    The following sum converges very rapidly, so it is most
+    efficient to sum it by disabling convergence acceleration::
+
+        >>> mp.dps = 1000
+        >>> a = nsum(lambda k: -(-1)**k * k**2 / fac(2*k), [1, inf],
+        ...     method='direct')
+        >>> b = (cos(1)+sin(1))/4
+        >>> abs(a-b) < mpf('1e-998')
+        True
+
+    **Examples with Richardson extrapolation**
+
+    Richardson extrapolation works well for sums over rational
+    functions, as well as their alternating counterparts::
+
+        >>> mp.dps = 50
+        >>> nsum(lambda k: 1 / k**3, [1, inf],
+        ...     method='richardson')
+        1.2020569031595942853997381615114499907649862923405
+        >>> zeta(3)
+        1.2020569031595942853997381615114499907649862923405
+
+        >>> nsum(lambda n: (n + 3)/(n**3 + n**2), [1, inf],
+        ...     method='richardson')
+        2.9348022005446793094172454999380755676568497036204
+        >>> pi**2/2-2
+        2.9348022005446793094172454999380755676568497036204
+
+        >>> nsum(lambda k: (-1)**k / k**3, [1, inf],
+        ...     method='richardson')
+        -0.90154267736969571404980362113358749307373971925537
+        >>> -3*zeta(3)/4
+        -0.90154267736969571404980362113358749307373971925538
+
+    **Examples with Shanks transformation**
+
+    The Shanks transformation works well for geometric series
+    and typically provides excellent acceleration for Taylor
+    series near the border of their disk of convergence.
+    Here we apply it to a series for `\log(2)`, which can be
+    seen as the Taylor series for `\log(1+x)` with `x = 1`::
+
+        >>> nsum(lambda k: -(-1)**k/k, [1, inf],
+        ...     method='shanks')
+        0.69314718055994530941723212145817656807550013436025
+        >>> log(2)
+        0.69314718055994530941723212145817656807550013436025
+
+    Here we apply it to a slowly convergent geometric series::
+
+        >>> nsum(lambda k: mpf('0.995')**k, [0, inf],
+        ...     method='shanks')
+        200.0
+
+    Finally, Shanks' method works very well for alternating series
+    where `f(k) = (-1)^k g(k)`, and often does so regardless of
+    the exact decay rate of `g(k)`::
+
+        >>> mp.dps = 15
+        >>> nsum(lambda k: (-1)**(k+1) / k**1.5, [1, inf],
+        ...     method='shanks')
+        0.765147024625408
+        >>> (2-sqrt(2))*zeta(1.5)/2
+        0.765147024625408
+
+    The following slowly convergent alternating series has no known
+    closed-form value. Evaluating the sum a second time at higher
+    precision indicates that the value is probably correct::
+
+        >>> nsum(lambda k: (-1)**k / log(k), [2, inf],
+        ...     method='shanks')
+        0.924299897222939
+        >>> mp.dps = 30
+        >>> nsum(lambda k: (-1)**k / log(k), [2, inf],
+        ...     method='shanks')
+        0.92429989722293885595957018136
+
+    **Examples with Levin transformation**
+
+    The following example calculates Euler's constant as the constant term in
+    the Laurent expansion of zeta(s) at s=1. This sum converges extremly slow
+    because of the logarithmic convergence behaviour of the Dirichlet series
+    for zeta.
+
+      >>> mp.dps = 30
+      >>> z = mp.mpf(10) ** (-10)
+      >>> a = mp.nsum(lambda n: n**(-(1+z)), [1, mp.inf], method = "levin") - 1 / z
+      >>> print(mp.chop(a - mp.euler, tol = 1e-10))
+      0.0
+
+    Now we sum the zeta function outside its range of convergence
+    (attention: This does not work at the negative integers!):
+
+      >>> mp.dps = 15
+      >>> w = mp.nsum(lambda n: n ** (2 + 3j), [1, mp.inf], method = "levin", levin_variant = "v")
+      >>> print(mp.chop(w - mp.zeta(-2-3j)))
+      0.0
+
+    The next example resummates an asymptotic series expansion of an integral
+    related to the exponential integral.
+
+      >>> mp.dps = 15
+      >>> z = mp.mpf(10)
+      >>> # exact = mp.quad(lambda x: mp.exp(-x)/(1+x/z),[0,mp.inf])
+      >>> exact = z * mp.exp(z) * mp.expint(1,z) # this is the symbolic expression for the integral
+      >>> w = mp.nsum(lambda n: (-1) ** n * mp.fac(n) * z ** (-n), [0, mp.inf], method = "sidi", levin_variant = "t")
+      >>> print(mp.chop(w - exact))
+      0.0
+
+    Following highly divergent asymptotic expansion needs some care. Firstly we
+    need copious amount of working precision. Secondly the stepsize must not be
+    chosen to large, otherwise nsum may miss the point where the Levin transform
+    converges and reach the point where only numerical garbage is produced due to
+    numerical cancellation.
+
+      >>> mp.dps = 15
+      >>> z = mp.mpf(2)
+      >>> # exact = mp.quad(lambda x: mp.exp( -x * x / 2 - z * x ** 4), [0,mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
+      >>> exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi)) # this is the symbolic expression for the integral
+      >>> w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n)),
+      ...   [0, mp.inf], method = "levin", levin_variant = "t", workprec = 8*mp.prec, steps = [2] + [1 for x in xrange(1000)])
+      >>> print(mp.chop(w - exact))
+      0.0
+
+    The hypergeoemtric function can also be summed outside its range of convergence:
+
+      >>> mp.dps = 15
+      >>> z = 2 + 1j
+      >>> exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
+      >>> f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
+      >>> v = mp.nsum(f, [0, mp.inf], method = "levin", steps = [10 for x in xrange(1000)])
+      >>> print(mp.chop(exact-v))
+      0.0
+
+    **Examples with Cohen's alternating series resummation**
+
+      The next example sums the alternating zeta function:
+
+      >>> v = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "a")
+      >>> print(mp.chop(v - mp.log(2)))
+      0.0
+
+      The derivate of the alternating zeta function outside its range of
+      convergence:
+
+      >>> v = mp.nsum(lambda n: (-1)**n * mp.log(n) * n, [1, mp.inf], method = "a")
+      >>> print(mp.chop(v - mp.diff(lambda s: mp.altzeta(s), -1)))
+      0.0
+
+    **Examples with Euler-Maclaurin summation**
+
+    The sum in the following example has the wrong rate of convergence
+    for either Richardson or Shanks to be effective.
+
+        >>> f = lambda k: log(k)/k**2.5
+        >>> mp.dps = 15
+        >>> nsum(f, [1, inf], method='euler-maclaurin')
+        0.38734195032621
+        >>> -diff(zeta, 2.5)
+        0.38734195032621
+
+    Increasing ``steps`` improves speed at higher precision::
+
+        >>> mp.dps = 50
+        >>> nsum(f, [1, inf], method='euler-maclaurin', steps=[250])
+        0.38734195032620997271199237593105101319948228874688
+        >>> -diff(zeta, 2.5)
+        0.38734195032620997271199237593105101319948228874688
+
+    **Divergent series**
+
+    The Shanks transformation is able to sum some *divergent*
+    series. In particular, it is often able to sum Taylor series
+    beyond their radius of convergence (this is due to a relation
+    between the Shanks transformation and Pade approximations;
+    see :func:`~mpmath.pade` for an alternative way to evaluate divergent
+    Taylor series). Furthermore the Levin-transform examples above
+    contain some divergent series resummation.
+
+    Here we apply it to `\log(1+x)` far outside the region of
+    convergence::
+
+        >>> mp.dps = 50
+        >>> nsum(lambda k: -(-9)**k/k, [1, inf],
+        ...     method='shanks')
+        2.3025850929940456840179914546843642076011014886288
+        >>> log(10)
+        2.3025850929940456840179914546843642076011014886288
+
+    A particular type of divergent series that can be summed
+    using the Shanks transformation is geometric series.
+    The result is the same as using the closed-form formula
+    for an infinite geometric series::
+
+        >>> mp.dps = 15
+        >>> for n in range(-8, 8):
+        ...     if n == 1:
+        ...         continue
+        ...     print("%s %s %s" % (mpf(n), mpf(1)/(1-n),
+        ...         nsum(lambda k: n**k, [0, inf], method='shanks')))
+        ...
+        -8.0 0.111111111111111 0.111111111111111
+        -7.0 0.125 0.125
+        -6.0 0.142857142857143 0.142857142857143
+        -5.0 0.166666666666667 0.166666666666667
+        -4.0 0.2 0.2
+        -3.0 0.25 0.25
+        -2.0 0.333333333333333 0.333333333333333
+        -1.0 0.5 0.5
+        0.0 1.0 1.0
+        2.0 -1.0 -1.0
+        3.0 -0.5 -0.5
+        4.0 -0.333333333333333 -0.333333333333333
+        5.0 -0.25 -0.25
+        6.0 -0.2 -0.2
+        7.0 -0.166666666666667 -0.166666666666667
+
+    **Multidimensional sums**
+
+    Any combination of finite and infinite ranges is allowed for the
+    summation indices::
+
+        >>> mp.dps = 15
+        >>> nsum(lambda x,y: x+y, [2,3], [4,5])
+        28.0
+        >>> nsum(lambda x,y: x/2**y, [1,3], [1,inf])
+        6.0
+        >>> nsum(lambda x,y: y/2**x, [1,inf], [1,3])
+        6.0
+        >>> nsum(lambda x,y,z: z/(2**x*2**y), [1,inf], [1,inf], [3,4])
+        7.0
+        >>> nsum(lambda x,y,z: y/(2**x*2**z), [1,inf], [3,4], [1,inf])
+        7.0
+        >>> nsum(lambda x,y,z: x/(2**z*2**y), [3,4], [1,inf], [1,inf])
+        7.0
+
+    Some nice examples of double series with analytic solutions or
+    reductions to single-dimensional series (see [1])::
+
+        >>> nsum(lambda m, n: 1/2**(m*n), [1,inf], [1,inf])
+        1.60669515241529
+        >>> nsum(lambda n: 1/(2**n-1), [1,inf])
+        1.60669515241529
+
+        >>> nsum(lambda i,j: (-1)**(i+j)/(i**2+j**2), [1,inf], [1,inf])
+        0.278070510848213
+        >>> pi*(pi-3*ln2)/12
+        0.278070510848213
+
+        >>> nsum(lambda i,j: (-1)**(i+j)/(i+j)**2, [1,inf], [1,inf])
+        0.129319852864168
+        >>> altzeta(2) - altzeta(1)
+        0.129319852864168
+
+        >>> nsum(lambda i,j: (-1)**(i+j)/(i+j)**3, [1,inf], [1,inf])
+        0.0790756439455825
+        >>> altzeta(3) - altzeta(2)
+        0.0790756439455825
+
+        >>> nsum(lambda m,n: m**2*n/(3**m*(n*3**m+m*3**n)),
+        ...     [1,inf], [1,inf])
+        0.28125
+        >>> mpf(9)/32
+        0.28125
+
+        >>> nsum(lambda i,j: fac(i-1)*fac(j-1)/fac(i+j),
+        ...     [1,inf], [1,inf], workprec=400)
+        1.64493406684823
+        >>> zeta(2)
+        1.64493406684823
+
+    A hard example of a multidimensional sum is the Madelung constant
+    in three dimensions (see [2]). The defining sum converges very
+    slowly and only conditionally, so :func:`~mpmath.nsum` is lucky to
+    obtain an accurate value through convergence acceleration. The
+    second evaluation below uses a much more efficient, rapidly
+    convergent 2D sum::
+
+        >>> nsum(lambda x,y,z: (-1)**(x+y+z)/(x*x+y*y+z*z)**0.5,
+        ...     [-inf,inf], [-inf,inf], [-inf,inf], ignore=True)
+        -1.74756459463318
+        >>> nsum(lambda x,y: -12*pi*sech(0.5*pi * \
+        ...     sqrt((2*x+1)**2+(2*y+1)**2))**2, [0,inf], [0,inf])
+        -1.74756459463318
+
+    Another example of a lattice sum in 2D::
+
+        >>> nsum(lambda x,y: (-1)**(x+y) / (x**2+y**2), [-inf,inf],
+        ...     [-inf,inf], ignore=True)
+        -2.1775860903036
+        >>> -pi*ln2
+        -2.1775860903036
+
+    An example of an Eisenstein series::
+
+        >>> nsum(lambda m,n: (m+n*1j)**(-4), [-inf,inf], [-inf,inf],
+        ...     ignore=True)
+        (3.1512120021539 + 0.0j)
+
+    **References**
+
+    1. [Weisstein]_ http://mathworld.wolfram.com/DoubleSeries.html,
+    2. [Weisstein]_ http://mathworld.wolfram.com/MadelungConstants.html
+
+    """
+    infinite, g = standardize(ctx, f, intervals, options)
+    if not infinite:
+        return +g()
+
+    def update(partial_sums, indices):
+        if partial_sums:
+            psum = partial_sums[-1]
+        else:
+            psum = ctx.zero
+        for k in indices:
+            psum = psum + g(ctx.mpf(k))
+            partial_sums.append(psum)
+
+    prec = ctx.prec
+
+    def emfun(point, tol):
+        workprec = ctx.prec
+        ctx.prec = prec + 10
+        v = ctx.sumem(g, [point, ctx.inf], tol, error=1)
+        ctx.prec = workprec
+        return v
+
+    return +ctx.adaptive_extrapolation(update, emfun, options)
+
+
+def wrapsafe(f):
+    def g(*args):
+        try:
+            return f(*args)
+        except (ArithmeticError, ValueError):
+            return 0
+    return g
+
+def standardize(ctx, f, intervals, options):
+    if options.get("ignore"):
+        f = wrapsafe(f)
+    finite = []
+    infinite = []
+    for k, points in enumerate(intervals):
+        a, b = ctx._as_points(points)
+        if b < a:
+            return False, (lambda: ctx.zero)
+        if a == ctx.ninf or b == ctx.inf:
+            infinite.append((k, (a,b)))
+        else:
+            finite.append((k, (int(a), int(b))))
+    if finite:
+        f = fold_finite(ctx, f, finite)
+        if not infinite:
+            return False, lambda: f(*([0]*len(intervals)))
+    if infinite:
+        f = standardize_infinite(ctx, f, infinite)
+        f = fold_infinite(ctx, f, infinite)
+        args = [0] * len(intervals)
+        d = infinite[0][0]
+        def g(k):
+            args[d] = k
+            return f(*args)
+        return True, g
+
+# backwards compatible itertools.product
+def cartesian_product(args):
+    pools = map(tuple, args)
+    result = [[]]
+    for pool in pools:
+        result = [x+[y] for x in result for y in pool]
+    for prod in result:
+        yield tuple(prod)
+
+def fold_finite(ctx, f, intervals):
+    if not intervals:
+        return f
+    indices = [v[0] for v in intervals]
+    points = [v[1] for v in intervals]
+    ranges = [xrange(a, b+1) for (a,b) in points]
+    def g(*args):
+        args = list(args)
+        s = ctx.zero
+        for xs in cartesian_product(ranges):
+            for dim, x in zip(indices, xs):
+                args[dim] = ctx.mpf(x)
+            s += f(*args)
+        return s
+    #print "Folded finite", indices
+    return g
+
+# Standardize each interval to [0,inf]
+def standardize_infinite(ctx, f, intervals):
+    if not intervals:
+        return f
+    dim, [a,b] = intervals[-1]
+    if a == ctx.ninf:
+        if b == ctx.inf:
+            def g(*args):
+                args = list(args)
+                k = args[dim]
+                if k:
+                    s = f(*args)
+                    args[dim] = -k
+                    s += f(*args)
+                    return s
+                else:
+                    return f(*args)
+        else:
+            def g(*args):
+                args = list(args)
+                args[dim] = b - args[dim]
+                return f(*args)
+    else:
+        def g(*args):
+            args = list(args)
+            args[dim] += a
+            return f(*args)
+    #print "Standardized infinity along dimension", dim, a, b
+    return standardize_infinite(ctx, g, intervals[:-1])
+
+def fold_infinite(ctx, f, intervals):
+    if len(intervals) < 2:
+        return f
+    dim1 = intervals[-2][0]
+    dim2 = intervals[-1][0]
+    # Assume intervals are [0,inf] x [0,inf] x ...
+    def g(*args):
+        args = list(args)
+        #args.insert(dim2, None)
+        n = int(args[dim1])
+        s = ctx.zero
+        #y = ctx.mpf(n)
+        args[dim2] = ctx.mpf(n) #y
+        for x in xrange(n+1):
+            args[dim1] = ctx.mpf(x)
+            s += f(*args)
+        args[dim1] = ctx.mpf(n) #ctx.mpf(n)
+        for y in xrange(n):
+            args[dim2] = ctx.mpf(y)
+            s += f(*args)
+        return s
+    #print "Folded infinite from", len(intervals), "to", (len(intervals)-1)
+    return fold_infinite(ctx, g, intervals[:-1])
+
+@defun
+def nprod(ctx, f, interval, nsum=False, **kwargs):
+    r"""
+    Computes the product
+
+    .. math ::
+
+        P = \prod_{k=a}^b f(k)
+
+    where `(a, b)` = *interval*, and where `a = -\infty` and/or
+    `b = \infty` are allowed.
+
+    By default, :func:`~mpmath.nprod` uses the same extrapolation methods as
+    :func:`~mpmath.nsum`, except applied to the partial products rather than
+    partial sums, and the same keyword options as for :func:`~mpmath.nsum` are
+    supported. If ``nsum=True``, the product is instead computed via
+    :func:`~mpmath.nsum` as
+
+    .. math ::
+
+        P = \exp\left( \sum_{k=a}^b \log(f(k)) \right).
+
+    This is slower, but can sometimes yield better results. It is
+    also required (and used automatically) when Euler-Maclaurin
+    summation is requested.
+
+    **Examples**
+
+    A simple finite product::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> nprod(lambda k: k, [1, 4])
+        24.0
+
+    A large number of infinite products have known exact values,
+    and can therefore be used as a reference. Most of the following
+    examples are taken from MathWorld [1].
+
+    A few infinite products with simple values are::
+
+        >>> 2*nprod(lambda k: (4*k**2)/(4*k**2-1), [1, inf])
+        3.141592653589793238462643
+        >>> nprod(lambda k: (1+1/k)**2/(1+2/k), [1, inf])
+        2.0
+        >>> nprod(lambda k: (k**3-1)/(k**3+1), [2, inf])
+        0.6666666666666666666666667
+        >>> nprod(lambda k: (1-1/k**2), [2, inf])
+        0.5
+
+    Next, several more infinite products with more complicated
+    values::
+
+        >>> nprod(lambda k: exp(1/k**2), [1, inf]); exp(pi**2/6)
+        5.180668317897115748416626
+        5.180668317897115748416626
+
+        >>> nprod(lambda k: (k**2-1)/(k**2+1), [2, inf]); pi*csch(pi)
+        0.2720290549821331629502366
+        0.2720290549821331629502366
+
+        >>> nprod(lambda k: (k**4-1)/(k**4+1), [2, inf])
+        0.8480540493529003921296502
+        >>> pi*sinh(pi)/(cosh(sqrt(2)*pi)-cos(sqrt(2)*pi))
+        0.8480540493529003921296502
+
+        >>> nprod(lambda k: (1+1/k+1/k**2)**2/(1+2/k+3/k**2), [1, inf])
+        1.848936182858244485224927
+        >>> 3*sqrt(2)*cosh(pi*sqrt(3)/2)**2*csch(pi*sqrt(2))/pi
+        1.848936182858244485224927
+
+        >>> nprod(lambda k: (1-1/k**4), [2, inf]); sinh(pi)/(4*pi)
+        0.9190194775937444301739244
+        0.9190194775937444301739244
+
+        >>> nprod(lambda k: (1-1/k**6), [2, inf])
+        0.9826842777421925183244759
+        >>> (1+cosh(pi*sqrt(3)))/(12*pi**2)
+        0.9826842777421925183244759
+
+        >>> nprod(lambda k: (1+1/k**2), [2, inf]); sinh(pi)/(2*pi)
+        1.838038955187488860347849
+        1.838038955187488860347849
+
+        >>> nprod(lambda n: (1+1/n)**n * exp(1/(2*n)-1), [1, inf])
+        1.447255926890365298959138
+        >>> exp(1+euler/2)/sqrt(2*pi)
+        1.447255926890365298959138
+
+    The following two products are equivalent and can be evaluated in
+    terms of a Jacobi theta function. Pi can be replaced by any value
+    (as long as convergence is preserved)::
+
+        >>> nprod(lambda k: (1-pi**-k)/(1+pi**-k), [1, inf])
+        0.3838451207481672404778686
+        >>> nprod(lambda k: tanh(k*log(pi)/2), [1, inf])
+        0.3838451207481672404778686
+        >>> jtheta(4,0,1/pi)
+        0.3838451207481672404778686
+
+    This product does not have a known closed form value::
+
+        >>> nprod(lambda k: (1-1/2**k), [1, inf])
+        0.2887880950866024212788997
+
+    A product taken from `-\infty`::
+
+        >>> nprod(lambda k: 1-k**(-3), [-inf,-2])
+        0.8093965973662901095786805
+        >>> cosh(pi*sqrt(3)/2)/(3*pi)
+        0.8093965973662901095786805
+
+    A doubly infinite product::
+
+        >>> nprod(lambda k: exp(1/(1+k**2)), [-inf, inf])
+        23.41432688231864337420035
+        >>> exp(pi/tanh(pi))
+        23.41432688231864337420035
+
+    A product requiring the use of Euler-Maclaurin summation to compute
+    an accurate value::
+
+        >>> nprod(lambda k: (1-1/k**2.5), [2, inf], method='e')
+        0.696155111336231052898125
+
+    **References**
+
+    1. [Weisstein]_ http://mathworld.wolfram.com/InfiniteProduct.html
+
+    """
+    if nsum or ('e' in kwargs.get('method', '')):
+        orig = ctx.prec
+        try:
+            # TODO: we are evaluating log(1+eps) -> eps, which is
+            # inaccurate. This currently works because nsum greatly
+            # increases the working precision. But we should be
+            # more intelligent and handle the precision here.
+            ctx.prec += 10
+            v = ctx.nsum(lambda n: ctx.ln(f(n)), interval, **kwargs)
+        finally:
+            ctx.prec = orig
+        return +ctx.exp(v)
+
+    a, b = ctx._as_points(interval)
+    if a == ctx.ninf:
+        if b == ctx.inf:
+            return f(0) * ctx.nprod(lambda k: f(-k) * f(k), [1, ctx.inf], **kwargs)
+        return ctx.nprod(f, [-b, ctx.inf], **kwargs)
+    elif b != ctx.inf:
+        return ctx.fprod(f(ctx.mpf(k)) for k in xrange(int(a), int(b)+1))
+
+    a = int(a)
+
+    def update(partial_products, indices):
+        if partial_products:
+            pprod = partial_products[-1]
+        else:
+            pprod = ctx.one
+        for k in indices:
+            pprod = pprod * f(a + ctx.mpf(k))
+            partial_products.append(pprod)
+
+    return +ctx.adaptive_extrapolation(update, None, kwargs)
+
+
+@defun
+def limit(ctx, f, x, direction=1, exp=False, **kwargs):
+    r"""
+    Computes an estimate of the limit
+
+    .. math ::
+
+        \lim_{t \to x} f(t)
+
+    where `x` may be finite or infinite.
+
+    For finite `x`, :func:`~mpmath.limit` evaluates `f(x + d/n)` for
+    consecutive integer values of `n`, where the approach direction
+    `d` may be specified using the *direction* keyword argument.
+    For infinite `x`, :func:`~mpmath.limit` evaluates values of
+    `f(\mathrm{sign}(x) \cdot n)`.
+
+    If the approach to the limit is not sufficiently fast to give
+    an accurate estimate directly, :func:`~mpmath.limit` attempts to find
+    the limit using Richardson extrapolation or the Shanks
+    transformation. You can select between these methods using
+    the *method* keyword (see documentation of :func:`~mpmath.nsum` for
+    more information).
+
+    **Options**
+
+    The following options are available with essentially the
+    same meaning as for :func:`~mpmath.nsum`: *tol*, *method*, *maxterms*,
+    *steps*, *verbose*.
+
+    If the option *exp=True* is set, `f` will be
+    sampled at exponentially spaced points `n = 2^1, 2^2, 2^3, \ldots`
+    instead of the linearly spaced points `n = 1, 2, 3, \ldots`.
+    This can sometimes improve the rate of convergence so that
+    :func:`~mpmath.limit` may return a more accurate answer (and faster).
+    However, do note that this can only be used if `f`
+    supports fast and accurate evaluation for arguments that
+    are extremely close to the limit point (or if infinite,
+    very large arguments).
+
+    **Examples**
+
+    A basic evaluation of a removable singularity::
+
+        >>> from mpmath import *
+        >>> mp.dps = 30; mp.pretty = True
+        >>> limit(lambda x: (x-sin(x))/x**3, 0)
+        0.166666666666666666666666666667
+
+    Computing the exponential function using its limit definition::
+
+        >>> limit(lambda n: (1+3/n)**n, inf)
+        20.0855369231876677409285296546
+        >>> exp(3)
+        20.0855369231876677409285296546
+
+    A limit for `\pi`::
+
+        >>> f = lambda n: 2**(4*n+1)*fac(n)**4/(2*n+1)/fac(2*n)**2
+        >>> limit(f, inf)
+        3.14159265358979323846264338328
+
+    Calculating the coefficient in Stirling's formula::
+
+        >>> limit(lambda n: fac(n) / (sqrt(n)*(n/e)**n), inf)
+        2.50662827463100050241576528481
+        >>> sqrt(2*pi)
+        2.50662827463100050241576528481
+
+    Evaluating Euler's constant `\gamma` using the limit representation
+
+    .. math ::
+
+        \gamma = \lim_{n \rightarrow \infty } \left[ \left(
+        \sum_{k=1}^n \frac{1}{k} \right) - \log(n) \right]
+
+    (which converges notoriously slowly)::
+
+        >>> f = lambda n: sum([mpf(1)/k for k in range(1,int(n)+1)]) - log(n)
+        >>> limit(f, inf)
+        0.577215664901532860606512090082
+        >>> +euler
+        0.577215664901532860606512090082
+
+    With default settings, the following limit converges too slowly
+    to be evaluated accurately. Changing to exponential sampling
+    however gives a perfect result::
+
+        >>> f = lambda x: sqrt(x**3+x**2)/(sqrt(x**3)+x)
+        >>> limit(f, inf)
+        0.992831158558330281129249686491
+        >>> limit(f, inf, exp=True)
+        1.0
+
+    """
+
+    if ctx.isinf(x):
+        direction = ctx.sign(x)
+        g = lambda k: f(ctx.mpf(k+1)*direction)
+    else:
+        direction *= ctx.one
+        g = lambda k: f(x + direction/(k+1))
+    if exp:
+        h = g
+        g = lambda k: h(2**k)
+
+    def update(values, indices):
+        for k in indices:
+            values.append(g(k+1))
+
+    # XXX: steps used by nsum don't work well
+    if not 'steps' in kwargs:
+        kwargs['steps'] = [10]
+
+    return +ctx.adaptive_extrapolation(update, None, kwargs)
diff --git a/lib/python3.11/site-packages/mpmath/calculus/inverselaplace.py b/lib/python3.11/site-packages/mpmath/calculus/inverselaplace.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2206b05c1601ee781b09dcbedf3c0fcd89cfa59
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/inverselaplace.py
@@ -0,0 +1,973 @@
+# contributed to mpmath by Kristopher L. Kuhlman, February 2017
+# contributed to mpmath by Guillermo Navas-Palencia, February 2022
+
+class InverseLaplaceTransform(object):
+    r"""
+    Inverse Laplace transform methods are implemented using this
+    class, in order to simplify the code and provide a common
+    infrastructure.
+
+    Implement a custom inverse Laplace transform algorithm by
+    subclassing :class:`InverseLaplaceTransform` and implementing the
+    appropriate methods. The subclass can then be used by
+    :func:`~mpmath.invertlaplace` by passing it as the *method*
+    argument.
+    """
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""
+        Determine the vector of Laplace parameter values needed for an
+        algorithm, this will depend on the choice of algorithm (de
+        Hoog is default), the algorithm-specific parameters passed (or
+        default ones), and desired time.
+        """
+        raise NotImplementedError
+
+    def calc_time_domain_solution(self, fp):
+        r"""
+        Compute the time domain solution, after computing the
+        Laplace-space function evaluations at the abscissa required
+        for the algorithm. Abscissa computed for one algorithm are
+        typically not useful for another algorithm.
+        """
+        raise NotImplementedError
+
+
+class FixedTalbot(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""The "fixed" Talbot method deforms the Bromwich contour towards
+        `-\infty` in the shape of a parabola. Traditionally the Talbot
+        algorithm has adjustable parameters, but the "fixed" version
+        does not. The `r` parameter could be passed in as a parameter,
+        if you want to override the default given by (Abate & Valko,
+        2004).
+
+        The Laplace parameter is sampled along a parabola opening
+        along the negative imaginary axis, with the base of the
+        parabola along the real axis at
+        `p=\frac{r}{t_\mathrm{max}}`. As the number of terms used in
+        the approximation (degree) grows, the abscissa required for
+        function evaluation tend towards `-\infty`, requiring high
+        precision to prevent overflow.  If any poles, branch cuts or
+        other singularities exist such that the deformed Bromwich
+        contour lies to the left of the singularity, the method will
+        fail.
+
+        **Optional arguments**
+
+        :class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter`
+        recognizes the following keywords
+
+        *tmax*
+            maximum time associated with vector of times
+            (typically just the time requested)
+        *degree*
+            integer order of approximation (M = number of terms)
+        *r*
+            abscissa for `p_0` (otherwise computed using rule
+            of thumb `2M/5`)
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        .. math ::
+
+            p_0=\frac{r}{t}
+
+        .. math ::
+
+            p_i=\frac{i r \pi}{Mt_\mathrm{max}}\left[\cot\left(
+            \frac{i\pi}{M}\right) + j \right] \qquad 1\le i <M
+
+        where `j=\sqrt{-1}`, `r=2M/5`, and `t_\mathrm{max}` is the
+        maximum specified time.
+
+        """
+
+        # required
+        # ------------------------------
+        # time of desired approximation
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+        # maximum time desired (used for scaling) default is requested
+        # time.
+        self.tmax = self.ctx.convert(kwargs.get('tmax', self.t))
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = self.degree
+        else:
+            self.dps_goal = int(1.72*self.ctx.dps)
+            self.degree = max(12, int(1.38*self.dps_goal))
+
+        M = self.degree
+
+        # this is adjusting the dps of the calling context hopefully
+        # the caller doesn't monkey around with it between calling
+        # this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        # Abate & Valko rule of thumb for r parameter
+        self.r = kwargs.get('r', self.ctx.fraction(2, 5)*M)
+
+        self.theta = self.ctx.linspace(0.0, self.ctx.pi, M+1)
+
+        self.cot_theta = self.ctx.matrix(M, 1)
+        self.cot_theta[0] = 0  # not used
+
+        # all but time-dependent part of p
+        self.delta = self.ctx.matrix(M, 1)
+        self.delta[0] = self.r
+
+        for i in range(1, M):
+            self.cot_theta[i] = self.ctx.cot(self.theta[i])
+            self.delta[i] = self.r*self.theta[i]*(self.cot_theta[i] + 1j)
+
+        self.p = self.ctx.matrix(M, 1)
+        self.p = self.delta/self.tmax
+
+        # NB: p is complex (mpc)
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""The fixed Talbot time-domain solution is computed from the
+        Laplace-space function evaluations using
+
+        .. math ::
+
+            f(t,M)=\frac{2}{5t}\sum_{k=0}^{M-1}\Re \left[
+            \gamma_k \bar{f}(p_k)\right]
+
+        where
+
+        .. math ::
+
+            \gamma_0 = \frac{1}{2}e^{r}\bar{f}(p_0)
+
+        .. math ::
+
+            \gamma_k = e^{tp_k}\left\lbrace 1 + \frac{jk\pi}{M}\left[1 +
+            \cot \left( \frac{k \pi}{M} \right)^2 \right] - j\cot\left(
+            \frac{k \pi}{M}\right)\right \rbrace \qquad 1\le k<M.
+
+        Again, `j=\sqrt{-1}`.
+
+        Before calling this function, call
+        :class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter`
+        to set the parameters and compute the required coefficients.
+
+        **References**
+
+        1. Abate, J., P. Valko (2004). Multi-precision Laplace
+           transform inversion. *International Journal for Numerical
+           Methods in Engineering* 60:979-993,
+           http://dx.doi.org/10.1002/nme.995
+        2. Talbot, A. (1979). The accurate numerical inversion of
+           Laplace transforms. *IMA Journal of Applied Mathematics*
+           23(1):97, http://dx.doi.org/10.1093/imamat/23.1.97
+        """
+
+        # required
+        # ------------------------------
+        self.t = self.ctx.convert(t)
+
+        # assume fp was computed from p matrix returned from
+        # calc_laplace_parameter(), so is already a list or matrix of
+        # mpmath 'mpc' types
+
+        # these were computed in previous call to
+        # calc_laplace_parameter()
+        theta = self.theta
+        delta = self.delta
+        M = self.degree
+        p = self.p
+        r = self.r
+
+        ans = self.ctx.matrix(M, 1)
+        ans[0] = self.ctx.exp(delta[0])*fp[0]/2
+
+        for i in range(1, M):
+            ans[i] = self.ctx.exp(delta[i])*fp[i]*(
+                1 + 1j*theta[i]*(1 + self.cot_theta[i]**2) -
+                1j*self.cot_theta[i])
+
+        result = self.ctx.fraction(2, 5)*self.ctx.fsum(ans)/self.t
+
+        # setting dps back to value when calc_laplace_parameter was
+        # called, unless flag is set.
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result.real
+
+
+# ****************************************
+
+class Stehfest(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""
+        The Gaver-Stehfest method is a discrete approximation of the
+        Widder-Post inversion algorithm, rather than a direct
+        approximation of the Bromwich contour integral.
+
+        The method abscissa along the real axis, and therefore has
+        issues inverting oscillatory functions (which have poles in
+        pairs away from the real axis).
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        .. math ::
+
+            p_k = \frac{k \log 2}{t} \qquad 1 \le k \le M
+        """
+
+        # required
+        # ------------------------------
+        # time of desired approximation
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.38*self.degree)
+        else:
+            self.dps_goal = int(2.93*self.ctx.dps)
+            self.degree = max(16, self.dps_goal)
+
+        # _coeff routine requires even degree
+        if self.degree % 2 > 0:
+            self.degree += 1
+
+        M = self.degree
+
+        # this is adjusting the dps of the calling context
+        # hopefully the caller doesn't monkey around with it
+        # between calling this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        self.V = self._coeff()
+        self.p = self.ctx.matrix(self.ctx.arange(1, M+1))*self.ctx.ln2/self.t
+
+        # NB: p is real (mpf)
+
+    def _coeff(self):
+        r"""Salzer summation weights (aka, "Stehfest coefficients")
+        only depend on the approximation order (M) and the precision"""
+
+        M = self.degree
+        M2 = int(M/2)  # checked earlier that M is even
+
+        V = self.ctx.matrix(M, 1)
+
+        # Salzer summation weights
+        # get very large in magnitude and oscillate in sign,
+        # if the precision is not high enough, there will be
+        # catastrophic cancellation
+        for k in range(1, M+1):
+            z = self.ctx.matrix(min(k, M2)+1, 1)
+            for j in range(int((k+1)/2), min(k, M2)+1):
+                z[j] = (self.ctx.power(j, M2)*self.ctx.fac(2*j)/
+                        (self.ctx.fac(M2-j)*self.ctx.fac(j)*
+                         self.ctx.fac(j-1)*self.ctx.fac(k-j)*
+                         self.ctx.fac(2*j-k)))
+            V[k-1] = self.ctx.power(-1, k+M2)*self.ctx.fsum(z)
+
+        return V
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Compute time-domain Stehfest algorithm solution.
+
+        .. math ::
+
+            f(t,M) = \frac{\log 2}{t} \sum_{k=1}^{M} V_k \bar{f}\left(
+            p_k \right)
+
+        where
+
+        .. math ::
+
+            V_k = (-1)^{k + N/2} \sum^{\min(k,N/2)}_{i=\lfloor(k+1)/2 \rfloor}
+            \frac{i^{\frac{N}{2}}(2i)!}{\left(\frac{N}{2}-i \right)! \, i! \,
+            \left(i-1 \right)! \, \left(k-i\right)! \, \left(2i-k \right)!}
+
+        As the degree increases, the abscissa (`p_k`) only increase
+        linearly towards `\infty`, but the Stehfest coefficients
+        (`V_k`) alternate in sign and increase rapidly in sign,
+        requiring high precision to prevent overflow or loss of
+        significance when evaluating the sum.
+
+        **References**
+
+        1. Widder, D. (1941). *The Laplace Transform*. Princeton.
+        2. Stehfest, H. (1970). Algorithm 368: numerical inversion of
+           Laplace transforms. *Communications of the ACM* 13(1):47-49,
+           http://dx.doi.org/10.1145/361953.361969
+
+        """
+
+        # required
+        self.t = self.ctx.convert(t)
+
+        # assume fp was computed from p matrix returned from
+        # calc_laplace_parameter(), so is already
+        # a list or matrix of mpmath 'mpf' types
+
+        result = self.ctx.fdot(self.V, fp)*self.ctx.ln2/self.t
+
+        # setting dps back to value when calc_laplace_parameter was called
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        # ignore any small imaginary part
+        return result.real
+
+
+# ****************************************
+
+class deHoog(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""the de Hoog, Knight & Stokes algorithm is an
+        accelerated form of the Fourier series numerical
+        inverse Laplace transform algorithms.
+
+        .. math ::
+
+            p_k = \gamma + \frac{jk}{T} \qquad 0 \le k < 2M+1
+
+        where
+
+        .. math ::
+
+            \gamma = \alpha - \frac{\log \mathrm{tol}}{2T},
+
+        `j=\sqrt{-1}`, `T = 2t_\mathrm{max}` is a scaled time,
+        `\alpha=10^{-\mathrm{dps\_goal}}` is the real part of the
+        rightmost pole or singularity, which is chosen based on the
+        desired accuracy (assuming the rightmost singularity is 0),
+        and `\mathrm{tol}=10\alpha` is the desired tolerance, which is
+        chosen in relation to `\alpha`.`
+
+        When increasing the degree, the abscissa increase towards
+        `j\infty`, but more slowly than the fixed Talbot
+        algorithm. The de Hoog et al. algorithm typically does better
+        with oscillatory functions of time, and less well-behaved
+        functions. The method tends to be slower than the Talbot and
+        Stehfest algorithsm, especially so at very high precision
+        (e.g., `>500` digits precision).
+
+        """
+
+        # required
+        # ------------------------------
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+        self.tmax = kwargs.get('tmax', self.t)
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.38*self.degree)
+        else:
+            self.dps_goal = int(self.ctx.dps*1.36)
+            self.degree = max(10, self.dps_goal)
+
+        # 2*M+1 terms in approximation
+        M = self.degree
+
+        # adjust alpha component of abscissa of convergence for higher
+        # precision
+        tmp = self.ctx.power(10.0, -self.dps_goal)
+        self.alpha = self.ctx.convert(kwargs.get('alpha', tmp))
+
+        # desired tolerance (here simply related to alpha)
+        self.tol = self.ctx.convert(kwargs.get('tol', self.alpha*10.0))
+        self.np = 2*self.degree+1  # number of terms in approximation
+
+        # this is adjusting the dps of the calling context
+        # hopefully the caller doesn't monkey around with it
+        # between calling this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        # scaling factor (likely tun-able, but 2 is typical)
+        self.scale = kwargs.get('scale', 2)
+        self.T = self.ctx.convert(kwargs.get('T', self.scale*self.tmax))
+
+        self.p = self.ctx.matrix(2*M+1, 1)
+        self.gamma = self.alpha - self.ctx.log(self.tol)/(self.scale*self.T)
+        self.p = (self.gamma + self.ctx.pi*
+                  self.ctx.matrix(self.ctx.arange(self.np))/self.T*1j)
+
+        # NB: p is complex (mpc)
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Calculate time-domain solution for
+        de Hoog, Knight & Stokes algorithm.
+
+        The un-accelerated Fourier series approach is:
+
+        .. math ::
+
+            f(t,2M+1) = \frac{e^{\gamma t}}{T} \sum_{k=0}^{2M}{}^{'}
+            \Re\left[\bar{f}\left( p_k \right)
+            e^{i\pi t/T} \right],
+
+        where the prime on the summation indicates the first term is halved.
+
+        This simplistic approach requires so many function evaluations
+        that it is not practical. Non-linear acceleration is
+        accomplished via Pade-approximation and an analytic expression
+        for the remainder of the continued fraction. See the original
+        paper (reference 2 below) a detailed description of the
+        numerical approach.
+
+        **References**
+
+        1. Davies, B. (2005). *Integral Transforms and their
+           Applications*, Third Edition. Springer.
+        2. de Hoog, F., J. Knight, A. Stokes (1982). An improved
+           method for numerical inversion of Laplace transforms. *SIAM
+           Journal of Scientific and Statistical Computing* 3:357-366,
+           http://dx.doi.org/10.1137/0903022
+
+        """
+
+        M = self.degree
+        np = self.np
+        T = self.T
+
+        self.t = self.ctx.convert(t)
+
+        # would it be useful to try re-using
+        # space between e&q and A&B?
+        e = self.ctx.zeros(np, M+1)
+        q = self.ctx.matrix(2*M, M)
+        d = self.ctx.matrix(np, 1)
+        A = self.ctx.zeros(np+1, 1)
+        B = self.ctx.ones(np+1, 1)
+
+        # initialize Q-D table
+        e[:, 0] = 0.0 + 0j
+        q[0, 0] = fp[1]/(fp[0]/2)
+        for i in range(1, 2*M):
+            q[i, 0] = fp[i+1]/fp[i]
+
+        # rhombus rule for filling triangular Q-D table (e & q)
+        for r in range(1, M+1):
+            # start with e, column 1, 0:2*M-2
+            mr = 2*(M-r) + 1
+            e[0:mr, r] = q[1:mr+1, r-1] - q[0:mr, r-1] + e[1:mr+1, r-1]
+            if not r == M:
+                rq = r+1
+                mr = 2*(M-rq)+1 + 2
+                for i in range(mr):
+                    q[i, rq-1] = q[i+1, rq-2]*e[i+1, rq-1]/e[i, rq-1]
+
+        # build up continued fraction coefficients (d)
+        d[0] = fp[0]/2
+        for r in range(1, M+1):
+            d[2*r-1] = -q[0, r-1]  # even terms
+            d[2*r]   = -e[0, r]    # odd terms
+
+        # seed A and B for recurrence
+        A[0] = 0.0 + 0.0j
+        A[1] = d[0]
+        B[0:2] = 1.0 + 0.0j
+
+        # base of the power series
+        z = self.ctx.expjpi(self.t/T)  # i*pi is already in fcn
+
+        # coefficients of Pade approximation (A & B)
+        # using recurrence for all but last term
+        for i in range(1, 2*M):
+            A[i+1] = A[i] + d[i]*A[i-1]*z
+            B[i+1] = B[i] + d[i]*B[i-1]*z
+
+        # "improved remainder" to continued fraction
+        brem = (1 + (d[2*M-1] - d[2*M])*z)/2
+        # powm1(x,y) computes x^y - 1 more accurately near zero
+        rem = brem*self.ctx.powm1(1 + d[2*M]*z/brem,
+                                  self.ctx.fraction(1, 2))
+
+        # last term of recurrence using new remainder
+        A[np] = A[2*M] + rem*A[2*M-1]
+        B[np] = B[2*M] + rem*B[2*M-1]
+
+        # diagonal Pade approximation
+        # F=A/B represents accelerated trapezoid rule
+        result = self.ctx.exp(self.gamma*self.t)/T*(A[np]/B[np]).real
+
+        # setting dps back to value when calc_laplace_parameter was called
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result
+
+
+# ****************************************
+
+class Cohen(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""The Cohen algorithm accelerates the convergence of the nearly
+        alternating series resulting from the application of the trapezoidal
+        rule to the Bromwich contour inversion integral.
+
+        .. math ::
+
+            p_k = \frac{\gamma}{2 t} + \frac{\pi i k}{t} \qquad 0 \le k < M
+
+        where
+
+        .. math ::
+
+            \gamma = \frac{2}{3} (d + \log(10) + \log(2 t)),
+
+        `d = \mathrm{dps\_goal}`, which is chosen based on the desired
+        accuracy using the method developed in [1] to improve numerical
+        stability. The Cohen algorithm shows robustness similar to the de Hoog
+        et al. algorithm, but it is faster than the fixed Talbot algorithm.
+
+        **Optional arguments**
+
+        *degree*
+            integer order of the approximation (M = number of terms)
+        *alpha*
+            abscissa for `p_0` (controls the discretization error)
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        **References**
+
+        1. P. Glasserman, J. Ruiz-Mata (2006). Computing the credit loss
+        distribution in the Gaussian copula model: a comparison of methods.
+        *Journal of Credit Risk* 2(4):33-66, 10.21314/JCR.2006.057
+
+        """
+        self.t = self.ctx.convert(t)
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.5 * self.degree)
+        else:
+            self.dps_goal = int(self.ctx.dps * 1.74)
+            self.degree = max(22, int(1.31 * self.dps_goal))
+
+        M = self.degree + 1
+
+        # this is adjusting the dps of the calling context hopefully
+        # the caller doesn't monkey around with it between calling
+        # this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        ttwo = 2 * self.t
+        tmp = self.ctx.dps * self.ctx.log(10) + self.ctx.log(ttwo)
+        tmp = self.ctx.fraction(2, 3) * tmp
+        self.alpha = self.ctx.convert(kwargs.get('alpha', tmp))
+
+        # all but time-dependent part of p
+        a_t = self.alpha / ttwo
+        p_t = self.ctx.pi * 1j / self.t
+
+        self.p = self.ctx.matrix(M, 1)
+        self.p[0] = a_t
+
+        for i in range(1, M):
+            self.p[i] = a_t + i * p_t
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Calculate time-domain solution for Cohen algorithm.
+
+        The accelerated nearly alternating series is:
+
+        .. math ::
+
+            f(t, M) = \frac{e^{\gamma / 2}}{t} \left[\frac{1}{2}
+            \Re\left(\bar{f}\left(\frac{\gamma}{2t}\right) \right) -
+            \sum_{k=0}^{M-1}\frac{c_{M,k}}{d_M}\Re\left(\bar{f}
+            \left(\frac{\gamma + 2(k+1) \pi i}{2t}\right)\right)\right],
+
+        where coefficients `\frac{c_{M, k}}{d_M}` are described in [1].
+
+        1. H. Cohen, F. Rodriguez Villegas, D. Zagier (2000). Convergence
+        acceleration of alternating series. *Experiment. Math* 9(1):3-12
+
+        """
+        self.t = self.ctx.convert(t)
+
+        n = self.degree
+        M = n + 1
+
+        A = self.ctx.matrix(M, 1)
+        for i in range(M):
+            A[i] = fp[i].real
+
+        d = (3 + self.ctx.sqrt(8)) ** n
+        d = (d + 1 / d) / 2
+        b = -self.ctx.one
+        c = -d
+        s = 0
+
+        for k in range(n):
+            c = b - c
+            s = s + c * A[k + 1]
+            b = 2 * (k + n) * (k - n) * b / ((2 * k + 1) * (k + self.ctx.one))
+
+        result = self.ctx.exp(self.alpha / 2) / self.t * (A[0] / 2 - s / d)
+
+        # setting dps back to value when calc_laplace_parameter was
+        # called, unless flag is set.
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result
+
+
+# ****************************************
+
+class LaplaceTransformInversionMethods(object):
+    def __init__(ctx, *args, **kwargs):
+        ctx._fixed_talbot = FixedTalbot(ctx)
+        ctx._stehfest = Stehfest(ctx)
+        ctx._de_hoog = deHoog(ctx)
+        ctx._cohen = Cohen(ctx)
+
+    def invertlaplace(ctx, f, t, **kwargs):
+        r"""Computes the numerical inverse Laplace transform for a
+        Laplace-space function at a given time.  The function being
+        evaluated is assumed to be a real-valued function of time.
+
+        The user must supply a Laplace-space function `\bar{f}(p)`,
+        and a desired time at which to estimate the time-domain
+        solution `f(t)`.
+
+        A few basic examples of Laplace-space functions with known
+        inverses (see references [1,2]) :
+
+        .. math ::
+
+            \mathcal{L}\left\lbrace f(t) \right\rbrace=\bar{f}(p)
+
+        .. math ::
+
+            \mathcal{L}^{-1}\left\lbrace \bar{f}(p) \right\rbrace = f(t)
+
+        .. math ::
+
+            \bar{f}(p) = \frac{1}{(p+1)^2}
+
+        .. math ::
+
+            f(t) = t e^{-t}
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> tt = [0.001, 0.01, 0.1, 1, 10]
+        >>> fp = lambda p: 1/(p+1)**2
+        >>> ft = lambda t: t*exp(-t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='talbot')
+        (0.000999000499833375, 8.57923043561212e-20)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='talbot')
+        (0.00990049833749168, 3.27007646698047e-19)
+        >>> ft(tt[2]),ft(tt[2])-invertlaplace(fp,tt[2],method='talbot')
+        (0.090483741803596, -1.75215800052168e-18)
+        >>> ft(tt[3]),ft(tt[3])-invertlaplace(fp,tt[3],method='talbot')
+        (0.367879441171442, 1.2428864009344e-17)
+        >>> ft(tt[4]),ft(tt[4])-invertlaplace(fp,tt[4],method='talbot')
+        (0.000453999297624849, 4.04513489306658e-20)
+
+        The methods also work for higher precision:
+
+        >>> mp.dps = 100; mp.pretty = True
+        >>> nstr(ft(tt[0]),15),nstr(ft(tt[0])-invertlaplace(fp,tt[0],method='talbot'),15)
+        ('0.000999000499833375', '-4.96868310693356e-105')
+        >>> nstr(ft(tt[1]),15),nstr(ft(tt[1])-invertlaplace(fp,tt[1],method='talbot'),15)
+        ('0.00990049833749168', '1.23032291513122e-104')
+
+        .. math ::
+
+            \bar{f}(p) = \frac{1}{p^2+1}
+
+        .. math ::
+
+            f(t) = \mathrm{J}_0(t)
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: 1/sqrt(p*p + 1)
+        >>> ft = lambda t: besselj(0,t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='dehoog')
+        (0.999999750000016, -6.09717765032273e-18)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='dehoog')
+        (0.99997500015625, -5.61756281076169e-17)
+
+        .. math ::
+
+            \bar{f}(p) = \frac{\log p}{p}
+
+        .. math ::
+
+            f(t) = -\gamma -\log t
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: log(p)/p
+        >>> ft = lambda t: -euler-log(t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='stehfest')
+        (6.3305396140806, -1.92126634837863e-16)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='stehfest')
+        (4.02795452108656, -4.81486093200704e-16)
+
+        **Options**
+
+        :func:`~mpmath.invertlaplace` recognizes the following optional
+        keywords valid for all methods:
+
+        *method*
+            Chooses numerical inverse Laplace transform algorithm
+            (described below).
+        *degree*
+            Number of terms used in the approximation
+
+        **Algorithms**
+
+        Mpmath implements four numerical inverse Laplace transform
+        algorithms, attributed to: Talbot, Stehfest, and de Hoog,
+        Knight and Stokes. These can be selected by using
+        *method='talbot'*, *method='stehfest'*, *method='dehoog'* or
+        *method='cohen'* or by passing the classes *method=FixedTalbot*,
+        *method=Stehfest*, *method=deHoog*, or *method=Cohen*. The functions
+        :func:`~mpmath.invlaptalbot`, :func:`~mpmath.invlapstehfest`,
+        :func:`~mpmath.invlapdehoog`, and :func:`~mpmath.invlapcohen`
+        are also available as shortcuts.
+
+        All four algorithms implement a heuristic balance between the
+        requested precision and the precision used internally for the
+        calculations. This has been tuned for a typical exponentially
+        decaying function and precision up to few hundred decimal
+        digits.
+
+        The Laplace transform converts the variable time (i.e., along
+        a line) into a parameter given by the right half of the
+        complex `p`-plane.  Singularities, poles, and branch cuts in
+        the complex `p`-plane contain all the information regarding
+        the time behavior of the corresponding function. Any numerical
+        method must therefore sample `p`-plane "close enough" to the
+        singularities to accurately characterize them, while not
+        getting too close to have catastrophic cancellation, overflow,
+        or underflow issues. Most significantly, if one or more of the
+        singularities in the `p`-plane is not on the left side of the
+        Bromwich contour, its effects will be left out of the computed
+        solution, and the answer will be completely wrong.
+
+        *Talbot*
+
+        The fixed Talbot method is high accuracy and fast, but the
+        method can catastrophically fail for certain classes of time-domain
+        behavior, including a Heaviside step function for positive
+        time (e.g., `H(t-2)`), or some oscillatory behaviors. The
+        Talbot method usually has adjustable parameters, but the
+        "fixed" variety implemented here does not. This method
+        deforms the Bromwich integral contour in the shape of a
+        parabola towards `-\infty`, which leads to problems
+        when the solution has a decaying exponential in it (e.g., a
+        Heaviside step function is equivalent to multiplying by a
+        decaying exponential in Laplace space).
+
+        *Stehfest*
+
+        The Stehfest algorithm only uses abscissa along the real axis
+        of the complex `p`-plane to estimate the time-domain
+        function. Oscillatory time-domain functions have poles away
+        from the real axis, so this method does not work well with
+        oscillatory functions, especially high-frequency ones. This
+        method also depends on summation of terms in a series that
+        grows very large, and will have catastrophic cancellation
+        during summation if the working precision is too low.
+
+        *de Hoog et al.*
+
+        The de Hoog, Knight, and Stokes method is essentially a
+        Fourier-series quadrature-type approximation to the Bromwich
+        contour integral, with non-linear series acceleration and an
+        analytical expression for the remainder term. This method is
+        typically one of the most robust. This method also involves the
+        greatest amount of overhead, so it is typically the slowest of the
+        four methods at high precision.
+
+        *Cohen*
+
+        The Cohen method is a trapezoidal rule approximation to the Bromwich
+        contour integral, with linear acceleration for alternating
+        series. This method is as robust as the de Hoog et al method and the
+        fastest of the four methods at high precision, and is therefore the
+        default method.
+
+        **Singularities**
+
+        All numerical inverse Laplace transform methods have problems
+        at large time when the Laplace-space function has poles,
+        singularities, or branch cuts to the right of the origin in
+        the complex plane. For simple poles in `\bar{f}(p)` at the
+        `p`-plane origin, the time function is constant in time (e.g.,
+        `\mathcal{L}\left\lbrace 1 \right\rbrace=1/p` has a pole at
+        `p=0`). A pole in `\bar{f}(p)` to the left of the origin is a
+        decreasing function of time (e.g., `\mathcal{L}\left\lbrace
+        e^{-t/2} \right\rbrace=1/(p+1/2)` has a pole at `p=-1/2`), and
+        a pole to the right of the origin leads to an increasing
+        function in time (e.g., `\mathcal{L}\left\lbrace t e^{t/4}
+        \right\rbrace = 1/(p-1/4)^2` has a pole at `p=1/4`).  When
+        singularities occur off the real `p` axis, the time-domain
+        function is oscillatory. For example `\mathcal{L}\left\lbrace
+        \mathrm{J}_0(t) \right\rbrace=1/\sqrt{p^2+1}` has a branch cut
+        starting at `p=j=\sqrt{-1}` and is a decaying oscillatory
+        function, This range of behaviors is illustrated in Duffy [3]
+        Figure 4.10.4, p. 228.
+
+        In general as `p \rightarrow \infty` `t \rightarrow 0` and
+        vice-versa. All numerical inverse Laplace transform methods
+        require their abscissa to shift closer to the origin for
+        larger times. If the abscissa shift left of the rightmost
+        singularity in the Laplace domain, the answer will be
+        completely wrong (the effect of singularities to the right of
+        the Bromwich contour are not included in the results).
+
+        For example, the following exponentially growing function has
+        a pole at `p=3`:
+
+        .. math ::
+
+            \bar{f}(p)=\frac{1}{p^2-9}
+
+        .. math ::
+
+            f(t)=\frac{1}{3}\sinh 3t
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: 1/(p*p-9)
+        >>> ft = lambda t: sinh(3*t)/3
+        >>> tt = [0.01,0.1,1.0,10.0]
+        >>> ft(tt[0]),invertlaplace(fp,tt[0],method='talbot')
+        (0.0100015000675014, 0.0100015000675014)
+        >>> ft(tt[1]),invertlaplace(fp,tt[1],method='talbot')
+        (0.101506764482381, 0.101506764482381)
+        >>> ft(tt[2]),invertlaplace(fp,tt[2],method='talbot')
+        (3.33929164246997, 3.33929164246997)
+        >>> ft(tt[3]),invertlaplace(fp,tt[3],method='talbot')
+        (1781079096920.74, -1.61331069624091e-14)
+
+        **References**
+
+        1. [DLMF]_ section 1.14 (http://dlmf.nist.gov/1.14T4)
+        2. Cohen, A.M. (2007). Numerical Methods for Laplace Transform
+           Inversion, Springer.
+        3. Duffy, D.G. (1998). Advanced Engineering Mathematics, CRC Press.
+
+        **Numerical Inverse Laplace Transform Reviews**
+
+        1. Bellman, R., R.E. Kalaba, J.A. Lockett (1966). *Numerical
+           inversion of the Laplace transform: Applications to Biology,
+           Economics, Engineering, and Physics*. Elsevier.
+        2. Davies, B., B. Martin (1979). Numerical inversion of the
+           Laplace transform: a survey and comparison of methods. *Journal
+           of Computational Physics* 33:1-32,
+           http://dx.doi.org/10.1016/0021-9991(79)90025-1
+        3. Duffy, D.G. (1993). On the numerical inversion of Laplace
+           transforms: Comparison of three new methods on characteristic
+           problems from applications. *ACM Transactions on Mathematical
+           Software* 19(3):333-359, http://dx.doi.org/10.1145/155743.155788
+        4. Kuhlman, K.L., (2013). Review of Inverse Laplace Transform
+           Algorithms for Laplace-Space Numerical Approaches, *Numerical
+           Algorithms*, 63(2):339-355.
+           http://dx.doi.org/10.1007/s11075-012-9625-3
+
+        """
+
+        rule = kwargs.get('method', 'cohen')
+        if type(rule) is str:
+            lrule = rule.lower()
+            if lrule == 'talbot':
+                rule = ctx._fixed_talbot
+            elif lrule == 'stehfest':
+                rule = ctx._stehfest
+            elif lrule == 'dehoog':
+                rule = ctx._de_hoog
+            elif rule == 'cohen':
+                rule = ctx._cohen
+            else:
+                raise ValueError("unknown invlap algorithm: %s" % rule)
+        else:
+            rule = rule(ctx)
+
+        # determine the vector of Laplace-space parameter
+        # needed for the requested method and desired time
+        rule.calc_laplace_parameter(t, **kwargs)
+
+        # compute the Laplace-space function evalutations
+        # at the required abscissa.
+        fp = [f(p) for p in rule.p]
+
+        # compute the time-domain solution from the
+        # Laplace-space function evaluations
+        return rule.calc_time_domain_solution(fp, t)
+
+    # shortcuts for the above function for specific methods
+    def invlaptalbot(ctx, *args, **kwargs):
+        kwargs['method'] = 'talbot'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapstehfest(ctx, *args, **kwargs):
+        kwargs['method'] = 'stehfest'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapdehoog(ctx, *args, **kwargs):
+        kwargs['method'] = 'dehoog'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapcohen(ctx, *args, **kwargs):
+        kwargs['method'] = 'cohen'
+        return ctx.invertlaplace(*args, **kwargs)
+
+
+# ****************************************
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.11/site-packages/mpmath/calculus/odes.py b/lib/python3.11/site-packages/mpmath/calculus/odes.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac6bd3cb056c8841e6cf77ba4d08a0b1abb2f2c9
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/odes.py
@@ -0,0 +1,288 @@
+from bisect import bisect
+from ..libmp.backend import xrange
+
+class ODEMethods(object):
+    pass
+
+def ode_taylor(ctx, derivs, x0, y0, tol_prec, n):
+    h = tol = ctx.ldexp(1, -tol_prec)
+    dim = len(y0)
+    xs = [x0]
+    ys = [y0]
+    x = x0
+    y = y0
+    orig = ctx.prec
+    try:
+        ctx.prec = orig*(1+n)
+        # Use n steps with Euler's method to get
+        # evaluation points for derivatives
+        for i in range(n):
+            fxy = derivs(x, y)
+            y = [y[i]+h*fxy[i] for i in xrange(len(y))]
+            x += h
+            xs.append(x)
+            ys.append(y)
+        # Compute derivatives
+        ser = [[] for d in range(dim)]
+        for j in range(n+1):
+            s = [0]*dim
+            b = (-1) ** (j & 1)
+            k = 1
+            for i in range(j+1):
+                for d in range(dim):
+                    s[d] += b * ys[i][d]
+                b = (b * (j-k+1)) // (-k)
+                k += 1
+            scale = h**(-j) / ctx.fac(j)
+            for d in range(dim):
+                s[d] = s[d] * scale
+                ser[d].append(s[d])
+    finally:
+        ctx.prec = orig
+    # Estimate radius for which we can get full accuracy.
+    # XXX: do this right for zeros
+    radius = ctx.one
+    for ts in ser:
+        if ts[-1]:
+            radius = min(radius, ctx.nthroot(tol/abs(ts[-1]), n))
+    radius /= 2  # XXX
+    return ser, x0+radius
+
+def odefun(ctx, F, x0, y0, tol=None, degree=None, method='taylor', verbose=False):
+    r"""
+    Returns a function `y(x) = [y_0(x), y_1(x), \ldots, y_n(x)]`
+    that is a numerical solution of the `n+1`-dimensional first-order
+    ordinary differential equation (ODE) system
+
+    .. math ::
+
+        y_0'(x) = F_0(x, [y_0(x), y_1(x), \ldots, y_n(x)])
+
+        y_1'(x) = F_1(x, [y_0(x), y_1(x), \ldots, y_n(x)])
+
+        \vdots
+
+        y_n'(x) = F_n(x, [y_0(x), y_1(x), \ldots, y_n(x)])
+
+    The derivatives are specified by the vector-valued function
+    *F* that evaluates
+    `[y_0', \ldots, y_n'] = F(x, [y_0, \ldots, y_n])`.
+    The initial point `x_0` is specified by the scalar argument *x0*,
+    and the initial value `y(x_0) =  [y_0(x_0), \ldots, y_n(x_0)]` is
+    specified by the vector argument *y0*.
+
+    For convenience, if the system is one-dimensional, you may optionally
+    provide just a scalar value for *y0*. In this case, *F* should accept
+    a scalar *y* argument and return a scalar. The solution function
+    *y* will return scalar values instead of length-1 vectors.
+
+    Evaluation of the solution function `y(x)` is permitted
+    for any `x \ge x_0`.
+
+    A high-order ODE can be solved by transforming it into first-order
+    vector form. This transformation is described in standard texts
+    on ODEs. Examples will also be given below.
+
+    **Options, speed and accuracy**
+
+    By default, :func:`~mpmath.odefun` uses a high-order Taylor series
+    method. For reasonably well-behaved problems, the solution will
+    be fully accurate to within the working precision. Note that
+    *F* must be possible to evaluate to very high precision
+    for the generation of Taylor series to work.
+
+    To get a faster but less accurate solution, you can set a large
+    value for *tol* (which defaults roughly to *eps*). If you just
+    want to plot the solution or perform a basic simulation,
+    *tol = 0.01* is likely sufficient.
+
+    The *degree* argument controls the degree of the solver (with
+    *method='taylor'*, this is the degree of the Taylor series
+    expansion). A higher degree means that a longer step can be taken
+    before a new local solution must be generated from *F*,
+    meaning that fewer steps are required to get from `x_0` to a given
+    `x_1`. On the other hand, a higher degree also means that each
+    local solution becomes more expensive (i.e., more evaluations of
+    *F* are required per step, and at higher precision).
+
+    The optimal setting therefore involves a tradeoff. Generally,
+    decreasing the *degree* for Taylor series is likely to give faster
+    solution at low precision, while increasing is likely to be better
+    at higher precision.
+
+    The function
+    object returned by :func:`~mpmath.odefun` caches the solutions at all step
+    points and uses polynomial interpolation between step points.
+    Therefore, once `y(x_1)` has been evaluated for some `x_1`,
+    `y(x)` can be evaluated very quickly for any `x_0 \le x \le x_1`.
+    and continuing the evaluation up to `x_2 > x_1` is also fast.
+
+    **Examples of first-order ODEs**
+
+    We will solve the standard test problem `y'(x) = y(x), y(0) = 1`
+    which has explicit solution `y(x) = \exp(x)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> f = odefun(lambda x, y: y, 0, 1)
+        >>> for x in [0, 1, 2.5]:
+        ...     print((f(x), exp(x)))
+        ...
+        (1.0, 1.0)
+        (2.71828182845905, 2.71828182845905)
+        (12.1824939607035, 12.1824939607035)
+
+    The solution with high precision::
+
+        >>> mp.dps = 50
+        >>> f = odefun(lambda x, y: y, 0, 1)
+        >>> f(1)
+        2.7182818284590452353602874713526624977572470937
+        >>> exp(1)
+        2.7182818284590452353602874713526624977572470937
+
+    Using the more general vectorized form, the test problem
+    can be input as (note that *f* returns a 1-element vector)::
+
+        >>> mp.dps = 15
+        >>> f = odefun(lambda x, y: [y[0]], 0, [1])
+        >>> f(1)
+        [2.71828182845905]
+
+    :func:`~mpmath.odefun` can solve nonlinear ODEs, which are generally
+    impossible (and at best difficult) to solve analytically. As
+    an example of a nonlinear ODE, we will solve `y'(x) = x \sin(y(x))`
+    for `y(0) = \pi/2`. An exact solution happens to be known
+    for this problem, and is given by
+    `y(x) = 2 \tan^{-1}\left(\exp\left(x^2/2\right)\right)`::
+
+        >>> f = odefun(lambda x, y: x*sin(y), 0, pi/2)
+        >>> for x in [2, 5, 10]:
+        ...     print((f(x), 2*atan(exp(mpf(x)**2/2))))
+        ...
+        (2.87255666284091, 2.87255666284091)
+        (3.14158520028345, 3.14158520028345)
+        (3.14159265358979, 3.14159265358979)
+
+    If `F` is independent of `y`, an ODE can be solved using direct
+    integration. We can therefore obtain a reference solution with
+    :func:`~mpmath.quad`::
+
+        >>> f = lambda x: (1+x**2)/(1+x**3)
+        >>> g = odefun(lambda x, y: f(x), pi, 0)
+        >>> g(2*pi)
+        0.72128263801696
+        >>> quad(f, [pi, 2*pi])
+        0.72128263801696
+
+    **Examples of second-order ODEs**
+
+    We will solve the harmonic oscillator equation `y''(x) + y(x) = 0`.
+    To do this, we introduce the helper functions `y_0 = y, y_1 = y_0'`
+    whereby the original equation can be written as `y_1' + y_0' = 0`. Put
+    together, we get the first-order, two-dimensional vector ODE
+
+    .. math ::
+
+        \begin{cases}
+        y_0' = y_1 \\
+        y_1' = -y_0
+        \end{cases}
+
+    To get a well-defined IVP, we need two initial values. With
+    `y(0) = y_0(0) = 1` and `-y'(0) = y_1(0) = 0`, the problem will of
+    course be solved by `y(x) = y_0(x) = \cos(x)` and
+    `-y'(x) = y_1(x) = \sin(x)`. We check this::
+
+        >>> f = odefun(lambda x, y: [-y[1], y[0]], 0, [1, 0])
+        >>> for x in [0, 1, 2.5, 10]:
+        ...     nprint(f(x), 15)
+        ...     nprint([cos(x), sin(x)], 15)
+        ...     print("---")
+        ...
+        [1.0, 0.0]
+        [1.0, 0.0]
+        ---
+        [0.54030230586814, 0.841470984807897]
+        [0.54030230586814, 0.841470984807897]
+        ---
+        [-0.801143615546934, 0.598472144103957]
+        [-0.801143615546934, 0.598472144103957]
+        ---
+        [-0.839071529076452, -0.54402111088937]
+        [-0.839071529076452, -0.54402111088937]
+        ---
+
+    Note that we get both the sine and the cosine solutions
+    simultaneously.
+
+    **TODO**
+
+    * Better automatic choice of degree and step size
+    * Make determination of Taylor series convergence radius
+      more robust
+    * Allow solution for `x < x_0`
+    * Allow solution for complex `x`
+    * Test for difficult (ill-conditioned) problems
+    * Implement Runge-Kutta and other algorithms
+
+    """
+    if tol:
+        tol_prec = int(-ctx.log(tol, 2))+10
+    else:
+        tol_prec = ctx.prec+10
+    degree = degree or (3 + int(3*ctx.dps/2.))
+    workprec = ctx.prec + 40
+    try:
+        len(y0)
+        return_vector = True
+    except TypeError:
+        F_ = F
+        F = lambda x, y: [F_(x, y[0])]
+        y0 = [y0]
+        return_vector = False
+    ser, xb = ode_taylor(ctx, F, x0, y0, tol_prec, degree)
+    series_boundaries = [x0, xb]
+    series_data = [(ser, x0, xb)]
+    # We will be working with vectors of Taylor series
+    def mpolyval(ser, a):
+        return [ctx.polyval(s[::-1], a) for s in ser]
+    # Find nearest expansion point; compute if necessary
+    def get_series(x):
+        if x < x0:
+            raise ValueError
+        n = bisect(series_boundaries, x)
+        if n < len(series_boundaries):
+            return series_data[n-1]
+        while 1:
+            ser, xa, xb = series_data[-1]
+            if verbose:
+                print("Computing Taylor series for [%f, %f]" % (xa, xb))
+            y = mpolyval(ser, xb-xa)
+            xa = xb
+            ser, xb = ode_taylor(ctx, F, xb, y, tol_prec, degree)
+            series_boundaries.append(xb)
+            series_data.append((ser, xa, xb))
+            if x <= xb:
+                return series_data[-1]
+    # Evaluation function
+    def interpolant(x):
+        x = ctx.convert(x)
+        orig = ctx.prec
+        try:
+            ctx.prec = workprec
+            ser, xa, xb = get_series(x)
+            y = mpolyval(ser, x-xa)
+        finally:
+            ctx.prec = orig
+        if return_vector:
+            return [+yk for yk in y]
+        else:
+            return +y[0]
+    return interpolant
+
+ODEMethods.odefun = odefun
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.11/site-packages/mpmath/calculus/optimization.py b/lib/python3.11/site-packages/mpmath/calculus/optimization.py
new file mode 100644
index 0000000000000000000000000000000000000000..69724f78336ee24856366db48917a47108b1b416
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/optimization.py
@@ -0,0 +1,1102 @@
+from __future__ import print_function
+
+from copy import copy
+
+from ..libmp.backend import xrange
+
+class OptimizationMethods(object):
+    def __init__(ctx):
+        pass
+
+##############
+# 1D-SOLVERS #
+##############
+
+class Newton:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting points x0 close to the root.
+
+    Pro:
+
+    * converges fast
+    * sometimes more robust than secant with bad second starting point
+
+    Contra:
+
+    * converges slowly for multiple roots
+    * needs first derivative
+    * 2 function evaluations per iteration
+    """
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) == 1:
+            self.x0 = x0[0]
+        else:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+
+    def __iter__(self):
+        f = self.f
+        df = self.df
+        x0 = self.x0
+        while True:
+            x1 = x0 - f(x0) / df(x0)
+            error = abs(x1 - x0)
+            x0 = x1
+            yield (x1, error)
+
+class Secant:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting points x0 and x1 close to the root.
+    x1 defaults to x0 + 0.25.
+
+    Pro:
+
+    * converges fast
+
+    Contra:
+
+    * converges slowly for multiple roots
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) == 1:
+            self.x0 = x0[0]
+            self.x1 = self.x0 + 0.25
+        elif len(x0) == 2:
+            self.x0 = x0[0]
+            self.x1 = x0[1]
+        else:
+            raise ValueError('expected 1 or 2 starting points, got %i' % len(x0))
+        self.f = f
+
+    def __iter__(self):
+        f = self.f
+        x0 = self.x0
+        x1 = self.x1
+        f0 = f(x0)
+        while True:
+            f1 = f(x1)
+            l = x1 - x0
+            if not l:
+                break
+            s = (f1 - f0) / l
+            if not s:
+                break
+            x0, x1 = x1, x1 - f1/s
+            f0 = f1
+            yield x1, abs(l)
+
+class MNewton:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting point x0 close to the root.
+    Uses modified Newton's method that converges fast regardless of the
+    multiplicity of the root.
+
+    Pro:
+
+    * converges fast for multiple roots
+
+    Contra:
+
+    * needs first and second derivative of f
+    * 3 function evaluations per iteration
+    """
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if not len(x0) == 1:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.x0 = x0[0]
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+        if not 'd2f' in kwargs:
+            def d2f(x):
+                return self.ctx.diff(df, x)
+        else:
+            d2f = kwargs['df']
+        self.d2f = d2f
+
+    def __iter__(self):
+        x = self.x0
+        f = self.f
+        df = self.df
+        d2f = self.d2f
+        while True:
+            prevx = x
+            fx = f(x)
+            if fx == 0:
+                break
+            dfx = df(x)
+            d2fx = d2f(x)
+            # x = x - F(x)/F'(x) with F(x) = f(x)/f'(x)
+            x -= fx / (dfx - fx * d2fx / dfx)
+            error = abs(x - prevx)
+            yield x, error
+
+class Halley:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs a starting point x0 close to the root.
+    Uses Halley's method with cubic convergence rate.
+
+    Pro:
+
+    * converges even faster the Newton's method
+    * useful when computing with *many* digits
+
+    Contra:
+
+    * needs first and second derivative of f
+    * 3 function evaluations per iteration
+    * converges slowly for multiple roots
+    """
+
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if not len(x0) == 1:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.x0 = x0[0]
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+        if not 'd2f' in kwargs:
+            def d2f(x):
+                return self.ctx.diff(df, x)
+        else:
+            d2f = kwargs['df']
+        self.d2f = d2f
+
+    def __iter__(self):
+        x = self.x0
+        f = self.f
+        df = self.df
+        d2f = self.d2f
+        while True:
+            prevx = x
+            fx = f(x)
+            dfx = df(x)
+            d2fx = d2f(x)
+            x -=  2*fx*dfx / (2*dfx**2 - fx*d2fx)
+            error = abs(x - prevx)
+            yield x, error
+
+class Muller:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Needs starting points x0, x1 and x2 close to the root.
+    x1 defaults to x0 + 0.25; x2 to x1 + 0.25.
+    Uses Muller's method that converges towards complex roots.
+
+    Pro:
+
+    * converges fast (somewhat faster than secant)
+    * can find complex roots
+
+    Contra:
+
+    * converges slowly for multiple roots
+    * may have complex values for real starting points and real roots
+
+    http://en.wikipedia.org/wiki/Muller's_method
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) == 1:
+            self.x0 = x0[0]
+            self.x1 = self.x0 + 0.25
+            self.x2 = self.x1 + 0.25
+        elif len(x0) == 2:
+            self.x0 = x0[0]
+            self.x1 = x0[1]
+            self.x2 = self.x1 + 0.25
+        elif len(x0) == 3:
+            self.x0 = x0[0]
+            self.x1 = x0[1]
+            self.x2 = x0[2]
+        else:
+            raise ValueError('expected 1, 2 or 3 starting points, got %i'
+                             % len(x0))
+        self.f = f
+        self.verbose = kwargs['verbose']
+
+    def __iter__(self):
+        f = self.f
+        x0 = self.x0
+        x1 = self.x1
+        x2 = self.x2
+        fx0 = f(x0)
+        fx1 = f(x1)
+        fx2 = f(x2)
+        while True:
+            # TODO: maybe refactoring with function for divided differences
+            # calculate divided differences
+            fx2x1 = (fx1 - fx2) / (x1 - x2)
+            fx2x0 = (fx0 - fx2) / (x0 - x2)
+            fx1x0 = (fx0 - fx1) / (x0 - x1)
+            w = fx2x1 + fx2x0 - fx1x0
+            fx2x1x0 = (fx1x0 - fx2x1) / (x0 - x2)
+            if w == 0 and fx2x1x0 == 0:
+                if self.verbose:
+                    print('canceled with')
+                    print('x0 =', x0, ', x1 =', x1, 'and x2 =', x2)
+                break
+            x0 = x1
+            fx0 = fx1
+            x1 = x2
+            fx1 = fx2
+            # denominator should be as large as possible => choose sign
+            r = self.ctx.sqrt(w**2 - 4*fx2*fx2x1x0)
+            if abs(w - r) > abs(w + r):
+                r = -r
+            x2 -= 2*fx2 / (w + r)
+            fx2 = f(x2)
+            error = abs(x2 - x1)
+            yield x2, error
+
+# TODO: consider raising a ValueError when there's no sign change in a and b
+class Bisection:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses bisection method to find a root of f in [a, b].
+    Might fail for multiple roots (needs sign change).
+
+    Pro:
+
+    * robust and reliable
+
+    Contra:
+
+    * converges slowly
+    * needs sign change
+    """
+    maxsteps = 100
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) != 2:
+            raise ValueError('expected interval of 2 points, got %i' % len(x0))
+        self.f = f
+        self.a = x0[0]
+        self.b = x0[1]
+
+    def __iter__(self):
+        f = self.f
+        a = self.a
+        b = self.b
+        l = b - a
+        fb = f(b)
+        while True:
+            m = self.ctx.ldexp(a + b, -1)
+            fm = f(m)
+            sign = fm * fb
+            if sign < 0:
+                a = m
+            elif sign > 0:
+                b = m
+                fb = fm
+            else:
+                yield m, self.ctx.zero
+            l /= 2
+            yield (a + b)/2, abs(l)
+
+def _getm(method):
+    """
+    Return a function to calculate m for Illinois-like methods.
+    """
+    if method == 'illinois':
+        def getm(fz, fb):
+            return 0.5
+    elif method == 'pegasus':
+        def getm(fz, fb):
+            return fb/(fb + fz)
+    elif method == 'anderson':
+        def getm(fz, fb):
+            m = 1 - fz/fb
+            if m > 0:
+                return m
+            else:
+                return 0.5
+    else:
+        raise ValueError("method '%s' not recognized" % method)
+    return getm
+
+class Illinois:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses Illinois method or similar to find a root of f in [a, b].
+    Might fail for multiple roots (needs sign change).
+    Combines bisect with secant (improved regula falsi).
+
+    The only difference between the methods is the scaling factor m, which is
+    used to ensure convergence (you can choose one using the 'method' keyword):
+
+    Illinois method ('illinois'):
+        m = 0.5
+
+    Pegasus method ('pegasus'):
+        m = fb/(fb + fz)
+
+    Anderson-Bjoerk method ('anderson'):
+        m = 1 - fz/fb if positive else 0.5
+
+    Pro:
+
+    * converges very fast
+
+    Contra:
+
+    * has problems with multiple roots
+    * needs sign change
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if len(x0) != 2:
+            raise ValueError('expected interval of 2 points, got %i' % len(x0))
+        self.a = x0[0]
+        self.b = x0[1]
+        self.f = f
+        self.tol = kwargs['tol']
+        self.verbose = kwargs['verbose']
+        self.method = kwargs.get('method', 'illinois')
+        self.getm = _getm(self.method)
+        if self.verbose:
+            print('using %s method' % self.method)
+
+    def __iter__(self):
+        method = self.method
+        f = self.f
+        a = self.a
+        b = self.b
+        fa = f(a)
+        fb = f(b)
+        m = None
+        while True:
+            l = b - a
+            if l == 0:
+                break
+            s = (fb - fa) / l
+            z = a - fa/s
+            fz = f(z)
+            if abs(fz) < self.tol:
+                # TODO: better condition (when f is very flat)
+                if self.verbose:
+                    print('canceled with z =', z)
+                yield z, l
+                break
+            if fz * fb < 0: # root in [z, b]
+                a = b
+                fa = fb
+                b = z
+                fb = fz
+            else: # root in [a, z]
+                m = self.getm(fz, fb)
+                b = z
+                fb = fz
+                fa = m*fa # scale down to ensure convergence
+            if self.verbose and m and not method == 'illinois':
+                print('m:', m)
+            yield (a + b)/2, abs(l)
+
+def Pegasus(*args, **kwargs):
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses Pegasus method to find a root of f in [a, b].
+    Wrapper for illinois to use method='pegasus'.
+    """
+    kwargs['method'] = 'pegasus'
+    return Illinois(*args, **kwargs)
+
+def Anderson(*args, **kwargs):
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Uses Anderson-Bjoerk method to find a root of f in [a, b].
+    Wrapper for illinois to use method='pegasus'.
+    """
+    kwargs['method'] = 'anderson'
+    return Illinois(*args, **kwargs)
+
+# TODO: check whether it's possible to combine it with Illinois stuff
+class Ridder:
+    """
+    1d-solver generating pairs of approximative root and error.
+
+    Ridders' method to find a root of f in [a, b].
+    Is told to perform as well as Brent's method while being simpler.
+
+    Pro:
+
+    * very fast
+    * simpler than Brent's method
+
+    Contra:
+
+    * two function evaluations per step
+    * has problems with multiple roots
+    * needs sign change
+
+    http://en.wikipedia.org/wiki/Ridders'_method
+    """
+    maxsteps = 30
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        self.f = f
+        if len(x0) != 2:
+            raise ValueError('expected interval of 2 points, got %i' % len(x0))
+        self.x1 = x0[0]
+        self.x2 = x0[1]
+        self.verbose = kwargs['verbose']
+        self.tol = kwargs['tol']
+
+    def __iter__(self):
+        ctx = self.ctx
+        f = self.f
+        x1 = self.x1
+        fx1 = f(x1)
+        x2 = self.x2
+        fx2 = f(x2)
+        while True:
+            x3 = 0.5*(x1 + x2)
+            fx3 = f(x3)
+            x4 = x3 + (x3 - x1) * ctx.sign(fx1 - fx2) * fx3 / ctx.sqrt(fx3**2 - fx1*fx2)
+            fx4 = f(x4)
+            if abs(fx4) < self.tol:
+                # TODO: better condition (when f is very flat)
+                if self.verbose:
+                    print('canceled with f(x4) =', fx4)
+                yield x4, abs(x1 - x2)
+                break
+            if fx4 * fx2 < 0: # root in [x4, x2]
+                x1 = x4
+                fx1 = fx4
+            else: # root in [x1, x4]
+                x2 = x4
+                fx2 = fx4
+            error = abs(x1 - x2)
+            yield (x1 + x2)/2, error
+
+class ANewton:
+    """
+    EXPERIMENTAL 1d-solver generating pairs of approximative root and error.
+
+    Uses Newton's method modified to use Steffensens method when convergence is
+    slow. (I.e. for multiple roots.)
+    """
+    maxsteps = 20
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        if not len(x0) == 1:
+            raise ValueError('expected 1 starting point, got %i' % len(x0))
+        self.x0 = x0[0]
+        self.f = f
+        if not 'df' in kwargs:
+            def df(x):
+                return self.ctx.diff(f, x)
+        else:
+            df = kwargs['df']
+        self.df = df
+        def phi(x):
+            return x - f(x) / df(x)
+        self.phi = phi
+        self.verbose = kwargs['verbose']
+
+    def __iter__(self):
+        x0 = self.x0
+        f = self.f
+        df = self.df
+        phi = self.phi
+        error = 0
+        counter = 0
+        while True:
+            prevx = x0
+            try:
+                x0 = phi(x0)
+            except ZeroDivisionError:
+                if self.verbose:
+                    print('ZeroDivisionError: canceled with x =', x0)
+                break
+            preverror = error
+            error = abs(prevx - x0)
+            # TODO: decide not to use convergence acceleration
+            if error and abs(error - preverror) / error < 1:
+                if self.verbose:
+                    print('converging slowly')
+                counter += 1
+            if counter >= 3:
+                # accelerate convergence
+                phi = steffensen(phi)
+                counter = 0
+                if self.verbose:
+                    print('accelerating convergence')
+            yield x0, error
+
+# TODO: add Brent
+
+############################
+# MULTIDIMENSIONAL SOLVERS #
+############################
+
+def jacobian(ctx, f, x):
+    """
+    Calculate the Jacobian matrix of a function at the point x0.
+
+    This is the first derivative of a vectorial function:
+
+        f : R^m -> R^n with m >= n
+    """
+    x = ctx.matrix(x)
+    h = ctx.sqrt(ctx.eps)
+    fx = ctx.matrix(f(*x))
+    m = len(fx)
+    n = len(x)
+    J = ctx.matrix(m, n)
+    for j in xrange(n):
+        xj = x.copy()
+        xj[j] += h
+        Jj = (ctx.matrix(f(*xj)) - fx) / h
+        for i in xrange(m):
+            J[i,j] = Jj[i]
+    return J
+
+# TODO: test with user-specified jacobian matrix
+class MDNewton:
+    """
+    Find the root of a vector function numerically using Newton's method.
+
+    f is a vector function representing a nonlinear equation system.
+
+    x0 is the starting point close to the root.
+
+    J is a function returning the Jacobian matrix for a point.
+
+    Supports overdetermined systems.
+
+    Use the 'norm' keyword to specify which norm to use. Defaults to max-norm.
+    The function to calculate the Jacobian matrix can be given using the
+    keyword 'J'. Otherwise it will be calculated numerically.
+
+    Please note that this method converges only locally. Especially for high-
+    dimensional systems it is not trivial to find a good starting point being
+    close enough to the root.
+
+    It is recommended to use a faster, low-precision solver from SciPy [1] or
+    OpenOpt [2] to get an initial guess. Afterwards you can use this method for
+    root-polishing to any precision.
+
+    [1] http://scipy.org
+
+    [2] http://openopt.org/Welcome
+    """
+    maxsteps = 10
+
+    def __init__(self, ctx, f, x0, **kwargs):
+        self.ctx = ctx
+        self.f = f
+        if isinstance(x0, (tuple, list)):
+            x0 = ctx.matrix(x0)
+        assert x0.cols == 1, 'need a vector'
+        self.x0 = x0
+        if 'J' in kwargs:
+            self.J = kwargs['J']
+        else:
+            def J(*x):
+                return ctx.jacobian(f, x)
+            self.J = J
+        self.norm = kwargs['norm']
+        self.verbose = kwargs['verbose']
+
+    def __iter__(self):
+        f = self.f
+        x0 = self.x0
+        norm = self.norm
+        J = self.J
+        fx = self.ctx.matrix(f(*x0))
+        fxnorm = norm(fx)
+        cancel = False
+        while not cancel:
+            # get direction of descent
+            fxn = -fx
+            Jx = J(*x0)
+            s = self.ctx.lu_solve(Jx, fxn)
+            if self.verbose:
+                print('Jx:')
+                print(Jx)
+                print('s:', s)
+            # damping step size TODO: better strategy (hard task)
+            l = self.ctx.one
+            x1 = x0 + s
+            while True:
+                if x1 == x0:
+                    if self.verbose:
+                        print("canceled, won't get more excact")
+                    cancel = True
+                    break
+                fx = self.ctx.matrix(f(*x1))
+                newnorm = norm(fx)
+                if newnorm < fxnorm:
+                    # new x accepted
+                    fxnorm = newnorm
+                    x0 = x1
+                    break
+                l /= 2
+                x1 = x0 + l*s
+            yield (x0, fxnorm)
+
+#############
+# UTILITIES #
+#############
+
+str2solver = {'newton':Newton, 'secant':Secant, 'mnewton':MNewton,
+              'halley':Halley, 'muller':Muller, 'bisect':Bisection,
+              'illinois':Illinois, 'pegasus':Pegasus, 'anderson':Anderson,
+              'ridder':Ridder, 'anewton':ANewton, 'mdnewton':MDNewton}
+
+def findroot(ctx, f, x0, solver='secant', tol=None, verbose=False, verify=True, **kwargs):
+    r"""
+    Find an approximate solution to `f(x) = 0`, using *x0* as starting point or
+    interval for *x*.
+
+    Multidimensional overdetermined systems are supported.
+    You can specify them using a function or a list of functions.
+
+    Mathematically speaking, this function returns `x` such that
+    `|f(x)|^2 \leq \mathrm{tol}` is true within the current working precision.
+    If the computed value does not meet this criterion, an exception is raised.
+    This exception can be disabled with *verify=False*.
+
+    For interval arithmetic (``iv.findroot()``), please note that
+    the returned interval ``x`` is not guaranteed to contain `f(x)=0`!
+    It is only some `x` for which `|f(x)|^2 \leq \mathrm{tol}` certainly holds
+    regardless of numerical error. This may be improved in the future.
+
+    **Arguments**
+
+    *f*
+        one dimensional function
+    *x0*
+        starting point, several starting points or interval (depends on solver)
+    *tol*
+        the returned solution has an error smaller than this
+    *verbose*
+        print additional information for each iteration if true
+    *verify*
+        verify the solution and raise a ValueError if `|f(x)|^2 > \mathrm{tol}`
+    *solver*
+        a generator for *f* and *x0* returning approximative solution and error
+    *maxsteps*
+        after how many steps the solver will cancel
+    *df*
+        first derivative of *f* (used by some solvers)
+    *d2f*
+        second derivative of *f* (used by some solvers)
+    *multidimensional*
+        force multidimensional solving
+    *J*
+        Jacobian matrix of *f* (used by multidimensional solvers)
+    *norm*
+        used vector norm (used by multidimensional solvers)
+
+    solver has to be callable with ``(f, x0, **kwargs)`` and return an generator
+    yielding pairs of approximative solution and estimated error (which is
+    expected to be positive).
+    You can use the following string aliases:
+    'secant', 'mnewton', 'halley', 'muller', 'illinois', 'pegasus', 'anderson',
+    'ridder', 'anewton', 'bisect'
+
+    See mpmath.calculus.optimization for their documentation.
+
+    **Examples**
+
+    The function :func:`~mpmath.findroot` locates a root of a given function using the
+    secant method by default. A simple example use of the secant method is to
+    compute `\pi` as the root of `\sin x` closest to `x_0 = 3`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 30; mp.pretty = True
+        >>> findroot(sin, 3)
+        3.14159265358979323846264338328
+
+    The secant method can be used to find complex roots of analytic functions,
+    although it must in that case generally be given a nonreal starting value
+    (or else it will never leave the real line)::
+
+        >>> mp.dps = 15
+        >>> findroot(lambda x: x**3 + 2*x + 1, j)
+        (0.226698825758202 + 1.46771150871022j)
+
+    A nice application is to compute nontrivial roots of the Riemann zeta
+    function with many digits (good initial values are needed for convergence)::
+
+        >>> mp.dps = 30
+        >>> findroot(zeta, 0.5+14j)
+        (0.5 + 14.1347251417346937904572519836j)
+
+    The secant method can also be used as an optimization algorithm, by passing
+    it a derivative of a function. The following example locates the positive
+    minimum of the gamma function::
+
+        >>> mp.dps = 20
+        >>> findroot(lambda x: diff(gamma, x), 1)
+        1.4616321449683623413
+
+    Finally, a useful application is to compute inverse functions, such as the
+    Lambert W function which is the inverse of `w e^w`, given the first
+    term of the solution's asymptotic expansion as the initial value. In basic
+    cases, this gives identical results to mpmath's built-in ``lambertw``
+    function::
+
+        >>> def lambert(x):
+        ...     return findroot(lambda w: w*exp(w) - x, log(1+x))
+        ...
+        >>> mp.dps = 15
+        >>> lambert(1); lambertw(1)
+        0.567143290409784
+        0.567143290409784
+        >>> lambert(1000); lambert(1000)
+        5.2496028524016
+        5.2496028524016
+
+    Multidimensional functions are also supported::
+
+        >>> f = [lambda x1, x2: x1**2 + x2,
+        ...      lambda x1, x2: 5*x1**2 - 3*x1 + 2*x2 - 3]
+        >>> findroot(f, (0, 0))
+        [-0.618033988749895]
+        [-0.381966011250105]
+        >>> findroot(f, (10, 10))
+        [ 1.61803398874989]
+        [-2.61803398874989]
+
+    You can verify this by solving the system manually.
+
+    Please note that the following (more general) syntax also works::
+
+        >>> def f(x1, x2):
+        ...     return x1**2 + x2, 5*x1**2 - 3*x1 + 2*x2 - 3
+        ...
+        >>> findroot(f, (0, 0))
+        [-0.618033988749895]
+        [-0.381966011250105]
+
+
+    **Multiple roots**
+
+    For multiple roots all methods of the Newtonian family (including secant)
+    converge slowly. Consider this example::
+
+        >>> f = lambda x: (x - 1)**99
+        >>> findroot(f, 0.9, verify=False)
+        0.918073542444929
+
+    Even for a very close starting point the secant method converges very
+    slowly. Use ``verbose=True`` to illustrate this.
+
+    It is possible to modify Newton's method to make it converge regardless of
+    the root's multiplicity::
+
+        >>> findroot(f, -10, solver='mnewton')
+        1.0
+
+    This variant uses the first and second derivative of the function, which is
+    not very efficient.
+
+    Alternatively you can use an experimental Newtonian solver that keeps track
+    of the speed of convergence and accelerates it using Steffensen's method if
+    necessary::
+
+        >>> findroot(f, -10, solver='anewton', verbose=True)
+        x:     -9.88888888888888888889
+        error: 0.111111111111111111111
+        converging slowly
+        x:     -9.77890011223344556678
+        error: 0.10998877665544332211
+        converging slowly
+        x:     -9.67002233332199662166
+        error: 0.108877778911448945119
+        converging slowly
+        accelerating convergence
+        x:     -9.5622443299551077669
+        error: 0.107778003366888854764
+        converging slowly
+        x:     0.99999999999999999214
+        error: 10.562244329955107759
+        x:     1.0
+        error: 7.8598304758094664213e-18
+        ZeroDivisionError: canceled with x = 1.0
+        1.0
+
+    **Complex roots**
+
+    For complex roots it's recommended to use Muller's method as it converges
+    even for real starting points very fast::
+
+        >>> findroot(lambda x: x**4 + x + 1, (0, 1, 2), solver='muller')
+        (0.727136084491197 + 0.934099289460529j)
+
+
+    **Intersection methods**
+
+    When you need to find a root in a known interval, it's highly recommended to
+    use an intersection-based solver like ``'anderson'`` or ``'ridder'``.
+    Usually they converge faster and more reliable. They have however problems
+    with multiple roots and usually need a sign change to find a root::
+
+        >>> findroot(lambda x: x**3, (-1, 1), solver='anderson')
+        0.0
+
+    Be careful with symmetric functions::
+
+        >>> findroot(lambda x: x**2, (-1, 1), solver='anderson') #doctest:+ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ZeroDivisionError
+
+    It fails even for better starting points, because there is no sign change::
+
+        >>> findroot(lambda x: x**2, (-1, .5), solver='anderson')
+        Traceback (most recent call last):
+          ...
+        ValueError: Could not find root within given tolerance. (1.0 > 2.16840434497100886801e-19)
+        Try another starting point or tweak arguments.
+
+    """
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+
+        # initialize arguments
+        if tol is None:
+            tol = ctx.eps * 2**10
+
+        kwargs['verbose'] = kwargs.get('verbose', verbose)
+
+        if 'd1f' in kwargs:
+            kwargs['df'] = kwargs['d1f']
+
+        kwargs['tol'] = tol
+        if isinstance(x0, (list, tuple)):
+            x0 = [ctx.convert(x) for x in x0]
+        else:
+            x0 = [ctx.convert(x0)]
+
+        if isinstance(solver, str):
+            try:
+                solver = str2solver[solver]
+            except KeyError:
+                raise ValueError('could not recognize solver')
+
+        # accept list of functions
+        if isinstance(f, (list, tuple)):
+            f2 = copy(f)
+            def tmp(*args):
+                return [fn(*args) for fn in f2]
+            f = tmp
+
+        # detect multidimensional functions
+        try:
+            fx = f(*x0)
+            multidimensional = isinstance(fx, (list, tuple, ctx.matrix))
+        except TypeError:
+            fx = f(x0[0])
+            multidimensional = False
+        if 'multidimensional' in kwargs:
+            multidimensional = kwargs['multidimensional']
+        if multidimensional:
+            # only one multidimensional solver available at the moment
+            solver = MDNewton
+            if not 'norm' in kwargs:
+                norm = lambda x: ctx.norm(x, 'inf')
+                kwargs['norm'] = norm
+            else:
+                norm = kwargs['norm']
+        else:
+            norm = abs
+
+        # happily return starting point if it's a root
+        if norm(fx) == 0:
+            if multidimensional:
+                return ctx.matrix(x0)
+            else:
+                return x0[0]
+
+        # use solver
+        iterations = solver(ctx, f, x0, **kwargs)
+        if 'maxsteps' in kwargs:
+            maxsteps = kwargs['maxsteps']
+        else:
+            maxsteps = iterations.maxsteps
+        i = 0
+        for x, error in iterations:
+            if verbose:
+                print('x:    ', x)
+                print('error:', error)
+            i += 1
+            if error < tol * max(1, norm(x)) or i >= maxsteps:
+                break
+        else:
+            if not i:
+                raise ValueError('Could not find root using the given solver.\n'
+                                 'Try another starting point or tweak arguments.')
+        if not isinstance(x, (list, tuple, ctx.matrix)):
+            xl = [x]
+        else:
+            xl = x
+        if verify and norm(f(*xl))**2 > tol: # TODO: better condition?
+            raise ValueError('Could not find root within given tolerance. '
+                             '(%s > %s)\n'
+                             'Try another starting point or tweak arguments.'
+                             % (norm(f(*xl))**2, tol))
+        return x
+    finally:
+        ctx.prec = prec
+
+
+def multiplicity(ctx, f, root, tol=None, maxsteps=10, **kwargs):
+    """
+    Return the multiplicity of a given root of f.
+
+    Internally, numerical derivatives are used. This might be inefficient for
+    higher order derviatives. Due to this, ``multiplicity`` cancels after
+    evaluating 10 derivatives by default. You can be specify the n-th derivative
+    using the dnf keyword.
+
+    >>> from mpmath import *
+    >>> multiplicity(lambda x: sin(x) - 1, pi/2)
+    2
+
+    """
+    if tol is None:
+        tol = ctx.eps ** 0.8
+    kwargs['d0f'] = f
+    for i in xrange(maxsteps):
+        dfstr = 'd' + str(i) + 'f'
+        if dfstr in kwargs:
+            df = kwargs[dfstr]
+        else:
+            df = lambda x: ctx.diff(f, x, i)
+        if not abs(df(root)) < tol:
+            break
+    return i
+
+def steffensen(f):
+    """
+    linear convergent function -> quadratic convergent function
+
+    Steffensen's method for quadratic convergence of a linear converging
+    sequence.
+    Don not use it for higher rates of convergence.
+    It may even work for divergent sequences.
+
+    Definition:
+    F(x) = (x*f(f(x)) - f(x)**2) / (f(f(x)) - 2*f(x) + x)
+
+    Example
+    .......
+
+    You can use Steffensen's method to accelerate a fixpoint iteration of linear
+    (or less) convergence.
+
+    x* is a fixpoint of the iteration x_{k+1} = phi(x_k) if x* = phi(x*). For
+    phi(x) = x**2 there are two fixpoints: 0 and 1.
+
+    Let's try Steffensen's method:
+
+    >>> f = lambda x: x**2
+    >>> from mpmath.calculus.optimization import steffensen
+    >>> F = steffensen(f)
+    >>> for x in [0.5, 0.9, 2.0]:
+    ...     fx = Fx = x
+    ...     for i in xrange(9):
+    ...         try:
+    ...             fx = f(fx)
+    ...         except OverflowError:
+    ...             pass
+    ...         try:
+    ...             Fx = F(Fx)
+    ...         except ZeroDivisionError:
+    ...             pass
+    ...         print('%20g  %20g' % (fx, Fx))
+                    0.25                  -0.5
+                  0.0625                   0.1
+              0.00390625            -0.0011236
+             1.52588e-05           1.41691e-09
+             2.32831e-10          -2.84465e-27
+             5.42101e-20           2.30189e-80
+             2.93874e-39          -1.2197e-239
+             8.63617e-78                     0
+            7.45834e-155                     0
+                    0.81               1.02676
+                  0.6561               1.00134
+                0.430467                     1
+                0.185302                     1
+               0.0343368                     1
+              0.00117902                     1
+             1.39008e-06                     1
+             1.93233e-12                     1
+             3.73392e-24                     1
+                       4                   1.6
+                      16                1.2962
+                     256               1.10194
+                   65536               1.01659
+             4.29497e+09               1.00053
+             1.84467e+19                     1
+             3.40282e+38                     1
+             1.15792e+77                     1
+            1.34078e+154                     1
+
+    Unmodified, the iteration converges only towards 0. Modified it converges
+    not only much faster, it converges even to the repelling fixpoint 1.
+    """
+    def F(x):
+        fx = f(x)
+        ffx = f(fx)
+        return (x*ffx - fx**2) / (ffx - 2*fx + x)
+    return F
+
+OptimizationMethods.jacobian = jacobian
+OptimizationMethods.findroot = findroot
+OptimizationMethods.multiplicity = multiplicity
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.11/site-packages/mpmath/calculus/polynomials.py b/lib/python3.11/site-packages/mpmath/calculus/polynomials.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba75c1e88cbc5d40aa590a786c0af5229f193103
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/polynomials.py
@@ -0,0 +1,213 @@
+from ..libmp.backend import xrange
+from .calculus import defun
+
+#----------------------------------------------------------------------------#
+#                                Polynomials                                 #
+#----------------------------------------------------------------------------#
+
+# XXX: extra precision
+@defun
+def polyval(ctx, coeffs, x, derivative=False):
+    r"""
+    Given coefficients `[c_n, \ldots, c_2, c_1, c_0]` and a number `x`,
+    :func:`~mpmath.polyval` evaluates the polynomial
+
+    .. math ::
+
+        P(x) = c_n x^n + \ldots + c_2 x^2 + c_1 x + c_0.
+
+    If *derivative=True* is set, :func:`~mpmath.polyval` simultaneously
+    evaluates `P(x)` with the derivative, `P'(x)`, and returns the
+    tuple `(P(x), P'(x))`.
+
+        >>> from mpmath import *
+        >>> mp.pretty = True
+        >>> polyval([3, 0, 2], 0.5)
+        2.75
+        >>> polyval([3, 0, 2], 0.5, derivative=True)
+        (2.75, 3.0)
+
+    The coefficients and the evaluation point may be any combination
+    of real or complex numbers.
+    """
+    if not coeffs:
+        return ctx.zero
+    p = ctx.convert(coeffs[0])
+    q = ctx.zero
+    for c in coeffs[1:]:
+        if derivative:
+            q = p + x*q
+        p = c + x*p
+    if derivative:
+        return p, q
+    else:
+        return p
+
+@defun
+def polyroots(ctx, coeffs, maxsteps=50, cleanup=True, extraprec=10,
+        error=False, roots_init=None):
+    """
+    Computes all roots (real or complex) of a given polynomial.
+
+    The roots are returned as a sorted list, where real roots appear first
+    followed by complex conjugate roots as adjacent elements. The polynomial
+    should be given as a list of coefficients, in the format used by
+    :func:`~mpmath.polyval`. The leading coefficient must be nonzero.
+
+    With *error=True*, :func:`~mpmath.polyroots` returns a tuple *(roots, err)*
+    where *err* is an estimate of the maximum error among the computed roots.
+
+    **Examples**
+
+    Finding the three real roots of `x^3 - x^2 - 14x + 24`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nprint(polyroots([1,-1,-14,24]), 4)
+        [-4.0, 2.0, 3.0]
+
+    Finding the two complex conjugate roots of `4x^2 + 3x + 2`, with an
+    error estimate::
+
+        >>> roots, err = polyroots([4,3,2], error=True)
+        >>> for r in roots:
+        ...     print(r)
+        ...
+        (-0.375 + 0.59947894041409j)
+        (-0.375 - 0.59947894041409j)
+        >>>
+        >>> err
+        2.22044604925031e-16
+        >>>
+        >>> polyval([4,3,2], roots[0])
+        (2.22044604925031e-16 + 0.0j)
+        >>> polyval([4,3,2], roots[1])
+        (2.22044604925031e-16 + 0.0j)
+
+    The following example computes all the 5th roots of unity; that is,
+    the roots of `x^5 - 1`::
+
+        >>> mp.dps = 20
+        >>> for r in polyroots([1, 0, 0, 0, 0, -1]):
+        ...     print(r)
+        ...
+        1.0
+        (-0.8090169943749474241 + 0.58778525229247312917j)
+        (-0.8090169943749474241 - 0.58778525229247312917j)
+        (0.3090169943749474241 + 0.95105651629515357212j)
+        (0.3090169943749474241 - 0.95105651629515357212j)
+
+    **Precision and conditioning**
+
+    The roots are computed to the current working precision accuracy. If this
+    accuracy cannot be achieved in ``maxsteps`` steps, then a
+    ``NoConvergence`` exception is raised. The algorithm internally is using
+    the current working precision extended by ``extraprec``. If
+    ``NoConvergence`` was raised, that is caused either by not having enough
+    extra precision to achieve convergence (in which case increasing
+    ``extraprec`` should fix the problem) or too low ``maxsteps`` (in which
+    case increasing ``maxsteps`` should fix the problem), or a combination of
+    both.
+
+    The user should always do a convergence study with regards to
+    ``extraprec`` to ensure accurate results. It is possible to get
+    convergence to a wrong answer with too low ``extraprec``.
+
+    Provided there are no repeated roots, :func:`~mpmath.polyroots` can
+    typically compute all roots of an arbitrary polynomial to high precision::
+
+        >>> mp.dps = 60
+        >>> for r in polyroots([1, 0, -10, 0, 1]):
+        ...     print(r)
+        ...
+        -3.14626436994197234232913506571557044551247712918732870123249
+        -0.317837245195782244725757617296174288373133378433432554879127
+        0.317837245195782244725757617296174288373133378433432554879127
+        3.14626436994197234232913506571557044551247712918732870123249
+        >>>
+        >>> sqrt(3) + sqrt(2)
+        3.14626436994197234232913506571557044551247712918732870123249
+        >>> sqrt(3) - sqrt(2)
+        0.317837245195782244725757617296174288373133378433432554879127
+
+    **Algorithm**
+
+    :func:`~mpmath.polyroots` implements the Durand-Kerner method [1], which
+    uses complex arithmetic to locate all roots simultaneously.
+    The Durand-Kerner method can be viewed as approximately performing
+    simultaneous Newton iteration for all the roots. In particular,
+    the convergence to simple roots is quadratic, just like Newton's
+    method.
+
+    Although all roots are internally calculated using complex arithmetic, any
+    root found to have an imaginary part smaller than the estimated numerical
+    error is truncated to a real number (small real parts are also chopped).
+    Real roots are placed first in the returned list, sorted by value. The
+    remaining complex roots are sorted by their real parts so that conjugate
+    roots end up next to each other.
+
+    **References**
+
+    1. http://en.wikipedia.org/wiki/Durand-Kerner_method
+
+    """
+    if len(coeffs) <= 1:
+        if not coeffs or not coeffs[0]:
+            raise ValueError("Input to polyroots must not be the zero polynomial")
+        # Constant polynomial with no roots
+        return []
+
+    orig = ctx.prec
+    tol = +ctx.eps
+    with ctx.extraprec(extraprec):
+        deg = len(coeffs) - 1
+        # Must be monic
+        lead = ctx.convert(coeffs[0])
+        if lead == 1:
+            coeffs = [ctx.convert(c) for c in coeffs]
+        else:
+            coeffs = [c/lead for c in coeffs]
+        f = lambda x: ctx.polyval(coeffs, x)
+        if roots_init is None:
+            roots = [ctx.mpc((0.4+0.9j)**n) for n in xrange(deg)]
+        else:
+            roots = [None]*deg;
+            deg_init = min(deg, len(roots_init))
+            roots[:deg_init] = list(roots_init[:deg_init])
+            roots[deg_init:] = [ctx.mpc((0.4+0.9j)**n) for n
+                                in xrange(deg_init,deg)]
+        err = [ctx.one for n in xrange(deg)]
+        # Durand-Kerner iteration until convergence
+        for step in xrange(maxsteps):
+            if abs(max(err)) < tol:
+                break
+            for i in xrange(deg):
+                p = roots[i]
+                x = f(p)
+                for j in range(deg):
+                    if i != j:
+                        try:
+                            x /= (p-roots[j])
+                        except ZeroDivisionError:
+                            continue
+                roots[i] = p - x
+                err[i] = abs(x)
+        if abs(max(err)) >= tol:
+            raise ctx.NoConvergence("Didn't converge in maxsteps=%d steps." \
+                    % maxsteps)
+        # Remove small real or imaginary parts
+        if cleanup:
+            for i in xrange(deg):
+                if abs(roots[i]) < tol:
+                    roots[i] = ctx.zero
+                elif abs(ctx._im(roots[i])) < tol:
+                    roots[i] = roots[i].real
+                elif abs(ctx._re(roots[i])) < tol:
+                    roots[i] = roots[i].imag * 1j
+        roots.sort(key=lambda x: (abs(ctx._im(x)), ctx._re(x)))
+    if error:
+        err = max(err)
+        err = max(err, ctx.ldexp(1, -orig+1))
+        return [+r for r in roots], +err
+    else:
+        return [+r for r in roots]
diff --git a/lib/python3.11/site-packages/mpmath/calculus/quadrature.py b/lib/python3.11/site-packages/mpmath/calculus/quadrature.py
new file mode 100644
index 0000000000000000000000000000000000000000..0545b3ad3e6f70a44f4ec31a0c3bcfb4ffde422b
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/calculus/quadrature.py
@@ -0,0 +1,1115 @@
+import math
+
+from ..libmp.backend import xrange
+
+class QuadratureRule(object):
+    """
+    Quadrature rules are implemented using this class, in order to
+    simplify the code and provide a common infrastructure
+    for tasks such as error estimation and node caching.
+
+    You can implement a custom quadrature rule by subclassing
+    :class:`QuadratureRule` and implementing the appropriate
+    methods. The subclass can then be used by :func:`~mpmath.quad` by
+    passing it as the *method* argument.
+
+    :class:`QuadratureRule` instances are supposed to be singletons.
+    :class:`QuadratureRule` therefore implements instance caching
+    in :func:`~mpmath.__new__`.
+    """
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+        self.standard_cache = {}
+        self.transformed_cache = {}
+        self.interval_count = {}
+
+    def clear(self):
+        """
+        Delete cached node data.
+        """
+        self.standard_cache = {}
+        self.transformed_cache = {}
+        self.interval_count = {}
+
+    def calc_nodes(self, degree, prec, verbose=False):
+        r"""
+        Compute nodes for the standard interval `[-1, 1]`. Subclasses
+        should probably implement only this method, and use
+        :func:`~mpmath.get_nodes` method to retrieve the nodes.
+        """
+        raise NotImplementedError
+
+    def get_nodes(self, a, b, degree, prec, verbose=False):
+        """
+        Return nodes for given interval, degree and precision. The
+        nodes are retrieved from a cache if already computed;
+        otherwise they are computed by calling :func:`~mpmath.calc_nodes`
+        and are then cached.
+
+        Subclasses should probably not implement this method,
+        but just implement :func:`~mpmath.calc_nodes` for the actual
+        node computation.
+        """
+        key = (a, b, degree, prec)
+        if key in self.transformed_cache:
+            return self.transformed_cache[key]
+        orig = self.ctx.prec
+        try:
+            self.ctx.prec = prec+20
+            # Get nodes on standard interval
+            if (degree, prec) in self.standard_cache:
+                nodes = self.standard_cache[degree, prec]
+            else:
+                nodes = self.calc_nodes(degree, prec, verbose)
+                self.standard_cache[degree, prec] = nodes
+            # Transform to general interval
+            nodes = self.transform_nodes(nodes, a, b, verbose)
+            if key in self.interval_count:
+                self.transformed_cache[key] = nodes
+            else:
+                self.interval_count[key] = True
+        finally:
+            self.ctx.prec = orig
+        return nodes
+
+    def transform_nodes(self, nodes, a, b, verbose=False):
+        r"""
+        Rescale standardized nodes (for `[-1, 1]`) to a general
+        interval `[a, b]`. For a finite interval, a simple linear
+        change of variables is used. Otherwise, the following
+        transformations are used:
+
+        .. math ::
+
+            \lbrack a, \infty \rbrack : t = \frac{1}{x} + (a-1)
+
+            \lbrack -\infty, b \rbrack : t = (b+1) - \frac{1}{x}
+
+            \lbrack -\infty, \infty \rbrack : t = \frac{x}{\sqrt{1-x^2}}
+
+        """
+        ctx = self.ctx
+        a = ctx.convert(a)
+        b = ctx.convert(b)
+        one = ctx.one
+        if (a, b) == (-one, one):
+            return nodes
+        half = ctx.mpf(0.5)
+        new_nodes = []
+        if ctx.isinf(a) or ctx.isinf(b):
+            if (a, b) == (ctx.ninf, ctx.inf):
+                p05 = -half
+                for x, w in nodes:
+                    x2 = x*x
+                    px1 = one-x2
+                    spx1 = px1**p05
+                    x = x*spx1
+                    w *= spx1/px1
+                    new_nodes.append((x, w))
+            elif a == ctx.ninf:
+                b1 = b+1
+                for x, w in nodes:
+                    u = 2/(x+one)
+                    x = b1-u
+                    w *= half*u**2
+                    new_nodes.append((x, w))
+            elif b == ctx.inf:
+                a1 = a-1
+                for x, w in nodes:
+                    u = 2/(x+one)
+                    x = a1+u
+                    w *= half*u**2
+                    new_nodes.append((x, w))
+            elif a == ctx.inf or b == ctx.ninf:
+                return [(x,-w) for (x,w) in self.transform_nodes(nodes, b, a, verbose)]
+            else:
+                raise NotImplementedError
+        else:
+            # Simple linear change of variables
+            C = (b-a)/2
+            D = (b+a)/2
+            for x, w in nodes:
+                new_nodes.append((D+C*x, C*w))
+        return new_nodes
+
+    def guess_degree(self, prec):
+        """
+        Given a desired precision `p` in bits, estimate the degree `m`
+        of the quadrature required to accomplish full accuracy for
+        typical integrals. By default, :func:`~mpmath.quad` will perform up
+        to `m` iterations. The value of `m` should be a slight
+        overestimate, so that "slightly bad" integrals can be dealt
+        with automatically using a few extra iterations. On the
+        other hand, it should not be too big, so :func:`~mpmath.quad` can
+        quit within a reasonable amount of time when it is given
+        an "unsolvable" integral.
+
+        The default formula used by :func:`~mpmath.guess_degree` is tuned
+        for both :class:`TanhSinh` and :class:`GaussLegendre`.
+        The output is roughly as follows:
+
+            +---------+---------+
+            | `p`     | `m`     |
+            +=========+=========+
+            | 50      | 6       |
+            +---------+---------+
+            | 100     | 7       |
+            +---------+---------+
+            | 500     | 10      |
+            +---------+---------+
+            | 3000    | 12      |
+            +---------+---------+
+
+        This formula is based purely on a limited amount of
+        experimentation and will sometimes be wrong.
+        """
+        # Expected degree
+        # XXX: use mag
+        g = int(4 + max(0, self.ctx.log(prec/30.0, 2)))
+        # Reasonable "worst case"
+        g += 2
+        return g
+
+    def estimate_error(self, results, prec, epsilon):
+        r"""
+        Given results from integrations `[I_1, I_2, \ldots, I_k]` done
+        with a quadrature of rule of degree `1, 2, \ldots, k`, estimate
+        the error of `I_k`.
+
+        For `k = 2`, we estimate  `|I_{\infty}-I_2|` as `|I_2-I_1|`.
+
+        For `k > 2`, we extrapolate `|I_{\infty}-I_k| \approx |I_{k+1}-I_k|`
+        from `|I_k-I_{k-1}|` and `|I_k-I_{k-2}|` under the assumption
+        that each degree increment roughly doubles the accuracy of
+        the quadrature rule (this is true for both :class:`TanhSinh`
+        and :class:`GaussLegendre`). The extrapolation formula is given
+        by Borwein, Bailey & Girgensohn. Although not very conservative,
+        this method seems to be very robust in practice.
+        """
+        if len(results) == 2:
+            return abs(results[0]-results[1])
+        try:
+            if results[-1] == results[-2] == results[-3]:
+                return self.ctx.zero
+            D1 = self.ctx.log(abs(results[-1]-results[-2]), 10)
+            D2 = self.ctx.log(abs(results[-1]-results[-3]), 10)
+        except ValueError:
+            return epsilon
+        D3 = -prec
+        D4 = min(0, max(D1**2/D2, 2*D1, D3))
+        return self.ctx.mpf(10) ** int(D4)
+
+    def summation(self, f, points, prec, epsilon, max_degree, verbose=False):
+        """
+        Main integration function. Computes the 1D integral over
+        the interval specified by *points*. For each subinterval,
+        performs quadrature of degree from 1 up to *max_degree*
+        until :func:`~mpmath.estimate_error` signals convergence.
+
+        :func:`~mpmath.summation` transforms each subintegration to
+        the standard interval and then calls :func:`~mpmath.sum_next`.
+        """
+        ctx = self.ctx
+        I = total_err = ctx.zero
+        for i in xrange(len(points)-1):
+            a, b = points[i], points[i+1]
+            if a == b:
+                continue
+            # XXX: we could use a single variable transformation,
+            # but this is not good in practice. We get better accuracy
+            # by having 0 as an endpoint.
+            if (a, b) == (ctx.ninf, ctx.inf):
+                _f = f
+                f = lambda x: _f(-x) + _f(x)
+                a, b = (ctx.zero, ctx.inf)
+            results = []
+            err = ctx.zero
+            for degree in xrange(1, max_degree+1):
+                nodes = self.get_nodes(a, b, degree, prec, verbose)
+                if verbose:
+                    print("Integrating from %s to %s (degree %s of %s)" % \
+                        (ctx.nstr(a), ctx.nstr(b), degree, max_degree))
+                result = self.sum_next(f, nodes, degree, prec, results, verbose)
+                results.append(result)
+                if degree > 1:
+                    err = self.estimate_error(results, prec, epsilon)
+                    if verbose:
+                        print("Estimated error:", ctx.nstr(err), " epsilon:", ctx.nstr(epsilon), " result: ", ctx.nstr(result))
+                    if err <= epsilon:
+                        break
+            I += results[-1]
+            total_err += err
+        if total_err > epsilon:
+            if verbose:
+                print("Failed to reach full accuracy. Estimated error:", ctx.nstr(total_err))
+        return I, total_err
+
+    def sum_next(self, f, nodes, degree, prec, previous, verbose=False):
+        r"""
+        Evaluates the step sum `\sum w_k f(x_k)` where the *nodes* list
+        contains the `(w_k, x_k)` pairs.
+
+        :func:`~mpmath.summation` will supply the list *results* of
+        values computed by :func:`~mpmath.sum_next` at previous degrees, in
+        case the quadrature rule is able to reuse them.
+        """
+        return self.ctx.fdot((w, f(x)) for (x,w) in nodes)
+
+
+class TanhSinh(QuadratureRule):
+    r"""
+    This class implements "tanh-sinh" or "doubly exponential"
+    quadrature. This quadrature rule is based on the Euler-Maclaurin
+    integral formula. By performing a change of variables involving
+    nested exponentials / hyperbolic functions (hence the name), the
+    derivatives at the endpoints vanish rapidly. Since the error term
+    in the Euler-Maclaurin formula depends on the derivatives at the
+    endpoints, a simple step sum becomes extremely accurate. In
+    practice, this means that doubling the number of evaluation
+    points roughly doubles the number of accurate digits.
+
+    Comparison to Gauss-Legendre:
+      * Initial computation of nodes is usually faster
+      * Handles endpoint singularities better
+      * Handles infinite integration intervals better
+      * Is slower for smooth integrands once nodes have been computed
+
+    The implementation of the tanh-sinh algorithm is based on the
+    description given in Borwein, Bailey & Girgensohn, "Experimentation
+    in Mathematics - Computational Paths to Discovery", A K Peters,
+    2003, pages 312-313. In the present implementation, a few
+    improvements have been made:
+
+      * A more efficient scheme is used to compute nodes (exploiting
+        recurrence for the exponential function)
+      * The nodes are computed successively instead of all at once
+
+    **References**
+
+    * [Bailey]_
+    * http://users.cs.dal.ca/~jborwein/tanh-sinh.pdf
+
+    """
+
+    def sum_next(self, f, nodes, degree, prec, previous, verbose=False):
+        """
+        Step sum for tanh-sinh quadrature of degree `m`. We exploit the
+        fact that half of the abscissas at degree `m` are precisely the
+        abscissas from degree `m-1`. Thus reusing the result from
+        the previous level allows a 2x speedup.
+        """
+        h = self.ctx.mpf(2)**(-degree)
+        # Abscissas overlap, so reusing saves half of the time
+        if previous:
+            S = previous[-1]/(h*2)
+        else:
+            S = self.ctx.zero
+        S += self.ctx.fdot((w,f(x)) for (x,w) in nodes)
+        return h*S
+
+    def calc_nodes(self, degree, prec, verbose=False):
+        r"""
+        The abscissas and weights for tanh-sinh quadrature of degree
+        `m` are given by
+
+        .. math::
+
+            x_k = \tanh(\pi/2 \sinh(t_k))
+
+            w_k = \pi/2 \cosh(t_k) / \cosh(\pi/2 \sinh(t_k))^2
+
+        where `t_k = t_0 + hk` for a step length `h \sim 2^{-m}`. The
+        list of nodes is actually infinite, but the weights die off so
+        rapidly that only a few are needed.
+        """
+        ctx = self.ctx
+        nodes = []
+
+        extra = 20
+        ctx.prec += extra
+        tol = ctx.ldexp(1, -prec-10)
+        pi4 = ctx.pi/4
+
+        # For simplicity, we work in steps h = 1/2^n, with the first point
+        # offset so that we can reuse the sum from the previous degree
+
+        # We define degree 1 to include the "degree 0" steps, including
+        # the point x = 0. (It doesn't work well otherwise; not sure why.)
+        t0 = ctx.ldexp(1, -degree)
+        if degree == 1:
+            #nodes.append((mpf(0), pi4))
+            #nodes.append((-mpf(0), pi4))
+            nodes.append((ctx.zero, ctx.pi/2))
+            h = t0
+        else:
+            h = t0*2
+
+        # Since h is fixed, we can compute the next exponential
+        # by simply multiplying by exp(h)
+        expt0 = ctx.exp(t0)
+        a = pi4 * expt0
+        b = pi4 / expt0
+        udelta = ctx.exp(h)
+        urdelta = 1/udelta
+
+        for k in xrange(0, 20*2**degree+1):
+            # Reference implementation:
+            # t = t0 + k*h
+            # x = tanh(pi/2 * sinh(t))
+            # w = pi/2 * cosh(t) / cosh(pi/2 * sinh(t))**2
+
+            # Fast implementation. Note that c = exp(pi/2 * sinh(t))
+            c = ctx.exp(a-b)
+            d = 1/c
+            co = (c+d)/2
+            si = (c-d)/2
+            x = si / co
+            w = (a+b) / co**2
+            diff = abs(x-1)
+            if diff <= tol:
+                break
+
+            nodes.append((x, w))
+            nodes.append((-x, w))
+
+            a *= udelta
+            b *= urdelta
+
+            if verbose and k % 300 == 150:
+                # Note: the number displayed is rather arbitrary. Should
+                # figure out how to print something that looks more like a
+                # percentage
+                print("Calculating nodes:", ctx.nstr(-ctx.log(diff, 10) / prec))
+
+        ctx.prec -= extra
+        return nodes
+
+
+class GaussLegendre(QuadratureRule):
+    r"""
+    This class implements Gauss-Legendre quadrature, which is
+    exceptionally efficient for polynomials and polynomial-like (i.e.
+    very smooth) integrands.
+
+    The abscissas and weights are given by roots and values of
+    Legendre polynomials, which are the orthogonal polynomials
+    on `[-1, 1]` with respect to the unit weight
+    (see :func:`~mpmath.legendre`).
+
+    In this implementation, we take the "degree" `m` of the quadrature
+    to denote a Gauss-Legendre rule of degree `3 \cdot 2^m` (following
+    Borwein, Bailey & Girgensohn). This way we get quadratic, rather
+    than linear, convergence as the degree is incremented.
+
+    Comparison to tanh-sinh quadrature:
+      * Is faster for smooth integrands once nodes have been computed
+      * Initial computation of nodes is usually slower
+      * Handles endpoint singularities worse
+      * Handles infinite integration intervals worse
+
+    """
+
+    def calc_nodes(self, degree, prec, verbose=False):
+        r"""
+        Calculates the abscissas and weights for Gauss-Legendre
+        quadrature of degree of given degree (actually `3 \cdot 2^m`).
+        """
+        ctx = self.ctx
+        # It is important that the epsilon is set lower than the
+        # "real" epsilon
+        epsilon = ctx.ldexp(1, -prec-8)
+        # Fairly high precision might be required for accurate
+        # evaluation of the roots
+        orig = ctx.prec
+        ctx.prec = int(prec*1.5)
+        if degree == 1:
+            x = ctx.sqrt(ctx.mpf(3)/5)
+            w = ctx.mpf(5)/9
+            nodes = [(-x,w),(ctx.zero,ctx.mpf(8)/9),(x,w)]
+            ctx.prec = orig
+            return nodes
+        nodes = []
+        n = 3*2**(degree-1)
+        upto = n//2 + 1
+        for j in xrange(1, upto):
+            # Asymptotic formula for the roots
+            r = ctx.mpf(math.cos(math.pi*(j-0.25)/(n+0.5)))
+            # Newton iteration
+            while 1:
+                t1, t2 = 1, 0
+                # Evaluates the Legendre polynomial using its defining
+                # recurrence relation
+                for j1 in xrange(1,n+1):
+                    t3, t2, t1 = t2, t1, ((2*j1-1)*r*t1 - (j1-1)*t2)/j1
+                t4 = n*(r*t1-t2)/(r**2-1)
+                a = t1/t4
+                r = r - a
+                if abs(a) < epsilon:
+                    break
+            x = r
+            w = 2/((1-r**2)*t4**2)
+            if verbose  and j % 30 == 15:
+                print("Computing nodes (%i of %i)" % (j, upto))
+            nodes.append((x, w))
+            nodes.append((-x, w))
+        ctx.prec = orig
+        return nodes
+
+class QuadratureMethods(object):
+
+    def __init__(ctx, *args, **kwargs):
+        ctx._gauss_legendre = GaussLegendre(ctx)
+        ctx._tanh_sinh = TanhSinh(ctx)
+
+    def quad(ctx, f, *points, **kwargs):
+        r"""
+        Computes a single, double or triple integral over a given
+        1D interval, 2D rectangle, or 3D cuboid. A basic example::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> quad(sin, [0, pi])
+            2.0
+
+        A basic 2D integral::
+
+            >>> f = lambda x, y: cos(x+y/2)
+            >>> quad(f, [-pi/2, pi/2], [0, pi])
+            4.0
+
+        **Interval format**
+
+        The integration range for each dimension may be specified
+        using a list or tuple. Arguments are interpreted as follows:
+
+        ``quad(f, [x1, x2])`` -- calculates
+        `\int_{x_1}^{x_2} f(x) \, dx`
+
+        ``quad(f, [x1, x2], [y1, y2])`` -- calculates
+        `\int_{x_1}^{x_2} \int_{y_1}^{y_2} f(x,y) \, dy \, dx`
+
+        ``quad(f, [x1, x2], [y1, y2], [z1, z2])`` -- calculates
+        `\int_{x_1}^{x_2} \int_{y_1}^{y_2} \int_{z_1}^{z_2} f(x,y,z)
+        \, dz \, dy \, dx`
+
+        Endpoints may be finite or infinite. An interval descriptor
+        may also contain more than two points. In this
+        case, the integration is split into subintervals, between
+        each pair of consecutive points. This is useful for
+        dealing with mid-interval discontinuities, or integrating
+        over large intervals where the function is irregular or
+        oscillates.
+
+        **Options**
+
+        :func:`~mpmath.quad` recognizes the following keyword arguments:
+
+        *method*
+            Chooses integration algorithm (described below).
+        *error*
+            If set to true, :func:`~mpmath.quad` returns `(v, e)` where `v` is the
+            integral and `e` is the estimated error.
+        *maxdegree*
+            Maximum degree of the quadrature rule to try before
+            quitting.
+        *verbose*
+            Print details about progress.
+
+        **Algorithms**
+
+        Mpmath presently implements two integration algorithms: tanh-sinh
+        quadrature and Gauss-Legendre quadrature. These can be selected
+        using *method='tanh-sinh'* or *method='gauss-legendre'* or by
+        passing the classes *method=TanhSinh*, *method=GaussLegendre*.
+        The functions :func:`~mpmath.quadts` and :func:`~mpmath.quadgl` are also available
+        as shortcuts.
+
+        Both algorithms have the property that doubling the number of
+        evaluation points roughly doubles the accuracy, so both are ideal
+        for high precision quadrature (hundreds or thousands of digits).
+
+        At high precision, computing the nodes and weights for the
+        integration can be expensive (more expensive than computing the
+        function values). To make repeated integrations fast, nodes
+        are automatically cached.
+
+        The advantages of the tanh-sinh algorithm are that it tends to
+        handle endpoint singularities well, and that the nodes are cheap
+        to compute on the first run. For these reasons, it is used by
+        :func:`~mpmath.quad` as the default algorithm.
+
+        Gauss-Legendre quadrature often requires fewer function
+        evaluations, and is therefore often faster for repeated use, but
+        the algorithm does not handle endpoint singularities as well and
+        the nodes are more expensive to compute. Gauss-Legendre quadrature
+        can be a better choice if the integrand is smooth and repeated
+        integrations are required (e.g. for multiple integrals).
+
+        See the documentation for :class:`TanhSinh` and
+        :class:`GaussLegendre` for additional details.
+
+        **Examples of 1D integrals**
+
+        Intervals may be infinite or half-infinite. The following two
+        examples evaluate the limits of the inverse tangent function
+        (`\int 1/(1+x^2) = \tan^{-1} x`), and the Gaussian integral
+        `\int_{\infty}^{\infty} \exp(-x^2)\,dx = \sqrt{\pi}`::
+
+            >>> mp.dps = 15
+            >>> quad(lambda x: 2/(x**2+1), [0, inf])
+            3.14159265358979
+            >>> quad(lambda x: exp(-x**2), [-inf, inf])**2
+            3.14159265358979
+
+        Integrals can typically be resolved to high precision.
+        The following computes 50 digits of `\pi` by integrating the
+        area of the half-circle defined by `x^2 + y^2 \le 1`,
+        `-1 \le x \le 1`, `y \ge 0`::
+
+            >>> mp.dps = 50
+            >>> 2*quad(lambda x: sqrt(1-x**2), [-1, 1])
+            3.1415926535897932384626433832795028841971693993751
+
+        One can just as well compute 1000 digits (output truncated)::
+
+            >>> mp.dps = 1000
+            >>> 2*quad(lambda x: sqrt(1-x**2), [-1, 1])  #doctest:+ELLIPSIS
+            3.141592653589793238462643383279502884...216420199
+
+        Complex integrals are supported. The following computes
+        a residue at `z = 0` by integrating counterclockwise along the
+        diamond-shaped path from `1` to `+i` to `-1` to `-i` to `1`::
+
+            >>> mp.dps = 15
+            >>> chop(quad(lambda z: 1/z, [1,j,-1,-j,1]))
+            (0.0 + 6.28318530717959j)
+
+        **Examples of 2D and 3D integrals**
+
+        Here are several nice examples of analytically solvable
+        2D integrals (taken from MathWorld [1]) that can be evaluated
+        to high precision fairly rapidly by :func:`~mpmath.quad`::
+
+            >>> mp.dps = 30
+            >>> f = lambda x, y: (x-1)/((1-x*y)*log(x*y))
+            >>> quad(f, [0, 1], [0, 1])
+            0.577215664901532860606512090082
+            >>> +euler
+            0.577215664901532860606512090082
+
+            >>> f = lambda x, y: 1/sqrt(1+x**2+y**2)
+            >>> quad(f, [-1, 1], [-1, 1])
+            3.17343648530607134219175646705
+            >>> 4*log(2+sqrt(3))-2*pi/3
+            3.17343648530607134219175646705
+
+            >>> f = lambda x, y: 1/(1-x**2 * y**2)
+            >>> quad(f, [0, 1], [0, 1])
+            1.23370055013616982735431137498
+            >>> pi**2 / 8
+            1.23370055013616982735431137498
+
+            >>> quad(lambda x, y: 1/(1-x*y), [0, 1], [0, 1])
+            1.64493406684822643647241516665
+            >>> pi**2 / 6
+            1.64493406684822643647241516665
+
+        Multiple integrals may be done over infinite ranges::
+
+            >>> mp.dps = 15
+            >>> print(quad(lambda x,y: exp(-x-y), [0, inf], [1, inf]))
+            0.367879441171442
+            >>> print(1/e)
+            0.367879441171442
+
+        For nonrectangular areas, one can call :func:`~mpmath.quad` recursively.
+        For example, we can replicate the earlier example of calculating
+        `\pi` by integrating over the unit-circle, and actually use double
+        quadrature to actually measure the area circle::
+
+            >>> f = lambda x: quad(lambda y: 1, [-sqrt(1-x**2), sqrt(1-x**2)])
+            >>> quad(f, [-1, 1])
+            3.14159265358979
+
+        Here is a simple triple integral::
+
+            >>> mp.dps = 15
+            >>> f = lambda x,y,z: x*y/(1+z)
+            >>> quad(f, [0,1], [0,1], [1,2], method='gauss-legendre')
+            0.101366277027041
+            >>> (log(3)-log(2))/4
+            0.101366277027041
+
+        **Singularities**
+
+        Both tanh-sinh and Gauss-Legendre quadrature are designed to
+        integrate smooth (infinitely differentiable) functions. Neither
+        algorithm copes well with mid-interval singularities (such as
+        mid-interval discontinuities in `f(x)` or `f'(x)`).
+        The best solution is to split the integral into parts::
+
+            >>> mp.dps = 15
+            >>> quad(lambda x: abs(sin(x)), [0, 2*pi])   # Bad
+            3.99900894176779
+            >>> quad(lambda x: abs(sin(x)), [0, pi, 2*pi])  # Good
+            4.0
+
+        The tanh-sinh rule often works well for integrands having a
+        singularity at one or both endpoints::
+
+            >>> mp.dps = 15
+            >>> quad(log, [0, 1], method='tanh-sinh')  # Good
+            -1.0
+            >>> quad(log, [0, 1], method='gauss-legendre')  # Bad
+            -0.999932197413801
+
+        However, the result may still be inaccurate for some functions::
+
+            >>> quad(lambda x: 1/sqrt(x), [0, 1], method='tanh-sinh')
+            1.99999999946942
+
+        This problem is not due to the quadrature rule per se, but to
+        numerical amplification of errors in the nodes. The problem can be
+        circumvented by temporarily increasing the precision::
+
+            >>> mp.dps = 30
+            >>> a = quad(lambda x: 1/sqrt(x), [0, 1], method='tanh-sinh')
+            >>> mp.dps = 15
+            >>> +a
+            2.0
+
+        **Highly variable functions**
+
+        For functions that are smooth (in the sense of being infinitely
+        differentiable) but contain sharp mid-interval peaks or many
+        "bumps", :func:`~mpmath.quad` may fail to provide full accuracy. For
+        example, with default settings, :func:`~mpmath.quad` is able to integrate
+        `\sin(x)` accurately over an interval of length 100 but not over
+        length 1000::
+
+            >>> quad(sin, [0, 100]); 1-cos(100)   # Good
+            0.137681127712316
+            0.137681127712316
+            >>> quad(sin, [0, 1000]); 1-cos(1000)   # Bad
+            -37.8587612408485
+            0.437620923709297
+
+        One solution is to break the integration into 10 intervals of
+        length 100::
+
+            >>> quad(sin, linspace(0, 1000, 10))   # Good
+            0.437620923709297
+
+        Another is to increase the degree of the quadrature::
+
+            >>> quad(sin, [0, 1000], maxdegree=10)   # Also good
+            0.437620923709297
+
+        Whether splitting the interval or increasing the degree is
+        more efficient differs from case to case. Another example is the
+        function `1/(1+x^2)`, which has a sharp peak centered around
+        `x = 0`::
+
+            >>> f = lambda x: 1/(1+x**2)
+            >>> quad(f, [-100, 100])   # Bad
+            3.64804647105268
+            >>> quad(f, [-100, 100], maxdegree=10)   # Good
+            3.12159332021646
+            >>> quad(f, [-100, 0, 100])   # Also good
+            3.12159332021646
+
+        **References**
+
+        1. http://mathworld.wolfram.com/DoubleIntegral.html
+
+        """
+        rule = kwargs.get('method', 'tanh-sinh')
+        if type(rule) is str:
+            if rule == 'tanh-sinh':
+                rule = ctx._tanh_sinh
+            elif rule == 'gauss-legendre':
+                rule = ctx._gauss_legendre
+            else:
+                raise ValueError("unknown quadrature rule: %s" % rule)
+        else:
+            rule = rule(ctx)
+        verbose = kwargs.get('verbose')
+        dim = len(points)
+        orig = prec = ctx.prec
+        epsilon = ctx.eps/8
+        m = kwargs.get('maxdegree') or rule.guess_degree(prec)
+        points = [ctx._as_points(p) for p in points]
+        try:
+            ctx.prec += 20
+            if dim == 1:
+                v, err = rule.summation(f, points[0], prec, epsilon, m, verbose)
+            elif dim == 2:
+                v, err = rule.summation(lambda x: \
+                        rule.summation(lambda y: f(x,y), \
+                        points[1], prec, epsilon, m)[0],
+                    points[0], prec, epsilon, m, verbose)
+            elif dim == 3:
+                v, err = rule.summation(lambda x: \
+                        rule.summation(lambda y: \
+                            rule.summation(lambda z: f(x,y,z), \
+                            points[2], prec, epsilon, m)[0],
+                        points[1], prec, epsilon, m)[0],
+                    points[0], prec, epsilon, m, verbose)
+            else:
+                raise NotImplementedError("quadrature must have dim 1, 2 or 3")
+        finally:
+            ctx.prec = orig
+        if kwargs.get("error"):
+            return +v, err
+        return +v
+
+    def quadts(ctx, *args, **kwargs):
+        """
+        Performs tanh-sinh quadrature. The call
+
+            quadts(func, *points, ...)
+
+        is simply a shortcut for:
+
+            quad(func, *points, ..., method=TanhSinh)
+
+        For example, a single integral and a double integral:
+
+            quadts(lambda x: exp(cos(x)), [0, 1])
+            quadts(lambda x, y: exp(cos(x+y)), [0, 1], [0, 1])
+
+        See the documentation for quad for information about how points
+        arguments and keyword arguments are parsed.
+
+        See documentation for TanhSinh for algorithmic information about
+        tanh-sinh quadrature.
+        """
+        kwargs['method'] = 'tanh-sinh'
+        return ctx.quad(*args, **kwargs)
+
+    def quadgl(ctx, *args, **kwargs):
+        """
+        Performs Gauss-Legendre quadrature. The call
+
+            quadgl(func, *points, ...)
+
+        is simply a shortcut for:
+
+            quad(func, *points, ..., method=GaussLegendre)
+
+        For example, a single integral and a double integral:
+
+            quadgl(lambda x: exp(cos(x)), [0, 1])
+            quadgl(lambda x, y: exp(cos(x+y)), [0, 1], [0, 1])
+
+        See the documentation for quad for information about how points
+        arguments and keyword arguments are parsed.
+
+        See documentation for TanhSinh for algorithmic information about
+        tanh-sinh quadrature.
+        """
+        kwargs['method'] = 'gauss-legendre'
+        return ctx.quad(*args, **kwargs)
+
+    def quadosc(ctx, f, interval, omega=None, period=None, zeros=None):
+        r"""
+        Calculates
+
+        .. math ::
+
+            I = \int_a^b f(x) dx
+
+        where at least one of `a` and `b` is infinite and where
+        `f(x) = g(x) \cos(\omega x  + \phi)` for some slowly
+        decreasing function `g(x)`. With proper input, :func:`~mpmath.quadosc`
+        can also handle oscillatory integrals where the oscillation
+        rate is different from a pure sine or cosine wave.
+
+        In the standard case when `|a| < \infty, b = \infty`,
+        :func:`~mpmath.quadosc` works by evaluating the infinite series
+
+        .. math ::
+
+            I = \int_a^{x_1} f(x) dx +
+            \sum_{k=1}^{\infty} \int_{x_k}^{x_{k+1}} f(x) dx
+
+        where `x_k` are consecutive zeros (alternatively
+        some other periodic reference point) of `f(x)`.
+        Accordingly, :func:`~mpmath.quadosc` requires information about the
+        zeros of `f(x)`. For a periodic function, you can specify
+        the zeros by either providing the angular frequency `\omega`
+        (*omega*) or the *period* `2 \pi/\omega`. In general, you can
+        specify the `n`-th zero by providing the *zeros* arguments.
+        Below is an example of each::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> f = lambda x: sin(3*x)/(x**2+1)
+            >>> quadosc(f, [0,inf], omega=3)
+            0.37833007080198
+            >>> quadosc(f, [0,inf], period=2*pi/3)
+            0.37833007080198
+            >>> quadosc(f, [0,inf], zeros=lambda n: pi*n/3)
+            0.37833007080198
+            >>> (ei(3)*exp(-3)-exp(3)*ei(-3))/2  # Computed by Mathematica
+            0.37833007080198
+
+        Note that *zeros* was specified to multiply `n` by the
+        *half-period*, not the full period. In theory, it does not matter
+        whether each partial integral is done over a half period or a full
+        period. However, if done over half-periods, the infinite series
+        passed to :func:`~mpmath.nsum` becomes an *alternating series* and this
+        typically makes the extrapolation much more efficient.
+
+        Here is an example of an integration over the entire real line,
+        and a half-infinite integration starting at `-\infty`::
+
+            >>> quadosc(lambda x: cos(x)/(1+x**2), [-inf, inf], omega=1)
+            1.15572734979092
+            >>> pi/e
+            1.15572734979092
+            >>> quadosc(lambda x: cos(x)/x**2, [-inf, -1], period=2*pi)
+            -0.0844109505595739
+            >>> cos(1)+si(1)-pi/2
+            -0.0844109505595738
+
+        Of course, the integrand may contain a complex exponential just as
+        well as a real sine or cosine::
+
+            >>> quadosc(lambda x: exp(3*j*x)/(1+x**2), [-inf,inf], omega=3)
+            (0.156410688228254 + 0.0j)
+            >>> pi/e**3
+            0.156410688228254
+            >>> quadosc(lambda x: exp(3*j*x)/(2+x+x**2), [-inf,inf], omega=3)
+            (0.00317486988463794 - 0.0447701735209082j)
+            >>> 2*pi/sqrt(7)/exp(3*(j+sqrt(7))/2)
+            (0.00317486988463794 - 0.0447701735209082j)
+
+        **Non-periodic functions**
+
+        If `f(x) = g(x) h(x)` for some function `h(x)` that is not
+        strictly periodic, *omega* or *period* might not work, and it might
+        be necessary to use *zeros*.
+
+        A notable exception can be made for Bessel functions which, though not
+        periodic, are "asymptotically periodic" in a sufficiently strong sense
+        that the sum extrapolation will work out::
+
+            >>> quadosc(j0, [0, inf], period=2*pi)
+            1.0
+            >>> quadosc(j1, [0, inf], period=2*pi)
+            1.0
+
+        More properly, one should provide the exact Bessel function zeros::
+
+            >>> j0zero = lambda n: findroot(j0, pi*(n-0.25))
+            >>> quadosc(j0, [0, inf], zeros=j0zero)
+            1.0
+
+        For an example where *zeros* becomes necessary, consider the
+        complete Fresnel integrals
+
+        .. math ::
+
+            \int_0^{\infty} \cos x^2\,dx = \int_0^{\infty} \sin x^2\,dx
+            = \sqrt{\frac{\pi}{8}}.
+
+        Although the integrands do not decrease in magnitude as
+        `x \to \infty`, the integrals are convergent since the oscillation
+        rate increases (causing consecutive periods to asymptotically
+        cancel out). These integrals are virtually impossible to calculate
+        to any kind of accuracy using standard quadrature rules. However,
+        if one provides the correct asymptotic distribution of zeros
+        (`x_n \sim \sqrt{n}`), :func:`~mpmath.quadosc` works::
+
+            >>> mp.dps = 30
+            >>> f = lambda x: cos(x**2)
+            >>> quadosc(f, [0,inf], zeros=lambda n:sqrt(pi*n))
+            0.626657068657750125603941321203
+            >>> f = lambda x: sin(x**2)
+            >>> quadosc(f, [0,inf], zeros=lambda n:sqrt(pi*n))
+            0.626657068657750125603941321203
+            >>> sqrt(pi/8)
+            0.626657068657750125603941321203
+
+        (Interestingly, these integrals can still be evaluated if one
+        places some other constant than `\pi` in the square root sign.)
+
+        In general, if `f(x) \sim g(x) \cos(h(x))`, the zeros follow
+        the inverse-function distribution `h^{-1}(x)`::
+
+            >>> mp.dps = 15
+            >>> f = lambda x: sin(exp(x))
+            >>> quadosc(f, [1,inf], zeros=lambda n: log(n))
+            -0.25024394235267
+            >>> pi/2-si(e)
+            -0.250243942352671
+
+        **Non-alternating functions**
+
+        If the integrand oscillates around a positive value, without
+        alternating signs, the extrapolation might fail. A simple trick
+        that sometimes works is to multiply or divide the frequency by 2::
+
+            >>> f = lambda x: 1/x**2+sin(x)/x**4
+            >>> quadosc(f, [1,inf], omega=1)  # Bad
+            1.28642190869861
+            >>> quadosc(f, [1,inf], omega=0.5)  # Perfect
+            1.28652953559617
+            >>> 1+(cos(1)+ci(1)+sin(1))/6
+            1.28652953559617
+
+        **Fast decay**
+
+        :func:`~mpmath.quadosc` is primarily useful for slowly decaying
+        integrands. If the integrand decreases exponentially or faster,
+        :func:`~mpmath.quad` will likely handle it without trouble (and generally be
+        much faster than :func:`~mpmath.quadosc`)::
+
+            >>> quadosc(lambda x: cos(x)/exp(x), [0, inf], omega=1)
+            0.5
+            >>> quad(lambda x: cos(x)/exp(x), [0, inf])
+            0.5
+
+        """
+        a, b = ctx._as_points(interval)
+        a = ctx.convert(a)
+        b = ctx.convert(b)
+        if [omega, period, zeros].count(None) != 2:
+            raise ValueError( \
+                "must specify exactly one of omega, period, zeros")
+        if a == ctx.ninf and b == ctx.inf:
+            s1 = ctx.quadosc(f, [a, 0], omega=omega, zeros=zeros, period=period)
+            s2 = ctx.quadosc(f, [0, b], omega=omega, zeros=zeros, period=period)
+            return s1 + s2
+        if a == ctx.ninf:
+            if zeros:
+                return ctx.quadosc(lambda x:f(-x), [-b,-a], lambda n: zeros(-n))
+            else:
+                return ctx.quadosc(lambda x:f(-x), [-b,-a], omega=omega, period=period)
+        if b != ctx.inf:
+            raise ValueError("quadosc requires an infinite integration interval")
+        if not zeros:
+            if omega:
+                period = 2*ctx.pi/omega
+            zeros = lambda n: n*period/2
+        #for n in range(1,10):
+        #    p = zeros(n)
+        #    if p > a:
+        #        break
+        #if n >= 9:
+        #    raise ValueError("zeros do not appear to be correctly indexed")
+        n = 1
+        s = ctx.quadgl(f, [a, zeros(n)])
+        def term(k):
+            return ctx.quadgl(f, [zeros(k), zeros(k+1)])
+        s += ctx.nsum(term, [n, ctx.inf])
+        return s
+
+    def quadsubdiv(ctx, f, interval, tol=None, maxintervals=None, **kwargs):
+        """
+        Computes the integral of *f* over the interval or path specified
+        by *interval*, using :func:`~mpmath.quad` together with adaptive
+        subdivision of the interval.
+
+        This function gives an accurate answer for some integrals where
+        :func:`~mpmath.quad` fails::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> quad(lambda x: abs(sin(x)), [0, 2*pi])
+            3.99900894176779
+            >>> quadsubdiv(lambda x: abs(sin(x)), [0, 2*pi])
+            4.0
+            >>> quadsubdiv(sin, [0, 1000])
+            0.437620923709297
+            >>> quadsubdiv(lambda x: 1/(1+x**2), [-100, 100])
+            3.12159332021646
+            >>> quadsubdiv(lambda x: ceil(x), [0, 100])
+            5050.0
+            >>> quadsubdiv(lambda x: sin(x+exp(x)), [0,8])
+            0.347400172657248
+
+        The argument *maxintervals* can be set to limit the permissible
+        subdivision::
+
+            >>> quadsubdiv(lambda x: sin(x**2), [0,100], maxintervals=5, error=True)
+            (-5.40487904307774, 5.011)
+            >>> quadsubdiv(lambda x: sin(x**2), [0,100], maxintervals=100, error=True)
+            (0.631417921866934, 1.10101120134116e-17)
+
+        Subdivision does not guarantee a correct answer since, the error
+        estimate on subintervals may be inaccurate::
+
+            >>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, [0,1], error=True)
+            (0.210802735500549, 1.0001111101e-17)
+            >>> mp.dps = 20
+            >>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, [0,1], error=True)
+            (0.21080273550054927738, 2.200000001e-24)
+
+        The second answer is correct. We can get an accurate result at lower
+        precision by forcing a finer initial subdivision::
+
+            >>> mp.dps = 15
+            >>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, linspace(0,1,5))
+            0.210802735500549
+
+        The following integral is too oscillatory for convergence, but we can get a
+        reasonable estimate::
+
+            >>> v, err = fp.quadsubdiv(lambda x: fp.sin(1/x), [0,1], error=True)
+            >>> round(v, 6), round(err, 6)
+            (0.504067, 1e-06)
+            >>> sin(1) - ci(1)
+            0.504067061906928
+
+        """
+        queue = []
+        for i in range(len(interval)-1):
+            queue.append((interval[i], interval[i+1]))
+        total = ctx.zero
+        total_error = ctx.zero
+        if maxintervals is None:
+            maxintervals = 10 * ctx.prec
+        count = 0
+        quad_args = kwargs.copy()
+        quad_args["verbose"] = False
+        quad_args["error"] = True
+        if tol is None:
+            tol = +ctx.eps
+        orig = ctx.prec
+        try:
+            ctx.prec += 5
+            while queue:
+                a, b = queue.pop()
+                s, err = ctx.quad(f, [a, b], **quad_args)
+                if kwargs.get("verbose"):
+                    print("subinterval", count, a, b, err)
+                if err < tol or count > maxintervals:
+                    total += s
+                    total_error += err
+                else:
+                    count += 1
+                    if count == maxintervals and kwargs.get("verbose"):
+                        print("warning: number of intervals exceeded maxintervals")
+                    if a == -ctx.inf and b == ctx.inf:
+                        m = 0
+                    elif a == -ctx.inf:
+                        m = min(b-1, 2*b)
+                    elif b == ctx.inf:
+                        m = max(a+1, 2*a)
+                    else:
+                        m = a + (b - a) / 2
+                    queue.append((a, m))
+                    queue.append((m, b))
+        finally:
+            ctx.prec = orig
+        if kwargs.get("error"):
+            return +total, +total_error
+        else:
+            return +total
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.11/site-packages/mpmath/ctx_base.py b/lib/python3.11/site-packages/mpmath/ctx_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..1946f8daf4dbe165b3943be09af361812828aab1
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/ctx_base.py
@@ -0,0 +1,494 @@
+from operator import gt, lt
+
+from .libmp.backend import xrange
+
+from .functions.functions import SpecialFunctions
+from .functions.rszeta import RSCache
+from .calculus.quadrature import QuadratureMethods
+from .calculus.inverselaplace import LaplaceTransformInversionMethods
+from .calculus.calculus import CalculusMethods
+from .calculus.optimization import OptimizationMethods
+from .calculus.odes import ODEMethods
+from .matrices.matrices import MatrixMethods
+from .matrices.calculus import MatrixCalculusMethods
+from .matrices.linalg import LinearAlgebraMethods
+from .matrices.eigen import Eigen
+from .identification import IdentificationMethods
+from .visualization import VisualizationMethods
+
+from . import libmp
+
+class Context(object):
+    pass
+
+class StandardBaseContext(Context,
+    SpecialFunctions,
+    RSCache,
+    QuadratureMethods,
+    LaplaceTransformInversionMethods,
+    CalculusMethods,
+    MatrixMethods,
+    MatrixCalculusMethods,
+    LinearAlgebraMethods,
+    Eigen,
+    IdentificationMethods,
+    OptimizationMethods,
+    ODEMethods,
+    VisualizationMethods):
+
+    NoConvergence = libmp.NoConvergence
+    ComplexResult = libmp.ComplexResult
+
+    def __init__(ctx):
+        ctx._aliases = {}
+        # Call those that need preinitialization (e.g. for wrappers)
+        SpecialFunctions.__init__(ctx)
+        RSCache.__init__(ctx)
+        QuadratureMethods.__init__(ctx)
+        LaplaceTransformInversionMethods.__init__(ctx)
+        CalculusMethods.__init__(ctx)
+        MatrixMethods.__init__(ctx)
+
+    def _init_aliases(ctx):
+        for alias, value in ctx._aliases.items():
+            try:
+                setattr(ctx, alias, getattr(ctx, value))
+            except AttributeError:
+                pass
+
+    _fixed_precision = False
+
+    # XXX
+    verbose = False
+
+    def warn(ctx, msg):
+        print("Warning:", msg)
+
+    def bad_domain(ctx, msg):
+        raise ValueError(msg)
+
+    def _re(ctx, x):
+        if hasattr(x, "real"):
+            return x.real
+        return x
+
+    def _im(ctx, x):
+        if hasattr(x, "imag"):
+            return x.imag
+        return ctx.zero
+
+    def _as_points(ctx, x):
+        return x
+
+    def fneg(ctx, x, **kwargs):
+        return -ctx.convert(x)
+
+    def fadd(ctx, x, y, **kwargs):
+        return ctx.convert(x)+ctx.convert(y)
+
+    def fsub(ctx, x, y, **kwargs):
+        return ctx.convert(x)-ctx.convert(y)
+
+    def fmul(ctx, x, y, **kwargs):
+        return ctx.convert(x)*ctx.convert(y)
+
+    def fdiv(ctx, x, y, **kwargs):
+        return ctx.convert(x)/ctx.convert(y)
+
+    def fsum(ctx, args, absolute=False, squared=False):
+        if absolute:
+            if squared:
+                return sum((abs(x)**2 for x in args), ctx.zero)
+            return sum((abs(x) for x in args), ctx.zero)
+        if squared:
+            return sum((x**2 for x in args), ctx.zero)
+        return sum(args, ctx.zero)
+
+    def fdot(ctx, xs, ys=None, conjugate=False):
+        if ys is not None:
+            xs = zip(xs, ys)
+        if conjugate:
+            cf = ctx.conj
+            return sum((x*cf(y) for (x,y) in xs), ctx.zero)
+        else:
+            return sum((x*y for (x,y) in xs), ctx.zero)
+
+    def fprod(ctx, args):
+        prod = ctx.one
+        for arg in args:
+            prod *= arg
+        return prod
+
+    def nprint(ctx, x, n=6, **kwargs):
+        """
+        Equivalent to ``print(nstr(x, n))``.
+        """
+        print(ctx.nstr(x, n, **kwargs))
+
+    def chop(ctx, x, tol=None):
+        """
+        Chops off small real or imaginary parts, or converts
+        numbers close to zero to exact zeros. The input can be a
+        single number or an iterable::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> chop(5+1e-10j, tol=1e-9)
+            mpf('5.0')
+            >>> nprint(chop([1.0, 1e-20, 3+1e-18j, -4, 2]))
+            [1.0, 0.0, 3.0, -4.0, 2.0]
+
+        The tolerance defaults to ``100*eps``.
+        """
+        if tol is None:
+            tol = 100*ctx.eps
+        try:
+            x = ctx.convert(x)
+            absx = abs(x)
+            if abs(x) < tol:
+                return ctx.zero
+            if ctx._is_complex_type(x):
+                #part_tol = min(tol, absx*tol)
+                part_tol = max(tol, absx*tol)
+                if abs(x.imag) < part_tol:
+                    return x.real
+                if abs(x.real) < part_tol:
+                    return ctx.mpc(0, x.imag)
+        except TypeError:
+            if isinstance(x, ctx.matrix):
+                return x.apply(lambda a: ctx.chop(a, tol))
+            if hasattr(x, "__iter__"):
+                return [ctx.chop(a, tol) for a in x]
+        return x
+
+    def almosteq(ctx, s, t, rel_eps=None, abs_eps=None):
+        r"""
+        Determine whether the difference between `s` and `t` is smaller
+        than a given epsilon, either relatively or absolutely.
+
+        Both a maximum relative difference and a maximum difference
+        ('epsilons') may be specified. The absolute difference is
+        defined as `|s-t|` and the relative difference is defined
+        as `|s-t|/\max(|s|, |t|)`.
+
+        If only one epsilon is given, both are set to the same value.
+        If none is given, both epsilons are set to `2^{-p+m}` where
+        `p` is the current working precision and `m` is a small
+        integer. The default setting typically allows :func:`~mpmath.almosteq`
+        to be used to check for mathematical equality
+        in the presence of small rounding errors.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> almosteq(3.141592653589793, 3.141592653589790)
+            True
+            >>> almosteq(3.141592653589793, 3.141592653589700)
+            False
+            >>> almosteq(3.141592653589793, 3.141592653589700, 1e-10)
+            True
+            >>> almosteq(1e-20, 2e-20)
+            True
+            >>> almosteq(1e-20, 2e-20, rel_eps=0, abs_eps=0)
+            False
+
+        """
+        t = ctx.convert(t)
+        if abs_eps is None and rel_eps is None:
+            rel_eps = abs_eps = ctx.ldexp(1, -ctx.prec+4)
+        if abs_eps is None:
+            abs_eps = rel_eps
+        elif rel_eps is None:
+            rel_eps = abs_eps
+        diff = abs(s-t)
+        if diff <= abs_eps:
+            return True
+        abss = abs(s)
+        abst = abs(t)
+        if abss < abst:
+            err = diff/abst
+        else:
+            err = diff/abss
+        return err <= rel_eps
+
+    def arange(ctx, *args):
+        r"""
+        This is a generalized version of Python's :func:`~mpmath.range` function
+        that accepts fractional endpoints and step sizes and
+        returns a list of ``mpf`` instances. Like :func:`~mpmath.range`,
+        :func:`~mpmath.arange` can be called with 1, 2 or 3 arguments:
+
+        ``arange(b)``
+            `[0, 1, 2, \ldots, x]`
+        ``arange(a, b)``
+            `[a, a+1, a+2, \ldots, x]`
+        ``arange(a, b, h)``
+            `[a, a+h, a+h, \ldots, x]`
+
+        where `b-1 \le x < b` (in the third case, `b-h \le x < b`).
+
+        Like Python's :func:`~mpmath.range`, the endpoint is not included. To
+        produce ranges where the endpoint is included, :func:`~mpmath.linspace`
+        is more convenient.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> arange(4)
+            [mpf('0.0'), mpf('1.0'), mpf('2.0'), mpf('3.0')]
+            >>> arange(1, 2, 0.25)
+            [mpf('1.0'), mpf('1.25'), mpf('1.5'), mpf('1.75')]
+            >>> arange(1, -1, -0.75)
+            [mpf('1.0'), mpf('0.25'), mpf('-0.5')]
+
+        """
+        if not len(args) <= 3:
+            raise TypeError('arange expected at most 3 arguments, got %i'
+                            % len(args))
+        if not len(args) >= 1:
+            raise TypeError('arange expected at least 1 argument, got %i'
+                            % len(args))
+        # set default
+        a = 0
+        dt = 1
+        # interpret arguments
+        if len(args) == 1:
+            b = args[0]
+        elif len(args) >= 2:
+            a = args[0]
+            b = args[1]
+        if len(args) == 3:
+            dt = args[2]
+        a, b, dt = ctx.mpf(a), ctx.mpf(b), ctx.mpf(dt)
+        assert a + dt != a, 'dt is too small and would cause an infinite loop'
+        # adapt code for sign of dt
+        if a > b:
+            if dt > 0:
+                return []
+            op = gt
+        else:
+            if dt < 0:
+                return []
+            op = lt
+        # create list
+        result = []
+        i = 0
+        t = a
+        while 1:
+            t = a + dt*i
+            i += 1
+            if op(t, b):
+                result.append(t)
+            else:
+                break
+        return result
+
+    def linspace(ctx, *args, **kwargs):
+        """
+        ``linspace(a, b, n)`` returns a list of `n` evenly spaced
+        samples from `a` to `b`. The syntax ``linspace(mpi(a,b), n)``
+        is also valid.
+
+        This function is often more convenient than :func:`~mpmath.arange`
+        for partitioning an interval into subintervals, since
+        the endpoint is included::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> linspace(1, 4, 4)
+            [mpf('1.0'), mpf('2.0'), mpf('3.0'), mpf('4.0')]
+
+        You may also provide the keyword argument ``endpoint=False``::
+
+            >>> linspace(1, 4, 4, endpoint=False)
+            [mpf('1.0'), mpf('1.75'), mpf('2.5'), mpf('3.25')]
+
+        """
+        if len(args) == 3:
+            a = ctx.mpf(args[0])
+            b = ctx.mpf(args[1])
+            n = int(args[2])
+        elif len(args) == 2:
+            assert hasattr(args[0], '_mpi_')
+            a = args[0].a
+            b = args[0].b
+            n = int(args[1])
+        else:
+            raise TypeError('linspace expected 2 or 3 arguments, got %i' \
+                            % len(args))
+        if n < 1:
+            raise ValueError('n must be greater than 0')
+        if not 'endpoint' in kwargs or kwargs['endpoint']:
+            if n == 1:
+                return [ctx.mpf(a)]
+            step = (b - a) / ctx.mpf(n - 1)
+            y = [i*step + a for i in xrange(n)]
+            y[-1] = b
+        else:
+            step = (b - a) / ctx.mpf(n)
+            y = [i*step + a for i in xrange(n)]
+        return y
+
+    def cos_sin(ctx, z, **kwargs):
+        return ctx.cos(z, **kwargs), ctx.sin(z, **kwargs)
+
+    def cospi_sinpi(ctx, z, **kwargs):
+        return ctx.cospi(z, **kwargs), ctx.sinpi(z, **kwargs)
+
+    def _default_hyper_maxprec(ctx, p):
+        return int(1000 * p**0.25 + 4*p)
+
+    _gcd = staticmethod(libmp.gcd)
+    list_primes = staticmethod(libmp.list_primes)
+    isprime = staticmethod(libmp.isprime)
+    bernfrac = staticmethod(libmp.bernfrac)
+    moebius = staticmethod(libmp.moebius)
+    _ifac = staticmethod(libmp.ifac)
+    _eulernum = staticmethod(libmp.eulernum)
+    _stirling1 = staticmethod(libmp.stirling1)
+    _stirling2 = staticmethod(libmp.stirling2)
+
+    def sum_accurately(ctx, terms, check_step=1):
+        prec = ctx.prec
+        try:
+            extraprec = 10
+            while 1:
+                ctx.prec = prec + extraprec + 5
+                max_mag = ctx.ninf
+                s = ctx.zero
+                k = 0
+                for term in terms():
+                    s += term
+                    if (not k % check_step) and term:
+                        term_mag = ctx.mag(term)
+                        max_mag = max(max_mag, term_mag)
+                        sum_mag = ctx.mag(s)
+                        if sum_mag - term_mag > ctx.prec:
+                            break
+                    k += 1
+                cancellation = max_mag - sum_mag
+                if cancellation != cancellation:
+                    break
+                if cancellation < extraprec or ctx._fixed_precision:
+                    break
+                extraprec += min(ctx.prec, cancellation)
+            return s
+        finally:
+            ctx.prec = prec
+
+    def mul_accurately(ctx, factors, check_step=1):
+        prec = ctx.prec
+        try:
+            extraprec = 10
+            while 1:
+                ctx.prec = prec + extraprec + 5
+                max_mag = ctx.ninf
+                one = ctx.one
+                s = one
+                k = 0
+                for factor in factors():
+                    s *= factor
+                    term = factor - one
+                    if (not k % check_step):
+                        term_mag = ctx.mag(term)
+                        max_mag = max(max_mag, term_mag)
+                        sum_mag = ctx.mag(s-one)
+                        #if sum_mag - term_mag > ctx.prec:
+                        #    break
+                        if -term_mag > ctx.prec:
+                            break
+                    k += 1
+                cancellation = max_mag - sum_mag
+                if cancellation != cancellation:
+                    break
+                if cancellation < extraprec or ctx._fixed_precision:
+                    break
+                extraprec += min(ctx.prec, cancellation)
+            return s
+        finally:
+            ctx.prec = prec
+
+    def power(ctx, x, y):
+        r"""Converts `x` and `y` to mpmath numbers and evaluates
+        `x^y = \exp(y \log(x))`::
+
+            >>> from mpmath import *
+            >>> mp.dps = 30; mp.pretty = True
+            >>> power(2, 0.5)
+            1.41421356237309504880168872421
+
+        This shows the leading few digits of a large Mersenne prime
+        (performing the exact calculation ``2**43112609-1`` and
+        displaying the result in Python would be very slow)::
+
+            >>> power(2, 43112609)-1
+            3.16470269330255923143453723949e+12978188
+        """
+        return ctx.convert(x) ** ctx.convert(y)
+
+    def _zeta_int(ctx, n):
+        return ctx.zeta(n)
+
+    def maxcalls(ctx, f, N):
+        """
+        Return a wrapped copy of *f* that raises ``NoConvergence`` when *f*
+        has been called more than *N* times::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> f = maxcalls(sin, 10)
+            >>> print(sum(f(n) for n in range(10)))
+            1.95520948210738
+            >>> f(10) # doctest: +IGNORE_EXCEPTION_DETAIL
+            Traceback (most recent call last):
+              ...
+            NoConvergence: maxcalls: function evaluated 10 times
+
+        """
+        counter = [0]
+        def f_maxcalls_wrapped(*args, **kwargs):
+            counter[0] += 1
+            if counter[0] > N:
+                raise ctx.NoConvergence("maxcalls: function evaluated %i times" % N)
+            return f(*args, **kwargs)
+        return f_maxcalls_wrapped
+
+    def memoize(ctx, f):
+        """
+        Return a wrapped copy of *f* that caches computed values, i.e.
+        a memoized copy of *f*. Values are only reused if the cached precision
+        is equal to or higher than the working precision::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> f = memoize(maxcalls(sin, 1))
+            >>> f(2)
+            0.909297426825682
+            >>> f(2)
+            0.909297426825682
+            >>> mp.dps = 25
+            >>> f(2) # doctest: +IGNORE_EXCEPTION_DETAIL
+            Traceback (most recent call last):
+              ...
+            NoConvergence: maxcalls: function evaluated 1 times
+
+        """
+        f_cache = {}
+        def f_cached(*args, **kwargs):
+            if kwargs:
+                key = args, tuple(kwargs.items())
+            else:
+                key = args
+            prec = ctx.prec
+            if key in f_cache:
+                cprec, cvalue = f_cache[key]
+                if cprec >= prec:
+                    return +cvalue
+            value = f(*args, **kwargs)
+            f_cache[key] = (prec, value)
+            return value
+        f_cached.__name__ = f.__name__
+        f_cached.__doc__ = f.__doc__
+        return f_cached
diff --git a/lib/python3.11/site-packages/mpmath/ctx_fp.py b/lib/python3.11/site-packages/mpmath/ctx_fp.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa72ea5b03fde4da66b0d8fbf8ffa4012e3f6178
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/ctx_fp.py
@@ -0,0 +1,253 @@
+from .ctx_base import StandardBaseContext
+
+import math
+import cmath
+from . import math2
+
+from . import function_docs
+
+from .libmp import mpf_bernoulli, to_float, int_types
+from . import libmp
+
+class FPContext(StandardBaseContext):
+    """
+    Context for fast low-precision arithmetic (53-bit precision, giving at most
+    about 15-digit accuracy), using Python's builtin float and complex.
+    """
+
+    def __init__(ctx):
+        StandardBaseContext.__init__(ctx)
+
+        # Override SpecialFunctions implementation
+        ctx.loggamma = math2.loggamma
+        ctx._bernoulli_cache = {}
+        ctx.pretty = False
+
+        ctx._init_aliases()
+
+    _mpq = lambda cls, x: float(x[0])/x[1]
+
+    NoConvergence = libmp.NoConvergence
+
+    def _get_prec(ctx): return 53
+    def _set_prec(ctx, p): return
+    def _get_dps(ctx): return 15
+    def _set_dps(ctx, p): return
+
+    _fixed_precision = True
+
+    prec = property(_get_prec, _set_prec)
+    dps = property(_get_dps, _set_dps)
+
+    zero = 0.0
+    one = 1.0
+    eps = math2.EPS
+    inf = math2.INF
+    ninf = math2.NINF
+    nan = math2.NAN
+    j = 1j
+
+    # Called by SpecialFunctions.__init__()
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        if wrap:
+            def f_wrapped(ctx, *args, **kwargs):
+                convert = ctx.convert
+                args = [convert(a) for a in args]
+                return f(ctx, *args, **kwargs)
+        else:
+            f_wrapped = f
+        f_wrapped.__doc__ = function_docs.__dict__.get(name, f.__doc__)
+        setattr(cls, name, f_wrapped)
+
+    def bernoulli(ctx, n):
+        cache = ctx._bernoulli_cache
+        if n in cache:
+            return cache[n]
+        cache[n] = to_float(mpf_bernoulli(n, 53, 'n'), strict=True)
+        return cache[n]
+
+    pi = math2.pi
+    e = math2.e
+    euler = math2.euler
+    sqrt2 = 1.4142135623730950488
+    sqrt5 = 2.2360679774997896964
+    phi = 1.6180339887498948482
+    ln2 = 0.69314718055994530942
+    ln10 = 2.302585092994045684
+    euler = 0.57721566490153286061
+    catalan = 0.91596559417721901505
+    khinchin = 2.6854520010653064453
+    apery = 1.2020569031595942854
+    glaisher = 1.2824271291006226369
+
+    absmin = absmax = abs
+
+    def is_special(ctx, x):
+        return x - x != 0.0
+
+    def isnan(ctx, x):
+        return x != x
+
+    def isinf(ctx, x):
+        return abs(x) == math2.INF
+
+    def isnormal(ctx, x):
+        if x:
+            return x - x == 0.0
+        return False
+
+    def isnpint(ctx, x):
+        if type(x) is complex:
+            if x.imag:
+                return False
+            x = x.real
+        return x <= 0.0 and round(x) == x
+
+    mpf = float
+    mpc = complex
+
+    def convert(ctx, x):
+        try:
+            return float(x)
+        except:
+            return complex(x)
+
+    power = staticmethod(math2.pow)
+    sqrt = staticmethod(math2.sqrt)
+    exp = staticmethod(math2.exp)
+    ln = log = staticmethod(math2.log)
+    cos = staticmethod(math2.cos)
+    sin = staticmethod(math2.sin)
+    tan = staticmethod(math2.tan)
+    cos_sin = staticmethod(math2.cos_sin)
+    acos = staticmethod(math2.acos)
+    asin = staticmethod(math2.asin)
+    atan = staticmethod(math2.atan)
+    cosh = staticmethod(math2.cosh)
+    sinh = staticmethod(math2.sinh)
+    tanh = staticmethod(math2.tanh)
+    gamma = staticmethod(math2.gamma)
+    rgamma = staticmethod(math2.rgamma)
+    fac = factorial = staticmethod(math2.factorial)
+    floor = staticmethod(math2.floor)
+    ceil = staticmethod(math2.ceil)
+    cospi = staticmethod(math2.cospi)
+    sinpi = staticmethod(math2.sinpi)
+    cbrt = staticmethod(math2.cbrt)
+    _nthroot = staticmethod(math2.nthroot)
+    _ei = staticmethod(math2.ei)
+    _e1 = staticmethod(math2.e1)
+    _zeta = _zeta_int = staticmethod(math2.zeta)
+
+    # XXX: math2
+    def arg(ctx, z):
+        z = complex(z)
+        return math.atan2(z.imag, z.real)
+
+    def expj(ctx, x):
+        return ctx.exp(ctx.j*x)
+
+    def expjpi(ctx, x):
+        return ctx.exp(ctx.j*ctx.pi*x)
+
+    ldexp = math.ldexp
+    frexp = math.frexp
+
+    def mag(ctx, z):
+        if z:
+            return ctx.frexp(abs(z))[1]
+        return ctx.ninf
+
+    def isint(ctx, z):
+        if hasattr(z, "imag"):   # float/int don't have .real/.imag in py2.5
+            if z.imag:
+                return False
+            z = z.real
+        try:
+            return z == int(z)
+        except:
+            return False
+
+    def nint_distance(ctx, z):
+        if hasattr(z, "imag"):   # float/int don't have .real/.imag in py2.5
+            n = round(z.real)
+        else:
+            n = round(z)
+        if n == z:
+            return n, ctx.ninf
+        return n, ctx.mag(abs(z-n))
+
+    def _convert_param(ctx, z):
+        if type(z) is tuple:
+            p, q = z
+            return ctx.mpf(p) / q, 'R'
+        if hasattr(z, "imag"):    # float/int don't have .real/.imag in py2.5
+            intz = int(z.real)
+        else:
+            intz = int(z)
+        if z == intz:
+            return intz, 'Z'
+        return z, 'R'
+
+    def _is_real_type(ctx, z):
+        return isinstance(z, float) or isinstance(z, int_types)
+
+    def _is_complex_type(ctx, z):
+        return isinstance(z, complex)
+
+    def hypsum(ctx, p, q, types, coeffs, z, maxterms=6000, **kwargs):
+        coeffs = list(coeffs)
+        num = range(p)
+        den = range(p,p+q)
+        tol = ctx.eps
+        s = t = 1.0
+        k = 0
+        while 1:
+            for i in num: t *= (coeffs[i]+k)
+            for i in den: t /= (coeffs[i]+k)
+            k += 1; t /= k; t *= z; s += t
+            if abs(t) < tol:
+                return s
+            if k > maxterms:
+                raise ctx.NoConvergence
+
+    def atan2(ctx, x, y):
+        return math.atan2(x, y)
+
+    def psi(ctx, m, z):
+        m = int(m)
+        if m == 0:
+            return ctx.digamma(z)
+        return (-1)**(m+1) * ctx.fac(m) * ctx.zeta(m+1, z)
+
+    digamma = staticmethod(math2.digamma)
+
+    def harmonic(ctx, x):
+        x = ctx.convert(x)
+        if x == 0 or x == 1:
+            return x
+        return ctx.digamma(x+1) + ctx.euler
+
+    nstr = str
+
+    def to_fixed(ctx, x, prec):
+        return int(math.ldexp(x, prec))
+
+    def rand(ctx):
+        import random
+        return random.random()
+
+    _erf = staticmethod(math2.erf)
+    _erfc = staticmethod(math2.erfc)
+
+    def sum_accurately(ctx, terms, check_step=1):
+        s = ctx.zero
+        k = 0
+        for term in terms():
+            s += term
+            if (not k % check_step) and term:
+                if abs(term) <= 1e-18*abs(s):
+                    break
+            k += 1
+        return s
diff --git a/lib/python3.11/site-packages/mpmath/ctx_iv.py b/lib/python3.11/site-packages/mpmath/ctx_iv.py
new file mode 100644
index 0000000000000000000000000000000000000000..c038e00a5677e318d222b63c22d225e3045e1c2b
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/ctx_iv.py
@@ -0,0 +1,551 @@
+import operator
+
+from . import libmp
+
+from .libmp.backend import basestring
+
+from .libmp import (
+    int_types, MPZ_ONE,
+    prec_to_dps, dps_to_prec, repr_dps,
+    round_floor, round_ceiling,
+    fzero, finf, fninf, fnan,
+    mpf_le, mpf_neg,
+    from_int, from_float, from_str, from_rational,
+    mpi_mid, mpi_delta, mpi_str,
+    mpi_abs, mpi_pos, mpi_neg, mpi_add, mpi_sub,
+    mpi_mul, mpi_div, mpi_pow_int, mpi_pow,
+    mpi_from_str,
+    mpci_pos, mpci_neg, mpci_add, mpci_sub, mpci_mul, mpci_div, mpci_pow,
+    mpci_abs, mpci_pow, mpci_exp, mpci_log,
+    ComplexResult,
+    mpf_hash, mpc_hash)
+from .matrices.matrices import _matrix
+
+mpi_zero = (fzero, fzero)
+
+from .ctx_base import StandardBaseContext
+
+new = object.__new__
+
+def convert_mpf_(x, prec, rounding):
+    if hasattr(x, "_mpf_"): return x._mpf_
+    if isinstance(x, int_types): return from_int(x, prec, rounding)
+    if isinstance(x, float): return from_float(x, prec, rounding)
+    if isinstance(x, basestring): return from_str(x, prec, rounding)
+    raise NotImplementedError
+
+
+class ivmpf(object):
+    """
+    Interval arithmetic class. Precision is controlled by iv.prec.
+    """
+
+    def __new__(cls, x=0):
+        return cls.ctx.convert(x)
+
+    def cast(self, cls, f_convert):
+        a, b = self._mpi_
+        if a == b:
+            return cls(f_convert(a))
+        raise ValueError
+
+    def __int__(self):
+        return self.cast(int, libmp.to_int)
+
+    def __float__(self):
+        return self.cast(float, libmp.to_float)
+
+    def __complex__(self):
+        return self.cast(complex, libmp.to_float)
+
+    def __hash__(self):
+        a, b = self._mpi_
+        if a == b:
+            return mpf_hash(a)
+        else:
+            return hash(self._mpi_)
+
+    @property
+    def real(self): return self
+
+    @property
+    def imag(self): return self.ctx.zero
+
+    def conjugate(self): return self
+
+    @property
+    def a(self):
+        a, b = self._mpi_
+        return self.ctx.make_mpf((a, a))
+
+    @property
+    def b(self):
+        a, b = self._mpi_
+        return self.ctx.make_mpf((b, b))
+
+    @property
+    def mid(self):
+        ctx = self.ctx
+        v = mpi_mid(self._mpi_, ctx.prec)
+        return ctx.make_mpf((v, v))
+
+    @property
+    def delta(self):
+        ctx = self.ctx
+        v = mpi_delta(self._mpi_, ctx.prec)
+        return ctx.make_mpf((v,v))
+
+    @property
+    def _mpci_(self):
+        return self._mpi_, mpi_zero
+
+    def _compare(*args):
+        raise TypeError("no ordering relation is defined for intervals")
+
+    __gt__ = _compare
+    __le__ = _compare
+    __gt__ = _compare
+    __ge__ = _compare
+
+    def __contains__(self, t):
+        t = self.ctx.mpf(t)
+        return (self.a <= t.a) and (t.b <= self.b)
+
+    def __str__(self):
+        return mpi_str(self._mpi_, self.ctx.prec)
+
+    def __repr__(self):
+        if self.ctx.pretty:
+            return str(self)
+        a, b = self._mpi_
+        n = repr_dps(self.ctx.prec)
+        a = libmp.to_str(a, n)
+        b = libmp.to_str(b, n)
+        return "mpi(%r, %r)" % (a, b)
+
+    def _compare(s, t, cmpfun):
+        if not hasattr(t, "_mpi_"):
+            try:
+                t = s.ctx.convert(t)
+            except:
+                return NotImplemented
+        return cmpfun(s._mpi_, t._mpi_)
+
+    def __eq__(s, t): return s._compare(t, libmp.mpi_eq)
+    def __ne__(s, t): return s._compare(t, libmp.mpi_ne)
+    def __lt__(s, t): return s._compare(t, libmp.mpi_lt)
+    def __le__(s, t): return s._compare(t, libmp.mpi_le)
+    def __gt__(s, t): return s._compare(t, libmp.mpi_gt)
+    def __ge__(s, t): return s._compare(t, libmp.mpi_ge)
+
+    def __abs__(self):
+        return self.ctx.make_mpf(mpi_abs(self._mpi_, self.ctx.prec))
+    def __pos__(self):
+        return self.ctx.make_mpf(mpi_pos(self._mpi_, self.ctx.prec))
+    def __neg__(self):
+        return self.ctx.make_mpf(mpi_neg(self._mpi_, self.ctx.prec))
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.ctx.almosteq(s, t, rel_eps, abs_eps)
+
+class ivmpc(object):
+
+    def __new__(cls, re=0, im=0):
+        re = cls.ctx.convert(re)
+        im = cls.ctx.convert(im)
+        y = new(cls)
+        y._mpci_ = re._mpi_, im._mpi_
+        return y
+
+    def __hash__(self):
+        (a, b), (c,d) = self._mpci_
+        if a == b and c == d:
+            return mpc_hash((a, c))
+        else:
+            return hash(self._mpci_)
+
+    def __repr__(s):
+        if s.ctx.pretty:
+            return str(s)
+        return "iv.mpc(%s, %s)" % (repr(s.real), repr(s.imag))
+
+    def __str__(s):
+        return "(%s + %s*j)" % (str(s.real), str(s.imag))
+
+    @property
+    def a(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((a, a))
+
+    @property
+    def b(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((b, b))
+
+    @property
+    def c(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((c, c))
+
+    @property
+    def d(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((d, d))
+
+    @property
+    def real(s):
+        return s.ctx.make_mpf(s._mpci_[0])
+
+    @property
+    def imag(s):
+        return s.ctx.make_mpf(s._mpci_[1])
+
+    def conjugate(s):
+        a, b = s._mpci_
+        return s.ctx.make_mpc((a, mpf_neg(b)))
+
+    def overlap(s, t):
+        t = s.ctx.convert(t)
+        real_overlap = (s.a <= t.a <= s.b) or (s.a <= t.b <= s.b) or (t.a <= s.a <= t.b) or (t.a <= s.b <= t.b)
+        imag_overlap = (s.c <= t.c <= s.d) or (s.c <= t.d <= s.d) or (t.c <= s.c <= t.d) or (t.c <= s.d <= t.d)
+        return real_overlap and imag_overlap
+
+    def __contains__(s, t):
+        t = s.ctx.convert(t)
+        return t.real in s.real and t.imag in s.imag
+
+    def _compare(s, t, ne=False):
+        if not isinstance(t, s.ctx._types):
+            try:
+                t = s.ctx.convert(t)
+            except:
+                return NotImplemented
+        if hasattr(t, '_mpi_'):
+            tval = t._mpi_, mpi_zero
+        elif hasattr(t, '_mpci_'):
+            tval = t._mpci_
+        if ne:
+            return s._mpci_ != tval
+        return s._mpci_ == tval
+
+    def __eq__(s, t): return s._compare(t)
+    def __ne__(s, t): return s._compare(t, True)
+
+    def __lt__(s, t): raise TypeError("complex intervals cannot be ordered")
+    __le__ = __gt__ = __ge__ = __lt__
+
+    def __neg__(s): return s.ctx.make_mpc(mpci_neg(s._mpci_, s.ctx.prec))
+    def __pos__(s): return s.ctx.make_mpc(mpci_pos(s._mpci_, s.ctx.prec))
+    def __abs__(s): return s.ctx.make_mpf(mpci_abs(s._mpci_, s.ctx.prec))
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.ctx.almosteq(s, t, rel_eps, abs_eps)
+
+def _binary_op(f_real, f_complex):
+    def g_complex(ctx, sval, tval):
+        return ctx.make_mpc(f_complex(sval, tval, ctx.prec))
+    def g_real(ctx, sval, tval):
+        try:
+            return ctx.make_mpf(f_real(sval, tval, ctx.prec))
+        except ComplexResult:
+            sval = (sval, mpi_zero)
+            tval = (tval, mpi_zero)
+            return g_complex(ctx, sval, tval)
+    def lop_real(s, t):
+        if isinstance(t, _matrix): return NotImplemented
+        ctx = s.ctx
+        if not isinstance(t, ctx._types): t = ctx.convert(t)
+        if hasattr(t, "_mpi_"): return g_real(ctx, s._mpi_, t._mpi_)
+        if hasattr(t, "_mpci_"): return g_complex(ctx, (s._mpi_, mpi_zero), t._mpci_)
+        return NotImplemented
+    def rop_real(s, t):
+        ctx = s.ctx
+        if not isinstance(t, ctx._types): t = ctx.convert(t)
+        if hasattr(t, "_mpi_"): return g_real(ctx, t._mpi_, s._mpi_)
+        if hasattr(t, "_mpci_"): return g_complex(ctx, t._mpci_, (s._mpi_, mpi_zero))
+        return NotImplemented
+    def lop_complex(s, t):
+        if isinstance(t, _matrix): return NotImplemented
+        ctx = s.ctx
+        if not isinstance(t, s.ctx._types):
+            try:
+                t = s.ctx.convert(t)
+            except (ValueError, TypeError):
+                return NotImplemented
+        return g_complex(ctx, s._mpci_, t._mpci_)
+    def rop_complex(s, t):
+        ctx = s.ctx
+        if not isinstance(t, s.ctx._types):
+            t = s.ctx.convert(t)
+        return g_complex(ctx, t._mpci_, s._mpci_)
+    return lop_real, rop_real, lop_complex, rop_complex
+
+ivmpf.__add__, ivmpf.__radd__, ivmpc.__add__, ivmpc.__radd__ = _binary_op(mpi_add, mpci_add)
+ivmpf.__sub__, ivmpf.__rsub__, ivmpc.__sub__, ivmpc.__rsub__ = _binary_op(mpi_sub, mpci_sub)
+ivmpf.__mul__, ivmpf.__rmul__, ivmpc.__mul__, ivmpc.__rmul__ = _binary_op(mpi_mul, mpci_mul)
+ivmpf.__div__, ivmpf.__rdiv__, ivmpc.__div__, ivmpc.__rdiv__ = _binary_op(mpi_div, mpci_div)
+ivmpf.__pow__, ivmpf.__rpow__, ivmpc.__pow__, ivmpc.__rpow__ = _binary_op(mpi_pow, mpci_pow)
+
+ivmpf.__truediv__ = ivmpf.__div__; ivmpf.__rtruediv__ = ivmpf.__rdiv__
+ivmpc.__truediv__ = ivmpc.__div__; ivmpc.__rtruediv__ = ivmpc.__rdiv__
+
+class ivmpf_constant(ivmpf):
+    def __new__(cls, f):
+        self = new(cls)
+        self._f = f
+        return self
+    def _get_mpi_(self):
+        prec = self.ctx._prec[0]
+        a = self._f(prec, round_floor)
+        b = self._f(prec, round_ceiling)
+        return a, b
+    _mpi_ = property(_get_mpi_)
+
+class MPIntervalContext(StandardBaseContext):
+
+    def __init__(ctx):
+        ctx.mpf = type('ivmpf', (ivmpf,), {})
+        ctx.mpc = type('ivmpc', (ivmpc,), {})
+        ctx._types = (ctx.mpf, ctx.mpc)
+        ctx._constant = type('ivmpf_constant', (ivmpf_constant,), {})
+        ctx._prec = [53]
+        ctx._set_prec(53)
+        ctx._constant._ctxdata = ctx.mpf._ctxdata = ctx.mpc._ctxdata = [ctx.mpf, new, ctx._prec]
+        ctx._constant.ctx = ctx.mpf.ctx = ctx.mpc.ctx = ctx
+        ctx.pretty = False
+        StandardBaseContext.__init__(ctx)
+        ctx._init_builtins()
+
+    def _mpi(ctx, a, b=None):
+        if b is None:
+            return ctx.mpf(a)
+        return ctx.mpf((a,b))
+
+    def _init_builtins(ctx):
+        ctx.one = ctx.mpf(1)
+        ctx.zero = ctx.mpf(0)
+        ctx.inf = ctx.mpf('inf')
+        ctx.ninf = -ctx.inf
+        ctx.nan = ctx.mpf('nan')
+        ctx.j = ctx.mpc(0,1)
+        ctx.exp = ctx._wrap_mpi_function(libmp.mpi_exp, libmp.mpci_exp)
+        ctx.sqrt = ctx._wrap_mpi_function(libmp.mpi_sqrt)
+        ctx.ln = ctx._wrap_mpi_function(libmp.mpi_log, libmp.mpci_log)
+        ctx.cos = ctx._wrap_mpi_function(libmp.mpi_cos, libmp.mpci_cos)
+        ctx.sin = ctx._wrap_mpi_function(libmp.mpi_sin, libmp.mpci_sin)
+        ctx.tan = ctx._wrap_mpi_function(libmp.mpi_tan)
+        ctx.gamma = ctx._wrap_mpi_function(libmp.mpi_gamma, libmp.mpci_gamma)
+        ctx.loggamma = ctx._wrap_mpi_function(libmp.mpi_loggamma, libmp.mpci_loggamma)
+        ctx.rgamma = ctx._wrap_mpi_function(libmp.mpi_rgamma, libmp.mpci_rgamma)
+        ctx.factorial = ctx._wrap_mpi_function(libmp.mpi_factorial, libmp.mpci_factorial)
+        ctx.fac = ctx.factorial
+
+        ctx.eps = ctx._constant(lambda prec, rnd: (0, MPZ_ONE, 1-prec, 1))
+        ctx.pi = ctx._constant(libmp.mpf_pi)
+        ctx.e = ctx._constant(libmp.mpf_e)
+        ctx.ln2 = ctx._constant(libmp.mpf_ln2)
+        ctx.ln10 = ctx._constant(libmp.mpf_ln10)
+        ctx.phi = ctx._constant(libmp.mpf_phi)
+        ctx.euler = ctx._constant(libmp.mpf_euler)
+        ctx.catalan = ctx._constant(libmp.mpf_catalan)
+        ctx.glaisher = ctx._constant(libmp.mpf_glaisher)
+        ctx.khinchin = ctx._constant(libmp.mpf_khinchin)
+        ctx.twinprime = ctx._constant(libmp.mpf_twinprime)
+
+    def _wrap_mpi_function(ctx, f_real, f_complex=None):
+        def g(x, **kwargs):
+            if kwargs:
+                prec = kwargs.get('prec', ctx._prec[0])
+            else:
+                prec = ctx._prec[0]
+            x = ctx.convert(x)
+            if hasattr(x, "_mpi_"):
+                return ctx.make_mpf(f_real(x._mpi_, prec))
+            if hasattr(x, "_mpci_"):
+                return ctx.make_mpc(f_complex(x._mpci_, prec))
+            raise ValueError
+        return g
+
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        if wrap:
+            def f_wrapped(ctx, *args, **kwargs):
+                convert = ctx.convert
+                args = [convert(a) for a in args]
+                prec = ctx.prec
+                try:
+                    ctx.prec += 10
+                    retval = f(ctx, *args, **kwargs)
+                finally:
+                    ctx.prec = prec
+                return +retval
+        else:
+            f_wrapped = f
+        setattr(cls, name, f_wrapped)
+
+    def _set_prec(ctx, n):
+        ctx._prec[0] = max(1, int(n))
+        ctx._dps = prec_to_dps(n)
+
+    def _set_dps(ctx, n):
+        ctx._prec[0] = dps_to_prec(n)
+        ctx._dps = max(1, int(n))
+
+    prec = property(lambda ctx: ctx._prec[0], _set_prec)
+    dps = property(lambda ctx: ctx._dps, _set_dps)
+
+    def make_mpf(ctx, v):
+        a = new(ctx.mpf)
+        a._mpi_ = v
+        return a
+
+    def make_mpc(ctx, v):
+        a = new(ctx.mpc)
+        a._mpci_ = v
+        return a
+
+    def _mpq(ctx, pq):
+        p, q = pq
+        a = libmp.from_rational(p, q, ctx.prec, round_floor)
+        b = libmp.from_rational(p, q, ctx.prec, round_ceiling)
+        return ctx.make_mpf((a, b))
+
+    def convert(ctx, x):
+        if isinstance(x, (ctx.mpf, ctx.mpc)):
+            return x
+        if isinstance(x, ctx._constant):
+            return +x
+        if isinstance(x, complex) or hasattr(x, "_mpc_"):
+            re = ctx.convert(x.real)
+            im = ctx.convert(x.imag)
+            return ctx.mpc(re,im)
+        if isinstance(x, basestring):
+            v = mpi_from_str(x, ctx.prec)
+            return ctx.make_mpf(v)
+        if hasattr(x, "_mpi_"):
+            a, b = x._mpi_
+        else:
+            try:
+                a, b = x
+            except (TypeError, ValueError):
+                a = b = x
+            if hasattr(a, "_mpi_"):
+                a = a._mpi_[0]
+            else:
+                a = convert_mpf_(a, ctx.prec, round_floor)
+            if hasattr(b, "_mpi_"):
+                b = b._mpi_[1]
+            else:
+                b = convert_mpf_(b, ctx.prec, round_ceiling)
+        if a == fnan or b == fnan:
+            a = fninf
+            b = finf
+        assert mpf_le(a, b), "endpoints must be properly ordered"
+        return ctx.make_mpf((a, b))
+
+    def nstr(ctx, x, n=5, **kwargs):
+        x = ctx.convert(x)
+        if hasattr(x, "_mpi_"):
+            return libmp.mpi_to_str(x._mpi_, n, **kwargs)
+        if hasattr(x, "_mpci_"):
+            re = libmp.mpi_to_str(x._mpci_[0], n, **kwargs)
+            im = libmp.mpi_to_str(x._mpci_[1], n, **kwargs)
+            return "(%s + %s*j)" % (re, im)
+
+    def mag(ctx, x):
+        x = ctx.convert(x)
+        if isinstance(x, ctx.mpc):
+            return max(ctx.mag(x.real), ctx.mag(x.imag)) + 1
+        a, b = libmp.mpi_abs(x._mpi_)
+        sign, man, exp, bc = b
+        if man:
+            return exp+bc
+        if b == fzero:
+            return ctx.ninf
+        if b == fnan:
+            return ctx.nan
+        return ctx.inf
+
+    def isnan(ctx, x):
+        return False
+
+    def isinf(ctx, x):
+        return x == ctx.inf
+
+    def isint(ctx, x):
+        x = ctx.convert(x)
+        a, b = x._mpi_
+        if a == b:
+            sign, man, exp, bc = a
+            if man:
+                return exp >= 0
+            return a == fzero
+        return None
+
+    def ldexp(ctx, x, n):
+        a, b = ctx.convert(x)._mpi_
+        a = libmp.mpf_shift(a, n)
+        b = libmp.mpf_shift(b, n)
+        return ctx.make_mpf((a,b))
+
+    def absmin(ctx, x):
+        return abs(ctx.convert(x)).a
+
+    def absmax(ctx, x):
+        return abs(ctx.convert(x)).b
+
+    def atan2(ctx, y, x):
+        y = ctx.convert(y)._mpi_
+        x = ctx.convert(x)._mpi_
+        return ctx.make_mpf(libmp.mpi_atan2(y,x,ctx.prec))
+
+    def _convert_param(ctx, x):
+        if isinstance(x, libmp.int_types):
+            return x, 'Z'
+        if isinstance(x, tuple):
+            p, q = x
+            return (ctx.mpf(p) / ctx.mpf(q), 'R')
+        x = ctx.convert(x)
+        if isinstance(x, ctx.mpf):
+            return x, 'R'
+        if isinstance(x, ctx.mpc):
+            return x, 'C'
+        raise ValueError
+
+    def _is_real_type(ctx, z):
+        return isinstance(z, ctx.mpf) or isinstance(z, int_types)
+
+    def _is_complex_type(ctx, z):
+        return isinstance(z, ctx.mpc)
+
+    def hypsum(ctx, p, q, types, coeffs, z, maxterms=6000, **kwargs):
+        coeffs = list(coeffs)
+        num = range(p)
+        den = range(p,p+q)
+        #tol = ctx.eps
+        s = t = ctx.one
+        k = 0
+        while 1:
+            for i in num: t *= (coeffs[i]+k)
+            for i in den: t /= (coeffs[i]+k)
+            k += 1; t /= k; t *= z; s += t
+            if t == 0:
+                return s
+            #if abs(t) < tol:
+            #    return s
+            if k > maxterms:
+                raise ctx.NoConvergence
+
+
+# Register with "numbers" ABC
+#     We do not subclass, hence we do not use the @abstractmethod checks. While
+#     this is less invasive it may turn out that we do not actually support
+#     parts of the expected interfaces.  See
+#     http://docs.python.org/2/library/numbers.html for list of abstract
+#     methods.
+try:
+    import numbers
+    numbers.Complex.register(ivmpc)
+    numbers.Real.register(ivmpf)
+except ImportError:
+    pass
diff --git a/lib/python3.11/site-packages/mpmath/ctx_mp.py b/lib/python3.11/site-packages/mpmath/ctx_mp.py
new file mode 100644
index 0000000000000000000000000000000000000000..93594dd44474a415c74e4b0beb83bd7012666c9d
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/ctx_mp.py
@@ -0,0 +1,1339 @@
+"""
+This module defines the mpf, mpc classes, and standard functions for
+operating with them.
+"""
+__docformat__ = 'plaintext'
+
+import functools
+
+import re
+
+from .ctx_base import StandardBaseContext
+
+from .libmp.backend import basestring, BACKEND
+
+from . import libmp
+
+from .libmp import (MPZ, MPZ_ZERO, MPZ_ONE, int_types, repr_dps,
+    round_floor, round_ceiling, dps_to_prec, round_nearest, prec_to_dps,
+    ComplexResult, to_pickable, from_pickable, normalize,
+    from_int, from_float, from_str, to_int, to_float, to_str,
+    from_rational, from_man_exp,
+    fone, fzero, finf, fninf, fnan,
+    mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_mul_int,
+    mpf_div, mpf_rdiv_int, mpf_pow_int, mpf_mod,
+    mpf_eq, mpf_cmp, mpf_lt, mpf_gt, mpf_le, mpf_ge,
+    mpf_hash, mpf_rand,
+    mpf_sum,
+    bitcount, to_fixed,
+    mpc_to_str,
+    mpc_to_complex, mpc_hash, mpc_pos, mpc_is_nonzero, mpc_neg, mpc_conjugate,
+    mpc_abs, mpc_add, mpc_add_mpf, mpc_sub, mpc_sub_mpf, mpc_mul, mpc_mul_mpf,
+    mpc_mul_int, mpc_div, mpc_div_mpf, mpc_pow, mpc_pow_mpf, mpc_pow_int,
+    mpc_mpf_div,
+    mpf_pow,
+    mpf_pi, mpf_degree, mpf_e, mpf_phi, mpf_ln2, mpf_ln10,
+    mpf_euler, mpf_catalan, mpf_apery, mpf_khinchin,
+    mpf_glaisher, mpf_twinprime, mpf_mertens,
+    int_types)
+
+from . import function_docs
+from . import rational
+
+new = object.__new__
+
+get_complex = re.compile(r'^\(?(?P<re>[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?)??'
+                         r'(?P<im>[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?j)?\)?$')
+
+if BACKEND == 'sage':
+    from sage.libs.mpmath.ext_main import Context as BaseMPContext
+    # pickle hack
+    import sage.libs.mpmath.ext_main as _mpf_module
+else:
+    from .ctx_mp_python import PythonMPContext as BaseMPContext
+    from . import ctx_mp_python as _mpf_module
+
+from .ctx_mp_python import _mpf, _mpc, mpnumeric
+
+class MPContext(BaseMPContext, StandardBaseContext):
+    """
+    Context for multiprecision arithmetic with a global precision.
+    """
+
+    def __init__(ctx):
+        BaseMPContext.__init__(ctx)
+        ctx.trap_complex = False
+        ctx.pretty = False
+        ctx.types = [ctx.mpf, ctx.mpc, ctx.constant]
+        ctx._mpq = rational.mpq
+        ctx.default()
+        StandardBaseContext.__init__(ctx)
+
+        ctx.mpq = rational.mpq
+        ctx.init_builtins()
+
+        ctx.hyp_summators = {}
+
+        ctx._init_aliases()
+
+        # XXX: automate
+        try:
+            ctx.bernoulli.im_func.func_doc = function_docs.bernoulli
+            ctx.primepi.im_func.func_doc = function_docs.primepi
+            ctx.psi.im_func.func_doc = function_docs.psi
+            ctx.atan2.im_func.func_doc = function_docs.atan2
+        except AttributeError:
+            # python 3
+            ctx.bernoulli.__func__.func_doc = function_docs.bernoulli
+            ctx.primepi.__func__.func_doc = function_docs.primepi
+            ctx.psi.__func__.func_doc = function_docs.psi
+            ctx.atan2.__func__.func_doc = function_docs.atan2
+
+        ctx.digamma.func_doc = function_docs.digamma
+        ctx.cospi.func_doc = function_docs.cospi
+        ctx.sinpi.func_doc = function_docs.sinpi
+
+    def init_builtins(ctx):
+
+        mpf = ctx.mpf
+        mpc = ctx.mpc
+
+        # Exact constants
+        ctx.one = ctx.make_mpf(fone)
+        ctx.zero = ctx.make_mpf(fzero)
+        ctx.j = ctx.make_mpc((fzero,fone))
+        ctx.inf = ctx.make_mpf(finf)
+        ctx.ninf = ctx.make_mpf(fninf)
+        ctx.nan = ctx.make_mpf(fnan)
+
+        eps = ctx.constant(lambda prec, rnd: (0, MPZ_ONE, 1-prec, 1),
+            "epsilon of working precision", "eps")
+        ctx.eps = eps
+
+        # Approximate constants
+        ctx.pi = ctx.constant(mpf_pi, "pi", "pi")
+        ctx.ln2 = ctx.constant(mpf_ln2, "ln(2)", "ln2")
+        ctx.ln10 = ctx.constant(mpf_ln10, "ln(10)", "ln10")
+        ctx.phi = ctx.constant(mpf_phi, "Golden ratio phi", "phi")
+        ctx.e = ctx.constant(mpf_e, "e = exp(1)", "e")
+        ctx.euler = ctx.constant(mpf_euler, "Euler's constant", "euler")
+        ctx.catalan = ctx.constant(mpf_catalan, "Catalan's constant", "catalan")
+        ctx.khinchin = ctx.constant(mpf_khinchin, "Khinchin's constant", "khinchin")
+        ctx.glaisher = ctx.constant(mpf_glaisher, "Glaisher's constant", "glaisher")
+        ctx.apery = ctx.constant(mpf_apery, "Apery's constant", "apery")
+        ctx.degree = ctx.constant(mpf_degree, "1 deg = pi / 180", "degree")
+        ctx.twinprime = ctx.constant(mpf_twinprime, "Twin prime constant", "twinprime")
+        ctx.mertens = ctx.constant(mpf_mertens, "Mertens' constant", "mertens")
+
+        # Standard functions
+        ctx.sqrt = ctx._wrap_libmp_function(libmp.mpf_sqrt, libmp.mpc_sqrt)
+        ctx.cbrt = ctx._wrap_libmp_function(libmp.mpf_cbrt, libmp.mpc_cbrt)
+        ctx.ln = ctx._wrap_libmp_function(libmp.mpf_log, libmp.mpc_log)
+        ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.mpc_atan)
+        ctx.exp = ctx._wrap_libmp_function(libmp.mpf_exp, libmp.mpc_exp)
+        ctx.expj = ctx._wrap_libmp_function(libmp.mpf_expj, libmp.mpc_expj)
+        ctx.expjpi = ctx._wrap_libmp_function(libmp.mpf_expjpi, libmp.mpc_expjpi)
+        ctx.sin = ctx._wrap_libmp_function(libmp.mpf_sin, libmp.mpc_sin)
+        ctx.cos = ctx._wrap_libmp_function(libmp.mpf_cos, libmp.mpc_cos)
+        ctx.tan = ctx._wrap_libmp_function(libmp.mpf_tan, libmp.mpc_tan)
+        ctx.sinh = ctx._wrap_libmp_function(libmp.mpf_sinh, libmp.mpc_sinh)
+        ctx.cosh = ctx._wrap_libmp_function(libmp.mpf_cosh, libmp.mpc_cosh)
+        ctx.tanh = ctx._wrap_libmp_function(libmp.mpf_tanh, libmp.mpc_tanh)
+        ctx.asin = ctx._wrap_libmp_function(libmp.mpf_asin, libmp.mpc_asin)
+        ctx.acos = ctx._wrap_libmp_function(libmp.mpf_acos, libmp.mpc_acos)
+        ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.mpc_atan)
+        ctx.asinh = ctx._wrap_libmp_function(libmp.mpf_asinh, libmp.mpc_asinh)
+        ctx.acosh = ctx._wrap_libmp_function(libmp.mpf_acosh, libmp.mpc_acosh)
+        ctx.atanh = ctx._wrap_libmp_function(libmp.mpf_atanh, libmp.mpc_atanh)
+        ctx.sinpi = ctx._wrap_libmp_function(libmp.mpf_sin_pi, libmp.mpc_sin_pi)
+        ctx.cospi = ctx._wrap_libmp_function(libmp.mpf_cos_pi, libmp.mpc_cos_pi)
+        ctx.floor = ctx._wrap_libmp_function(libmp.mpf_floor, libmp.mpc_floor)
+        ctx.ceil = ctx._wrap_libmp_function(libmp.mpf_ceil, libmp.mpc_ceil)
+        ctx.nint = ctx._wrap_libmp_function(libmp.mpf_nint, libmp.mpc_nint)
+        ctx.frac = ctx._wrap_libmp_function(libmp.mpf_frac, libmp.mpc_frac)
+        ctx.fib = ctx.fibonacci = ctx._wrap_libmp_function(libmp.mpf_fibonacci, libmp.mpc_fibonacci)
+
+        ctx.gamma = ctx._wrap_libmp_function(libmp.mpf_gamma, libmp.mpc_gamma)
+        ctx.rgamma = ctx._wrap_libmp_function(libmp.mpf_rgamma, libmp.mpc_rgamma)
+        ctx.loggamma = ctx._wrap_libmp_function(libmp.mpf_loggamma, libmp.mpc_loggamma)
+        ctx.fac = ctx.factorial = ctx._wrap_libmp_function(libmp.mpf_factorial, libmp.mpc_factorial)
+
+        ctx.digamma = ctx._wrap_libmp_function(libmp.mpf_psi0, libmp.mpc_psi0)
+        ctx.harmonic = ctx._wrap_libmp_function(libmp.mpf_harmonic, libmp.mpc_harmonic)
+        ctx.ei = ctx._wrap_libmp_function(libmp.mpf_ei, libmp.mpc_ei)
+        ctx.e1 = ctx._wrap_libmp_function(libmp.mpf_e1, libmp.mpc_e1)
+        ctx._ci = ctx._wrap_libmp_function(libmp.mpf_ci, libmp.mpc_ci)
+        ctx._si = ctx._wrap_libmp_function(libmp.mpf_si, libmp.mpc_si)
+        ctx.ellipk = ctx._wrap_libmp_function(libmp.mpf_ellipk, libmp.mpc_ellipk)
+        ctx._ellipe = ctx._wrap_libmp_function(libmp.mpf_ellipe, libmp.mpc_ellipe)
+        ctx.agm1 = ctx._wrap_libmp_function(libmp.mpf_agm1, libmp.mpc_agm1)
+        ctx._erf = ctx._wrap_libmp_function(libmp.mpf_erf, None)
+        ctx._erfc = ctx._wrap_libmp_function(libmp.mpf_erfc, None)
+        ctx._zeta = ctx._wrap_libmp_function(libmp.mpf_zeta, libmp.mpc_zeta)
+        ctx._altzeta = ctx._wrap_libmp_function(libmp.mpf_altzeta, libmp.mpc_altzeta)
+
+        # Faster versions
+        ctx.sqrt = getattr(ctx, "_sage_sqrt", ctx.sqrt)
+        ctx.exp = getattr(ctx, "_sage_exp", ctx.exp)
+        ctx.ln = getattr(ctx, "_sage_ln", ctx.ln)
+        ctx.cos = getattr(ctx, "_sage_cos", ctx.cos)
+        ctx.sin = getattr(ctx, "_sage_sin", ctx.sin)
+
+    def to_fixed(ctx, x, prec):
+        return x.to_fixed(prec)
+
+    def hypot(ctx, x, y):
+        r"""
+        Computes the Euclidean norm of the vector `(x, y)`, equal
+        to `\sqrt{x^2 + y^2}`. Both `x` and `y` must be real."""
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        return ctx.make_mpf(libmp.mpf_hypot(x._mpf_, y._mpf_, *ctx._prec_rounding))
+
+    def _gamma_upper_int(ctx, n, z):
+        n = int(ctx._re(n))
+        if n == 0:
+            return ctx.e1(z)
+        if not hasattr(z, '_mpf_'):
+            raise NotImplementedError
+        prec, rounding = ctx._prec_rounding
+        real, imag = libmp.mpf_expint(n, z._mpf_, prec, rounding, gamma=True)
+        if imag is None:
+            return ctx.make_mpf(real)
+        else:
+            return ctx.make_mpc((real, imag))
+
+    def _expint_int(ctx, n, z):
+        n = int(n)
+        if n == 1:
+            return ctx.e1(z)
+        if not hasattr(z, '_mpf_'):
+            raise NotImplementedError
+        prec, rounding = ctx._prec_rounding
+        real, imag = libmp.mpf_expint(n, z._mpf_, prec, rounding)
+        if imag is None:
+            return ctx.make_mpf(real)
+        else:
+            return ctx.make_mpc((real, imag))
+
+    def _nthroot(ctx, x, n):
+        if hasattr(x, '_mpf_'):
+            try:
+                return ctx.make_mpf(libmp.mpf_nthroot(x._mpf_, n, *ctx._prec_rounding))
+            except ComplexResult:
+                if ctx.trap_complex:
+                    raise
+                x = (x._mpf_, libmp.fzero)
+        else:
+            x = x._mpc_
+        return ctx.make_mpc(libmp.mpc_nthroot(x, n, *ctx._prec_rounding))
+
+    def _besselj(ctx, n, z):
+        prec, rounding = ctx._prec_rounding
+        if hasattr(z, '_mpf_'):
+            return ctx.make_mpf(libmp.mpf_besseljn(n, z._mpf_, prec, rounding))
+        elif hasattr(z, '_mpc_'):
+            return ctx.make_mpc(libmp.mpc_besseljn(n, z._mpc_, prec, rounding))
+
+    def _agm(ctx, a, b=1):
+        prec, rounding = ctx._prec_rounding
+        if hasattr(a, '_mpf_') and hasattr(b, '_mpf_'):
+            try:
+                v = libmp.mpf_agm(a._mpf_, b._mpf_, prec, rounding)
+                return ctx.make_mpf(v)
+            except ComplexResult:
+                pass
+        if hasattr(a, '_mpf_'): a = (a._mpf_, libmp.fzero)
+        else: a = a._mpc_
+        if hasattr(b, '_mpf_'): b = (b._mpf_, libmp.fzero)
+        else: b = b._mpc_
+        return ctx.make_mpc(libmp.mpc_agm(a, b, prec, rounding))
+
+    def bernoulli(ctx, n):
+        return ctx.make_mpf(libmp.mpf_bernoulli(int(n), *ctx._prec_rounding))
+
+    def _zeta_int(ctx, n):
+        return ctx.make_mpf(libmp.mpf_zeta_int(int(n), *ctx._prec_rounding))
+
+    def atan2(ctx, y, x):
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        return ctx.make_mpf(libmp.mpf_atan2(y._mpf_, x._mpf_, *ctx._prec_rounding))
+
+    def psi(ctx, m, z):
+        z = ctx.convert(z)
+        m = int(m)
+        if ctx._is_real_type(z):
+            return ctx.make_mpf(libmp.mpf_psi(m, z._mpf_, *ctx._prec_rounding))
+        else:
+            return ctx.make_mpc(libmp.mpc_psi(m, z._mpc_, *ctx._prec_rounding))
+
+    def cos_sin(ctx, x, **kwargs):
+        if type(x) not in ctx.types:
+            x = ctx.convert(x)
+        prec, rounding = ctx._parse_prec(kwargs)
+        if hasattr(x, '_mpf_'):
+            c, s = libmp.mpf_cos_sin(x._mpf_, prec, rounding)
+            return ctx.make_mpf(c), ctx.make_mpf(s)
+        elif hasattr(x, '_mpc_'):
+            c, s = libmp.mpc_cos_sin(x._mpc_, prec, rounding)
+            return ctx.make_mpc(c), ctx.make_mpc(s)
+        else:
+            return ctx.cos(x, **kwargs), ctx.sin(x, **kwargs)
+
+    def cospi_sinpi(ctx, x, **kwargs):
+        if type(x) not in ctx.types:
+            x = ctx.convert(x)
+        prec, rounding = ctx._parse_prec(kwargs)
+        if hasattr(x, '_mpf_'):
+            c, s = libmp.mpf_cos_sin_pi(x._mpf_, prec, rounding)
+            return ctx.make_mpf(c), ctx.make_mpf(s)
+        elif hasattr(x, '_mpc_'):
+            c, s = libmp.mpc_cos_sin_pi(x._mpc_, prec, rounding)
+            return ctx.make_mpc(c), ctx.make_mpc(s)
+        else:
+            return ctx.cos(x, **kwargs), ctx.sin(x, **kwargs)
+
+    def clone(ctx):
+        """
+        Create a copy of the context, with the same working precision.
+        """
+        a = ctx.__class__()
+        a.prec = ctx.prec
+        return a
+
+    # Several helper methods
+    # TODO: add more of these, make consistent, write docstrings, ...
+
+    def _is_real_type(ctx, x):
+        if hasattr(x, '_mpc_') or type(x) is complex:
+            return False
+        return True
+
+    def _is_complex_type(ctx, x):
+        if hasattr(x, '_mpc_') or type(x) is complex:
+            return True
+        return False
+
+    def isnan(ctx, x):
+        """
+        Return *True* if *x* is a NaN (not-a-number), or for a complex
+        number, whether either the real or complex part is NaN;
+        otherwise return *False*::
+
+            >>> from mpmath import *
+            >>> isnan(3.14)
+            False
+            >>> isnan(nan)
+            True
+            >>> isnan(mpc(3.14,2.72))
+            False
+            >>> isnan(mpc(3.14,nan))
+            True
+
+        """
+        if hasattr(x, "_mpf_"):
+            return x._mpf_ == fnan
+        if hasattr(x, "_mpc_"):
+            return fnan in x._mpc_
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return False
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isnan(x)
+        raise TypeError("isnan() needs a number as input")
+
+    def isfinite(ctx, x):
+        """
+        Return *True* if *x* is a finite number, i.e. neither
+        an infinity or a NaN.
+
+            >>> from mpmath import *
+            >>> isfinite(inf)
+            False
+            >>> isfinite(-inf)
+            False
+            >>> isfinite(3)
+            True
+            >>> isfinite(nan)
+            False
+            >>> isfinite(3+4j)
+            True
+            >>> isfinite(mpc(3,inf))
+            False
+            >>> isfinite(mpc(nan,3))
+            False
+
+        """
+        if ctx.isinf(x) or ctx.isnan(x):
+            return False
+        return True
+
+    def isnpint(ctx, x):
+        """
+        Determine if *x* is a nonpositive integer.
+        """
+        if not x:
+            return True
+        if hasattr(x, '_mpf_'):
+            sign, man, exp, bc = x._mpf_
+            return sign and exp >= 0
+        if hasattr(x, '_mpc_'):
+            return not x.imag and ctx.isnpint(x.real)
+        if type(x) in int_types:
+            return x <= 0
+        if isinstance(x, ctx.mpq):
+            p, q = x._mpq_
+            if not p:
+                return True
+            return q == 1 and p <= 0
+        return ctx.isnpint(ctx.convert(x))
+
+    def __str__(ctx):
+        lines = ["Mpmath settings:",
+            ("  mp.prec = %s" % ctx.prec).ljust(30) + "[default: 53]",
+            ("  mp.dps = %s" % ctx.dps).ljust(30) + "[default: 15]",
+            ("  mp.trap_complex = %s" % ctx.trap_complex).ljust(30) + "[default: False]",
+        ]
+        return "\n".join(lines)
+
+    @property
+    def _repr_digits(ctx):
+        return repr_dps(ctx._prec)
+
+    @property
+    def _str_digits(ctx):
+        return ctx._dps
+
+    def extraprec(ctx, n, normalize_output=False):
+        """
+        The block
+
+            with extraprec(n):
+                <code>
+
+        increases the precision n bits, executes <code>, and then
+        restores the precision.
+
+        extraprec(n)(f) returns a decorated version of the function f
+        that increases the working precision by n bits before execution,
+        and restores the parent precision afterwards. With
+        normalize_output=True, it rounds the return value to the parent
+        precision.
+        """
+        return PrecisionManager(ctx, lambda p: p + n, None, normalize_output)
+
+    def extradps(ctx, n, normalize_output=False):
+        """
+        This function is analogous to extraprec (see documentation)
+        but changes the decimal precision instead of the number of bits.
+        """
+        return PrecisionManager(ctx, None, lambda d: d + n, normalize_output)
+
+    def workprec(ctx, n, normalize_output=False):
+        """
+        The block
+
+            with workprec(n):
+                <code>
+
+        sets the precision to n bits, executes <code>, and then restores
+        the precision.
+
+        workprec(n)(f) returns a decorated version of the function f
+        that sets the precision to n bits before execution,
+        and restores the precision afterwards. With normalize_output=True,
+        it rounds the return value to the parent precision.
+        """
+        return PrecisionManager(ctx, lambda p: n, None, normalize_output)
+
+    def workdps(ctx, n, normalize_output=False):
+        """
+        This function is analogous to workprec (see documentation)
+        but changes the decimal precision instead of the number of bits.
+        """
+        return PrecisionManager(ctx, None, lambda d: n, normalize_output)
+
+    def autoprec(ctx, f, maxprec=None, catch=(), verbose=False):
+        r"""
+        Return a wrapped copy of *f* that repeatedly evaluates *f*
+        with increasing precision until the result converges to the
+        full precision used at the point of the call.
+
+        This heuristically protects against rounding errors, at the cost of
+        roughly a 2x slowdown compared to manually setting the optimal
+        precision. This method can, however, easily be fooled if the results
+        from *f* depend "discontinuously" on the precision, for instance
+        if catastrophic cancellation can occur. Therefore, :func:`~mpmath.autoprec`
+        should be used judiciously.
+
+        **Examples**
+
+        Many functions are sensitive to perturbations of the input arguments.
+        If the arguments are decimal numbers, they may have to be converted
+        to binary at a much higher precision. If the amount of required
+        extra precision is unknown, :func:`~mpmath.autoprec` is convenient::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> mp.pretty = True
+            >>> besselj(5, 125 * 10**28)    # Exact input
+            -8.03284785591801e-17
+            >>> besselj(5, '1.25e30')   # Bad
+            7.12954868316652e-16
+            >>> autoprec(besselj)(5, '1.25e30')   # Good
+            -8.03284785591801e-17
+
+        The following fails to converge because `\sin(\pi) = 0` whereas all
+        finite-precision approximations of `\pi` give nonzero values::
+
+            >>> autoprec(sin)(pi) # doctest: +IGNORE_EXCEPTION_DETAIL
+            Traceback (most recent call last):
+              ...
+            NoConvergence: autoprec: prec increased to 2910 without convergence
+
+        As the following example shows, :func:`~mpmath.autoprec` can protect against
+        cancellation, but is fooled by too severe cancellation::
+
+            >>> x = 1e-10
+            >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
+            1.00000008274037e-10
+            1.00000000005e-10
+            1.00000000005e-10
+            >>> x = 1e-50
+            >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
+            0.0
+            1.0e-50
+            0.0
+
+        With *catch*, an exception or list of exceptions to intercept
+        may be specified. The raised exception is interpreted
+        as signaling insufficient precision. This permits, for example,
+        evaluating a function where a too low precision results in a
+        division by zero::
+
+            >>> f = lambda x: 1/(exp(x)-1)
+            >>> f(1e-30)
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError
+            >>> autoprec(f, catch=ZeroDivisionError)(1e-30)
+            1.0e+30
+
+
+        """
+        def f_autoprec_wrapped(*args, **kwargs):
+            prec = ctx.prec
+            if maxprec is None:
+                maxprec2 = ctx._default_hyper_maxprec(prec)
+            else:
+                maxprec2 = maxprec
+            try:
+                ctx.prec = prec + 10
+                try:
+                    v1 = f(*args, **kwargs)
+                except catch:
+                    v1 = ctx.nan
+                prec2 = prec + 20
+                while 1:
+                    ctx.prec = prec2
+                    try:
+                        v2 = f(*args, **kwargs)
+                    except catch:
+                        v2 = ctx.nan
+                    if v1 == v2:
+                        break
+                    err = ctx.mag(v2-v1) - ctx.mag(v2)
+                    if err < (-prec):
+                        break
+                    if verbose:
+                        print("autoprec: target=%s, prec=%s, accuracy=%s" \
+                            % (prec, prec2, -err))
+                    v1 = v2
+                    if prec2 >= maxprec2:
+                        raise ctx.NoConvergence(\
+                        "autoprec: prec increased to %i without convergence"\
+                        % prec2)
+                    prec2 += int(prec2*2)
+                    prec2 = min(prec2, maxprec2)
+            finally:
+                ctx.prec = prec
+            return +v2
+        return f_autoprec_wrapped
+
+    def nstr(ctx, x, n=6, **kwargs):
+        """
+        Convert an ``mpf`` or ``mpc`` to a decimal string literal with *n*
+        significant digits. The small default value for *n* is chosen to
+        make this function useful for printing collections of numbers
+        (lists, matrices, etc).
+
+        If *x* is a list or tuple, :func:`~mpmath.nstr` is applied recursively
+        to each element. For unrecognized classes, :func:`~mpmath.nstr`
+        simply returns ``str(x)``.
+
+        The companion function :func:`~mpmath.nprint` prints the result
+        instead of returning it.
+
+        The keyword arguments *strip_zeros*, *min_fixed*, *max_fixed*
+        and *show_zero_exponent* are forwarded to :func:`~mpmath.libmp.to_str`.
+
+        The number will be printed in fixed-point format if the position
+        of the leading digit is strictly between min_fixed
+        (default = min(-dps/3,-5)) and max_fixed (default = dps).
+
+        To force fixed-point format always, set min_fixed = -inf,
+        max_fixed = +inf. To force floating-point format, set
+        min_fixed >= max_fixed.
+
+            >>> from mpmath import *
+            >>> nstr([+pi, ldexp(1,-500)])
+            '[3.14159, 3.05494e-151]'
+            >>> nprint([+pi, ldexp(1,-500)])
+            [3.14159, 3.05494e-151]
+            >>> nstr(mpf("5e-10"), 5)
+            '5.0e-10'
+            >>> nstr(mpf("5e-10"), 5, strip_zeros=False)
+            '5.0000e-10'
+            >>> nstr(mpf("5e-10"), 5, strip_zeros=False, min_fixed=-11)
+            '0.00000000050000'
+            >>> nstr(mpf(0), 5, show_zero_exponent=True)
+            '0.0e+0'
+
+        """
+        if isinstance(x, list):
+            return "[%s]" % (", ".join(ctx.nstr(c, n, **kwargs) for c in x))
+        if isinstance(x, tuple):
+            return "(%s)" % (", ".join(ctx.nstr(c, n, **kwargs) for c in x))
+        if hasattr(x, '_mpf_'):
+            return to_str(x._mpf_, n, **kwargs)
+        if hasattr(x, '_mpc_'):
+            return "(" + mpc_to_str(x._mpc_, n, **kwargs)  + ")"
+        if isinstance(x, basestring):
+            return repr(x)
+        if isinstance(x, ctx.matrix):
+            return x.__nstr__(n, **kwargs)
+        return str(x)
+
+    def _convert_fallback(ctx, x, strings):
+        if strings and isinstance(x, basestring):
+            if 'j' in x.lower():
+                x = x.lower().replace(' ', '')
+                match = get_complex.match(x)
+                re = match.group('re')
+                if not re:
+                    re = 0
+                im = match.group('im').rstrip('j')
+                return ctx.mpc(ctx.convert(re), ctx.convert(im))
+        if hasattr(x, "_mpi_"):
+            a, b = x._mpi_
+            if a == b:
+                return ctx.make_mpf(a)
+            else:
+                raise ValueError("can only create mpf from zero-width interval")
+        raise TypeError("cannot create mpf from " + repr(x))
+
+    def mpmathify(ctx, *args, **kwargs):
+        return ctx.convert(*args, **kwargs)
+
+    def _parse_prec(ctx, kwargs):
+        if kwargs:
+            if kwargs.get('exact'):
+                return 0, 'f'
+            prec, rounding = ctx._prec_rounding
+            if 'rounding' in kwargs:
+                rounding = kwargs['rounding']
+            if 'prec' in kwargs:
+                prec = kwargs['prec']
+                if prec == ctx.inf:
+                    return 0, 'f'
+                else:
+                    prec = int(prec)
+            elif 'dps' in kwargs:
+                dps = kwargs['dps']
+                if dps == ctx.inf:
+                    return 0, 'f'
+                prec = dps_to_prec(dps)
+            return prec, rounding
+        return ctx._prec_rounding
+
+    _exact_overflow_msg = "the exact result does not fit in memory"
+
+    _hypsum_msg = """hypsum() failed to converge to the requested %i bits of accuracy
+using a working precision of %i bits. Try with a higher maxprec,
+maxterms, or set zeroprec."""
+
+    def hypsum(ctx, p, q, flags, coeffs, z, accurate_small=True, **kwargs):
+        if hasattr(z, "_mpf_"):
+            key = p, q, flags, 'R'
+            v = z._mpf_
+        elif hasattr(z, "_mpc_"):
+            key = p, q, flags, 'C'
+            v = z._mpc_
+        if key not in ctx.hyp_summators:
+            ctx.hyp_summators[key] = libmp.make_hyp_summator(key)[1]
+        summator = ctx.hyp_summators[key]
+        prec = ctx.prec
+        maxprec = kwargs.get('maxprec', ctx._default_hyper_maxprec(prec))
+        extraprec = 50
+        epsshift = 25
+        # Jumps in magnitude occur when parameters are close to negative
+        # integers. We must ensure that these terms are included in
+        # the sum and added accurately
+        magnitude_check = {}
+        max_total_jump = 0
+        for i, c in enumerate(coeffs):
+            if flags[i] == 'Z':
+                if i >= p and c <= 0:
+                    ok = False
+                    for ii, cc in enumerate(coeffs[:p]):
+                        # Note: c <= cc or c < cc, depending on convention
+                        if flags[ii] == 'Z' and cc <= 0 and c <= cc:
+                            ok = True
+                    if not ok:
+                        raise ZeroDivisionError("pole in hypergeometric series")
+                continue
+            n, d = ctx.nint_distance(c)
+            n = -int(n)
+            d = -d
+            if i >= p and n >= 0 and d > 4:
+                if n in magnitude_check:
+                    magnitude_check[n] += d
+                else:
+                    magnitude_check[n] = d
+                extraprec = max(extraprec, d - prec + 60)
+            max_total_jump += abs(d)
+        while 1:
+            if extraprec > maxprec:
+                raise ValueError(ctx._hypsum_msg % (prec, prec+extraprec))
+            wp = prec + extraprec
+            if magnitude_check:
+                mag_dict = dict((n,None) for n in magnitude_check)
+            else:
+                mag_dict = {}
+            zv, have_complex, magnitude = summator(coeffs, v, prec, wp, \
+                epsshift, mag_dict, **kwargs)
+            cancel = -magnitude
+            jumps_resolved = True
+            if extraprec < max_total_jump:
+                for n in mag_dict.values():
+                    if (n is None) or (n < prec):
+                        jumps_resolved = False
+                        break
+            accurate = (cancel < extraprec-25-5 or not accurate_small)
+            if jumps_resolved:
+                if accurate:
+                    break
+                # zero?
+                zeroprec = kwargs.get('zeroprec')
+                if zeroprec is not None:
+                    if cancel > zeroprec:
+                        if have_complex:
+                            return ctx.mpc(0)
+                        else:
+                            return ctx.zero
+
+            # Some near-singularities were not included, so increase
+            # precision and repeat until they are
+            extraprec *= 2
+            # Possible workaround for bad roundoff in fixed-point arithmetic
+            epsshift += 5
+            extraprec += 5
+
+        if type(zv) is tuple:
+            if have_complex:
+                return ctx.make_mpc(zv)
+            else:
+                return ctx.make_mpf(zv)
+        else:
+            return zv
+
+    def ldexp(ctx, x, n):
+        r"""
+        Computes `x 2^n` efficiently. No rounding is performed.
+        The argument `x` must be a real floating-point number (or
+        possible to convert into one) and `n` must be a Python ``int``.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> ldexp(1, 10)
+            mpf('1024.0')
+            >>> ldexp(1, -3)
+            mpf('0.125')
+
+        """
+        x = ctx.convert(x)
+        return ctx.make_mpf(libmp.mpf_shift(x._mpf_, n))
+
+    def frexp(ctx, x):
+        r"""
+        Given a real number `x`, returns `(y, n)` with `y \in [0.5, 1)`,
+        `n` a Python integer, and such that `x = y 2^n`. No rounding is
+        performed.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> frexp(7.5)
+            (mpf('0.9375'), 3)
+
+        """
+        x = ctx.convert(x)
+        y, n = libmp.mpf_frexp(x._mpf_)
+        return ctx.make_mpf(y), n
+
+    def fneg(ctx, x, **kwargs):
+        """
+        Negates the number *x*, giving a floating-point result, optionally
+        using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        An mpmath number is returned::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fneg(2.5)
+            mpf('-2.5')
+            >>> fneg(-5+2j)
+            mpc(real='5.0', imag='-2.0')
+
+        Precise control over rounding is possible::
+
+            >>> x = fadd(2, 1e-100, exact=True)
+            >>> fneg(x)
+            mpf('-2.0')
+            >>> fneg(x, rounding='f')
+            mpf('-2.0000000000000004')
+
+        Negating with and without roundoff::
+
+            >>> n = 200000000000000000000001
+            >>> print(int(-mpf(n)))
+            -200000000000000016777216
+            >>> print(int(fneg(n)))
+            -200000000000000016777216
+            >>> print(int(fneg(n, prec=log(n,2)+1)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, dps=log(n,10)+1)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, prec=inf)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, dps=inf)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, exact=True)))
+            -200000000000000000000001
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_'):
+            return ctx.make_mpf(mpf_neg(x._mpf_, prec, rounding))
+        if hasattr(x, '_mpc_'):
+            return ctx.make_mpc(mpc_neg(x._mpc_, prec, rounding))
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fadd(ctx, x, y, **kwargs):
+        """
+        Adds the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        The default precision is the working precision of the context.
+        You can specify a custom precision in bits by passing the *prec* keyword
+        argument, or by providing an equivalent decimal precision with the *dps*
+        keyword argument. If the precision is set to ``+inf``, or if the flag
+        *exact=True* is passed, an exact addition with no rounding is performed.
+
+        When the precision is finite, the optional *rounding* keyword argument
+        specifies the direction of rounding. Valid options are ``'n'`` for
+        nearest (default), ``'f'`` for floor, ``'c'`` for ceiling, ``'d'``
+        for down, ``'u'`` for up.
+
+        **Examples**
+
+        Using :func:`~mpmath.fadd` with precision and rounding control::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fadd(2, 1e-20)
+            mpf('2.0')
+            >>> fadd(2, 1e-20, rounding='u')
+            mpf('2.0000000000000004')
+            >>> nprint(fadd(2, 1e-20, prec=100), 25)
+            2.00000000000000000001
+            >>> nprint(fadd(2, 1e-20, dps=15), 25)
+            2.0
+            >>> nprint(fadd(2, 1e-20, dps=25), 25)
+            2.00000000000000000001
+            >>> nprint(fadd(2, 1e-20, exact=True), 25)
+            2.00000000000000000001
+
+        Exact addition avoids cancellation errors, enforcing familiar laws
+        of numbers such as `x+y-x = y`, which don't hold in floating-point
+        arithmetic with finite precision::
+
+            >>> x, y = mpf(2), mpf('1e-1000')
+            >>> print(x + y - x)
+            0.0
+            >>> print(fadd(x, y, prec=inf) - x)
+            1.0e-1000
+            >>> print(fadd(x, y, exact=True) - x)
+            1.0e-1000
+
+        Exact addition can be inefficient and may be impossible to perform
+        with large magnitude differences::
+
+            >>> fadd(1, '1e-100000000000000000000', prec=inf)
+            Traceback (most recent call last):
+              ...
+            OverflowError: the exact result does not fit in memory
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        try:
+            if hasattr(x, '_mpf_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpf(mpf_add(x._mpf_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_add_mpf(y._mpc_, x._mpf_, prec, rounding))
+            if hasattr(x, '_mpc_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpc(mpc_add_mpf(x._mpc_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_add(x._mpc_, y._mpc_, prec, rounding))
+        except (ValueError, OverflowError):
+            raise OverflowError(ctx._exact_overflow_msg)
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fsub(ctx, x, y, **kwargs):
+        """
+        Subtracts the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        Using :func:`~mpmath.fsub` with precision and rounding control::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fsub(2, 1e-20)
+            mpf('2.0')
+            >>> fsub(2, 1e-20, rounding='d')
+            mpf('1.9999999999999998')
+            >>> nprint(fsub(2, 1e-20, prec=100), 25)
+            1.99999999999999999999
+            >>> nprint(fsub(2, 1e-20, dps=15), 25)
+            2.0
+            >>> nprint(fsub(2, 1e-20, dps=25), 25)
+            1.99999999999999999999
+            >>> nprint(fsub(2, 1e-20, exact=True), 25)
+            1.99999999999999999999
+
+        Exact subtraction avoids cancellation errors, enforcing familiar laws
+        of numbers such as `x-y+y = x`, which don't hold in floating-point
+        arithmetic with finite precision::
+
+            >>> x, y = mpf(2), mpf('1e1000')
+            >>> print(x - y + y)
+            0.0
+            >>> print(fsub(x, y, prec=inf) + y)
+            2.0
+            >>> print(fsub(x, y, exact=True) + y)
+            2.0
+
+        Exact addition can be inefficient and may be impossible to perform
+        with large magnitude differences::
+
+            >>> fsub(1, '1e-100000000000000000000', prec=inf)
+            Traceback (most recent call last):
+              ...
+            OverflowError: the exact result does not fit in memory
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        try:
+            if hasattr(x, '_mpf_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpf(mpf_sub(x._mpf_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_sub((x._mpf_, fzero), y._mpc_, prec, rounding))
+            if hasattr(x, '_mpc_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpc(mpc_sub_mpf(x._mpc_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_sub(x._mpc_, y._mpc_, prec, rounding))
+        except (ValueError, OverflowError):
+            raise OverflowError(ctx._exact_overflow_msg)
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fmul(ctx, x, y, **kwargs):
+        """
+        Multiplies the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        The result is an mpmath number::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fmul(2, 5.0)
+            mpf('10.0')
+            >>> fmul(0.5j, 0.5)
+            mpc(real='0.0', imag='0.25')
+
+        Avoiding roundoff::
+
+            >>> x, y = 10**10+1, 10**15+1
+            >>> print(x*y)
+            10000000001000010000000001
+            >>> print(mpf(x) * mpf(y))
+            1.0000000001e+25
+            >>> print(int(mpf(x) * mpf(y)))
+            10000000001000011026399232
+            >>> print(int(fmul(x, y)))
+            10000000001000011026399232
+            >>> print(int(fmul(x, y, dps=25)))
+            10000000001000010000000001
+            >>> print(int(fmul(x, y, exact=True)))
+            10000000001000010000000001
+
+        Exact multiplication with complex numbers can be inefficient and may
+        be impossible to perform with large magnitude differences between
+        real and imaginary parts::
+
+            >>> x = 1+2j
+            >>> y = mpc(2, '1e-100000000000000000000')
+            >>> fmul(x, y)
+            mpc(real='2.0', imag='4.0')
+            >>> fmul(x, y, rounding='u')
+            mpc(real='2.0', imag='4.0000000000000009')
+            >>> fmul(x, y, exact=True)
+            Traceback (most recent call last):
+              ...
+            OverflowError: the exact result does not fit in memory
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        try:
+            if hasattr(x, '_mpf_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpf(mpf_mul(x._mpf_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_mul_mpf(y._mpc_, x._mpf_, prec, rounding))
+            if hasattr(x, '_mpc_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpc(mpc_mul_mpf(x._mpc_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_mul(x._mpc_, y._mpc_, prec, rounding))
+        except (ValueError, OverflowError):
+            raise OverflowError(ctx._exact_overflow_msg)
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fdiv(ctx, x, y, **kwargs):
+        """
+        Divides the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        The result is an mpmath number::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fdiv(3, 2)
+            mpf('1.5')
+            >>> fdiv(2, 3)
+            mpf('0.66666666666666663')
+            >>> fdiv(2+4j, 0.5)
+            mpc(real='4.0', imag='8.0')
+
+        The rounding direction and precision can be controlled::
+
+            >>> fdiv(2, 3, dps=3)    # Should be accurate to at least 3 digits
+            mpf('0.6666259765625')
+            >>> fdiv(2, 3, rounding='d')
+            mpf('0.66666666666666663')
+            >>> fdiv(2, 3, prec=60)
+            mpf('0.66666666666666667')
+            >>> fdiv(2, 3, rounding='u')
+            mpf('0.66666666666666674')
+
+        Checking the error of a division by performing it at higher precision::
+
+            >>> fdiv(2, 3) - fdiv(2, 3, prec=100)
+            mpf('-3.7007434154172148e-17')
+
+        Unlike :func:`~mpmath.fadd`, :func:`~mpmath.fmul`, etc., exact division is not
+        allowed since the quotient of two floating-point numbers generally
+        does not have an exact floating-point representation. (In the
+        future this might be changed to allow the case where the division
+        is actually exact.)
+
+            >>> fdiv(2, 3, exact=True)
+            Traceback (most recent call last):
+              ...
+            ValueError: division is not an exact operation
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        if not prec:
+            raise ValueError("division is not an exact operation")
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        if hasattr(x, '_mpf_'):
+            if hasattr(y, '_mpf_'):
+                return ctx.make_mpf(mpf_div(x._mpf_, y._mpf_, prec, rounding))
+            if hasattr(y, '_mpc_'):
+                return ctx.make_mpc(mpc_div((x._mpf_, fzero), y._mpc_, prec, rounding))
+        if hasattr(x, '_mpc_'):
+            if hasattr(y, '_mpf_'):
+                return ctx.make_mpc(mpc_div_mpf(x._mpc_, y._mpf_, prec, rounding))
+            if hasattr(y, '_mpc_'):
+                return ctx.make_mpc(mpc_div(x._mpc_, y._mpc_, prec, rounding))
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def nint_distance(ctx, x):
+        r"""
+        Return `(n,d)` where `n` is the nearest integer to `x` and `d` is
+        an estimate of `\log_2(|x-n|)`. If `d < 0`, `-d` gives the precision
+        (measured in bits) lost to cancellation when computing `x-n`.
+
+            >>> from mpmath import *
+            >>> n, d = nint_distance(5)
+            >>> print(n); print(d)
+            5
+            -inf
+            >>> n, d = nint_distance(mpf(5))
+            >>> print(n); print(d)
+            5
+            -inf
+            >>> n, d = nint_distance(mpf(5.00000001))
+            >>> print(n); print(d)
+            5
+            -26
+            >>> n, d = nint_distance(mpf(4.99999999))
+            >>> print(n); print(d)
+            5
+            -26
+            >>> n, d = nint_distance(mpc(5,10))
+            >>> print(n); print(d)
+            5
+            4
+            >>> n, d = nint_distance(mpc(5,0.000001))
+            >>> print(n); print(d)
+            5
+            -19
+
+        """
+        typx = type(x)
+        if typx in int_types:
+            return int(x), ctx.ninf
+        elif typx is rational.mpq:
+            p, q = x._mpq_
+            n, r = divmod(p, q)
+            if 2*r >= q:
+                n += 1
+            elif not r:
+                return n, ctx.ninf
+            # log(p/q-n) = log((p-nq)/q) = log(p-nq) - log(q)
+            d = bitcount(abs(p-n*q)) - bitcount(q)
+            return n, d
+        if hasattr(x, "_mpf_"):
+            re = x._mpf_
+            im_dist = ctx.ninf
+        elif hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            isign, iman, iexp, ibc = im
+            if iman:
+                im_dist = iexp + ibc
+            elif im == fzero:
+                im_dist = ctx.ninf
+            else:
+                raise ValueError("requires a finite number")
+        else:
+            x = ctx.convert(x)
+            if hasattr(x, "_mpf_") or hasattr(x, "_mpc_"):
+                return ctx.nint_distance(x)
+            else:
+                raise TypeError("requires an mpf/mpc")
+        sign, man, exp, bc = re
+        mag = exp+bc
+        # |x| < 0.5
+        if mag < 0:
+            n = 0
+            re_dist = mag
+        elif man:
+            # exact integer
+            if exp >= 0:
+                n = man << exp
+                re_dist = ctx.ninf
+            # exact half-integer
+            elif exp == -1:
+                n = (man>>1)+1
+                re_dist = 0
+            else:
+                d = (-exp-1)
+                t = man >> d
+                if t & 1:
+                    t += 1
+                    man = (t<<d) - man
+                else:
+                    man -= (t<<d)
+                n = t>>1   # int(t)>>1
+                re_dist = exp+bitcount(man)
+            if sign:
+                n = -n
+        elif re == fzero:
+            re_dist = ctx.ninf
+            n = 0
+        else:
+            raise ValueError("requires a finite number")
+        return n, max(re_dist, im_dist)
+
+    def fprod(ctx, factors):
+        r"""
+        Calculates a product containing a finite number of factors (for
+        infinite products, see :func:`~mpmath.nprod`). The factors will be
+        converted to mpmath numbers.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fprod([1, 2, 0.5, 7])
+            mpf('7.0')
+
+        """
+        orig = ctx.prec
+        try:
+            v = ctx.one
+            for p in factors:
+                v *= p
+        finally:
+            ctx.prec = orig
+        return +v
+
+    def rand(ctx):
+        """
+        Returns an ``mpf`` with value chosen randomly from `[0, 1)`.
+        The number of randomly generated bits in the mantissa is equal
+        to the working precision.
+        """
+        return ctx.make_mpf(mpf_rand(ctx._prec))
+
+    def fraction(ctx, p, q):
+        """
+        Given Python integers `(p, q)`, returns a lazy ``mpf`` representing
+        the fraction `p/q`. The value is updated with the precision.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> a = fraction(1,100)
+            >>> b = mpf(1)/100
+            >>> print(a); print(b)
+            0.01
+            0.01
+            >>> mp.dps = 30
+            >>> print(a); print(b)      # a will be accurate
+            0.01
+            0.0100000000000000002081668171172
+            >>> mp.dps = 15
+        """
+        return ctx.constant(lambda prec, rnd: from_rational(p, q, prec, rnd),
+            '%s/%s' % (p, q))
+
+    def absmin(ctx, x):
+        return abs(ctx.convert(x))
+
+    def absmax(ctx, x):
+        return abs(ctx.convert(x))
+
+    def _as_points(ctx, x):
+        # XXX: remove this?
+        if hasattr(x, '_mpi_'):
+            a, b = x._mpi_
+            return [ctx.make_mpf(a), ctx.make_mpf(b)]
+        return x
+
+    '''
+    def _zetasum(ctx, s, a, b):
+        """
+        Computes sum of k^(-s) for k = a, a+1, ..., b with a, b both small
+        integers.
+        """
+        a = int(a)
+        b = int(b)
+        s = ctx.convert(s)
+        prec, rounding = ctx._prec_rounding
+        if hasattr(s, '_mpf_'):
+            v = ctx.make_mpf(libmp.mpf_zetasum(s._mpf_, a, b, prec))
+        elif hasattr(s, '_mpc_'):
+            v = ctx.make_mpc(libmp.mpc_zetasum(s._mpc_, a, b, prec))
+        return v
+    '''
+
+    def _zetasum_fast(ctx, s, a, n, derivatives=[0], reflect=False):
+        if not (ctx.isint(a) and hasattr(s, "_mpc_")):
+            raise NotImplementedError
+        a = int(a)
+        prec = ctx._prec
+        xs, ys = libmp.mpc_zetasum(s._mpc_, a, n, derivatives, reflect, prec)
+        xs = [ctx.make_mpc(x) for x in xs]
+        ys = [ctx.make_mpc(y) for y in ys]
+        return xs, ys
+
+class PrecisionManager:
+    def __init__(self, ctx, precfun, dpsfun, normalize_output=False):
+        self.ctx = ctx
+        self.precfun = precfun
+        self.dpsfun = dpsfun
+        self.normalize_output = normalize_output
+    def __call__(self, f):
+        @functools.wraps(f)
+        def g(*args, **kwargs):
+            orig = self.ctx.prec
+            try:
+                if self.precfun:
+                    self.ctx.prec = self.precfun(self.ctx.prec)
+                else:
+                    self.ctx.dps = self.dpsfun(self.ctx.dps)
+                if self.normalize_output:
+                    v = f(*args, **kwargs)
+                    if type(v) is tuple:
+                        return tuple([+a for a in v])
+                    return +v
+                else:
+                    return f(*args, **kwargs)
+            finally:
+                self.ctx.prec = orig
+        return g
+    def __enter__(self):
+        self.origp = self.ctx.prec
+        if self.precfun:
+            self.ctx.prec = self.precfun(self.ctx.prec)
+        else:
+            self.ctx.dps = self.dpsfun(self.ctx.dps)
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.ctx.prec = self.origp
+        return False
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.11/site-packages/mpmath/ctx_mp_python.py b/lib/python3.11/site-packages/mpmath/ctx_mp_python.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfbd72fb8300bf840069c38529b7b41418d26eeb
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/ctx_mp_python.py
@@ -0,0 +1,1149 @@
+#from ctx_base import StandardBaseContext
+
+from .libmp.backend import basestring, exec_
+
+from .libmp import (MPZ, MPZ_ZERO, MPZ_ONE, int_types, repr_dps,
+    round_floor, round_ceiling, dps_to_prec, round_nearest, prec_to_dps,
+    ComplexResult, to_pickable, from_pickable, normalize,
+    from_int, from_float, from_npfloat, from_Decimal, from_str, to_int, to_float, to_str,
+    from_rational, from_man_exp,
+    fone, fzero, finf, fninf, fnan,
+    mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_mul_int,
+    mpf_div, mpf_rdiv_int, mpf_pow_int, mpf_mod,
+    mpf_eq, mpf_cmp, mpf_lt, mpf_gt, mpf_le, mpf_ge,
+    mpf_hash, mpf_rand,
+    mpf_sum,
+    bitcount, to_fixed,
+    mpc_to_str,
+    mpc_to_complex, mpc_hash, mpc_pos, mpc_is_nonzero, mpc_neg, mpc_conjugate,
+    mpc_abs, mpc_add, mpc_add_mpf, mpc_sub, mpc_sub_mpf, mpc_mul, mpc_mul_mpf,
+    mpc_mul_int, mpc_div, mpc_div_mpf, mpc_pow, mpc_pow_mpf, mpc_pow_int,
+    mpc_mpf_div,
+    mpf_pow,
+    mpf_pi, mpf_degree, mpf_e, mpf_phi, mpf_ln2, mpf_ln10,
+    mpf_euler, mpf_catalan, mpf_apery, mpf_khinchin,
+    mpf_glaisher, mpf_twinprime, mpf_mertens,
+    int_types)
+
+from . import rational
+from . import function_docs
+
+new = object.__new__
+
+class mpnumeric(object):
+    """Base class for mpf and mpc."""
+    __slots__ = []
+    def __new__(cls, val):
+        raise NotImplementedError
+
+class _mpf(mpnumeric):
+    """
+    An mpf instance holds a real-valued floating-point number. mpf:s
+    work analogously to Python floats, but support arbitrary-precision
+    arithmetic.
+    """
+    __slots__ = ['_mpf_']
+
+    def __new__(cls, val=fzero, **kwargs):
+        """A new mpf can be created from a Python float, an int, a
+        or a decimal string representing a number in floating-point
+        format."""
+        prec, rounding = cls.context._prec_rounding
+        if kwargs:
+            prec = kwargs.get('prec', prec)
+            if 'dps' in kwargs:
+                prec = dps_to_prec(kwargs['dps'])
+            rounding = kwargs.get('rounding', rounding)
+        if type(val) is cls:
+            sign, man, exp, bc = val._mpf_
+            if (not man) and exp:
+                return val
+            v = new(cls)
+            v._mpf_ = normalize(sign, man, exp, bc, prec, rounding)
+            return v
+        elif type(val) is tuple:
+            if len(val) == 2:
+                v = new(cls)
+                v._mpf_ = from_man_exp(val[0], val[1], prec, rounding)
+                return v
+            if len(val) == 4:
+                if val not in (finf, fninf, fnan):
+                    sign, man, exp, bc = val
+                    val = normalize(sign, MPZ(man), exp, bc, prec, rounding)
+                v = new(cls)
+                v._mpf_ = val
+                return v
+            raise ValueError
+        else:
+            v = new(cls)
+            v._mpf_ = mpf_pos(cls.mpf_convert_arg(val, prec, rounding), prec, rounding)
+            return v
+
+    @classmethod
+    def mpf_convert_arg(cls, x, prec, rounding):
+        if isinstance(x, int_types): return from_int(x)
+        if isinstance(x, float): return from_float(x)
+        if isinstance(x, basestring): return from_str(x, prec, rounding)
+        if isinstance(x, cls.context.constant): return x.func(prec, rounding)
+        if hasattr(x, '_mpf_'): return x._mpf_
+        if hasattr(x, '_mpmath_'):
+            t = cls.context.convert(x._mpmath_(prec, rounding))
+            if hasattr(t, '_mpf_'):
+                return t._mpf_
+        if hasattr(x, '_mpi_'):
+            a, b = x._mpi_
+            if a == b:
+                return a
+            raise ValueError("can only create mpf from zero-width interval")
+        raise TypeError("cannot create mpf from " + repr(x))
+
+    @classmethod
+    def mpf_convert_rhs(cls, x):
+        if isinstance(x, int_types): return from_int(x)
+        if isinstance(x, float): return from_float(x)
+        if isinstance(x, complex_types): return cls.context.mpc(x)
+        if isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            return from_rational(p, q, cls.context.prec)
+        if hasattr(x, '_mpf_'): return x._mpf_
+        if hasattr(x, '_mpmath_'):
+            t = cls.context.convert(x._mpmath_(*cls.context._prec_rounding))
+            if hasattr(t, '_mpf_'):
+                return t._mpf_
+            return t
+        return NotImplemented
+
+    @classmethod
+    def mpf_convert_lhs(cls, x):
+        x = cls.mpf_convert_rhs(x)
+        if type(x) is tuple:
+            return cls.context.make_mpf(x)
+        return x
+
+    man_exp = property(lambda self: self._mpf_[1:3])
+    man = property(lambda self: self._mpf_[1])
+    exp = property(lambda self: self._mpf_[2])
+    bc = property(lambda self: self._mpf_[3])
+
+    real = property(lambda self: self)
+    imag = property(lambda self: self.context.zero)
+
+    conjugate = lambda self: self
+
+    def __getstate__(self): return to_pickable(self._mpf_)
+    def __setstate__(self, val): self._mpf_ = from_pickable(val)
+
+    def __repr__(s):
+        if s.context.pretty:
+            return str(s)
+        return "mpf('%s')" % to_str(s._mpf_, s.context._repr_digits)
+
+    def __str__(s): return to_str(s._mpf_, s.context._str_digits)
+    def __hash__(s): return mpf_hash(s._mpf_)
+    def __int__(s): return int(to_int(s._mpf_))
+    def __long__(s): return long(to_int(s._mpf_))
+    def __float__(s): return to_float(s._mpf_, rnd=s.context._prec_rounding[1])
+    def __complex__(s): return complex(float(s))
+    def __nonzero__(s): return s._mpf_ != fzero
+
+    __bool__ = __nonzero__
+
+    def __abs__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpf_ = mpf_abs(s._mpf_, prec, rounding)
+        return v
+
+    def __pos__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpf_ = mpf_pos(s._mpf_, prec, rounding)
+        return v
+
+    def __neg__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpf_ = mpf_neg(s._mpf_, prec, rounding)
+        return v
+
+    def _cmp(s, t, func):
+        if hasattr(t, '_mpf_'):
+            t = t._mpf_
+        else:
+            t = s.mpf_convert_rhs(t)
+            if t is NotImplemented:
+                return t
+        return func(s._mpf_, t)
+
+    def __cmp__(s, t): return s._cmp(t, mpf_cmp)
+    def __lt__(s, t): return s._cmp(t, mpf_lt)
+    def __gt__(s, t): return s._cmp(t, mpf_gt)
+    def __le__(s, t): return s._cmp(t, mpf_le)
+    def __ge__(s, t): return s._cmp(t, mpf_ge)
+
+    def __ne__(s, t):
+        v = s.__eq__(t)
+        if v is NotImplemented:
+            return v
+        return not v
+
+    def __rsub__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if type(t) in int_types:
+            v = new(cls)
+            v._mpf_ = mpf_sub(from_int(t), s._mpf_, prec, rounding)
+            return v
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t - s
+
+    def __rdiv__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if isinstance(t, int_types):
+            v = new(cls)
+            v._mpf_ = mpf_rdiv_int(t, s._mpf_, prec, rounding)
+            return v
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t / s
+
+    def __rpow__(s, t):
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t ** s
+
+    def __rmod__(s, t):
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t % s
+
+    def sqrt(s):
+        return s.context.sqrt(s)
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.context.almosteq(s, t, rel_eps, abs_eps)
+
+    def to_fixed(self, prec):
+        return to_fixed(self._mpf_, prec)
+
+    def __round__(self, *args):
+        return round(float(self), *args)
+
+mpf_binary_op = """
+def %NAME%(self, other):
+    mpf, new, (prec, rounding) = self._ctxdata
+    sval = self._mpf_
+    if hasattr(other, '_mpf_'):
+        tval = other._mpf_
+        %WITH_MPF%
+    ttype = type(other)
+    if ttype in int_types:
+        %WITH_INT%
+    elif ttype is float:
+        tval = from_float(other)
+        %WITH_MPF%
+    elif hasattr(other, '_mpc_'):
+        tval = other._mpc_
+        mpc = type(other)
+        %WITH_MPC%
+    elif ttype is complex:
+        tval = from_float(other.real), from_float(other.imag)
+        mpc = self.context.mpc
+        %WITH_MPC%
+    if isinstance(other, mpnumeric):
+        return NotImplemented
+    try:
+        other = mpf.context.convert(other, strings=False)
+    except TypeError:
+        return NotImplemented
+    return self.%NAME%(other)
+"""
+
+return_mpf = "; obj = new(mpf); obj._mpf_ = val; return obj"
+return_mpc = "; obj = new(mpc); obj._mpc_ = val; return obj"
+
+mpf_pow_same = """
+        try:
+            val = mpf_pow(sval, tval, prec, rounding) %s
+        except ComplexResult:
+            if mpf.context.trap_complex:
+                raise
+            mpc = mpf.context.mpc
+            val = mpc_pow((sval, fzero), (tval, fzero), prec, rounding) %s
+""" % (return_mpf, return_mpc)
+
+def binary_op(name, with_mpf='', with_int='', with_mpc=''):
+    code = mpf_binary_op
+    code = code.replace("%WITH_INT%", with_int)
+    code = code.replace("%WITH_MPC%", with_mpc)
+    code = code.replace("%WITH_MPF%", with_mpf)
+    code = code.replace("%NAME%", name)
+    np = {}
+    exec_(code, globals(), np)
+    return np[name]
+
+_mpf.__eq__ = binary_op('__eq__',
+    'return mpf_eq(sval, tval)',
+    'return mpf_eq(sval, from_int(other))',
+    'return (tval[1] == fzero) and mpf_eq(tval[0], sval)')
+
+_mpf.__add__ = binary_op('__add__',
+    'val = mpf_add(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_add(sval, from_int(other), prec, rounding)' + return_mpf,
+    'val = mpc_add_mpf(tval, sval, prec, rounding)' + return_mpc)
+
+_mpf.__sub__ = binary_op('__sub__',
+    'val = mpf_sub(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_sub(sval, from_int(other), prec, rounding)' + return_mpf,
+    'val = mpc_sub((sval, fzero), tval, prec, rounding)' + return_mpc)
+
+_mpf.__mul__ = binary_op('__mul__',
+    'val = mpf_mul(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_mul_int(sval, other, prec, rounding)' + return_mpf,
+    'val = mpc_mul_mpf(tval, sval, prec, rounding)' + return_mpc)
+
+_mpf.__div__ = binary_op('__div__',
+    'val = mpf_div(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_div(sval, from_int(other), prec, rounding)' + return_mpf,
+    'val = mpc_mpf_div(sval, tval, prec, rounding)' + return_mpc)
+
+_mpf.__mod__ = binary_op('__mod__',
+    'val = mpf_mod(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_mod(sval, from_int(other), prec, rounding)' + return_mpf,
+    'raise NotImplementedError("complex modulo")')
+
+_mpf.__pow__ = binary_op('__pow__',
+    mpf_pow_same,
+    'val = mpf_pow_int(sval, other, prec, rounding)' + return_mpf,
+    'val = mpc_pow((sval, fzero), tval, prec, rounding)' + return_mpc)
+
+_mpf.__radd__ = _mpf.__add__
+_mpf.__rmul__ = _mpf.__mul__
+_mpf.__truediv__ = _mpf.__div__
+_mpf.__rtruediv__ = _mpf.__rdiv__
+
+
+class _constant(_mpf):
+    """Represents a mathematical constant with dynamic precision.
+    When printed or used in an arithmetic operation, a constant
+    is converted to a regular mpf at the working precision. A
+    regular mpf can also be obtained using the operation +x."""
+
+    def __new__(cls, func, name, docname=''):
+        a = object.__new__(cls)
+        a.name = name
+        a.func = func
+        a.__doc__ = getattr(function_docs, docname, '')
+        return a
+
+    def __call__(self, prec=None, dps=None, rounding=None):
+        prec2, rounding2 = self.context._prec_rounding
+        if not prec: prec = prec2
+        if not rounding: rounding = rounding2
+        if dps: prec = dps_to_prec(dps)
+        return self.context.make_mpf(self.func(prec, rounding))
+
+    @property
+    def _mpf_(self):
+        prec, rounding = self.context._prec_rounding
+        return self.func(prec, rounding)
+
+    def __repr__(self):
+        return "<%s: %s~>" % (self.name, self.context.nstr(self(dps=15)))
+
+
+class _mpc(mpnumeric):
+    """
+    An mpc represents a complex number using a pair of mpf:s (one
+    for the real part and another for the imaginary part.) The mpc
+    class behaves fairly similarly to Python's complex type.
+    """
+
+    __slots__ = ['_mpc_']
+
+    def __new__(cls, real=0, imag=0):
+        s = object.__new__(cls)
+        if isinstance(real, complex_types):
+            real, imag = real.real, real.imag
+        elif hasattr(real, '_mpc_'):
+            s._mpc_ = real._mpc_
+            return s
+        real = cls.context.mpf(real)
+        imag = cls.context.mpf(imag)
+        s._mpc_ = (real._mpf_, imag._mpf_)
+        return s
+
+    real = property(lambda self: self.context.make_mpf(self._mpc_[0]))
+    imag = property(lambda self: self.context.make_mpf(self._mpc_[1]))
+
+    def __getstate__(self):
+        return to_pickable(self._mpc_[0]), to_pickable(self._mpc_[1])
+
+    def __setstate__(self, val):
+        self._mpc_ = from_pickable(val[0]), from_pickable(val[1])
+
+    def __repr__(s):
+        if s.context.pretty:
+            return str(s)
+        r = repr(s.real)[4:-1]
+        i = repr(s.imag)[4:-1]
+        return "%s(real=%s, imag=%s)" % (type(s).__name__, r, i)
+
+    def __str__(s):
+        return "(%s)" % mpc_to_str(s._mpc_, s.context._str_digits)
+
+    def __complex__(s):
+        return mpc_to_complex(s._mpc_, rnd=s.context._prec_rounding[1])
+
+    def __pos__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpc_ = mpc_pos(s._mpc_, prec, rounding)
+        return v
+
+    def __abs__(s):
+        prec, rounding = s.context._prec_rounding
+        v = new(s.context.mpf)
+        v._mpf_ = mpc_abs(s._mpc_, prec, rounding)
+        return v
+
+    def __neg__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpc_ = mpc_neg(s._mpc_, prec, rounding)
+        return v
+
+    def conjugate(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpc_ = mpc_conjugate(s._mpc_, prec, rounding)
+        return v
+
+    def __nonzero__(s):
+        return mpc_is_nonzero(s._mpc_)
+
+    __bool__ = __nonzero__
+
+    def __hash__(s):
+        return mpc_hash(s._mpc_)
+
+    @classmethod
+    def mpc_convert_lhs(cls, x):
+        try:
+            y = cls.context.convert(x)
+            return y
+        except TypeError:
+            return NotImplemented
+
+    def __eq__(s, t):
+        if not hasattr(t, '_mpc_'):
+            if isinstance(t, str):
+                return False
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+        return s.real == t.real and s.imag == t.imag
+
+    def __ne__(s, t):
+        b = s.__eq__(t)
+        if b is NotImplemented:
+            return b
+        return not b
+
+    def _compare(*args):
+        raise TypeError("no ordering relation is defined for complex numbers")
+
+    __gt__ = _compare
+    __le__ = _compare
+    __gt__ = _compare
+    __ge__ = _compare
+
+    def __add__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_add_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+        v = new(cls)
+        v._mpc_ = mpc_add(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __sub__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_sub_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+        v = new(cls)
+        v._mpc_ = mpc_sub(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __mul__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            if isinstance(t, int_types):
+                v = new(cls)
+                v._mpc_ = mpc_mul_int(s._mpc_, t, prec, rounding)
+                return v
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_mul_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+            t = s.mpc_convert_lhs(t)
+        v = new(cls)
+        v._mpc_ = mpc_mul(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __div__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_div_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+        v = new(cls)
+        v._mpc_ = mpc_div(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __pow__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if isinstance(t, int_types):
+            v = new(cls)
+            v._mpc_ = mpc_pow_int(s._mpc_, t, prec, rounding)
+            return v
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        v = new(cls)
+        if hasattr(t, '_mpf_'):
+            v._mpc_ = mpc_pow_mpf(s._mpc_, t._mpf_, prec, rounding)
+        else:
+            v._mpc_ = mpc_pow(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    __radd__ = __add__
+
+    def __rsub__(s, t):
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t - s
+
+    def __rmul__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if isinstance(t, int_types):
+            v = new(cls)
+            v._mpc_ = mpc_mul_int(s._mpc_, t, prec, rounding)
+            return v
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t * s
+
+    def __rdiv__(s, t):
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t / s
+
+    def __rpow__(s, t):
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t ** s
+
+    __truediv__ = __div__
+    __rtruediv__ = __rdiv__
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.context.almosteq(s, t, rel_eps, abs_eps)
+
+
+complex_types = (complex, _mpc)
+
+
+class PythonMPContext(object):
+
+    def __init__(ctx):
+        ctx._prec_rounding = [53, round_nearest]
+        ctx.mpf = type('mpf', (_mpf,), {})
+        ctx.mpc = type('mpc', (_mpc,), {})
+        ctx.mpf._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+        ctx.mpc._ctxdata = [ctx.mpc, new, ctx._prec_rounding]
+        ctx.mpf.context = ctx
+        ctx.mpc.context = ctx
+        ctx.constant = type('constant', (_constant,), {})
+        ctx.constant._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+        ctx.constant.context = ctx
+
+    def make_mpf(ctx, v):
+        a = new(ctx.mpf)
+        a._mpf_ = v
+        return a
+
+    def make_mpc(ctx, v):
+        a = new(ctx.mpc)
+        a._mpc_ = v
+        return a
+
+    def default(ctx):
+        ctx._prec = ctx._prec_rounding[0] = 53
+        ctx._dps = 15
+        ctx.trap_complex = False
+
+    def _set_prec(ctx, n):
+        ctx._prec = ctx._prec_rounding[0] = max(1, int(n))
+        ctx._dps = prec_to_dps(n)
+
+    def _set_dps(ctx, n):
+        ctx._prec = ctx._prec_rounding[0] = dps_to_prec(n)
+        ctx._dps = max(1, int(n))
+
+    prec = property(lambda ctx: ctx._prec, _set_prec)
+    dps = property(lambda ctx: ctx._dps, _set_dps)
+
+    def convert(ctx, x, strings=True):
+        """
+        Converts *x* to an ``mpf`` or ``mpc``. If *x* is of type ``mpf``,
+        ``mpc``, ``int``, ``float``, ``complex``, the conversion
+        will be performed losslessly.
+
+        If *x* is a string, the result will be rounded to the present
+        working precision. Strings representing fractions or complex
+        numbers are permitted.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> mpmathify(3.5)
+            mpf('3.5')
+            >>> mpmathify('2.1')
+            mpf('2.1000000000000001')
+            >>> mpmathify('3/4')
+            mpf('0.75')
+            >>> mpmathify('2+3j')
+            mpc(real='2.0', imag='3.0')
+
+        """
+        if type(x) in ctx.types: return x
+        if isinstance(x, int_types): return ctx.make_mpf(from_int(x))
+        if isinstance(x, float): return ctx.make_mpf(from_float(x))
+        if isinstance(x, complex):
+            return ctx.make_mpc((from_float(x.real), from_float(x.imag)))
+        if type(x).__module__ == 'numpy': return ctx.npconvert(x)
+        if isinstance(x, numbers.Rational): # e.g. Fraction
+            try: x = rational.mpq(int(x.numerator), int(x.denominator))
+            except: pass
+        prec, rounding = ctx._prec_rounding
+        if isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            return ctx.make_mpf(from_rational(p, q, prec))
+        if strings and isinstance(x, basestring):
+            try:
+                _mpf_ = from_str(x, prec, rounding)
+                return ctx.make_mpf(_mpf_)
+            except ValueError:
+                pass
+        if hasattr(x, '_mpf_'): return ctx.make_mpf(x._mpf_)
+        if hasattr(x, '_mpc_'): return ctx.make_mpc(x._mpc_)
+        if hasattr(x, '_mpmath_'):
+            return ctx.convert(x._mpmath_(prec, rounding))
+        if type(x).__module__ == 'decimal':
+            try: return ctx.make_mpf(from_Decimal(x, prec, rounding))
+            except: pass
+        return ctx._convert_fallback(x, strings)
+
+    def npconvert(ctx, x):
+        """
+        Converts *x* to an ``mpf`` or ``mpc``. *x* should be a numpy
+        scalar.
+        """
+        import numpy as np
+        if isinstance(x, np.integer): return ctx.make_mpf(from_int(int(x)))
+        if isinstance(x, np.floating): return ctx.make_mpf(from_npfloat(x))
+        if isinstance(x, np.complexfloating):
+            return ctx.make_mpc((from_npfloat(x.real), from_npfloat(x.imag)))
+        raise TypeError("cannot create mpf from " + repr(x))
+
+    def isnan(ctx, x):
+        """
+        Return *True* if *x* is a NaN (not-a-number), or for a complex
+        number, whether either the real or complex part is NaN;
+        otherwise return *False*::
+
+            >>> from mpmath import *
+            >>> isnan(3.14)
+            False
+            >>> isnan(nan)
+            True
+            >>> isnan(mpc(3.14,2.72))
+            False
+            >>> isnan(mpc(3.14,nan))
+            True
+
+        """
+        if hasattr(x, "_mpf_"):
+            return x._mpf_ == fnan
+        if hasattr(x, "_mpc_"):
+            return fnan in x._mpc_
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return False
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isnan(x)
+        raise TypeError("isnan() needs a number as input")
+
+    def isinf(ctx, x):
+        """
+        Return *True* if the absolute value of *x* is infinite;
+        otherwise return *False*::
+
+            >>> from mpmath import *
+            >>> isinf(inf)
+            True
+            >>> isinf(-inf)
+            True
+            >>> isinf(3)
+            False
+            >>> isinf(3+4j)
+            False
+            >>> isinf(mpc(3,inf))
+            True
+            >>> isinf(mpc(inf,3))
+            True
+
+        """
+        if hasattr(x, "_mpf_"):
+            return x._mpf_ in (finf, fninf)
+        if hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            return re in (finf, fninf) or im in (finf, fninf)
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return False
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isinf(x)
+        raise TypeError("isinf() needs a number as input")
+
+    def isnormal(ctx, x):
+        """
+        Determine whether *x* is "normal" in the sense of floating-point
+        representation; that is, return *False* if *x* is zero, an
+        infinity or NaN; otherwise return *True*. By extension, a
+        complex number *x* is considered "normal" if its magnitude is
+        normal::
+
+            >>> from mpmath import *
+            >>> isnormal(3)
+            True
+            >>> isnormal(0)
+            False
+            >>> isnormal(inf); isnormal(-inf); isnormal(nan)
+            False
+            False
+            False
+            >>> isnormal(0+0j)
+            False
+            >>> isnormal(0+3j)
+            True
+            >>> isnormal(mpc(2,nan))
+            False
+        """
+        if hasattr(x, "_mpf_"):
+            return bool(x._mpf_[1])
+        if hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            re_normal = bool(re[1])
+            im_normal = bool(im[1])
+            if re == fzero: return im_normal
+            if im == fzero: return re_normal
+            return re_normal and im_normal
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return bool(x)
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isnormal(x)
+        raise TypeError("isnormal() needs a number as input")
+
+    def isint(ctx, x, gaussian=False):
+        """
+        Return *True* if *x* is integer-valued; otherwise return
+        *False*::
+
+            >>> from mpmath import *
+            >>> isint(3)
+            True
+            >>> isint(mpf(3))
+            True
+            >>> isint(3.2)
+            False
+            >>> isint(inf)
+            False
+
+        Optionally, Gaussian integers can be checked for::
+
+            >>> isint(3+0j)
+            True
+            >>> isint(3+2j)
+            False
+            >>> isint(3+2j, gaussian=True)
+            True
+
+        """
+        if isinstance(x, int_types):
+            return True
+        if hasattr(x, "_mpf_"):
+            sign, man, exp, bc = xval = x._mpf_
+            return bool((man and exp >= 0) or xval == fzero)
+        if hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            rsign, rman, rexp, rbc = re
+            isign, iman, iexp, ibc = im
+            re_isint = (rman and rexp >= 0) or re == fzero
+            if gaussian:
+                im_isint = (iman and iexp >= 0) or im == fzero
+                return re_isint and im_isint
+            return re_isint and im == fzero
+        if isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            return p % q == 0
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isint(x, gaussian)
+        raise TypeError("isint() needs a number as input")
+
+    def fsum(ctx, terms, absolute=False, squared=False):
+        """
+        Calculates a sum containing a finite number of terms (for infinite
+        series, see :func:`~mpmath.nsum`). The terms will be converted to
+        mpmath numbers. For len(terms) > 2, this function is generally
+        faster and produces more accurate results than the builtin
+        Python function :func:`sum`.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fsum([1, 2, 0.5, 7])
+            mpf('10.5')
+
+        With squared=True each term is squared, and with absolute=True
+        the absolute value of each term is used.
+        """
+        prec, rnd = ctx._prec_rounding
+        real = []
+        imag = []
+        for term in terms:
+            reval = imval = 0
+            if hasattr(term, "_mpf_"):
+                reval = term._mpf_
+            elif hasattr(term, "_mpc_"):
+                reval, imval = term._mpc_
+            else:
+                term = ctx.convert(term)
+                if hasattr(term, "_mpf_"):
+                    reval = term._mpf_
+                elif hasattr(term, "_mpc_"):
+                    reval, imval = term._mpc_
+                else:
+                    raise NotImplementedError
+            if imval:
+                if squared:
+                    if absolute:
+                        real.append(mpf_mul(reval,reval))
+                        real.append(mpf_mul(imval,imval))
+                    else:
+                        reval, imval = mpc_pow_int((reval,imval),2,prec+10)
+                        real.append(reval)
+                        imag.append(imval)
+                elif absolute:
+                    real.append(mpc_abs((reval,imval), prec))
+                else:
+                    real.append(reval)
+                    imag.append(imval)
+            else:
+                if squared:
+                    reval = mpf_mul(reval, reval)
+                elif absolute:
+                    reval = mpf_abs(reval)
+                real.append(reval)
+        s = mpf_sum(real, prec, rnd, absolute)
+        if imag:
+            s = ctx.make_mpc((s, mpf_sum(imag, prec, rnd)))
+        else:
+            s = ctx.make_mpf(s)
+        return s
+
+    def fdot(ctx, A, B=None, conjugate=False):
+        r"""
+        Computes the dot product of the iterables `A` and `B`,
+
+        .. math ::
+
+            \sum_{k=0} A_k B_k.
+
+        Alternatively, :func:`~mpmath.fdot` accepts a single iterable of pairs.
+        In other words, ``fdot(A,B)`` and ``fdot(zip(A,B))`` are equivalent.
+        The elements are automatically converted to mpmath numbers.
+
+        With ``conjugate=True``, the elements in the second vector
+        will be conjugated:
+
+        .. math ::
+
+            \sum_{k=0} A_k \overline{B_k}
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> A = [2, 1.5, 3]
+            >>> B = [1, -1, 2]
+            >>> fdot(A, B)
+            mpf('6.5')
+            >>> list(zip(A, B))
+            [(2, 1), (1.5, -1), (3, 2)]
+            >>> fdot(_)
+            mpf('6.5')
+            >>> A = [2, 1.5, 3j]
+            >>> B = [1+j, 3, -1-j]
+            >>> fdot(A, B)
+            mpc(real='9.5', imag='-1.0')
+            >>> fdot(A, B, conjugate=True)
+            mpc(real='3.5', imag='-5.0')
+
+        """
+        if B is not None:
+            A = zip(A, B)
+        prec, rnd = ctx._prec_rounding
+        real = []
+        imag = []
+        hasattr_ = hasattr
+        types = (ctx.mpf, ctx.mpc)
+        for a, b in A:
+            if type(a) not in types: a = ctx.convert(a)
+            if type(b) not in types: b = ctx.convert(b)
+            a_real = hasattr_(a, "_mpf_")
+            b_real = hasattr_(b, "_mpf_")
+            if a_real and b_real:
+                real.append(mpf_mul(a._mpf_, b._mpf_))
+                continue
+            a_complex = hasattr_(a, "_mpc_")
+            b_complex = hasattr_(b, "_mpc_")
+            if a_real and b_complex:
+                aval = a._mpf_
+                bre, bim = b._mpc_
+                if conjugate:
+                    bim = mpf_neg(bim)
+                real.append(mpf_mul(aval, bre))
+                imag.append(mpf_mul(aval, bim))
+            elif b_real and a_complex:
+                are, aim = a._mpc_
+                bval = b._mpf_
+                real.append(mpf_mul(are, bval))
+                imag.append(mpf_mul(aim, bval))
+            elif a_complex and b_complex:
+                #re, im = mpc_mul(a._mpc_, b._mpc_, prec+20)
+                are, aim = a._mpc_
+                bre, bim = b._mpc_
+                if conjugate:
+                    bim = mpf_neg(bim)
+                real.append(mpf_mul(are, bre))
+                real.append(mpf_neg(mpf_mul(aim, bim)))
+                imag.append(mpf_mul(are, bim))
+                imag.append(mpf_mul(aim, bre))
+            else:
+                raise NotImplementedError
+        s = mpf_sum(real, prec, rnd)
+        if imag:
+            s = ctx.make_mpc((s, mpf_sum(imag, prec, rnd)))
+        else:
+            s = ctx.make_mpf(s)
+        return s
+
+    def _wrap_libmp_function(ctx, mpf_f, mpc_f=None, mpi_f=None, doc="<no doc>"):
+        """
+        Given a low-level mpf_ function, and optionally similar functions
+        for mpc_ and mpi_, defines the function as a context method.
+
+        It is assumed that the return type is the same as that of
+        the input; the exception is that propagation from mpf to mpc is possible
+        by raising ComplexResult.
+
+        """
+        def f(x, **kwargs):
+            if type(x) not in ctx.types:
+                x = ctx.convert(x)
+            prec, rounding = ctx._prec_rounding
+            if kwargs:
+                prec = kwargs.get('prec', prec)
+                if 'dps' in kwargs:
+                    prec = dps_to_prec(kwargs['dps'])
+                rounding = kwargs.get('rounding', rounding)
+            if hasattr(x, '_mpf_'):
+                try:
+                    return ctx.make_mpf(mpf_f(x._mpf_, prec, rounding))
+                except ComplexResult:
+                    # Handle propagation to complex
+                    if ctx.trap_complex:
+                        raise
+                    return ctx.make_mpc(mpc_f((x._mpf_, fzero), prec, rounding))
+            elif hasattr(x, '_mpc_'):
+                return ctx.make_mpc(mpc_f(x._mpc_, prec, rounding))
+            raise NotImplementedError("%s of a %s" % (name, type(x)))
+        name = mpf_f.__name__[4:]
+        f.__doc__ = function_docs.__dict__.get(name, "Computes the %s of x" % doc)
+        return f
+
+    # Called by SpecialFunctions.__init__()
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        if wrap:
+            def f_wrapped(ctx, *args, **kwargs):
+                convert = ctx.convert
+                args = [convert(a) for a in args]
+                prec = ctx.prec
+                try:
+                    ctx.prec += 10
+                    retval = f(ctx, *args, **kwargs)
+                finally:
+                    ctx.prec = prec
+                return +retval
+        else:
+            f_wrapped = f
+        f_wrapped.__doc__ = function_docs.__dict__.get(name, f.__doc__)
+        setattr(cls, name, f_wrapped)
+
+    def _convert_param(ctx, x):
+        if hasattr(x, "_mpc_"):
+            v, im = x._mpc_
+            if im != fzero:
+                return x, 'C'
+        elif hasattr(x, "_mpf_"):
+            v = x._mpf_
+        else:
+            if type(x) in int_types:
+                return int(x), 'Z'
+            p = None
+            if isinstance(x, tuple):
+                p, q = x
+            elif hasattr(x, '_mpq_'):
+                p, q = x._mpq_
+            elif isinstance(x, basestring) and '/' in x:
+                p, q = x.split('/')
+                p = int(p)
+                q = int(q)
+            if p is not None:
+                if not p % q:
+                    return p // q, 'Z'
+                return ctx.mpq(p,q), 'Q'
+            x = ctx.convert(x)
+            if hasattr(x, "_mpc_"):
+                v, im = x._mpc_
+                if im != fzero:
+                    return x, 'C'
+            elif hasattr(x, "_mpf_"):
+                v = x._mpf_
+            else:
+                return x, 'U'
+        sign, man, exp, bc = v
+        if man:
+            if exp >= -4:
+                if sign:
+                    man = -man
+                if exp >= 0:
+                    return int(man) << exp, 'Z'
+                if exp >= -4:
+                    p, q = int(man), (1<<(-exp))
+                    return ctx.mpq(p,q), 'Q'
+            x = ctx.make_mpf(v)
+            return x, 'R'
+        elif not exp:
+            return 0, 'Z'
+        else:
+            return x, 'U'
+
+    def _mpf_mag(ctx, x):
+        sign, man, exp, bc = x
+        if man:
+            return exp+bc
+        if x == fzero:
+            return ctx.ninf
+        if x == finf or x == fninf:
+            return ctx.inf
+        return ctx.nan
+
+    def mag(ctx, x):
+        """
+        Quick logarithmic magnitude estimate of a number. Returns an
+        integer or infinity `m` such that `|x| <= 2^m`. It is not
+        guaranteed that `m` is an optimal bound, but it will never
+        be too large by more than 2 (and probably not more than 1).
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.pretty = True
+            >>> mag(10), mag(10.0), mag(mpf(10)), int(ceil(log(10,2)))
+            (4, 4, 4, 4)
+            >>> mag(10j), mag(10+10j)
+            (4, 5)
+            >>> mag(0.01), int(ceil(log(0.01,2)))
+            (-6, -6)
+            >>> mag(0), mag(inf), mag(-inf), mag(nan)
+            (-inf, +inf, +inf, nan)
+
+        """
+        if hasattr(x, "_mpf_"):
+            return ctx._mpf_mag(x._mpf_)
+        elif hasattr(x, "_mpc_"):
+            r, i = x._mpc_
+            if r == fzero:
+                return ctx._mpf_mag(i)
+            if i == fzero:
+                return ctx._mpf_mag(r)
+            return 1+max(ctx._mpf_mag(r), ctx._mpf_mag(i))
+        elif isinstance(x, int_types):
+            if x:
+                return bitcount(abs(x))
+            return ctx.ninf
+        elif isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            if p:
+                return 1 + bitcount(abs(p)) - bitcount(q)
+            return ctx.ninf
+        else:
+            x = ctx.convert(x)
+            if hasattr(x, "_mpf_") or hasattr(x, "_mpc_"):
+                return ctx.mag(x)
+            else:
+                raise TypeError("requires an mpf/mpc")
+
+
+# Register with "numbers" ABC
+#     We do not subclass, hence we do not use the @abstractmethod checks. While
+#     this is less invasive it may turn out that we do not actually support
+#     parts of the expected interfaces.  See
+#     http://docs.python.org/2/library/numbers.html for list of abstract
+#     methods.
+try:
+    import numbers
+    numbers.Complex.register(_mpc)
+    numbers.Real.register(_mpf)
+except ImportError:
+    pass
diff --git a/lib/python3.11/site-packages/mpmath/function_docs.py b/lib/python3.11/site-packages/mpmath/function_docs.py
new file mode 100644
index 0000000000000000000000000000000000000000..73c071dc30a25c0ea1366e06a407a20206bd18a2
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/function_docs.py
@@ -0,0 +1,10201 @@
+"""
+Extended docstrings for functions.py
+"""
+
+
+pi = r"""
+`\pi`, roughly equal to 3.141592654, represents the area of the unit
+circle, the half-period of trigonometric functions, and many other
+things in mathematics.
+
+Mpmath can evaluate `\pi` to arbitrary precision::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +pi
+    3.1415926535897932384626433832795028841971693993751
+
+This shows digits 99991-100000 of `\pi` (the last digit is actually
+a 4 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+    >>> mp.dps = 100000
+    >>> str(pi)[-10:]
+    '5549362465'
+
+**Possible issues**
+
+:data:`pi` always rounds to the nearest floating-point
+number when used. This means that exact mathematical identities
+involving `\pi` will generally not be preserved in floating-point
+arithmetic. In particular, multiples of :data:`pi` (except for
+the trivial case ``0*pi``) are *not* the exact roots of
+:func:`~mpmath.sin`, but differ roughly by the current epsilon::
+
+    >>> mp.dps = 15
+    >>> sin(pi)
+    1.22464679914735e-16
+
+One solution is to use the :func:`~mpmath.sinpi` function instead::
+
+    >>> sinpi(1)
+    0.0
+
+See the documentation of trigonometric functions for additional
+details.
+
+**References**
+
+* [BorweinBorwein]_
+
+"""
+
+degree = r"""
+Represents one degree of angle, `1^{\circ} = \pi/180`, or
+about 0.01745329. This constant may be evaluated to arbitrary
+precision::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +degree
+    0.017453292519943295769236907684886127134428718885417
+
+The :data:`degree` object is convenient for conversion
+to radians::
+
+    >>> sin(30 * degree)
+    0.5
+    >>> asin(0.5) / degree
+    30.0
+"""
+
+e = r"""
+The transcendental number `e` = 2.718281828... is the base of the
+natural logarithm (:func:`~mpmath.ln`) and of the exponential function
+(:func:`~mpmath.exp`).
+
+Mpmath can be evaluate `e` to arbitrary precision::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +e
+    2.7182818284590452353602874713526624977572470937
+
+This shows digits 99991-100000 of `e` (the last digit is actually
+a 5 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+    >>> mp.dps = 100000
+    >>> str(e)[-10:]
+    '2100427166'
+
+**Possible issues**
+
+:data:`e` always rounds to the nearest floating-point number
+when used, and mathematical identities involving `e` may not
+hold in floating-point arithmetic. For example, ``ln(e)``
+might not evaluate exactly to 1.
+
+In particular, don't use ``e**x`` to compute the exponential
+function. Use ``exp(x)`` instead; this is both faster and more
+accurate.
+"""
+
+phi = r"""
+Represents the golden ratio `\phi = (1+\sqrt 5)/2`,
+approximately equal to 1.6180339887. To high precision,
+its value is::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +phi
+    1.6180339887498948482045868343656381177203091798058
+
+Formulas for the golden ratio include the following::
+
+    >>> (1+sqrt(5))/2
+    1.6180339887498948482045868343656381177203091798058
+    >>> findroot(lambda x: x**2-x-1, 1)
+    1.6180339887498948482045868343656381177203091798058
+    >>> limit(lambda n: fib(n+1)/fib(n), inf)
+    1.6180339887498948482045868343656381177203091798058
+"""
+
+euler = r"""
+Euler's constant or the Euler-Mascheroni constant `\gamma`
+= 0.57721566... is a number of central importance to
+number theory and special functions. It is defined as the limit
+
+.. math ::
+
+    \gamma = \lim_{n\to\infty} H_n - \log n
+
+where `H_n = 1 + \frac{1}{2} + \ldots + \frac{1}{n}` is a harmonic
+number (see :func:`~mpmath.harmonic`).
+
+Evaluation of `\gamma` is supported at arbitrary precision::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +euler
+    0.57721566490153286060651209008240243104215933593992
+
+We can also compute `\gamma` directly from the definition,
+although this is less efficient::
+
+    >>> limit(lambda n: harmonic(n)-log(n), inf)
+    0.57721566490153286060651209008240243104215933593992
+
+This shows digits 9991-10000 of `\gamma` (the last digit is actually
+a 5 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+    >>> mp.dps = 10000
+    >>> str(euler)[-10:]
+    '4679858166'
+
+Integrals, series, and representations for `\gamma` in terms of
+special functions include the following (there are many others)::
+
+    >>> mp.dps = 25
+    >>> -quad(lambda x: exp(-x)*log(x), [0,inf])
+    0.5772156649015328606065121
+    >>> quad(lambda x,y: (x-1)/(1-x*y)/log(x*y), [0,1], [0,1])
+    0.5772156649015328606065121
+    >>> nsum(lambda k: 1/k-log(1+1/k), [1,inf])
+    0.5772156649015328606065121
+    >>> nsum(lambda k: (-1)**k*zeta(k)/k, [2,inf])
+    0.5772156649015328606065121
+    >>> -diff(gamma, 1)
+    0.5772156649015328606065121
+    >>> limit(lambda x: 1/x-gamma(x), 0)
+    0.5772156649015328606065121
+    >>> limit(lambda x: zeta(x)-1/(x-1), 1)
+    0.5772156649015328606065121
+    >>> (log(2*pi*nprod(lambda n:
+    ...     exp(-2+2/n)*(1+2/n)**n, [1,inf]))-3)/2
+    0.5772156649015328606065121
+
+For generalizations of the identities `\gamma = -\Gamma'(1)`
+and `\gamma = \lim_{x\to1} \zeta(x)-1/(x-1)`, see
+:func:`~mpmath.psi` and :func:`~mpmath.stieltjes` respectively.
+
+**References**
+
+* [BorweinBailey]_
+
+"""
+
+catalan = r"""
+Catalan's constant `K` = 0.91596559... is given by the infinite
+series
+
+.. math ::
+
+    K = \sum_{k=0}^{\infty} \frac{(-1)^k}{(2k+1)^2}.
+
+Mpmath can evaluate it to arbitrary precision::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +catalan
+    0.91596559417721901505460351493238411077414937428167
+
+One can also compute `K` directly from the definition, although
+this is significantly less efficient::
+
+    >>> nsum(lambda k: (-1)**k/(2*k+1)**2, [0, inf])
+    0.91596559417721901505460351493238411077414937428167
+
+This shows digits 9991-10000 of `K` (the last digit is actually
+a 3 when the decimal expansion is truncated, but here the nearest
+rounding is used)::
+
+    >>> mp.dps = 10000
+    >>> str(catalan)[-10:]
+    '9537871504'
+
+Catalan's constant has numerous integral representations::
+
+    >>> mp.dps = 50
+    >>> quad(lambda x: -log(x)/(1+x**2), [0, 1])
+    0.91596559417721901505460351493238411077414937428167
+    >>> quad(lambda x: atan(x)/x, [0, 1])
+    0.91596559417721901505460351493238411077414937428167
+    >>> quad(lambda x: ellipk(x**2)/2, [0, 1])
+    0.91596559417721901505460351493238411077414937428167
+    >>> quad(lambda x,y: 1/(1+(x*y)**2), [0, 1], [0, 1])
+    0.91596559417721901505460351493238411077414937428167
+
+As well as series representations::
+
+    >>> pi*log(sqrt(3)+2)/8 + 3*nsum(lambda n:
+    ...  (fac(n)/(2*n+1))**2/fac(2*n), [0, inf])/8
+    0.91596559417721901505460351493238411077414937428167
+    >>> 1-nsum(lambda n: n*zeta(2*n+1)/16**n, [1,inf])
+    0.91596559417721901505460351493238411077414937428167
+"""
+
+khinchin = r"""
+Khinchin's constant `K` = 2.68542... is a number that
+appears in the theory of continued fractions. Mpmath can evaluate
+it to arbitrary precision::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +khinchin
+    2.6854520010653064453097148354817956938203822939945
+
+An integral representation is::
+
+    >>> I = quad(lambda x: log((1-x**2)/sincpi(x))/x/(1+x), [0, 1])
+    >>> 2*exp(1/log(2)*I)
+    2.6854520010653064453097148354817956938203822939945
+
+The computation of ``khinchin`` is based on an efficient
+implementation of the following series::
+
+    >>> f = lambda n: (zeta(2*n)-1)/n*sum((-1)**(k+1)/mpf(k)
+    ...     for k in range(1,2*int(n)))
+    >>> exp(nsum(f, [1,inf])/log(2))
+    2.6854520010653064453097148354817956938203822939945
+"""
+
+glaisher = r"""
+Glaisher's constant `A`, also known as the Glaisher-Kinkelin
+constant, is a number approximately equal to 1.282427129 that
+sometimes appears in formulas related to gamma and zeta functions.
+It is also related to the Barnes G-function (see :func:`~mpmath.barnesg`).
+
+The constant is defined  as `A = \exp(1/12-\zeta'(-1))` where
+`\zeta'(s)` denotes the derivative of the Riemann zeta function
+(see :func:`~mpmath.zeta`).
+
+Mpmath can evaluate Glaisher's constant to arbitrary precision:
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +glaisher
+    1.282427129100622636875342568869791727767688927325
+
+We can verify that the value computed by :data:`glaisher` is
+correct using mpmath's facilities for numerical
+differentiation and arbitrary evaluation of the zeta function:
+
+    >>> exp(mpf(1)/12 - diff(zeta, -1))
+    1.282427129100622636875342568869791727767688927325
+
+Here is an example of an integral that can be evaluated in
+terms of Glaisher's constant:
+
+    >>> mp.dps = 15
+    >>> quad(lambda x: log(gamma(x)), [1, 1.5])
+    -0.0428537406502909
+    >>> -0.5 - 7*log(2)/24 + log(pi)/4 + 3*log(glaisher)/2
+    -0.042853740650291
+
+Mpmath computes Glaisher's constant by applying Euler-Maclaurin
+summation to a slowly convergent series. The implementation is
+reasonably efficient up to about 10,000 digits. See the source
+code for additional details.
+
+References:
+http://mathworld.wolfram.com/Glaisher-KinkelinConstant.html
+"""
+
+apery = r"""
+Represents Apery's constant, which is the irrational number
+approximately equal to 1.2020569 given by
+
+.. math ::
+
+    \zeta(3) = \sum_{k=1}^\infty\frac{1}{k^3}.
+
+The calculation is based on an efficient hypergeometric
+series. To 50 decimal places, the value is given by::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +apery
+    1.2020569031595942853997381615114499907649862923405
+
+Other ways to evaluate Apery's constant using mpmath
+include::
+
+    >>> zeta(3)
+    1.2020569031595942853997381615114499907649862923405
+    >>> -psi(2,1)/2
+    1.2020569031595942853997381615114499907649862923405
+    >>> 8*nsum(lambda k: 1/(2*k+1)**3, [0,inf])/7
+    1.2020569031595942853997381615114499907649862923405
+    >>> f = lambda k: 2/k**3/(exp(2*pi*k)-1)
+    >>> 7*pi**3/180 - nsum(f, [1,inf])
+    1.2020569031595942853997381615114499907649862923405
+
+This shows digits 9991-10000 of Apery's constant::
+
+    >>> mp.dps = 10000
+    >>> str(apery)[-10:]
+    '3189504235'
+"""
+
+mertens = r"""
+Represents the Mertens or Meissel-Mertens constant, which is the
+prime number analog of Euler's constant:
+
+.. math ::
+
+    B_1 = \lim_{N\to\infty}
+        \left(\sum_{p_k \le N} \frac{1}{p_k} - \log \log N \right)
+
+Here `p_k` denotes the `k`-th prime number. Other names for this
+constant include the Hadamard-de la Vallee-Poussin constant or
+the prime reciprocal constant.
+
+The following gives the Mertens constant to 50 digits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +mertens
+    0.2614972128476427837554268386086958590515666482612
+
+References:
+http://mathworld.wolfram.com/MertensConstant.html
+"""
+
+twinprime = r"""
+Represents the twin prime constant, which is the factor `C_2`
+featuring in the Hardy-Littlewood conjecture for the growth of the
+twin prime counting function,
+
+.. math ::
+
+    \pi_2(n) \sim 2 C_2 \frac{n}{\log^2 n}.
+
+It is given by the product over primes
+
+.. math ::
+
+    C_2 = \prod_{p\ge3} \frac{p(p-2)}{(p-1)^2} \approx 0.66016
+
+Computing `C_2` to 50 digits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 50; mp.pretty = True
+    >>> +twinprime
+    0.66016181584686957392781211001455577843262336028473
+
+References:
+http://mathworld.wolfram.com/TwinPrimesConstant.html
+"""
+
+ln = r"""
+Computes the natural logarithm of `x`, `\ln x`.
+See :func:`~mpmath.log` for additional documentation."""
+
+sqrt = r"""
+``sqrt(x)`` gives the principal square root of `x`, `\sqrt x`.
+For positive real numbers, the principal root is simply the
+positive square root. For arbitrary complex numbers, the principal
+square root is defined to satisfy `\sqrt x = \exp(\log(x)/2)`.
+The function thus has a branch cut along the negative half real axis.
+
+For all mpmath numbers ``x``, calling ``sqrt(x)`` is equivalent to
+performing ``x**0.5``.
+
+**Examples**
+
+Basic examples and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> sqrt(10)
+    3.16227766016838
+    >>> sqrt(100)
+    10.0
+    >>> sqrt(-4)
+    (0.0 + 2.0j)
+    >>> sqrt(1+1j)
+    (1.09868411346781 + 0.455089860562227j)
+    >>> sqrt(inf)
+    +inf
+
+Square root evaluation is fast at huge precision::
+
+    >>> mp.dps = 50000
+    >>> a = sqrt(3)
+    >>> str(a)[-10:]
+    '9329332815'
+
+:func:`mpmath.iv.sqrt` supports interval arguments::
+
+    >>> iv.dps = 15; iv.pretty = True
+    >>> iv.sqrt([16,100])
+    [4.0, 10.0]
+    >>> iv.sqrt(2)
+    [1.4142135623730949234, 1.4142135623730951455]
+    >>> iv.sqrt(2) ** 2
+    [1.9999999999999995559, 2.0000000000000004441]
+
+"""
+
+cbrt = r"""
+``cbrt(x)`` computes the cube root of `x`, `x^{1/3}`. This
+function is faster and more accurate than raising to a floating-point
+fraction::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = False
+    >>> 125**(mpf(1)/3)
+    mpf('4.9999999999999991')
+    >>> cbrt(125)
+    mpf('5.0')
+
+Every nonzero complex number has three cube roots. This function
+returns the cube root defined by `\exp(\log(x)/3)` where the
+principal branch of the natural logarithm is used. Note that this
+does not give a real cube root for negative real numbers::
+
+    >>> mp.pretty = True
+    >>> cbrt(-1)
+    (0.5 + 0.866025403784439j)
+"""
+
+exp = r"""
+Computes the exponential function,
+
+.. math ::
+
+    \exp(x) = e^x = \sum_{k=0}^{\infty} \frac{x^k}{k!}.
+
+For complex numbers, the exponential function also satisfies
+
+.. math ::
+
+    \exp(x+yi) = e^x (\cos y + i \sin y).
+
+**Basic examples**
+
+Some values of the exponential function::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> exp(0)
+    1.0
+    >>> exp(1)
+    2.718281828459045235360287
+    >>> exp(-1)
+    0.3678794411714423215955238
+    >>> exp(inf)
+    +inf
+    >>> exp(-inf)
+    0.0
+
+Arguments can be arbitrarily large::
+
+    >>> exp(10000)
+    8.806818225662921587261496e+4342
+    >>> exp(-10000)
+    1.135483865314736098540939e-4343
+
+Evaluation is supported for interval arguments via
+:func:`mpmath.iv.exp`::
+
+    >>> iv.dps = 25; iv.pretty = True
+    >>> iv.exp([-inf,0])
+    [0.0, 1.0]
+    >>> iv.exp([0,1])
+    [1.0, 2.71828182845904523536028749558]
+
+The exponential function can be evaluated efficiently to arbitrary
+precision::
+
+    >>> mp.dps = 10000
+    >>> exp(pi)  #doctest: +ELLIPSIS
+    23.140692632779269005729...8984304016040616
+
+**Functional properties**
+
+Numerical verification of Euler's identity for the complex
+exponential function::
+
+    >>> mp.dps = 15
+    >>> exp(j*pi)+1
+    (0.0 + 1.22464679914735e-16j)
+    >>> chop(exp(j*pi)+1)
+    0.0
+
+This recovers the coefficients (reciprocal factorials) in the
+Maclaurin series expansion of exp::
+
+    >>> nprint(taylor(exp, 0, 5))
+    [1.0, 1.0, 0.5, 0.166667, 0.0416667, 0.00833333]
+
+The exponential function is its own derivative and antiderivative::
+
+    >>> exp(pi)
+    23.1406926327793
+    >>> diff(exp, pi)
+    23.1406926327793
+    >>> quad(exp, [-inf, pi])
+    23.1406926327793
+
+The exponential function can be evaluated using various methods,
+including direct summation of the series, limits, and solving
+the defining differential equation::
+
+    >>> nsum(lambda k: pi**k/fac(k), [0,inf])
+    23.1406926327793
+    >>> limit(lambda k: (1+pi/k)**k, inf)
+    23.1406926327793
+    >>> odefun(lambda t, x: x, 0, 1)(pi)
+    23.1406926327793
+"""
+
+cosh = r"""
+Computes the hyperbolic cosine of `x`,
+`\cosh(x) = (e^x + e^{-x})/2`. Values and limits include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> cosh(0)
+    1.0
+    >>> cosh(1)
+    1.543080634815243778477906
+    >>> cosh(-inf), cosh(+inf)
+    (+inf, +inf)
+
+The hyperbolic cosine is an even, convex function with
+a global minimum at `x = 0`, having a Maclaurin series
+that starts::
+
+    >>> nprint(chop(taylor(cosh, 0, 5)))
+    [1.0, 0.0, 0.5, 0.0, 0.0416667, 0.0]
+
+Generalized to complex numbers, the hyperbolic cosine is
+equivalent to a cosine with the argument rotated
+in the imaginary direction, or `\cosh x = \cos ix`::
+
+    >>> cosh(2+3j)
+    (-3.724545504915322565473971 + 0.5118225699873846088344638j)
+    >>> cos(3-2j)
+    (-3.724545504915322565473971 + 0.5118225699873846088344638j)
+"""
+
+sinh = r"""
+Computes the hyperbolic sine of `x`,
+`\sinh(x) = (e^x - e^{-x})/2`. Values and limits include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> sinh(0)
+    0.0
+    >>> sinh(1)
+    1.175201193643801456882382
+    >>> sinh(-inf), sinh(+inf)
+    (-inf, +inf)
+
+The hyperbolic sine is an odd function, with a Maclaurin
+series that starts::
+
+    >>> nprint(chop(taylor(sinh, 0, 5)))
+    [0.0, 1.0, 0.0, 0.166667, 0.0, 0.00833333]
+
+Generalized to complex numbers, the hyperbolic sine is
+essentially a sine with a rotation `i` applied to
+the argument; more precisely, `\sinh x = -i \sin ix`::
+
+    >>> sinh(2+3j)
+    (-3.590564589985779952012565 + 0.5309210862485198052670401j)
+    >>> j*sin(3-2j)
+    (-3.590564589985779952012565 + 0.5309210862485198052670401j)
+"""
+
+tanh = r"""
+Computes the hyperbolic tangent of `x`,
+`\tanh(x) = \sinh(x)/\cosh(x)`. Values and limits include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> tanh(0)
+    0.0
+    >>> tanh(1)
+    0.7615941559557648881194583
+    >>> tanh(-inf), tanh(inf)
+    (-1.0, 1.0)
+
+The hyperbolic tangent is an odd, sigmoidal function, similar
+to the inverse tangent and error function. Its Maclaurin
+series is::
+
+    >>> nprint(chop(taylor(tanh, 0, 5)))
+    [0.0, 1.0, 0.0, -0.333333, 0.0, 0.133333]
+
+Generalized to complex numbers, the hyperbolic tangent is
+essentially a tangent with a rotation `i` applied to
+the argument; more precisely, `\tanh x = -i \tan ix`::
+
+    >>> tanh(2+3j)
+    (0.9653858790221331242784803 - 0.009884375038322493720314034j)
+    >>> j*tan(3-2j)
+    (0.9653858790221331242784803 - 0.009884375038322493720314034j)
+"""
+
+cos = r"""
+Computes the cosine of `x`, `\cos(x)`.
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> cos(pi/3)
+    0.5
+    >>> cos(100000001)
+    -0.9802850113244713353133243
+    >>> cos(2+3j)
+    (-4.189625690968807230132555 - 9.109227893755336597979197j)
+    >>> cos(inf)
+    nan
+    >>> nprint(chop(taylor(cos, 0, 6)))
+    [1.0, 0.0, -0.5, 0.0, 0.0416667, 0.0, -0.00138889]
+
+Intervals are supported via :func:`mpmath.iv.cos`::
+
+    >>> iv.dps = 25; iv.pretty = True
+    >>> iv.cos([0,1])
+    [0.540302305868139717400936602301, 1.0]
+    >>> iv.cos([0,2])
+    [-0.41614683654714238699756823214, 1.0]
+"""
+
+sin = r"""
+Computes the sine of `x`, `\sin(x)`.
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> sin(pi/3)
+    0.8660254037844386467637232
+    >>> sin(100000001)
+    0.1975887055794968911438743
+    >>> sin(2+3j)
+    (9.1544991469114295734673 - 4.168906959966564350754813j)
+    >>> sin(inf)
+    nan
+    >>> nprint(chop(taylor(sin, 0, 6)))
+    [0.0, 1.0, 0.0, -0.166667, 0.0, 0.00833333, 0.0]
+
+Intervals are supported via :func:`mpmath.iv.sin`::
+
+    >>> iv.dps = 25; iv.pretty = True
+    >>> iv.sin([0,1])
+    [0.0, 0.841470984807896506652502331201]
+    >>> iv.sin([0,2])
+    [0.0, 1.0]
+"""
+
+tan = r"""
+Computes the tangent of `x`, `\tan(x) = \frac{\sin(x)}{\cos(x)}`.
+The tangent function is singular at `x = (n+1/2)\pi`, but
+``tan(x)`` always returns a finite result since `(n+1/2)\pi`
+cannot be represented exactly using floating-point arithmetic.
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> tan(pi/3)
+    1.732050807568877293527446
+    >>> tan(100000001)
+    -0.2015625081449864533091058
+    >>> tan(2+3j)
+    (-0.003764025641504248292751221 + 1.003238627353609801446359j)
+    >>> tan(inf)
+    nan
+    >>> nprint(chop(taylor(tan, 0, 6)))
+    [0.0, 1.0, 0.0, 0.333333, 0.0, 0.133333, 0.0]
+
+Intervals are supported via :func:`mpmath.iv.tan`::
+
+    >>> iv.dps = 25; iv.pretty = True
+    >>> iv.tan([0,1])
+    [0.0, 1.55740772465490223050697482944]
+    >>> iv.tan([0,2])  # Interval includes a singularity
+    [-inf, +inf]
+"""
+
+sec = r"""
+Computes the secant of `x`, `\mathrm{sec}(x) = \frac{1}{\cos(x)}`.
+The secant function is singular at `x = (n+1/2)\pi`, but
+``sec(x)`` always returns a finite result since `(n+1/2)\pi`
+cannot be represented exactly using floating-point arithmetic.
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> sec(pi/3)
+    2.0
+    >>> sec(10000001)
+    -1.184723164360392819100265
+    >>> sec(2+3j)
+    (-0.04167496441114427004834991 + 0.0906111371962375965296612j)
+    >>> sec(inf)
+    nan
+    >>> nprint(chop(taylor(sec, 0, 6)))
+    [1.0, 0.0, 0.5, 0.0, 0.208333, 0.0, 0.0847222]
+
+Intervals are supported via :func:`mpmath.iv.sec`::
+
+    >>> iv.dps = 25; iv.pretty = True
+    >>> iv.sec([0,1])
+    [1.0, 1.85081571768092561791175326276]
+    >>> iv.sec([0,2])  # Interval includes a singularity
+    [-inf, +inf]
+"""
+
+csc = r"""
+Computes the cosecant of `x`, `\mathrm{csc}(x) = \frac{1}{\sin(x)}`.
+This cosecant function is singular at `x = n \pi`, but with the
+exception of the point `x = 0`, ``csc(x)`` returns a finite result
+since `n \pi` cannot be represented exactly using floating-point
+arithmetic.
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> csc(pi/3)
+    1.154700538379251529018298
+    >>> csc(10000001)
+    -1.864910497503629858938891
+    >>> csc(2+3j)
+    (0.09047320975320743980579048 + 0.04120098628857412646300981j)
+    >>> csc(inf)
+    nan
+
+Intervals are supported via :func:`mpmath.iv.csc`::
+
+    >>> iv.dps = 25; iv.pretty = True
+    >>> iv.csc([0,1])  # Interval includes a singularity
+    [1.18839510577812121626159943988, +inf]
+    >>> iv.csc([0,2])
+    [1.0, +inf]
+"""
+
+cot = r"""
+Computes the cotangent of `x`,
+`\mathrm{cot}(x) = \frac{1}{\tan(x)} = \frac{\cos(x)}{\sin(x)}`.
+This cotangent function is singular at `x = n \pi`, but with the
+exception of the point `x = 0`, ``cot(x)`` returns a finite result
+since `n \pi` cannot be represented exactly using floating-point
+arithmetic.
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> cot(pi/3)
+    0.5773502691896257645091488
+    >>> cot(10000001)
+    1.574131876209625656003562
+    >>> cot(2+3j)
+    (-0.003739710376336956660117409 - 0.9967577965693583104609688j)
+    >>> cot(inf)
+    nan
+
+Intervals are supported via :func:`mpmath.iv.cot`::
+
+    >>> iv.dps = 25; iv.pretty = True
+    >>> iv.cot([0,1])  # Interval includes a singularity
+    [0.642092615934330703006419974862, +inf]
+    >>> iv.cot([1,2])
+    [-inf, +inf]
+"""
+
+acos = r"""
+Computes the inverse cosine or arccosine of `x`, `\cos^{-1}(x)`.
+Since `-1 \le \cos(x) \le 1` for real `x`, the inverse
+cosine is real-valued only for `-1 \le x \le 1`. On this interval,
+:func:`~mpmath.acos` is defined to be a monotonically decreasing
+function assuming values between `+\pi` and `0`.
+
+Basic values are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> acos(-1)
+    3.141592653589793238462643
+    >>> acos(0)
+    1.570796326794896619231322
+    >>> acos(1)
+    0.0
+    >>> nprint(chop(taylor(acos, 0, 6)))
+    [1.5708, -1.0, 0.0, -0.166667, 0.0, -0.075, 0.0]
+
+:func:`~mpmath.acos` is defined so as to be a proper inverse function of
+`\cos(\theta)` for `0 \le \theta < \pi`.
+We have `\cos(\cos^{-1}(x)) = x` for all `x`, but
+`\cos^{-1}(\cos(x)) = x` only for `0 \le \Re[x] < \pi`::
+
+    >>> for x in [1, 10, -1, 2+3j, 10+3j]:
+    ...     print("%s %s" % (cos(acos(x)), acos(cos(x))))
+    ...
+    1.0 1.0
+    (10.0 + 0.0j) 2.566370614359172953850574
+    -1.0 1.0
+    (2.0 + 3.0j) (2.0 + 3.0j)
+    (10.0 + 3.0j) (2.566370614359172953850574 - 3.0j)
+
+The inverse cosine has two branch points: `x = \pm 1`. :func:`~mpmath.acos`
+places the branch cuts along the line segments `(-\infty, -1)` and
+`(+1, +\infty)`. In general,
+
+.. math ::
+
+    \cos^{-1}(x) = \frac{\pi}{2} + i \log\left(ix + \sqrt{1-x^2} \right)
+
+where the principal-branch log and square root are implied.
+"""
+
+asin = r"""
+Computes the inverse sine or arcsine of `x`, `\sin^{-1}(x)`.
+Since `-1 \le \sin(x) \le 1` for real `x`, the inverse
+sine is real-valued only for `-1 \le x \le 1`.
+On this interval, it is defined to be a monotonically increasing
+function assuming values between `-\pi/2` and `\pi/2`.
+
+Basic values are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> asin(-1)
+    -1.570796326794896619231322
+    >>> asin(0)
+    0.0
+    >>> asin(1)
+    1.570796326794896619231322
+    >>> nprint(chop(taylor(asin, 0, 6)))
+    [0.0, 1.0, 0.0, 0.166667, 0.0, 0.075, 0.0]
+
+:func:`~mpmath.asin` is defined so as to be a proper inverse function of
+`\sin(\theta)` for `-\pi/2 < \theta < \pi/2`.
+We have `\sin(\sin^{-1}(x)) = x` for all `x`, but
+`\sin^{-1}(\sin(x)) = x` only for `-\pi/2 < \Re[x] < \pi/2`::
+
+    >>> for x in [1, 10, -1, 1+3j, -2+3j]:
+    ...     print("%s %s" % (chop(sin(asin(x))), asin(sin(x))))
+    ...
+    1.0 1.0
+    10.0 -0.5752220392306202846120698
+    -1.0 -1.0
+    (1.0 + 3.0j) (1.0 + 3.0j)
+    (-2.0 + 3.0j) (-1.141592653589793238462643 - 3.0j)
+
+The inverse sine has two branch points: `x = \pm 1`. :func:`~mpmath.asin`
+places the branch cuts along the line segments `(-\infty, -1)` and
+`(+1, +\infty)`. In general,
+
+.. math ::
+
+    \sin^{-1}(x) = -i \log\left(ix + \sqrt{1-x^2} \right)
+
+where the principal-branch log and square root are implied.
+"""
+
+atan = r"""
+Computes the inverse tangent or arctangent of `x`, `\tan^{-1}(x)`.
+This is a real-valued function for all real `x`, with range
+`(-\pi/2, \pi/2)`.
+
+Basic values are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> atan(-inf)
+    -1.570796326794896619231322
+    >>> atan(-1)
+    -0.7853981633974483096156609
+    >>> atan(0)
+    0.0
+    >>> atan(1)
+    0.7853981633974483096156609
+    >>> atan(inf)
+    1.570796326794896619231322
+    >>> nprint(chop(taylor(atan, 0, 6)))
+    [0.0, 1.0, 0.0, -0.333333, 0.0, 0.2, 0.0]
+
+The inverse tangent is often used to compute angles. However,
+the atan2 function is often better for this as it preserves sign
+(see :func:`~mpmath.atan2`).
+
+:func:`~mpmath.atan` is defined so as to be a proper inverse function of
+`\tan(\theta)` for `-\pi/2 < \theta < \pi/2`.
+We have `\tan(\tan^{-1}(x)) = x` for all `x`, but
+`\tan^{-1}(\tan(x)) = x` only for `-\pi/2 < \Re[x] < \pi/2`::
+
+    >>> mp.dps = 25
+    >>> for x in [1, 10, -1, 1+3j, -2+3j]:
+    ...     print("%s %s" % (tan(atan(x)), atan(tan(x))))
+    ...
+    1.0 1.0
+    10.0 0.5752220392306202846120698
+    -1.0 -1.0
+    (1.0 + 3.0j) (1.000000000000000000000001 + 3.0j)
+    (-2.0 + 3.0j) (1.141592653589793238462644 + 3.0j)
+
+The inverse tangent has two branch points: `x = \pm i`. :func:`~mpmath.atan`
+places the branch cuts along the line segments `(-i \infty, -i)` and
+`(+i, +i \infty)`. In general,
+
+.. math ::
+
+    \tan^{-1}(x) = \frac{i}{2}\left(\log(1-ix)-\log(1+ix)\right)
+
+where the principal-branch log is implied.
+"""
+
+acot = r"""Computes the inverse cotangent of `x`,
+`\mathrm{cot}^{-1}(x) = \tan^{-1}(1/x)`."""
+
+asec = r"""Computes the inverse secant of `x`,
+`\mathrm{sec}^{-1}(x) = \cos^{-1}(1/x)`."""
+
+acsc = r"""Computes the inverse cosecant of `x`,
+`\mathrm{csc}^{-1}(x) = \sin^{-1}(1/x)`."""
+
+coth = r"""Computes the hyperbolic cotangent of `x`,
+`\mathrm{coth}(x) = \frac{\cosh(x)}{\sinh(x)}`.
+"""
+
+sech = r"""Computes the hyperbolic secant of `x`,
+`\mathrm{sech}(x) = \frac{1}{\cosh(x)}`.
+"""
+
+csch = r"""Computes the hyperbolic cosecant of `x`,
+`\mathrm{csch}(x) = \frac{1}{\sinh(x)}`.
+"""
+
+acosh = r"""Computes the inverse hyperbolic cosine of `x`,
+`\mathrm{cosh}^{-1}(x) = \log(x+\sqrt{x+1}\sqrt{x-1})`.
+"""
+
+asinh = r"""Computes the inverse hyperbolic sine of `x`,
+`\mathrm{sinh}^{-1}(x) = \log(x+\sqrt{1+x^2})`.
+"""
+
+atanh = r"""Computes the inverse hyperbolic tangent of `x`,
+`\mathrm{tanh}^{-1}(x) = \frac{1}{2}\left(\log(1+x)-\log(1-x)\right)`.
+"""
+
+acoth = r"""Computes the inverse hyperbolic cotangent of `x`,
+`\mathrm{coth}^{-1}(x) = \tanh^{-1}(1/x)`."""
+
+asech = r"""Computes the inverse hyperbolic secant of `x`,
+`\mathrm{sech}^{-1}(x) = \cosh^{-1}(1/x)`."""
+
+acsch = r"""Computes the inverse hyperbolic cosecant of `x`,
+`\mathrm{csch}^{-1}(x) = \sinh^{-1}(1/x)`."""
+
+
+
+sinpi = r"""
+Computes `\sin(\pi x)`, more accurately than the expression
+``sin(pi*x)``::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> sinpi(10**10), sin(pi*(10**10))
+    (0.0, -2.23936276195592e-6)
+    >>> sinpi(10**10+0.5), sin(pi*(10**10+0.5))
+    (1.0, 0.999999999998721)
+"""
+
+cospi = r"""
+Computes `\cos(\pi x)`, more accurately than the expression
+``cos(pi*x)``::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> cospi(10**10), cos(pi*(10**10))
+    (1.0, 0.999999999997493)
+    >>> cospi(10**10+0.5), cos(pi*(10**10+0.5))
+    (0.0, 1.59960492420134e-6)
+"""
+
+sinc = r"""
+``sinc(x)`` computes the unnormalized sinc function, defined as
+
+.. math ::
+
+    \mathrm{sinc}(x) = \begin{cases}
+        \sin(x)/x, & \mbox{if } x \ne 0 \\
+        1,         & \mbox{if } x = 0.
+    \end{cases}
+
+See :func:`~mpmath.sincpi` for the normalized sinc function.
+
+Simple values and limits include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> sinc(0)
+    1.0
+    >>> sinc(1)
+    0.841470984807897
+    >>> sinc(inf)
+    0.0
+
+The integral of the sinc function is the sine integral Si::
+
+    >>> quad(sinc, [0, 1])
+    0.946083070367183
+    >>> si(1)
+    0.946083070367183
+"""
+
+sincpi = r"""
+``sincpi(x)`` computes the normalized sinc function, defined as
+
+.. math ::
+
+    \mathrm{sinc}_{\pi}(x) = \begin{cases}
+        \sin(\pi x)/(\pi x), & \mbox{if } x \ne 0 \\
+        1,                   & \mbox{if } x = 0.
+    \end{cases}
+
+Equivalently, we have
+`\mathrm{sinc}_{\pi}(x) = \mathrm{sinc}(\pi x)`.
+
+The normalization entails that the function integrates
+to unity over the entire real line::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> quadosc(sincpi, [-inf, inf], period=2.0)
+    1.0
+
+Like, :func:`~mpmath.sinpi`, :func:`~mpmath.sincpi` is evaluated accurately
+at its roots::
+
+    >>> sincpi(10)
+    0.0
+"""
+
+expj = r"""
+Convenience function for computing `e^{ix}`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> expj(0)
+    (1.0 + 0.0j)
+    >>> expj(-1)
+    (0.5403023058681397174009366 - 0.8414709848078965066525023j)
+    >>> expj(j)
+    (0.3678794411714423215955238 + 0.0j)
+    >>> expj(1+j)
+    (0.1987661103464129406288032 + 0.3095598756531121984439128j)
+"""
+
+expjpi = r"""
+Convenience function for computing `e^{i \pi x}`.
+Evaluation is accurate near zeros (see also :func:`~mpmath.cospi`,
+:func:`~mpmath.sinpi`)::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> expjpi(0)
+    (1.0 + 0.0j)
+    >>> expjpi(1)
+    (-1.0 + 0.0j)
+    >>> expjpi(0.5)
+    (0.0 + 1.0j)
+    >>> expjpi(-1)
+    (-1.0 + 0.0j)
+    >>> expjpi(j)
+    (0.04321391826377224977441774 + 0.0j)
+    >>> expjpi(1+j)
+    (-0.04321391826377224977441774 + 0.0j)
+"""
+
+floor = r"""
+Computes the floor of `x`, `\lfloor x \rfloor`, defined as
+the largest integer less than or equal to `x`::
+
+    >>> from mpmath import *
+    >>> mp.pretty = False
+    >>> floor(3.5)
+    mpf('3.0')
+
+.. note ::
+
+    :func:`~mpmath.floor`, :func:`~mpmath.ceil` and :func:`~mpmath.nint` return a
+    floating-point number, not a Python ``int``. If `\lfloor x \rfloor` is
+    too large to be represented exactly at the present working precision,
+    the result will be rounded, not necessarily in the direction
+    implied by the mathematical definition of the function.
+
+To avoid rounding, use *prec=0*::
+
+    >>> mp.dps = 15
+    >>> print(int(floor(10**30+1)))
+    1000000000000000019884624838656
+    >>> print(int(floor(10**30+1, prec=0)))
+    1000000000000000000000000000001
+
+The floor function is defined for complex numbers and
+acts on the real and imaginary parts separately::
+
+    >>> floor(3.25+4.75j)
+    mpc(real='3.0', imag='4.0')
+"""
+
+ceil = r"""
+Computes the ceiling of `x`, `\lceil x \rceil`, defined as
+the smallest integer greater than or equal to `x`::
+
+    >>> from mpmath import *
+    >>> mp.pretty = False
+    >>> ceil(3.5)
+    mpf('4.0')
+
+The ceiling function is defined for complex numbers and
+acts on the real and imaginary parts separately::
+
+    >>> ceil(3.25+4.75j)
+    mpc(real='4.0', imag='5.0')
+
+See notes about rounding for :func:`~mpmath.floor`.
+"""
+
+nint = r"""
+Evaluates the nearest integer function, `\mathrm{nint}(x)`.
+This gives the nearest integer to `x`; on a tie, it
+gives the nearest even integer::
+
+    >>> from mpmath import *
+    >>> mp.pretty = False
+    >>> nint(3.2)
+    mpf('3.0')
+    >>> nint(3.8)
+    mpf('4.0')
+    >>> nint(3.5)
+    mpf('4.0')
+    >>> nint(4.5)
+    mpf('4.0')
+
+The nearest integer function is defined for complex numbers and
+acts on the real and imaginary parts separately::
+
+    >>> nint(3.25+4.75j)
+    mpc(real='3.0', imag='5.0')
+
+See notes about rounding for :func:`~mpmath.floor`.
+"""
+
+frac = r"""
+Gives the fractional part of `x`, defined as
+`\mathrm{frac}(x) = x - \lfloor x \rfloor` (see :func:`~mpmath.floor`).
+In effect, this computes `x` modulo 1, or `x+n` where
+`n \in \mathbb{Z}` is such that `x+n \in [0,1)`::
+
+    >>> from mpmath import *
+    >>> mp.pretty = False
+    >>> frac(1.25)
+    mpf('0.25')
+    >>> frac(3)
+    mpf('0.0')
+    >>> frac(-1.25)
+    mpf('0.75')
+
+For a complex number, the fractional part function applies to
+the real and imaginary parts separately::
+
+    >>> frac(2.25+3.75j)
+    mpc(real='0.25', imag='0.75')
+
+Plotted, the fractional part function gives a sawtooth
+wave. The Fourier series coefficients have a simple
+form::
+
+    >>> mp.dps = 15
+    >>> nprint(fourier(lambda x: frac(x)-0.5, [0,1], 4))
+    ([0.0, 0.0, 0.0, 0.0, 0.0], [0.0, -0.31831, -0.159155, -0.106103, -0.0795775])
+    >>> nprint([-1/(pi*k) for k in range(1,5)])
+    [-0.31831, -0.159155, -0.106103, -0.0795775]
+
+.. note::
+
+    The fractional part is sometimes defined as a symmetric
+    function, i.e. returning `-\mathrm{frac}(-x)` if `x < 0`.
+    This convention is used, for instance, by Mathematica's
+    ``FractionalPart``.
+
+"""
+
+sign = r"""
+Returns the sign of `x`, defined as `\mathrm{sign}(x) = x / |x|`
+(with the special case `\mathrm{sign}(0) = 0`)::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = False
+    >>> sign(10)
+    mpf('1.0')
+    >>> sign(-10)
+    mpf('-1.0')
+    >>> sign(0)
+    mpf('0.0')
+
+Note that the sign function is also defined for complex numbers,
+for which it gives the projection onto the unit circle::
+
+    >>> mp.dps = 15; mp.pretty = True
+    >>> sign(1+j)
+    (0.707106781186547 + 0.707106781186547j)
+
+"""
+
+arg = r"""
+Computes the complex argument (phase) of `x`, defined as the
+signed angle between the positive real axis and `x` in the
+complex plane::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> arg(3)
+    0.0
+    >>> arg(3+3j)
+    0.785398163397448
+    >>> arg(3j)
+    1.5707963267949
+    >>> arg(-3)
+    3.14159265358979
+    >>> arg(-3j)
+    -1.5707963267949
+
+The angle is defined to satisfy `-\pi < \arg(x) \le \pi` and
+with the sign convention that a nonnegative imaginary part
+results in a nonnegative argument.
+
+The value returned by :func:`~mpmath.arg` is an ``mpf`` instance.
+"""
+
+fabs = r"""
+Returns the absolute value of `x`, `|x|`. Unlike :func:`abs`,
+:func:`~mpmath.fabs` converts non-mpmath numbers (such as ``int``)
+into mpmath numbers::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = False
+    >>> fabs(3)
+    mpf('3.0')
+    >>> fabs(-3)
+    mpf('3.0')
+    >>> fabs(3+4j)
+    mpf('5.0')
+"""
+
+re = r"""
+Returns the real part of `x`, `\Re(x)`. :func:`~mpmath.re`
+converts a non-mpmath number to an mpmath number::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = False
+    >>> re(3)
+    mpf('3.0')
+    >>> re(-1+4j)
+    mpf('-1.0')
+"""
+
+im = r"""
+Returns the imaginary part of `x`, `\Im(x)`. :func:`~mpmath.im`
+converts a non-mpmath number to an mpmath number::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = False
+    >>> im(3)
+    mpf('0.0')
+    >>> im(-1+4j)
+    mpf('4.0')
+"""
+
+conj = r"""
+Returns the complex conjugate of `x`, `\overline{x}`. Unlike
+``x.conjugate()``, :func:`~mpmath.im` converts `x` to a mpmath number::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = False
+    >>> conj(3)
+    mpf('3.0')
+    >>> conj(-1+4j)
+    mpc(real='-1.0', imag='-4.0')
+"""
+
+polar = r"""
+Returns the polar representation of the complex number `z`
+as a pair `(r, \phi)` such that `z = r e^{i \phi}`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> polar(-2)
+    (2.0, 3.14159265358979)
+    >>> polar(3-4j)
+    (5.0, -0.927295218001612)
+"""
+
+rect = r"""
+Returns the complex number represented by polar
+coordinates `(r, \phi)`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> chop(rect(2, pi))
+    -2.0
+    >>> rect(sqrt(2), -pi/4)
+    (1.0 - 1.0j)
+"""
+
+expm1 = r"""
+Computes `e^x - 1`, accurately for small `x`.
+
+Unlike the expression ``exp(x) - 1``, ``expm1(x)`` does not suffer from
+potentially catastrophic cancellation::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> exp(1e-10)-1; print(expm1(1e-10))
+    1.00000008274037e-10
+    1.00000000005e-10
+    >>> exp(1e-20)-1; print(expm1(1e-20))
+    0.0
+    1.0e-20
+    >>> 1/(exp(1e-20)-1)
+    Traceback (most recent call last):
+      ...
+    ZeroDivisionError
+    >>> 1/expm1(1e-20)
+    1.0e+20
+
+Evaluation works for extremely tiny values::
+
+    >>> expm1(0)
+    0.0
+    >>> expm1('1e-10000000')
+    1.0e-10000000
+
+"""
+
+log1p = r"""
+Computes `\log(1+x)`, accurately for small `x`.
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> log(1+1e-10); print(mp.log1p(1e-10))
+    1.00000008269037e-10
+    9.9999999995e-11
+    >>> mp.log1p(1e-100j)
+    (5.0e-201 + 1.0e-100j)
+    >>> mp.log1p(0)
+    0.0
+
+"""
+
+
+powm1 = r"""
+Computes `x^y - 1`, accurately when `x^y` is very close to 1.
+
+This avoids potentially catastrophic cancellation::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> power(0.99999995, 1e-10) - 1
+    0.0
+    >>> powm1(0.99999995, 1e-10)
+    -5.00000012791934e-18
+
+Powers exactly equal to 1, and only those powers, yield 0 exactly::
+
+    >>> powm1(-j, 4)
+    (0.0 + 0.0j)
+    >>> powm1(3, 0)
+    0.0
+    >>> powm1(fadd(-1, 1e-100, exact=True), 4)
+    -4.0e-100
+
+Evaluation works for extremely tiny `y`::
+
+    >>> powm1(2, '1e-100000')
+    6.93147180559945e-100001
+    >>> powm1(j, '1e-1000')
+    (-1.23370055013617e-2000 + 1.5707963267949e-1000j)
+
+"""
+
+root = r"""
+``root(z, n, k=0)`` computes an `n`-th root of `z`, i.e. returns a number
+`r` that (up to possible approximation error) satisfies `r^n = z`.
+(``nthroot`` is available as an alias for ``root``.)
+
+Every complex number `z \ne 0` has `n` distinct `n`-th roots, which are
+equidistant points on a circle with radius `|z|^{1/n}`, centered around the
+origin. A specific root may be selected using the optional index
+`k`. The roots are indexed counterclockwise, starting with `k = 0` for the root
+closest to the positive real half-axis.
+
+The `k = 0` root is the so-called principal `n`-th root, often denoted by
+`\sqrt[n]{z}` or `z^{1/n}`, and also given by `\exp(\log(z) / n)`. If `z` is
+a positive real number, the principal root is just the unique positive
+`n`-th root of `z`. Under some circumstances, non-principal real roots exist:
+for positive real `z`, `n` even, there is a negative root given by `k = n/2`;
+for negative real `z`, `n` odd, there is a negative root given by `k = (n-1)/2`.
+
+To obtain all roots with a simple expression, use
+``[root(z,n,k) for k in range(n)]``.
+
+An important special case, ``root(1, n, k)`` returns the `k`-th `n`-th root of
+unity, `\zeta_k = e^{2 \pi i k / n}`. Alternatively, :func:`~mpmath.unitroots`
+provides a slightly more convenient way to obtain the roots of unity,
+including the option to compute only the primitive roots of unity.
+
+Both `k` and `n` should be integers; `k` outside of ``range(n)`` will be
+reduced modulo `n`. If `n` is negative, `x^{-1/n} = 1/x^{1/n}` (or
+the equivalent reciprocal for a non-principal root with `k \ne 0`) is computed.
+
+:func:`~mpmath.root` is implemented to use Newton's method for small
+`n`. At high precision, this makes `x^{1/n}` not much more
+expensive than the regular exponentiation, `x^n`. For very large
+`n`, :func:`~mpmath.nthroot` falls back to use the exponential function.
+
+**Examples**
+
+:func:`~mpmath.nthroot`/:func:`~mpmath.root` is faster and more accurate than raising to a
+floating-point fraction::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = False
+    >>> 16807 ** (mpf(1)/5)
+    mpf('7.0000000000000009')
+    >>> root(16807, 5)
+    mpf('7.0')
+    >>> nthroot(16807, 5)    # Alias
+    mpf('7.0')
+
+A high-precision root::
+
+    >>> mp.dps = 50; mp.pretty = True
+    >>> nthroot(10, 5)
+    1.584893192461113485202101373391507013269442133825
+    >>> nthroot(10, 5) ** 5
+    10.0
+
+Computing principal and non-principal square and cube roots::
+
+    >>> mp.dps = 15
+    >>> root(10, 2)
+    3.16227766016838
+    >>> root(10, 2, 1)
+    -3.16227766016838
+    >>> root(-10, 3)
+    (1.07721734501594 + 1.86579517236206j)
+    >>> root(-10, 3, 1)
+    -2.15443469003188
+    >>> root(-10, 3, 2)
+    (1.07721734501594 - 1.86579517236206j)
+
+All the 7th roots of a complex number::
+
+    >>> for r in [root(3+4j, 7, k) for k in range(7)]:
+    ...     print("%s %s" % (r, r**7))
+    ...
+    (1.24747270589553 + 0.166227124177353j) (3.0 + 4.0j)
+    (0.647824911301003 + 1.07895435170559j) (3.0 + 4.0j)
+    (-0.439648254723098 + 1.17920694574172j) (3.0 + 4.0j)
+    (-1.19605731775069 + 0.391492658196305j) (3.0 + 4.0j)
+    (-1.05181082538903 - 0.691023585965793j) (3.0 + 4.0j)
+    (-0.115529328478668 - 1.25318497558335j) (3.0 + 4.0j)
+    (0.907748109144957 - 0.871672518271819j) (3.0 + 4.0j)
+
+Cube roots of unity::
+
+    >>> for k in range(3): print(root(1, 3, k))
+    ...
+    1.0
+    (-0.5 + 0.866025403784439j)
+    (-0.5 - 0.866025403784439j)
+
+Some exact high order roots::
+
+    >>> root(75**210, 105)
+    5625.0
+    >>> root(1, 128, 96)
+    (0.0 - 1.0j)
+    >>> root(4**128, 128, 96)
+    (0.0 - 4.0j)
+
+"""
+
+unitroots = r"""
+``unitroots(n)`` returns `\zeta_0, \zeta_1, \ldots, \zeta_{n-1}`,
+all the distinct `n`-th roots of unity, as a list. If the option
+*primitive=True* is passed, only the primitive roots are returned.
+
+Every `n`-th root of unity satisfies `(\zeta_k)^n = 1`. There are `n` distinct
+roots for each `n` (`\zeta_k` and `\zeta_j` are the same when
+`k = j \pmod n`), which form a regular polygon with vertices on the unit
+circle. They are ordered counterclockwise with increasing `k`, starting
+with `\zeta_0 = 1`.
+
+**Examples**
+
+The roots of unity up to `n = 4`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> nprint(unitroots(1))
+    [1.0]
+    >>> nprint(unitroots(2))
+    [1.0, -1.0]
+    >>> nprint(unitroots(3))
+    [1.0, (-0.5 + 0.866025j), (-0.5 - 0.866025j)]
+    >>> nprint(unitroots(4))
+    [1.0, (0.0 + 1.0j), -1.0, (0.0 - 1.0j)]
+
+Roots of unity form a geometric series that sums to 0::
+
+    >>> mp.dps = 50
+    >>> chop(fsum(unitroots(25)))
+    0.0
+
+Primitive roots up to `n = 4`::
+
+    >>> mp.dps = 15
+    >>> nprint(unitroots(1, primitive=True))
+    [1.0]
+    >>> nprint(unitroots(2, primitive=True))
+    [-1.0]
+    >>> nprint(unitroots(3, primitive=True))
+    [(-0.5 + 0.866025j), (-0.5 - 0.866025j)]
+    >>> nprint(unitroots(4, primitive=True))
+    [(0.0 + 1.0j), (0.0 - 1.0j)]
+
+There are only four primitive 12th roots::
+
+    >>> nprint(unitroots(12, primitive=True))
+    [(0.866025 + 0.5j), (-0.866025 + 0.5j), (-0.866025 - 0.5j), (0.866025 - 0.5j)]
+
+The `n`-th roots of unity form a group, the cyclic group of order `n`.
+Any primitive root `r` is a generator for this group, meaning that
+`r^0, r^1, \ldots, r^{n-1}` gives the whole set of unit roots (in
+some permuted order)::
+
+    >>> for r in unitroots(6): print(r)
+    ...
+    1.0
+    (0.5 + 0.866025403784439j)
+    (-0.5 + 0.866025403784439j)
+    -1.0
+    (-0.5 - 0.866025403784439j)
+    (0.5 - 0.866025403784439j)
+    >>> r = unitroots(6, primitive=True)[1]
+    >>> for k in range(6): print(chop(r**k))
+    ...
+    1.0
+    (0.5 - 0.866025403784439j)
+    (-0.5 - 0.866025403784439j)
+    -1.0
+    (-0.5 + 0.866025403784438j)
+    (0.5 + 0.866025403784438j)
+
+The number of primitive roots equals the Euler totient function `\phi(n)`::
+
+    >>> [len(unitroots(n, primitive=True)) for n in range(1,20)]
+    [1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18]
+
+"""
+
+
+log = r"""
+Computes the base-`b` logarithm of `x`, `\log_b(x)`. If `b` is
+unspecified, :func:`~mpmath.log` computes the natural (base `e`) logarithm
+and is equivalent to :func:`~mpmath.ln`. In general, the base `b` logarithm
+is defined in terms of the natural logarithm as
+`\log_b(x) = \ln(x)/\ln(b)`.
+
+By convention, we take `\log(0) = -\infty`.
+
+The natural logarithm is real if `x > 0` and complex if `x < 0` or if
+`x` is complex. The principal branch of the complex logarithm is
+used, meaning that `\Im(\ln(x)) = -\pi < \arg(x) \le \pi`.
+
+**Examples**
+
+Some basic values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> log(1)
+    0.0
+    >>> log(2)
+    0.693147180559945
+    >>> log(1000,10)
+    3.0
+    >>> log(4, 16)
+    0.5
+    >>> log(j)
+    (0.0 + 1.5707963267949j)
+    >>> log(-1)
+    (0.0 + 3.14159265358979j)
+    >>> log(0)
+    -inf
+    >>> log(inf)
+    +inf
+
+The natural logarithm is the antiderivative of `1/x`::
+
+    >>> quad(lambda x: 1/x, [1, 5])
+    1.6094379124341
+    >>> log(5)
+    1.6094379124341
+    >>> diff(log, 10)
+    0.1
+
+The Taylor series expansion of the natural logarithm around
+`x = 1` has coefficients `(-1)^{n+1}/n`::
+
+    >>> nprint(taylor(log, 1, 7))
+    [0.0, 1.0, -0.5, 0.333333, -0.25, 0.2, -0.166667, 0.142857]
+
+:func:`~mpmath.log` supports arbitrary precision evaluation::
+
+    >>> mp.dps = 50
+    >>> log(pi)
+    1.1447298858494001741434273513530587116472948129153
+    >>> log(pi, pi**3)
+    0.33333333333333333333333333333333333333333333333333
+    >>> mp.dps = 25
+    >>> log(3+4j)
+    (1.609437912434100374600759 + 0.9272952180016122324285125j)
+"""
+
+log10 = r"""
+Computes the base-10 logarithm of `x`, `\log_{10}(x)`. ``log10(x)``
+is equivalent to ``log(x, 10)``.
+"""
+
+fmod = r"""
+Converts `x` and `y` to mpmath numbers and returns `x \mod y`.
+For mpmath numbers, this is equivalent to ``x % y``.
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> fmod(100, pi)
+    2.61062773871641
+
+You can use :func:`~mpmath.fmod` to compute fractional parts of numbers::
+
+    >>> fmod(10.25, 1)
+    0.25
+
+"""
+
+radians = r"""
+Converts the degree angle `x` to radians::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> radians(60)
+    1.0471975511966
+"""
+
+degrees = r"""
+Converts the radian angle `x` to a degree angle::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> degrees(pi/3)
+    60.0
+"""
+
+atan2 = r"""
+Computes the two-argument arctangent, `\mathrm{atan2}(y, x)`,
+giving the signed angle between the positive `x`-axis and the
+point `(x, y)` in the 2D plane. This function is defined for
+real `x` and `y` only.
+
+The two-argument arctangent essentially computes
+`\mathrm{atan}(y/x)`, but accounts for the signs of both
+`x` and `y` to give the angle for the correct quadrant. The
+following examples illustrate the difference::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> atan2(1,1), atan(1/1.)
+    (0.785398163397448, 0.785398163397448)
+    >>> atan2(1,-1), atan(1/-1.)
+    (2.35619449019234, -0.785398163397448)
+    >>> atan2(-1,1), atan(-1/1.)
+    (-0.785398163397448, -0.785398163397448)
+    >>> atan2(-1,-1), atan(-1/-1.)
+    (-2.35619449019234, 0.785398163397448)
+
+The angle convention is the same as that used for the complex
+argument; see :func:`~mpmath.arg`.
+"""
+
+fibonacci = r"""
+``fibonacci(n)`` computes the `n`-th Fibonacci number, `F(n)`. The
+Fibonacci numbers are defined by the recurrence `F(n) = F(n-1) + F(n-2)`
+with the initial values `F(0) = 0`, `F(1) = 1`. :func:`~mpmath.fibonacci`
+extends this definition to arbitrary real and complex arguments
+using the formula
+
+.. math ::
+
+  F(z) = \frac{\phi^z - \cos(\pi z) \phi^{-z}}{\sqrt 5}
+
+where `\phi` is the golden ratio. :func:`~mpmath.fibonacci` also uses this
+continuous formula to compute `F(n)` for extremely large `n`, where
+calculating the exact integer would be wasteful.
+
+For convenience, :func:`~mpmath.fib` is available as an alias for
+:func:`~mpmath.fibonacci`.
+
+**Basic examples**
+
+Some small Fibonacci numbers are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for i in range(10):
+    ...     print(fibonacci(i))
+    ...
+    0.0
+    1.0
+    1.0
+    2.0
+    3.0
+    5.0
+    8.0
+    13.0
+    21.0
+    34.0
+    >>> fibonacci(50)
+    12586269025.0
+
+The recurrence for `F(n)` extends backwards to negative `n`::
+
+    >>> for i in range(10):
+    ...     print(fibonacci(-i))
+    ...
+    0.0
+    1.0
+    -1.0
+    2.0
+    -3.0
+    5.0
+    -8.0
+    13.0
+    -21.0
+    34.0
+
+Large Fibonacci numbers will be computed approximately unless
+the precision is set high enough::
+
+    >>> fib(200)
+    2.8057117299251e+41
+    >>> mp.dps = 45
+    >>> fib(200)
+    280571172992510140037611932413038677189525.0
+
+:func:`~mpmath.fibonacci` can compute approximate Fibonacci numbers
+of stupendous size::
+
+    >>> mp.dps = 15
+    >>> fibonacci(10**25)
+    3.49052338550226e+2089876402499787337692720
+
+**Real and complex arguments**
+
+The extended Fibonacci function is an analytic function. The
+property `F(z) = F(z-1) + F(z-2)` holds for arbitrary `z`::
+
+    >>> mp.dps = 15
+    >>> fib(pi)
+    2.1170270579161
+    >>> fib(pi-1) + fib(pi-2)
+    2.1170270579161
+    >>> fib(3+4j)
+    (-5248.51130728372 - 14195.962288353j)
+    >>> fib(2+4j) + fib(1+4j)
+    (-5248.51130728372 - 14195.962288353j)
+
+The Fibonacci function has infinitely many roots on the
+negative half-real axis. The first root is at 0, the second is
+close to -0.18, and then there are infinitely many roots that
+asymptotically approach `-n+1/2`::
+
+    >>> findroot(fib, -0.2)
+    -0.183802359692956
+    >>> findroot(fib, -2)
+    -1.57077646820395
+    >>> findroot(fib, -17)
+    -16.4999999596115
+    >>> findroot(fib, -24)
+    -23.5000000000479
+
+**Mathematical relationships**
+
+For large `n`, `F(n+1)/F(n)` approaches the golden ratio::
+
+    >>> mp.dps = 50
+    >>> fibonacci(101)/fibonacci(100)
+    1.6180339887498948482045868343656381177203127439638
+    >>> +phi
+    1.6180339887498948482045868343656381177203091798058
+
+The sum of reciprocal Fibonacci numbers converges to an irrational
+number for which no closed form expression is known::
+
+    >>> mp.dps = 15
+    >>> nsum(lambda n: 1/fib(n), [1, inf])
+    3.35988566624318
+
+Amazingly, however, the sum of odd-index reciprocal Fibonacci
+numbers can be expressed in terms of a Jacobi theta function::
+
+    >>> nsum(lambda n: 1/fib(2*n+1), [0, inf])
+    1.82451515740692
+    >>> sqrt(5)*jtheta(2,0,(3-sqrt(5))/2)**2/4
+    1.82451515740692
+
+Some related sums can be done in closed form::
+
+    >>> nsum(lambda k: 1/(1+fib(2*k+1)), [0, inf])
+    1.11803398874989
+    >>> phi - 0.5
+    1.11803398874989
+    >>> f = lambda k:(-1)**(k+1) / sum(fib(n)**2 for n in range(1,int(k+1)))
+    >>> nsum(f, [1, inf])
+    0.618033988749895
+    >>> phi-1
+    0.618033988749895
+
+**References**
+
+1. http://mathworld.wolfram.com/FibonacciNumber.html
+"""
+
+altzeta = r"""
+Gives the Dirichlet eta function, `\eta(s)`, also known as the
+alternating zeta function. This function is defined in analogy
+with the Riemann zeta function as providing the sum of the
+alternating series
+
+.. math ::
+
+    \eta(s) = \sum_{k=0}^{\infty} \frac{(-1)^k}{k^s}
+        = 1-\frac{1}{2^s}+\frac{1}{3^s}-\frac{1}{4^s}+\ldots
+
+The eta function, unlike the Riemann zeta function, is an entire
+function, having a finite value for all complex `s`. The special case
+`\eta(1) = \log(2)` gives the value of the alternating harmonic series.
+
+The alternating zeta function may expressed using the Riemann zeta function
+as `\eta(s) = (1 - 2^{1-s}) \zeta(s)`. It can also be expressed
+in terms of the Hurwitz zeta function, for example using
+:func:`~mpmath.dirichlet` (see documentation for that function).
+
+**Examples**
+
+Some special values are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> altzeta(1)
+    0.693147180559945
+    >>> altzeta(0)
+    0.5
+    >>> altzeta(-1)
+    0.25
+    >>> altzeta(-2)
+    0.0
+
+An example of a sum that can be computed more accurately and
+efficiently via :func:`~mpmath.altzeta` than via numerical summation::
+
+    >>> sum(-(-1)**n / mpf(n)**2.5 for n in range(1, 100))
+    0.867204951503984
+    >>> altzeta(2.5)
+    0.867199889012184
+
+At positive even integers, the Dirichlet eta function
+evaluates to a rational multiple of a power of `\pi`::
+
+    >>> altzeta(2)
+    0.822467033424113
+    >>> pi**2/12
+    0.822467033424113
+
+Like the Riemann zeta function, `\eta(s)`, approaches 1
+as `s` approaches positive infinity, although it does
+so from below rather than from above::
+
+    >>> altzeta(30)
+    0.999999999068682
+    >>> altzeta(inf)
+    1.0
+    >>> mp.pretty = False
+    >>> altzeta(1000, rounding='d')
+    mpf('0.99999999999999989')
+    >>> altzeta(1000, rounding='u')
+    mpf('1.0')
+
+**References**
+
+1. http://mathworld.wolfram.com/DirichletEtaFunction.html
+
+2. http://en.wikipedia.org/wiki/Dirichlet_eta_function
+"""
+
+factorial = r"""
+Computes the factorial, `x!`. For integers `n \ge 0`, we have
+`n! = 1 \cdot 2 \cdots (n-1) \cdot n` and more generally the factorial
+is defined for real or complex `x` by `x! = \Gamma(x+1)`.
+
+**Examples**
+
+Basic values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for k in range(6):
+    ...     print("%s %s" % (k, fac(k)))
+    ...
+    0 1.0
+    1 1.0
+    2 2.0
+    3 6.0
+    4 24.0
+    5 120.0
+    >>> fac(inf)
+    +inf
+    >>> fac(0.5), sqrt(pi)/2
+    (0.886226925452758, 0.886226925452758)
+
+For large positive `x`, `x!` can be approximated by
+Stirling's formula::
+
+    >>> x = 10**10
+    >>> fac(x)
+    2.32579620567308e+95657055186
+    >>> sqrt(2*pi*x)*(x/e)**x
+    2.32579597597705e+95657055186
+
+:func:`~mpmath.fac` supports evaluation for astronomically large values::
+
+    >>> fac(10**30)
+    6.22311232304258e+29565705518096748172348871081098
+
+Reciprocal factorials appear in the Taylor series of the
+exponential function (among many other contexts)::
+
+    >>> nsum(lambda k: 1/fac(k), [0, inf]), exp(1)
+    (2.71828182845905, 2.71828182845905)
+    >>> nsum(lambda k: pi**k/fac(k), [0, inf]), exp(pi)
+    (23.1406926327793, 23.1406926327793)
+
+"""
+
+gamma = r"""
+Computes the gamma function, `\Gamma(x)`. The gamma function is a
+shifted version of the ordinary factorial, satisfying
+`\Gamma(n) = (n-1)!` for integers `n > 0`. More generally, it
+is defined by
+
+.. math ::
+
+    \Gamma(x) = \int_0^{\infty} t^{x-1} e^{-t}\, dt
+
+for any real or complex `x` with `\Re(x) > 0` and for `\Re(x) < 0`
+by analytic continuation.
+
+**Examples**
+
+Basic values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for k in range(1, 6):
+    ...     print("%s %s" % (k, gamma(k)))
+    ...
+    1 1.0
+    2 1.0
+    3 2.0
+    4 6.0
+    5 24.0
+    >>> gamma(inf)
+    +inf
+    >>> gamma(0)
+    Traceback (most recent call last):
+      ...
+    ValueError: gamma function pole
+
+The gamma function of a half-integer is a rational multiple of
+`\sqrt{\pi}`::
+
+    >>> gamma(0.5), sqrt(pi)
+    (1.77245385090552, 1.77245385090552)
+    >>> gamma(1.5), sqrt(pi)/2
+    (0.886226925452758, 0.886226925452758)
+
+We can check the integral definition::
+
+    >>> gamma(3.5)
+    3.32335097044784
+    >>> quad(lambda t: t**2.5*exp(-t), [0,inf])
+    3.32335097044784
+
+:func:`~mpmath.gamma` supports arbitrary-precision evaluation and
+complex arguments::
+
+    >>> mp.dps = 50
+    >>> gamma(sqrt(3))
+    0.91510229697308632046045539308226554038315280564184
+    >>> mp.dps = 25
+    >>> gamma(2j)
+    (0.009902440080927490985955066 - 0.07595200133501806872408048j)
+
+Arguments can also be large. Note that the gamma function grows
+very quickly::
+
+    >>> mp.dps = 15
+    >>> gamma(10**20)
+    1.9328495143101e+1956570551809674817225
+
+**References**
+
+* [Spouge]_
+
+"""
+
+psi = r"""
+Gives the polygamma function of order `m` of `z`, `\psi^{(m)}(z)`.
+Special cases are known as the *digamma function* (`\psi^{(0)}(z)`),
+the *trigamma function* (`\psi^{(1)}(z)`), etc. The polygamma
+functions are defined as the logarithmic derivatives of the gamma
+function:
+
+.. math ::
+
+    \psi^{(m)}(z) = \left(\frac{d}{dz}\right)^{m+1} \log \Gamma(z)
+
+In particular, `\psi^{(0)}(z) = \Gamma'(z)/\Gamma(z)`. In the
+present implementation of :func:`~mpmath.psi`, the order `m` must be a
+nonnegative integer, while the argument `z` may be an arbitrary
+complex number (with exception for the polygamma function's poles
+at `z = 0, -1, -2, \ldots`).
+
+**Examples**
+
+For various rational arguments, the polygamma function reduces to
+a combination of standard mathematical constants::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> psi(0, 1), -euler
+    (-0.5772156649015328606065121, -0.5772156649015328606065121)
+    >>> psi(1, '1/4'), pi**2+8*catalan
+    (17.19732915450711073927132, 17.19732915450711073927132)
+    >>> psi(2, '1/2'), -14*apery
+    (-16.82879664423431999559633, -16.82879664423431999559633)
+
+The polygamma functions are derivatives of each other::
+
+    >>> diff(lambda x: psi(3, x), pi), psi(4, pi)
+    (-0.1105749312578862734526952, -0.1105749312578862734526952)
+    >>> quad(lambda x: psi(4, x), [2, 3]), psi(3,3)-psi(3,2)
+    (-0.375, -0.375)
+
+The digamma function diverges logarithmically as `z \to \infty`,
+while higher orders tend to zero::
+
+    >>> psi(0,inf), psi(1,inf), psi(2,inf)
+    (+inf, 0.0, 0.0)
+
+Evaluation for a complex argument::
+
+    >>> psi(2, -1-2j)
+    (0.03902435405364952654838445 + 0.1574325240413029954685366j)
+
+Evaluation is supported for large orders `m` and/or large
+arguments `z`::
+
+    >>> psi(3, 10**100)
+    2.0e-300
+    >>> psi(250, 10**30+10**20*j)
+    (-1.293142504363642687204865e-7010 + 3.232856260909107391513108e-7018j)
+
+**Application to infinite series**
+
+Any infinite series where the summand is a rational function of
+the index `k` can be evaluated in closed form in terms of polygamma
+functions of the roots and poles of the summand::
+
+    >>> a = sqrt(2)
+    >>> b = sqrt(3)
+    >>> nsum(lambda k: 1/((k+a)**2*(k+b)), [0, inf])
+    0.4049668927517857061917531
+    >>> (psi(0,a)-psi(0,b)-a*psi(1,a)+b*psi(1,a))/(a-b)**2
+    0.4049668927517857061917531
+
+This follows from the series representation (`m > 0`)
+
+.. math ::
+
+    \psi^{(m)}(z) = (-1)^{m+1} m! \sum_{k=0}^{\infty}
+        \frac{1}{(z+k)^{m+1}}.
+
+Since the roots of a polynomial may be complex, it is sometimes
+necessary to use the complex polygamma function to evaluate
+an entirely real-valued sum::
+
+    >>> nsum(lambda k: 1/(k**2-2*k+3), [0, inf])
+    1.694361433907061256154665
+    >>> nprint(polyroots([1,-2,3]))
+    [(1.0 - 1.41421j), (1.0 + 1.41421j)]
+    >>> r1 = 1-sqrt(2)*j
+    >>> r2 = r1.conjugate()
+    >>> (psi(0,-r2)-psi(0,-r1))/(r1-r2)
+    (1.694361433907061256154665 + 0.0j)
+
+"""
+
+digamma = r"""
+Shortcut for ``psi(0,z)``.
+"""
+
+harmonic = r"""
+If `n` is an integer, ``harmonic(n)`` gives a floating-point
+approximation of the `n`-th harmonic number `H(n)`, defined as
+
+.. math ::
+
+    H(n) = 1 + \frac{1}{2} + \frac{1}{3} + \ldots + \frac{1}{n}
+
+The first few harmonic numbers are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(8):
+    ...     print("%s %s" % (n, harmonic(n)))
+    ...
+    0 0.0
+    1 1.0
+    2 1.5
+    3 1.83333333333333
+    4 2.08333333333333
+    5 2.28333333333333
+    6 2.45
+    7 2.59285714285714
+
+The infinite harmonic series `1 + 1/2 + 1/3 + \ldots` diverges::
+
+    >>> harmonic(inf)
+    +inf
+
+:func:`~mpmath.harmonic` is evaluated using the digamma function rather
+than by summing the harmonic series term by term. It can therefore
+be computed quickly for arbitrarily large `n`, and even for
+nonintegral arguments::
+
+    >>> harmonic(10**100)
+    230.835724964306
+    >>> harmonic(0.5)
+    0.613705638880109
+    >>> harmonic(3+4j)
+    (2.24757548223494 + 0.850502209186044j)
+
+:func:`~mpmath.harmonic` supports arbitrary precision evaluation::
+
+    >>> mp.dps = 50
+    >>> harmonic(11)
+    3.0198773448773448773448773448773448773448773448773
+    >>> harmonic(pi)
+    1.8727388590273302654363491032336134987519132374152
+
+The harmonic series diverges, but at a glacial pace. It is possible
+to calculate the exact number of terms required before the sum
+exceeds a given amount, say 100::
+
+    >>> mp.dps = 50
+    >>> v = 10**findroot(lambda x: harmonic(10**x) - 100, 10)
+    >>> v
+    15092688622113788323693563264538101449859496.864101
+    >>> v = int(ceil(v))
+    >>> print(v)
+    15092688622113788323693563264538101449859497
+    >>> harmonic(v-1)
+    99.999999999999999999999999999999999999999999942747
+    >>> harmonic(v)
+    100.000000000000000000000000000000000000000000009
+
+"""
+
+bernoulli = r"""
+Computes the nth Bernoulli number, `B_n`, for any integer `n \ge 0`.
+
+The Bernoulli numbers are rational numbers, but this function
+returns a floating-point approximation. To obtain an exact
+fraction, use :func:`~mpmath.bernfrac` instead.
+
+**Examples**
+
+Numerical values of the first few Bernoulli numbers::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(15):
+    ...     print("%s %s" % (n, bernoulli(n)))
+    ...
+    0 1.0
+    1 -0.5
+    2 0.166666666666667
+    3 0.0
+    4 -0.0333333333333333
+    5 0.0
+    6 0.0238095238095238
+    7 0.0
+    8 -0.0333333333333333
+    9 0.0
+    10 0.0757575757575758
+    11 0.0
+    12 -0.253113553113553
+    13 0.0
+    14 1.16666666666667
+
+Bernoulli numbers can be approximated with arbitrary precision::
+
+    >>> mp.dps = 50
+    >>> bernoulli(100)
+    -2.8382249570693706959264156336481764738284680928013e+78
+
+Arbitrarily large `n` are supported::
+
+    >>> mp.dps = 15
+    >>> bernoulli(10**20 + 2)
+    3.09136296657021e+1876752564973863312327
+
+The Bernoulli numbers are related to the Riemann zeta function
+at integer arguments::
+
+    >>> -bernoulli(8) * (2*pi)**8 / (2*fac(8))
+    1.00407735619794
+    >>> zeta(8)
+    1.00407735619794
+
+**Algorithm**
+
+For small `n` (`n < 3000`) :func:`~mpmath.bernoulli` uses a recurrence
+formula due to Ramanujan. All results in this range are cached,
+so sequential computation of small Bernoulli numbers is
+guaranteed to be fast.
+
+For larger `n`, `B_n` is evaluated in terms of the Riemann zeta
+function.
+"""
+
+stieltjes = r"""
+For a nonnegative integer `n`, ``stieltjes(n)`` computes the
+`n`-th Stieltjes constant `\gamma_n`, defined as the
+`n`-th coefficient in the Laurent series expansion of the
+Riemann zeta function around the pole at `s = 1`. That is,
+we have:
+
+.. math ::
+
+  \zeta(s) = \frac{1}{s-1} \sum_{n=0}^{\infty}
+      \frac{(-1)^n}{n!} \gamma_n (s-1)^n
+
+More generally, ``stieltjes(n, a)`` gives the corresponding
+coefficient `\gamma_n(a)` for the Hurwitz zeta function
+`\zeta(s,a)` (with `\gamma_n = \gamma_n(1)`).
+
+**Examples**
+
+The zeroth Stieltjes constant is just Euler's constant `\gamma`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> stieltjes(0)
+    0.577215664901533
+
+Some more values are::
+
+    >>> stieltjes(1)
+    -0.0728158454836767
+    >>> stieltjes(10)
+    0.000205332814909065
+    >>> stieltjes(30)
+    0.00355772885557316
+    >>> stieltjes(1000)
+    -1.57095384420474e+486
+    >>> stieltjes(2000)
+    2.680424678918e+1109
+    >>> stieltjes(1, 2.5)
+    -0.23747539175716
+
+An alternative way to compute `\gamma_1`::
+
+    >>> diff(extradps(15)(lambda x: 1/(x-1) - zeta(x)), 1)
+    -0.0728158454836767
+
+:func:`~mpmath.stieltjes` supports arbitrary precision evaluation::
+
+    >>> mp.dps = 50
+    >>> stieltjes(2)
+    -0.0096903631928723184845303860352125293590658061013408
+
+**Algorithm**
+
+:func:`~mpmath.stieltjes` numerically evaluates the integral in
+the following representation due to Ainsworth, Howell and
+Coffey [1], [2]:
+
+.. math ::
+
+  \gamma_n(a) = \frac{\log^n a}{2a} - \frac{\log^{n+1}(a)}{n+1} +
+      \frac{2}{a} \Re \int_0^{\infty}
+      \frac{(x/a-i)\log^n(a-ix)}{(1+x^2/a^2)(e^{2\pi x}-1)} dx.
+
+For some reference values with `a = 1`, see e.g. [4].
+
+**References**
+
+1. O. R. Ainsworth & L. W. Howell, "An integral representation of
+   the generalized Euler-Mascheroni constants", NASA Technical
+   Paper 2456 (1985),
+   http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19850014994_1985014994.pdf
+
+2. M. W. Coffey, "The Stieltjes constants, their relation to the
+   `\eta_j` coefficients, and representation of the Hurwitz
+   zeta function", 	arXiv:0706.0343v1 http://arxiv.org/abs/0706.0343
+
+3. http://mathworld.wolfram.com/StieltjesConstants.html
+
+4. http://pi.lacim.uqam.ca/piDATA/stieltjesgamma.txt
+
+"""
+
+gammaprod = r"""
+Given iterables `a` and `b`, ``gammaprod(a, b)`` computes the
+product / quotient of gamma functions:
+
+.. math ::
+
+    \frac{\Gamma(a_0) \Gamma(a_1) \cdots \Gamma(a_p)}
+         {\Gamma(b_0) \Gamma(b_1) \cdots \Gamma(b_q)}
+
+Unlike direct calls to :func:`~mpmath.gamma`, :func:`~mpmath.gammaprod` considers
+the entire product as a limit and evaluates this limit properly if
+any of the numerator or denominator arguments are nonpositive
+integers such that poles of the gamma function are encountered.
+That is, :func:`~mpmath.gammaprod` evaluates
+
+.. math ::
+
+    \lim_{\epsilon \to 0}
+    \frac{\Gamma(a_0+\epsilon) \Gamma(a_1+\epsilon) \cdots
+        \Gamma(a_p+\epsilon)}
+         {\Gamma(b_0+\epsilon) \Gamma(b_1+\epsilon) \cdots
+        \Gamma(b_q+\epsilon)}
+
+In particular:
+
+* If there are equally many poles in the numerator and the
+  denominator, the limit is a rational number times the remaining,
+  regular part of the product.
+
+* If there are more poles in the numerator, :func:`~mpmath.gammaprod`
+  returns ``+inf``.
+
+* If there are more poles in the denominator, :func:`~mpmath.gammaprod`
+  returns 0.
+
+**Examples**
+
+The reciprocal gamma function `1/\Gamma(x)` evaluated at `x = 0`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15
+    >>> gammaprod([], [0])
+    0.0
+
+A limit::
+
+    >>> gammaprod([-4], [-3])
+    -0.25
+    >>> limit(lambda x: gamma(x-1)/gamma(x), -3, direction=1)
+    -0.25
+    >>> limit(lambda x: gamma(x-1)/gamma(x), -3, direction=-1)
+    -0.25
+
+"""
+
+beta = r"""
+Computes the beta function,
+`B(x,y) = \Gamma(x) \Gamma(y) / \Gamma(x+y)`.
+The beta function is also commonly defined by the integral
+representation
+
+.. math ::
+
+    B(x,y) = \int_0^1 t^{x-1} (1-t)^{y-1} \, dt
+
+**Examples**
+
+For integer and half-integer arguments where all three gamma
+functions are finite, the beta function becomes either rational
+number or a rational multiple of `\pi`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> beta(5, 2)
+    0.0333333333333333
+    >>> beta(1.5, 2)
+    0.266666666666667
+    >>> 16*beta(2.5, 1.5)
+    3.14159265358979
+
+Where appropriate, :func:`~mpmath.beta` evaluates limits. A pole
+of the beta function is taken to result in ``+inf``::
+
+    >>> beta(-0.5, 0.5)
+    0.0
+    >>> beta(-3, 3)
+    -0.333333333333333
+    >>> beta(-2, 3)
+    +inf
+    >>> beta(inf, 1)
+    0.0
+    >>> beta(inf, 0)
+    nan
+
+:func:`~mpmath.beta` supports complex numbers and arbitrary precision
+evaluation::
+
+    >>> beta(1, 2+j)
+    (0.4 - 0.2j)
+    >>> mp.dps = 25
+    >>> beta(j,0.5)
+    (1.079424249270925780135675 - 1.410032405664160838288752j)
+    >>> mp.dps = 50
+    >>> beta(pi, e)
+    0.037890298781212201348153837138927165984170287886464
+
+Various integrals can be computed by means of the
+beta function::
+
+    >>> mp.dps = 15
+    >>> quad(lambda t: t**2.5*(1-t)**2, [0, 1])
+    0.0230880230880231
+    >>> beta(3.5, 3)
+    0.0230880230880231
+    >>> quad(lambda t: sin(t)**4 * sqrt(cos(t)), [0, pi/2])
+    0.319504062596158
+    >>> beta(2.5, 0.75)/2
+    0.319504062596158
+
+"""
+
+betainc = r"""
+``betainc(a, b, x1=0, x2=1, regularized=False)`` gives the generalized
+incomplete beta function,
+
+.. math ::
+
+    I_{x_1}^{x_2}(a,b) = \int_{x_1}^{x_2} t^{a-1} (1-t)^{b-1} dt.
+
+When `x_1 = 0, x_2 = 1`, this reduces to the ordinary (complete)
+beta function `B(a,b)`; see :func:`~mpmath.beta`.
+
+With the keyword argument ``regularized=True``, :func:`~mpmath.betainc`
+computes the regularized incomplete beta function
+`I_{x_1}^{x_2}(a,b) / B(a,b)`. This is the cumulative distribution of the
+beta distribution with parameters `a`, `b`.
+
+.. note :
+
+    Implementations of the incomplete beta function in some other
+    software uses a different argument order. For example, Mathematica uses the
+    reversed argument order ``Beta[x1,x2,a,b]``. For the equivalent of SciPy's
+    three-argument incomplete beta integral (implicitly with `x1 = 0`), use
+    ``betainc(a,b,0,x2,regularized=True)``.
+
+**Examples**
+
+Verifying that :func:`~mpmath.betainc` computes the integral in the
+definition::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> x,y,a,b = 3, 4, 0, 6
+    >>> betainc(x, y, a, b)
+    -4010.4
+    >>> quad(lambda t: t**(x-1) * (1-t)**(y-1), [a, b])
+    -4010.4
+
+The arguments may be arbitrary complex numbers::
+
+    >>> betainc(0.75, 1-4j, 0, 2+3j)
+    (0.2241657956955709603655887 + 0.3619619242700451992411724j)
+
+With regularization::
+
+    >>> betainc(1, 2, 0, 0.25, regularized=True)
+    0.4375
+    >>> betainc(pi, e, 0, 1, regularized=True)   # Complete
+    1.0
+
+The beta integral satisfies some simple argument transformation
+symmetries::
+
+    >>> mp.dps = 15
+    >>> betainc(2,3,4,5), -betainc(2,3,5,4), betainc(3,2,1-5,1-4)
+    (56.0833333333333, 56.0833333333333, 56.0833333333333)
+
+The beta integral can often be evaluated analytically. For integer and
+rational arguments, the incomplete beta function typically reduces to a
+simple algebraic-logarithmic expression::
+
+    >>> mp.dps = 25
+    >>> identify(chop(betainc(0, 0, 3, 4)))
+    '-(log((9/8)))'
+    >>> identify(betainc(2, 3, 4, 5))
+    '(673/12)'
+    >>> identify(betainc(1.5, 1, 1, 2))
+    '((-12+sqrt(1152))/18)'
+
+"""
+
+binomial = r"""
+Computes the binomial coefficient
+
+.. math ::
+
+    {n \choose k} = \frac{n!}{k!(n-k)!}.
+
+The binomial coefficient gives the number of ways that `k` items
+can be chosen from a set of `n` items. More generally, the binomial
+coefficient is a well-defined function of arbitrary real or
+complex `n` and `k`, via the gamma function.
+
+**Examples**
+
+Generate Pascal's triangle::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(5):
+    ...     nprint([binomial(n,k) for k in range(n+1)])
+    ...
+    [1.0]
+    [1.0, 1.0]
+    [1.0, 2.0, 1.0]
+    [1.0, 3.0, 3.0, 1.0]
+    [1.0, 4.0, 6.0, 4.0, 1.0]
+
+There is 1 way to select 0 items from the empty set, and 0 ways to
+select 1 item from the empty set::
+
+    >>> binomial(0, 0)
+    1.0
+    >>> binomial(0, 1)
+    0.0
+
+:func:`~mpmath.binomial` supports large arguments::
+
+    >>> binomial(10**20, 10**20-5)
+    8.33333333333333e+97
+    >>> binomial(10**20, 10**10)
+    2.60784095465201e+104342944813
+
+Nonintegral binomial coefficients find use in series
+expansions::
+
+    >>> nprint(taylor(lambda x: (1+x)**0.25, 0, 4))
+    [1.0, 0.25, -0.09375, 0.0546875, -0.0375977]
+    >>> nprint([binomial(0.25, k) for k in range(5)])
+    [1.0, 0.25, -0.09375, 0.0546875, -0.0375977]
+
+An integral representation::
+
+    >>> n, k = 5, 3
+    >>> f = lambda t: exp(-j*k*t)*(1+exp(j*t))**n
+    >>> chop(quad(f, [-pi,pi])/(2*pi))
+    10.0
+    >>> binomial(n,k)
+    10.0
+
+"""
+
+rf = r"""
+Computes the rising factorial or Pochhammer symbol,
+
+.. math ::
+
+    x^{(n)} = x (x+1) \cdots (x+n-1) = \frac{\Gamma(x+n)}{\Gamma(x)}
+
+where the rightmost expression is valid for nonintegral `n`.
+
+**Examples**
+
+For integral `n`, the rising factorial is a polynomial::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(5):
+    ...     nprint(taylor(lambda x: rf(x,n), 0, n))
+    ...
+    [1.0]
+    [0.0, 1.0]
+    [0.0, 1.0, 1.0]
+    [0.0, 2.0, 3.0, 1.0]
+    [0.0, 6.0, 11.0, 6.0, 1.0]
+
+Evaluation is supported for arbitrary arguments::
+
+    >>> rf(2+3j, 5.5)
+    (-7202.03920483347 - 3777.58810701527j)
+"""
+
+ff = r"""
+Computes the falling factorial,
+
+.. math ::
+
+    (x)_n = x (x-1) \cdots (x-n+1) = \frac{\Gamma(x+1)}{\Gamma(x-n+1)}
+
+where the rightmost expression is valid for nonintegral `n`.
+
+**Examples**
+
+For integral `n`, the falling factorial is a polynomial::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(5):
+    ...     nprint(taylor(lambda x: ff(x,n), 0, n))
+    ...
+    [1.0]
+    [0.0, 1.0]
+    [0.0, -1.0, 1.0]
+    [0.0, 2.0, -3.0, 1.0]
+    [0.0, -6.0, 11.0, -6.0, 1.0]
+
+Evaluation is supported for arbitrary arguments::
+
+    >>> ff(2+3j, 5.5)
+    (-720.41085888203 + 316.101124983878j)
+"""
+
+fac2 = r"""
+Computes the double factorial `x!!`, defined for integers
+`x > 0` by
+
+.. math ::
+
+    x!! = \begin{cases}
+        1 \cdot 3 \cdots (x-2) \cdot x & x \;\mathrm{odd} \\
+        2 \cdot 4 \cdots (x-2) \cdot x & x \;\mathrm{even}
+    \end{cases}
+
+and more generally by [1]
+
+.. math ::
+
+    x!! = 2^{x/2} \left(\frac{\pi}{2}\right)^{(\cos(\pi x)-1)/4}
+          \Gamma\left(\frac{x}{2}+1\right).
+
+**Examples**
+
+The integer sequence of double factorials begins::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> nprint([fac2(n) for n in range(10)])
+    [1.0, 1.0, 2.0, 3.0, 8.0, 15.0, 48.0, 105.0, 384.0, 945.0]
+
+For large `x`, double factorials follow a Stirling-like asymptotic
+approximation::
+
+    >>> x = mpf(10000)
+    >>> fac2(x)
+    5.97272691416282e+17830
+    >>> sqrt(pi)*x**((x+1)/2)*exp(-x/2)
+    5.97262736954392e+17830
+
+The recurrence formula `x!! = x (x-2)!!` can be reversed to
+define the double factorial of negative odd integers (but
+not negative even integers)::
+
+    >>> fac2(-1), fac2(-3), fac2(-5), fac2(-7)
+    (1.0, -1.0, 0.333333333333333, -0.0666666666666667)
+    >>> fac2(-2)
+    Traceback (most recent call last):
+      ...
+    ValueError: gamma function pole
+
+With the exception of the poles at negative even integers,
+:func:`~mpmath.fac2` supports evaluation for arbitrary complex arguments.
+The recurrence formula is valid generally::
+
+    >>> fac2(pi+2j)
+    (-1.3697207890154e-12 + 3.93665300979176e-12j)
+    >>> (pi+2j)*fac2(pi-2+2j)
+    (-1.3697207890154e-12 + 3.93665300979176e-12j)
+
+Double factorials should not be confused with nested factorials,
+which are immensely larger::
+
+    >>> fac(fac(20))
+    5.13805976125208e+43675043585825292774
+    >>> fac2(20)
+    3715891200.0
+
+Double factorials appear, among other things, in series expansions
+of Gaussian functions and the error function. Infinite series
+include::
+
+    >>> nsum(lambda k: 1/fac2(k), [0, inf])
+    3.05940740534258
+    >>> sqrt(e)*(1+sqrt(pi/2)*erf(sqrt(2)/2))
+    3.05940740534258
+    >>> nsum(lambda k: 2**k/fac2(2*k-1), [1, inf])
+    4.06015693855741
+    >>> e * erf(1) * sqrt(pi)
+    4.06015693855741
+
+A beautiful Ramanujan sum::
+
+    >>> nsum(lambda k: (-1)**k*(fac2(2*k-1)/fac2(2*k))**3, [0,inf])
+    0.90917279454693
+    >>> (gamma('9/8')/gamma('5/4')/gamma('7/8'))**2
+    0.90917279454693
+
+**References**
+
+1. http://functions.wolfram.com/GammaBetaErf/Factorial2/27/01/0002/
+
+2. http://mathworld.wolfram.com/DoubleFactorial.html
+
+"""
+
+hyper = r"""
+Evaluates the generalized hypergeometric function
+
+.. math ::
+
+    \,_pF_q(a_1,\ldots,a_p; b_1,\ldots,b_q; z) =
+    \sum_{n=0}^\infty \frac{(a_1)_n (a_2)_n \ldots (a_p)_n}
+       {(b_1)_n(b_2)_n\ldots(b_q)_n} \frac{z^n}{n!}
+
+where `(x)_n` denotes the rising factorial (see :func:`~mpmath.rf`).
+
+The parameters lists ``a_s`` and ``b_s`` may contain integers,
+real numbers, complex numbers, as well as exact fractions given in
+the form of tuples `(p, q)`. :func:`~mpmath.hyper` is optimized to handle
+integers and fractions more efficiently than arbitrary
+floating-point parameters (since rational parameters are by
+far the most common).
+
+**Examples**
+
+Verifying that :func:`~mpmath.hyper` gives the sum in the definition, by
+comparison with :func:`~mpmath.nsum`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> a,b,c,d = 2,3,4,5
+    >>> x = 0.25
+    >>> hyper([a,b],[c,d],x)
+    1.078903941164934876086237
+    >>> fn = lambda n: rf(a,n)*rf(b,n)/rf(c,n)/rf(d,n)*x**n/fac(n)
+    >>> nsum(fn, [0, inf])
+    1.078903941164934876086237
+
+The parameters can be any combination of integers, fractions,
+floats and complex numbers::
+
+    >>> a, b, c, d, e = 1, (-1,2), pi, 3+4j, (2,3)
+    >>> x = 0.2j
+    >>> hyper([a,b],[c,d,e],x)
+    (0.9923571616434024810831887 - 0.005753848733883879742993122j)
+    >>> b, e = -0.5, mpf(2)/3
+    >>> fn = lambda n: rf(a,n)*rf(b,n)/rf(c,n)/rf(d,n)/rf(e,n)*x**n/fac(n)
+    >>> nsum(fn, [0, inf])
+    (0.9923571616434024810831887 - 0.005753848733883879742993122j)
+
+The `\,_0F_0` and `\,_1F_0` series are just elementary functions::
+
+    >>> a, z = sqrt(2), +pi
+    >>> hyper([],[],z)
+    23.14069263277926900572909
+    >>> exp(z)
+    23.14069263277926900572909
+    >>> hyper([a],[],z)
+    (-0.09069132879922920160334114 + 0.3283224323946162083579656j)
+    >>> (1-z)**(-a)
+    (-0.09069132879922920160334114 + 0.3283224323946162083579656j)
+
+If any `a_k` coefficient is a nonpositive integer, the series terminates
+into a finite polynomial::
+
+    >>> hyper([1,1,1,-3],[2,5],1)
+    0.7904761904761904761904762
+    >>> identify(_)
+    '(83/105)'
+
+If any `b_k` is a nonpositive integer, the function is undefined (unless the
+series terminates before the division by zero occurs)::
+
+    >>> hyper([1,1,1,-3],[-2,5],1)
+    Traceback (most recent call last):
+      ...
+    ZeroDivisionError: pole in hypergeometric series
+    >>> hyper([1,1,1,-1],[-2,5],1)
+    1.1
+
+Except for polynomial cases, the radius of convergence `R` of the hypergeometric
+series is either `R = \infty` (if `p \le q`), `R = 1` (if `p = q+1`), or
+`R = 0` (if `p > q+1`).
+
+The analytic continuations of the functions with `p = q+1`, i.e. `\,_2F_1`,
+`\,_3F_2`,  `\,_4F_3`, etc, are all implemented and therefore these functions
+can be evaluated for `|z| \ge 1`. The shortcuts :func:`~mpmath.hyp2f1`, :func:`~mpmath.hyp3f2`
+are available to handle the most common cases (see their documentation),
+but functions of higher degree are also supported via :func:`~mpmath.hyper`::
+
+    >>> hyper([1,2,3,4], [5,6,7], 1)   # 4F3 at finite-valued branch point
+    1.141783505526870731311423
+    >>> hyper([4,5,6,7], [1,2,3], 1)   # 4F3 at pole
+    +inf
+    >>> hyper([1,2,3,4,5], [6,7,8,9], 10)    # 5F4
+    (1.543998916527972259717257 - 0.5876309929580408028816365j)
+    >>> hyper([1,2,3,4,5,6], [7,8,9,10,11], 1j)   # 6F5
+    (0.9996565821853579063502466 + 0.0129721075905630604445669j)
+
+Near `z = 1` with noninteger parameters::
+
+    >>> hyper(['1/3',1,'3/2',2], ['1/5','11/6','41/8'], 1)
+    2.219433352235586121250027
+    >>> hyper(['1/3',1,'3/2',2], ['1/5','11/6','5/4'], 1)
+    +inf
+    >>> eps1 = extradps(6)(lambda: 1 - mpf('1e-6'))()
+    >>> hyper(['1/3',1,'3/2',2], ['1/5','11/6','5/4'], eps1)
+    2923978034.412973409330956
+
+Please note that, as currently implemented, evaluation of `\,_pF_{p-1}`
+with `p \ge 3` may be slow or inaccurate when `|z-1|` is small,
+for some parameter values.
+
+Evaluation may be aborted if convergence appears to be too slow.
+The optional ``maxterms`` (limiting the number of series terms) and ``maxprec``
+(limiting the internal precision) keyword arguments can be used
+to control evaluation::
+
+    >>> hyper([1,2,3], [4,5,6], 10000)              # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+      ...
+    NoConvergence: Hypergeometric series converges too slowly. Try increasing maxterms.
+    >>> hyper([1,2,3], [4,5,6], 10000, maxterms=10**6)
+    7.622806053177969474396918e+4310
+
+Additional options include ``force_series`` (which forces direct use of
+a hypergeometric series even if another evaluation method might work better)
+and ``asymp_tol`` which controls the target tolerance for using
+asymptotic series.
+
+When `p > q+1`, ``hyper`` computes the (iterated) Borel sum of the divergent
+series. For `\,_2F_0` the Borel sum has an analytic solution and can be
+computed efficiently (see :func:`~mpmath.hyp2f0`). For higher degrees, the functions
+is evaluated first by attempting to sum it directly as an asymptotic
+series (this only works for tiny `|z|`), and then by evaluating the Borel
+regularized sum using numerical integration. Except for
+special parameter combinations, this can be extremely slow.
+
+    >>> hyper([1,1], [], 0.5)          # regularization of 2F0
+    (1.340965419580146562086448 + 0.8503366631752726568782447j)
+    >>> hyper([1,1,1,1], [1], 0.5)     # regularization of 4F1
+    (1.108287213689475145830699 + 0.5327107430640678181200491j)
+
+With the following magnitude of argument, the asymptotic series for `\,_3F_1`
+gives only a few digits. Using Borel summation, ``hyper`` can produce
+a value with full accuracy::
+
+    >>> mp.dps = 15
+    >>> hyper([2,0.5,4], [5.25], '0.08', force_series=True)             # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+      ...
+    NoConvergence: Hypergeometric series converges too slowly. Try increasing maxterms.
+    >>> hyper([2,0.5,4], [5.25], '0.08', asymp_tol=1e-4)
+    1.0725535790737
+    >>> hyper([2,0.5,4], [5.25], '0.08')
+    (1.07269542893559 + 5.54668863216891e-5j)
+    >>> hyper([2,0.5,4], [5.25], '-0.08', asymp_tol=1e-4)
+    0.946344925484879
+    >>> hyper([2,0.5,4], [5.25], '-0.08')
+    0.946312503737771
+    >>> mp.dps = 25
+    >>> hyper([2,0.5,4], [5.25], '-0.08')
+    0.9463125037377662296700858
+
+Note that with the positive `z` value, there is a complex part in the
+correct result, which falls below the tolerance of the asymptotic series.
+
+By default, a parameter that appears in both ``a_s`` and ``b_s`` will be removed
+unless it is a nonpositive integer. This generally speeds up evaluation
+by producing a hypergeometric function of lower order.
+This optimization can be disabled by passing ``eliminate=False``.
+
+    >>> hyper([1,2,3], [4,5,3], 10000)
+    1.268943190440206905892212e+4321
+    >>> hyper([1,2,3], [4,5,3], 10000, eliminate=False)             # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+      ...
+    NoConvergence: Hypergeometric series converges too slowly. Try increasing maxterms.
+    >>> hyper([1,2,3], [4,5,3], 10000, eliminate=False, maxterms=10**6)
+    1.268943190440206905892212e+4321
+
+If a nonpositive integer `-n` appears in both ``a_s`` and ``b_s``, this parameter
+cannot be unambiguously removed since it creates a term 0 / 0.
+In this case the hypergeometric series is understood to terminate before
+the division by zero occurs. This convention is consistent with Mathematica.
+An alternative convention of eliminating the parameters can be toggled
+with ``eliminate_all=True``:
+
+    >>> hyper([2,-1], [-1], 3)
+    7.0
+    >>> hyper([2,-1], [-1], 3, eliminate_all=True)
+    0.25
+    >>> hyper([2], [], 3)
+    0.25
+
+"""
+
+hypercomb = r"""
+Computes a weighted combination of hypergeometric functions
+
+.. math ::
+
+    \sum_{r=1}^N \left[ \prod_{k=1}^{l_r} {w_{r,k}}^{c_{r,k}}
+    \frac{\prod_{k=1}^{m_r} \Gamma(\alpha_{r,k})}{\prod_{k=1}^{n_r}
+    \Gamma(\beta_{r,k})}
+    \,_{p_r}F_{q_r}(a_{r,1},\ldots,a_{r,p}; b_{r,1},
+    \ldots, b_{r,q}; z_r)\right].
+
+Typically the parameters are linear combinations of a small set of base
+parameters; :func:`~mpmath.hypercomb` permits computing a correct value in
+the case that some of the `\alpha`, `\beta`, `b` turn out to be
+nonpositive integers, or if division by zero occurs for some `w^c`,
+assuming that there are opposing singularities that cancel out.
+The limit is computed by evaluating the function with the base
+parameters perturbed, at a higher working precision.
+
+The first argument should be a function that takes the perturbable
+base parameters ``params`` as input and returns `N` tuples
+``(w, c, alpha, beta, a, b, z)``, where the coefficients ``w``, ``c``,
+gamma factors ``alpha``, ``beta``, and hypergeometric coefficients
+``a``, ``b`` each should be lists of numbers, and ``z`` should be a single
+number.
+
+**Examples**
+
+The following evaluates
+
+.. math ::
+
+    (a-1) \frac{\Gamma(a-3)}{\Gamma(a-4)} \,_1F_1(a,a-1,z) = e^z(a-4)(a+z-1)
+
+with `a=1, z=3`. There is a zero factor, two gamma function poles, and
+the 1F1 function is singular; all singularities cancel out to give a finite
+value::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> hypercomb(lambda a: [([a-1],[1],[a-3],[a-4],[a],[a-1],3)], [1])
+    -180.769832308689
+    >>> -9*exp(3)
+    -180.769832308689
+
+"""
+
+hyp0f1 = r"""
+Gives the hypergeometric function `\,_0F_1`, sometimes known as the
+confluent limit function, defined as
+
+.. math ::
+
+    \,_0F_1(a,z) = \sum_{k=0}^{\infty} \frac{1}{(a)_k} \frac{z^k}{k!}.
+
+This function satisfies the differential equation `z f''(z) + a f'(z) = f(z)`,
+and is related to the Bessel function of the first kind (see :func:`~mpmath.besselj`).
+
+``hyp0f1(a,z)`` is equivalent to ``hyper([],[a],z)``; see documentation for
+:func:`~mpmath.hyper` for more information.
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hyp0f1(2, 0.25)
+    1.130318207984970054415392
+    >>> hyp0f1((1,2), 1234567)
+    6.27287187546220705604627e+964
+    >>> hyp0f1(3+4j, 1000000j)
+    (3.905169561300910030267132e+606 + 3.807708544441684513934213e+606j)
+
+Evaluation is supported for arbitrarily large values of `z`,
+using asymptotic expansions::
+
+    >>> hyp0f1(1, 10**50)
+    2.131705322874965310390701e+8685889638065036553022565
+    >>> hyp0f1(1, -10**50)
+    1.115945364792025420300208e-13
+
+Verifying the differential equation::
+
+    >>> a = 2.5
+    >>> f = lambda z: hyp0f1(a,z)
+    >>> for z in [0, 10, 3+4j]:
+    ...     chop(z*diff(f,z,2) + a*diff(f,z) - f(z))
+    ...
+    0.0
+    0.0
+    0.0
+
+"""
+
+hyp1f1 = r"""
+Gives the confluent hypergeometric function of the first kind,
+
+.. math ::
+
+    \,_1F_1(a,b,z) = \sum_{k=0}^{\infty} \frac{(a)_k}{(b)_k} \frac{z^k}{k!},
+
+also known as Kummer's function and sometimes denoted by `M(a,b,z)`. This
+function gives one solution to the confluent (Kummer's) differential equation
+
+.. math ::
+
+    z f''(z) + (b-z) f'(z) - af(z) = 0.
+
+A second solution is given by the `U` function; see :func:`~mpmath.hyperu`.
+Solutions are also given in an alternate form by the Whittaker
+functions (:func:`~mpmath.whitm`, :func:`~mpmath.whitw`).
+
+``hyp1f1(a,b,z)`` is equivalent
+to ``hyper([a],[b],z)``; see documentation for :func:`~mpmath.hyper` for more
+information.
+
+**Examples**
+
+Evaluation for real and complex values of the argument `z`, with
+fixed parameters `a = 2, b = -1/3`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hyp1f1(2, (-1,3), 3.25)
+    -2815.956856924817275640248
+    >>> hyp1f1(2, (-1,3), -3.25)
+    -1.145036502407444445553107
+    >>> hyp1f1(2, (-1,3), 1000)
+    -8.021799872770764149793693e+441
+    >>> hyp1f1(2, (-1,3), -1000)
+    0.000003131987633006813594535331
+    >>> hyp1f1(2, (-1,3), 100+100j)
+    (-3.189190365227034385898282e+48 - 1.106169926814270418999315e+49j)
+
+Parameters may be complex::
+
+    >>> hyp1f1(2+3j, -1+j, 10j)
+    (261.8977905181045142673351 + 160.8930312845682213562172j)
+
+Arbitrarily large values of `z` are supported::
+
+    >>> hyp1f1(3, 4, 10**20)
+    3.890569218254486878220752e+43429448190325182745
+    >>> hyp1f1(3, 4, -10**20)
+    6.0e-60
+    >>> hyp1f1(3, 4, 10**20*j)
+    (-1.935753855797342532571597e-20 - 2.291911213325184901239155e-20j)
+
+Verifying the differential equation::
+
+    >>> a, b = 1.5, 2
+    >>> f = lambda z: hyp1f1(a,b,z)
+    >>> for z in [0, -10, 3, 3+4j]:
+    ...     chop(z*diff(f,z,2) + (b-z)*diff(f,z) - a*f(z))
+    ...
+    0.0
+    0.0
+    0.0
+    0.0
+
+An integral representation::
+
+    >>> a, b = 1.5, 3
+    >>> z = 1.5
+    >>> hyp1f1(a,b,z)
+    2.269381460919952778587441
+    >>> g = lambda t: exp(z*t)*t**(a-1)*(1-t)**(b-a-1)
+    >>> gammaprod([b],[a,b-a])*quad(g, [0,1])
+    2.269381460919952778587441
+
+
+"""
+
+hyp1f2 = r"""
+Gives the hypergeometric function `\,_1F_2(a_1,a_2;b_1,b_2; z)`.
+The call ``hyp1f2(a1,b1,b2,z)`` is equivalent to
+``hyper([a1],[b1,b2],z)``.
+
+Evaluation works for complex and arbitrarily large arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> a, b, c = 1.5, (-1,3), 2.25
+    >>> hyp1f2(a, b, c, 10**20)
+    -1.159388148811981535941434e+8685889639
+    >>> hyp1f2(a, b, c, -10**20)
+    -12.60262607892655945795907
+    >>> hyp1f2(a, b, c, 10**20*j)
+    (4.237220401382240876065501e+6141851464 - 2.950930337531768015892987e+6141851464j)
+    >>> hyp1f2(2+3j, -2j, 0.5j, 10-20j)
+    (135881.9905586966432662004 - 86681.95885418079535738828j)
+
+"""
+
+hyp2f2 = r"""
+Gives the hypergeometric function `\,_2F_2(a_1,a_2;b_1,b_2; z)`.
+The call ``hyp2f2(a1,a2,b1,b2,z)`` is equivalent to
+``hyper([a1,a2],[b1,b2],z)``.
+
+Evaluation works for complex and arbitrarily large arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> a, b, c, d = 1.5, (-1,3), 2.25, 4
+    >>> hyp2f2(a, b, c, d, 10**20)
+    -5.275758229007902299823821e+43429448190325182663
+    >>> hyp2f2(a, b, c, d, -10**20)
+    2561445.079983207701073448
+    >>> hyp2f2(a, b, c, d, 10**20*j)
+    (2218276.509664121194836667 - 1280722.539991603850462856j)
+    >>> hyp2f2(2+3j, -2j, 0.5j, 4j, 10-20j)
+    (80500.68321405666957342788 - 20346.82752982813540993502j)
+
+"""
+
+hyp2f3 = r"""
+Gives the hypergeometric function `\,_2F_3(a_1,a_2;b_1,b_2,b_3; z)`.
+The call ``hyp2f3(a1,a2,b1,b2,b3,z)`` is equivalent to
+``hyper([a1,a2],[b1,b2,b3],z)``.
+
+Evaluation works for arbitrarily large arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> a1,a2,b1,b2,b3 = 1.5, (-1,3), 2.25, 4, (1,5)
+    >>> hyp2f3(a1,a2,b1,b2,b3,10**20)
+    -4.169178177065714963568963e+8685889590
+    >>> hyp2f3(a1,a2,b1,b2,b3,-10**20)
+    7064472.587757755088178629
+    >>> hyp2f3(a1,a2,b1,b2,b3,10**20*j)
+    (-5.163368465314934589818543e+6141851415 + 1.783578125755972803440364e+6141851416j)
+    >>> hyp2f3(2+3j, -2j, 0.5j, 4j, -1-j, 10-20j)
+    (-2280.938956687033150740228 + 13620.97336609573659199632j)
+    >>> hyp2f3(2+3j, -2j, 0.5j, 4j, -1-j, 10000000-20000000j)
+    (4.849835186175096516193e+3504 - 3.365981529122220091353633e+3504j)
+
+"""
+
+hyp2f1 = r"""
+Gives the Gauss hypergeometric function `\,_2F_1` (often simply referred to as
+*the* hypergeometric function), defined for `|z| < 1` as
+
+.. math ::
+
+    \,_2F_1(a,b,c,z) = \sum_{k=0}^{\infty}
+        \frac{(a)_k (b)_k}{(c)_k} \frac{z^k}{k!}.
+
+and for `|z| \ge 1` by analytic continuation, with a branch cut on `(1, \infty)`
+when necessary.
+
+Special cases of this function include many of the orthogonal polynomials as
+well as the incomplete beta function and other functions. Properties of the
+Gauss hypergeometric function are documented comprehensively in many references,
+for example Abramowitz & Stegun, section 15.
+
+The implementation supports the analytic continuation as well as evaluation
+close to the unit circle where `|z| \approx 1`. The syntax ``hyp2f1(a,b,c,z)``
+is equivalent to ``hyper([a,b],[c],z)``.
+
+**Examples**
+
+Evaluation with `z` inside, outside and on the unit circle, for
+fixed parameters::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hyp2f1(2, (1,2), 4, 0.75)
+    1.303703703703703703703704
+    >>> hyp2f1(2, (1,2), 4, -1.75)
+    0.7431290566046919177853916
+    >>> hyp2f1(2, (1,2), 4, 1.75)
+    (1.418075801749271137026239 - 1.114976146679907015775102j)
+    >>> hyp2f1(2, (1,2), 4, 1)
+    1.6
+    >>> hyp2f1(2, (1,2), 4, -1)
+    0.8235498012182875315037882
+    >>> hyp2f1(2, (1,2), 4, j)
+    (0.9144026291433065674259078 + 0.2050415770437884900574923j)
+    >>> hyp2f1(2, (1,2), 4, 2+j)
+    (0.9274013540258103029011549 + 0.7455257875808100868984496j)
+    >>> hyp2f1(2, (1,2), 4, 0.25j)
+    (0.9931169055799728251931672 + 0.06154836525312066938147793j)
+
+Evaluation with complex parameter values::
+
+    >>> hyp2f1(1+j, 0.75, 10j, 1+5j)
+    (0.8834833319713479923389638 + 0.7053886880648105068343509j)
+
+Evaluation with `z = 1`::
+
+    >>> hyp2f1(-2.5, 3.5, 1.5, 1)
+    0.0
+    >>> hyp2f1(-2.5, 3, 4, 1)
+    0.06926406926406926406926407
+    >>> hyp2f1(2, 3, 4, 1)
+    +inf
+
+Evaluation for huge arguments::
+
+    >>> hyp2f1((-1,3), 1.75, 4, '1e100')
+    (7.883714220959876246415651e+32 + 1.365499358305579597618785e+33j)
+    >>> hyp2f1((-1,3), 1.75, 4, '1e1000000')
+    (7.883714220959876246415651e+333332 + 1.365499358305579597618785e+333333j)
+    >>> hyp2f1((-1,3), 1.75, 4, '1e1000000j')
+    (1.365499358305579597618785e+333333 - 7.883714220959876246415651e+333332j)
+
+An integral representation::
+
+    >>> a,b,c,z = -0.5, 1, 2.5, 0.25
+    >>> g = lambda t: t**(b-1) * (1-t)**(c-b-1) * (1-t*z)**(-a)
+    >>> gammaprod([c],[b,c-b]) * quad(g, [0,1])
+    0.9480458814362824478852618
+    >>> hyp2f1(a,b,c,z)
+    0.9480458814362824478852618
+
+Verifying the hypergeometric differential equation::
+
+    >>> f = lambda z: hyp2f1(a,b,c,z)
+    >>> chop(z*(1-z)*diff(f,z,2) + (c-(a+b+1)*z)*diff(f,z) - a*b*f(z))
+    0.0
+
+"""
+
+hyp3f2 = r"""
+Gives the generalized hypergeometric function `\,_3F_2`, defined for `|z| < 1`
+as
+
+.. math ::
+
+    \,_3F_2(a_1,a_2,a_3,b_1,b_2,z) = \sum_{k=0}^{\infty}
+        \frac{(a_1)_k (a_2)_k (a_3)_k}{(b_1)_k (b_2)_k} \frac{z^k}{k!}.
+
+and for `|z| \ge 1` by analytic continuation. The analytic structure of this
+function is similar to that of `\,_2F_1`, generally with a singularity at
+`z = 1` and a branch cut on `(1, \infty)`.
+
+Evaluation is supported inside, on, and outside
+the circle of convergence `|z| = 1`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hyp3f2(1,2,3,4,5,0.25)
+    1.083533123380934241548707
+    >>> hyp3f2(1,2+2j,3,4,5,-10+10j)
+    (0.1574651066006004632914361 - 0.03194209021885226400892963j)
+    >>> hyp3f2(1,2,3,4,5,-10)
+    0.3071141169208772603266489
+    >>> hyp3f2(1,2,3,4,5,10)
+    (-0.4857045320523947050581423 - 0.5988311440454888436888028j)
+    >>> hyp3f2(0.25,1,1,2,1.5,1)
+    1.157370995096772047567631
+    >>> (8-pi-2*ln2)/3
+    1.157370995096772047567631
+    >>> hyp3f2(1+j,0.5j,2,1,-2j,-1)
+    (1.74518490615029486475959 + 0.1454701525056682297614029j)
+    >>> hyp3f2(1+j,0.5j,2,1,-2j,sqrt(j))
+    (0.9829816481834277511138055 - 0.4059040020276937085081127j)
+    >>> hyp3f2(-3,2,1,-5,4,1)
+    1.41
+    >>> hyp3f2(-3,2,1,-5,4,2)
+    2.12
+
+Evaluation very close to the unit circle::
+
+    >>> hyp3f2(1,2,3,4,5,'1.0001')
+    (1.564877796743282766872279 - 3.76821518787438186031973e-11j)
+    >>> hyp3f2(1,2,3,4,5,'1+0.0001j')
+    (1.564747153061671573212831 + 0.0001305757570366084557648482j)
+    >>> hyp3f2(1,2,3,4,5,'0.9999')
+    1.564616644881686134983664
+    >>> hyp3f2(1,2,3,4,5,'-0.9999')
+    0.7823896253461678060196207
+
+.. note ::
+
+    Evaluation for `|z-1|` small can currently be inaccurate or slow
+    for some parameter combinations.
+
+For various parameter combinations, `\,_3F_2` admits representation in terms
+of hypergeometric functions of lower degree, or in terms of
+simpler functions::
+
+    >>> for a, b, z in [(1,2,-1), (2,0.5,1)]:
+    ...     hyp2f1(a,b,a+b+0.5,z)**2
+    ...     hyp3f2(2*a,a+b,2*b,a+b+0.5,2*a+2*b,z)
+    ...
+    0.4246104461966439006086308
+    0.4246104461966439006086308
+    7.111111111111111111111111
+    7.111111111111111111111111
+
+    >>> z = 2+3j
+    >>> hyp3f2(0.5,1,1.5,2,2,z)
+    (0.7621440939243342419729144 + 0.4249117735058037649915723j)
+    >>> 4*(pi-2*ellipe(z))/(pi*z)
+    (0.7621440939243342419729144 + 0.4249117735058037649915723j)
+
+"""
+
+hyperu = r"""
+Gives the Tricomi confluent hypergeometric function `U`, also known as
+the Kummer or confluent hypergeometric function of the second kind. This
+function gives a second linearly independent solution to the confluent
+hypergeometric differential equation (the first is provided by `\,_1F_1`  --
+see :func:`~mpmath.hyp1f1`).
+
+**Examples**
+
+Evaluation for arbitrary complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hyperu(2,3,4)
+    0.0625
+    >>> hyperu(0.25, 5, 1000)
+    0.1779949416140579573763523
+    >>> hyperu(0.25, 5, -1000)
+    (0.1256256609322773150118907 - 0.1256256609322773150118907j)
+
+The `U` function may be singular at `z = 0`::
+
+    >>> hyperu(1.5, 2, 0)
+    +inf
+    >>> hyperu(1.5, -2, 0)
+    0.1719434921288400112603671
+
+Verifying the differential equation::
+
+    >>> a, b = 1.5, 2
+    >>> f = lambda z: hyperu(a,b,z)
+    >>> for z in [-10, 3, 3+4j]:
+    ...     chop(z*diff(f,z,2) + (b-z)*diff(f,z) - a*f(z))
+    ...
+    0.0
+    0.0
+    0.0
+
+An integral representation::
+
+    >>> a,b,z = 2, 3.5, 4.25
+    >>> hyperu(a,b,z)
+    0.06674960718150520648014567
+    >>> quad(lambda t: exp(-z*t)*t**(a-1)*(1+t)**(b-a-1),[0,inf]) / gamma(a)
+    0.06674960718150520648014567
+
+
+[1] http://people.math.sfu.ca/~cbm/aands/page_504.htm
+"""
+
+hyp2f0 = r"""
+Gives the hypergeometric function `\,_2F_0`, defined formally by the
+series
+
+.. math ::
+
+    \,_2F_0(a,b;;z) = \sum_{n=0}^{\infty} (a)_n (b)_n \frac{z^n}{n!}.
+
+This series usually does not converge. For small enough `z`, it can be viewed
+as an asymptotic series that may be summed directly with an appropriate
+truncation. When this is not the case, :func:`~mpmath.hyp2f0` gives a regularized sum,
+or equivalently, it uses a representation in terms of the
+hypergeometric U function [1]. The series also converges when either `a` or `b`
+is a nonpositive integer, as it then terminates into a polynomial
+after `-a` or `-b` terms.
+
+**Examples**
+
+Evaluation is supported for arbitrary complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hyp2f0((2,3), 1.25, -100)
+    0.07095851870980052763312791
+    >>> hyp2f0((2,3), 1.25, 100)
+    (-0.03254379032170590665041131 + 0.07269254613282301012735797j)
+    >>> hyp2f0(-0.75, 1-j, 4j)
+    (-0.3579987031082732264862155 - 3.052951783922142735255881j)
+
+Even with real arguments, the regularized value of 2F0 is often complex-valued,
+but the imaginary part decreases exponentially as `z \to 0`. In the following
+example, the first call uses complex evaluation while the second has a small
+enough `z` to evaluate using the direct series and thus the returned value
+is strictly real (this should be taken to indicate that the imaginary
+part is less than ``eps``)::
+
+    >>> mp.dps = 15
+    >>> hyp2f0(1.5, 0.5, 0.05)
+    (1.04166637647907 + 8.34584913683906e-8j)
+    >>> hyp2f0(1.5, 0.5, 0.0005)
+    1.00037535207621
+
+The imaginary part can be retrieved by increasing the working precision::
+
+    >>> mp.dps = 80
+    >>> nprint(hyp2f0(1.5, 0.5, 0.009).imag)
+    1.23828e-46
+
+In the polynomial case (the series terminating), 2F0 can evaluate exactly::
+
+    >>> mp.dps = 15
+    >>> hyp2f0(-6,-6,2)
+    291793.0
+    >>> identify(hyp2f0(-2,1,0.25))
+    '(5/8)'
+
+The coefficients of the polynomials can be recovered using Taylor expansion::
+
+    >>> nprint(taylor(lambda x: hyp2f0(-3,0.5,x), 0, 10))
+    [1.0, -1.5, 2.25, -1.875, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    >>> nprint(taylor(lambda x: hyp2f0(-4,0.5,x), 0, 10))
+    [1.0, -2.0, 4.5, -7.5, 6.5625, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+
+
+[1] http://people.math.sfu.ca/~cbm/aands/page_504.htm
+"""
+
+
+gammainc = r"""
+``gammainc(z, a=0, b=inf)`` computes the (generalized) incomplete
+gamma function with integration limits `[a, b]`:
+
+.. math ::
+
+  \Gamma(z,a,b) = \int_a^b t^{z-1} e^{-t} \, dt
+
+The generalized incomplete gamma function reduces to the
+following special cases when one or both endpoints are fixed:
+
+* `\Gamma(z,0,\infty)` is the standard ("complete")
+  gamma function, `\Gamma(z)` (available directly
+  as the mpmath function :func:`~mpmath.gamma`)
+* `\Gamma(z,a,\infty)` is the "upper" incomplete gamma
+  function, `\Gamma(z,a)`
+* `\Gamma(z,0,b)` is the "lower" incomplete gamma
+  function, `\gamma(z,b)`.
+
+Of course, we have
+`\Gamma(z,0,x) + \Gamma(z,x,\infty) = \Gamma(z)`
+for all `z` and `x`.
+
+Note however that some authors reverse the order of the
+arguments when defining the lower and upper incomplete
+gamma function, so one should be careful to get the correct
+definition.
+
+If also given the keyword argument ``regularized=True``,
+:func:`~mpmath.gammainc` computes the "regularized" incomplete gamma
+function
+
+.. math ::
+
+  P(z,a,b) = \frac{\Gamma(z,a,b)}{\Gamma(z)}.
+
+**Examples**
+
+We can compare with numerical quadrature to verify that
+:func:`~mpmath.gammainc` computes the integral in the definition::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> gammainc(2+3j, 4, 10)
+    (0.00977212668627705160602312 - 0.0770637306312989892451977j)
+    >>> quad(lambda t: t**(2+3j-1) * exp(-t), [4, 10])
+    (0.00977212668627705160602312 - 0.0770637306312989892451977j)
+
+Argument symmetries follow directly from the integral definition::
+
+    >>> gammainc(3, 4, 5) + gammainc(3, 5, 4)
+    0.0
+    >>> gammainc(3,0,2) + gammainc(3,2,4); gammainc(3,0,4)
+    1.523793388892911312363331
+    1.523793388892911312363331
+    >>> findroot(lambda z: gammainc(2,z,3), 1)
+    3.0
+
+Evaluation for arbitrarily large arguments::
+
+    >>> gammainc(10, 100)
+    4.083660630910611272288592e-26
+    >>> gammainc(10, 10000000000000000)
+    5.290402449901174752972486e-4342944819032375
+    >>> gammainc(3+4j, 1000000+1000000j)
+    (-1.257913707524362408877881e-434284 + 2.556691003883483531962095e-434284j)
+
+Evaluation of a generalized incomplete gamma function automatically chooses
+the representation that gives a more accurate result, depending on which
+parameter is larger::
+
+    >>> gammainc(10000000, 3) - gammainc(10000000, 2)   # Bad
+    0.0
+    >>> gammainc(10000000, 2, 3)   # Good
+    1.755146243738946045873491e+4771204
+    >>> gammainc(2, 0, 100000001) - gammainc(2, 0, 100000000)   # Bad
+    0.0
+    >>> gammainc(2, 100000000, 100000001)   # Good
+    4.078258353474186729184421e-43429441
+
+The incomplete gamma functions satisfy simple recurrence
+relations::
+
+    >>> mp.dps = 25
+    >>> z, a = mpf(3.5), mpf(2)
+    >>> gammainc(z+1, a); z*gammainc(z,a) + a**z*exp(-a)
+    10.60130296933533459267329
+    10.60130296933533459267329
+    >>> gammainc(z+1,0,a); z*gammainc(z,0,a) - a**z*exp(-a)
+    1.030425427232114336470932
+    1.030425427232114336470932
+
+Evaluation at integers and poles::
+
+    >>> gammainc(-3, -4, -5)
+    (-0.2214577048967798566234192 + 0.0j)
+    >>> gammainc(-3, 0, 5)
+    +inf
+
+If `z` is an integer, the recurrence reduces the incomplete gamma
+function to `P(a) \exp(-a) + Q(b) \exp(-b)` where `P` and
+`Q` are polynomials::
+
+    >>> gammainc(1, 2); exp(-2)
+    0.1353352832366126918939995
+    0.1353352832366126918939995
+    >>> mp.dps = 50
+    >>> identify(gammainc(6, 1, 2), ['exp(-1)', 'exp(-2)'])
+    '(326*exp(-1) + (-872)*exp(-2))'
+
+The incomplete gamma functions reduce to functions such as
+the exponential integral Ei and the error function for special
+arguments::
+
+    >>> mp.dps = 25
+    >>> gammainc(0, 4); -ei(-4)
+    0.00377935240984890647887486
+    0.00377935240984890647887486
+    >>> gammainc(0.5, 0, 2); sqrt(pi)*erf(sqrt(2))
+    1.691806732945198336509541
+    1.691806732945198336509541
+
+"""
+
+erf = r"""
+Computes the error function, `\mathrm{erf}(x)`. The error
+function is the normalized antiderivative of the Gaussian function
+`\exp(-t^2)`. More precisely,
+
+.. math::
+
+  \mathrm{erf}(x) = \frac{2}{\sqrt \pi} \int_0^x \exp(-t^2) \,dt
+
+**Basic examples**
+
+Simple values and limits include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> erf(0)
+    0.0
+    >>> erf(1)
+    0.842700792949715
+    >>> erf(-1)
+    -0.842700792949715
+    >>> erf(inf)
+    1.0
+    >>> erf(-inf)
+    -1.0
+
+For large real `x`, `\mathrm{erf}(x)` approaches 1 very
+rapidly::
+
+    >>> erf(3)
+    0.999977909503001
+    >>> erf(5)
+    0.999999999998463
+
+The error function is an odd function::
+
+    >>> nprint(chop(taylor(erf, 0, 5)))
+    [0.0, 1.12838, 0.0, -0.376126, 0.0, 0.112838]
+
+:func:`~mpmath.erf` implements arbitrary-precision evaluation and
+supports complex numbers::
+
+    >>> mp.dps = 50
+    >>> erf(0.5)
+    0.52049987781304653768274665389196452873645157575796
+    >>> mp.dps = 25
+    >>> erf(1+j)
+    (1.316151281697947644880271 + 0.1904534692378346862841089j)
+
+Evaluation is supported for large arguments::
+
+    >>> mp.dps = 25
+    >>> erf('1e1000')
+    1.0
+    >>> erf('-1e1000')
+    -1.0
+    >>> erf('1e-1000')
+    1.128379167095512573896159e-1000
+    >>> erf('1e7j')
+    (0.0 + 8.593897639029319267398803e+43429448190317j)
+    >>> erf('1e7+1e7j')
+    (0.9999999858172446172631323 + 3.728805278735270407053139e-8j)
+
+**Related functions**
+
+See also :func:`~mpmath.erfc`, which is more accurate for large `x`,
+and :func:`~mpmath.erfi` which gives the antiderivative of
+`\exp(t^2)`.
+
+The Fresnel integrals :func:`~mpmath.fresnels` and :func:`~mpmath.fresnelc`
+are also related to the error function.
+"""
+
+erfc = r"""
+Computes the complementary error function,
+`\mathrm{erfc}(x) = 1-\mathrm{erf}(x)`.
+This function avoids cancellation that occurs when naively
+computing the complementary error function as ``1-erf(x)``::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> 1 - erf(10)
+    0.0
+    >>> erfc(10)
+    2.08848758376254e-45
+
+:func:`~mpmath.erfc` works accurately even for ludicrously large
+arguments::
+
+    >>> erfc(10**10)
+    4.3504398860243e-43429448190325182776
+
+Complex arguments are supported::
+
+    >>> erfc(500+50j)
+    (1.19739830969552e-107492 + 1.46072418957528e-107491j)
+
+"""
+
+
+erfi = r"""
+Computes the imaginary error function, `\mathrm{erfi}(x)`.
+The imaginary error function is defined in analogy with the
+error function, but with a positive sign in the integrand:
+
+.. math ::
+
+  \mathrm{erfi}(x) = \frac{2}{\sqrt \pi} \int_0^x \exp(t^2) \,dt
+
+Whereas the error function rapidly converges to 1 as `x` grows,
+the imaginary error function rapidly diverges to infinity.
+The functions are related as
+`\mathrm{erfi}(x) = -i\,\mathrm{erf}(ix)` for all complex
+numbers `x`.
+
+**Examples**
+
+Basic values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> erfi(0)
+    0.0
+    >>> erfi(1)
+    1.65042575879754
+    >>> erfi(-1)
+    -1.65042575879754
+    >>> erfi(inf)
+    +inf
+    >>> erfi(-inf)
+    -inf
+
+Note the symmetry between erf and erfi::
+
+    >>> erfi(3j)
+    (0.0 + 0.999977909503001j)
+    >>> erf(3)
+    0.999977909503001
+    >>> erf(1+2j)
+    (-0.536643565778565 - 5.04914370344703j)
+    >>> erfi(2+1j)
+    (-5.04914370344703 - 0.536643565778565j)
+
+Large arguments are supported::
+
+    >>> erfi(1000)
+    1.71130938718796e+434291
+    >>> erfi(10**10)
+    7.3167287567024e+43429448190325182754
+    >>> erfi(-10**10)
+    -7.3167287567024e+43429448190325182754
+    >>> erfi(1000-500j)
+    (2.49895233563961e+325717 + 2.6846779342253e+325717j)
+    >>> erfi(100000j)
+    (0.0 + 1.0j)
+    >>> erfi(-100000j)
+    (0.0 - 1.0j)
+
+
+"""
+
+erfinv = r"""
+Computes the inverse error function, satisfying
+
+.. math ::
+
+    \mathrm{erf}(\mathrm{erfinv}(x)) =
+    \mathrm{erfinv}(\mathrm{erf}(x)) = x.
+
+This function is defined only for `-1 \le x \le 1`.
+
+**Examples**
+
+Special values include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> erfinv(0)
+    0.0
+    >>> erfinv(1)
+    +inf
+    >>> erfinv(-1)
+    -inf
+
+The domain is limited to the standard interval::
+
+    >>> erfinv(2)
+    Traceback (most recent call last):
+      ...
+    ValueError: erfinv(x) is defined only for -1 <= x <= 1
+
+It is simple to check that :func:`~mpmath.erfinv` computes inverse values of
+:func:`~mpmath.erf` as promised::
+
+    >>> erf(erfinv(0.75))
+    0.75
+    >>> erf(erfinv(-0.995))
+    -0.995
+
+:func:`~mpmath.erfinv` supports arbitrary-precision evaluation::
+
+    >>> mp.dps = 50
+    >>> x = erf(2)
+    >>> x
+    0.99532226501895273416206925636725292861089179704006
+    >>> erfinv(x)
+    2.0
+
+A definite integral involving the inverse error function::
+
+    >>> mp.dps = 15
+    >>> quad(erfinv, [0, 1])
+    0.564189583547756
+    >>> 1/sqrt(pi)
+    0.564189583547756
+
+The inverse error function can be used to generate random numbers
+with a Gaussian distribution (although this is a relatively
+inefficient algorithm)::
+
+    >>> nprint([erfinv(2*rand()-1) for n in range(6)]) # doctest: +SKIP
+    [-0.586747, 1.10233, -0.376796, 0.926037, -0.708142, -0.732012]
+
+"""
+
+npdf = r"""
+``npdf(x, mu=0, sigma=1)`` evaluates the probability density
+function of a normal distribution with mean value `\mu`
+and variance `\sigma^2`.
+
+Elementary properties of the probability distribution can
+be verified using numerical integration::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> quad(npdf, [-inf, inf])
+    1.0
+    >>> quad(lambda x: npdf(x, 3), [3, inf])
+    0.5
+    >>> quad(lambda x: npdf(x, 3, 2), [3, inf])
+    0.5
+
+See also :func:`~mpmath.ncdf`, which gives the cumulative
+distribution.
+"""
+
+ncdf = r"""
+``ncdf(x, mu=0, sigma=1)`` evaluates the cumulative distribution
+function of a normal distribution with mean value `\mu`
+and variance `\sigma^2`.
+
+See also :func:`~mpmath.npdf`, which gives the probability density.
+
+Elementary properties include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> ncdf(pi, mu=pi)
+    0.5
+    >>> ncdf(-inf)
+    0.0
+    >>> ncdf(+inf)
+    1.0
+
+The cumulative distribution is the integral of the density
+function having identical mu and sigma::
+
+    >>> mp.dps = 15
+    >>> diff(ncdf, 2)
+    0.053990966513188
+    >>> npdf(2)
+    0.053990966513188
+    >>> diff(lambda x: ncdf(x, 1, 0.5), 0)
+    0.107981933026376
+    >>> npdf(0, 1, 0.5)
+    0.107981933026376
+"""
+
+expint = r"""
+:func:`~mpmath.expint(n,z)` gives the generalized exponential integral
+or En-function,
+
+.. math ::
+
+    \mathrm{E}_n(z) = \int_1^{\infty} \frac{e^{-zt}}{t^n} dt,
+
+where `n` and `z` may both be complex numbers. The case with `n = 1` is
+also given by :func:`~mpmath.e1`.
+
+**Examples**
+
+Evaluation at real and complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> expint(1, 6.25)
+    0.0002704758872637179088496194
+    >>> expint(-3, 2+3j)
+    (0.00299658467335472929656159 + 0.06100816202125885450319632j)
+    >>> expint(2+3j, 4-5j)
+    (0.001803529474663565056945248 - 0.002235061547756185403349091j)
+
+At negative integer values of `n`, `E_n(z)` reduces to a
+rational-exponential function::
+
+    >>> f = lambda n, z: fac(n)*sum(z**k/fac(k-1) for k in range(1,n+2))/\
+    ...     exp(z)/z**(n+2)
+    >>> n = 3
+    >>> z = 1/pi
+    >>> expint(-n,z)
+    584.2604820613019908668219
+    >>> f(n,z)
+    584.2604820613019908668219
+    >>> n = 5
+    >>> expint(-n,z)
+    115366.5762594725451811138
+    >>> f(n,z)
+    115366.5762594725451811138
+"""
+
+e1 = r"""
+Computes the exponential integral `\mathrm{E}_1(z)`, given by
+
+.. math ::
+
+    \mathrm{E}_1(z) = \int_z^{\infty} \frac{e^{-t}}{t} dt.
+
+This is equivalent to :func:`~mpmath.expint` with `n = 1`.
+
+**Examples**
+
+Two ways to evaluate this function::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> e1(6.25)
+    0.0002704758872637179088496194
+    >>> expint(1,6.25)
+    0.0002704758872637179088496194
+
+The E1-function is essentially the same as the Ei-function (:func:`~mpmath.ei`)
+with negated argument, except for an imaginary branch cut term::
+
+    >>> e1(2.5)
+    0.02491491787026973549562801
+    >>> -ei(-2.5)
+    0.02491491787026973549562801
+    >>> e1(-2.5)
+    (-7.073765894578600711923552 - 3.141592653589793238462643j)
+    >>> -ei(2.5)
+    -7.073765894578600711923552
+
+"""
+
+ei = r"""
+Computes the exponential integral or Ei-function, `\mathrm{Ei}(x)`.
+The exponential integral is defined as
+
+.. math ::
+
+  \mathrm{Ei}(x) = \int_{-\infty\,}^x \frac{e^t}{t} \, dt.
+
+When the integration range includes `t = 0`, the exponential
+integral is interpreted as providing the Cauchy principal value.
+
+For real `x`, the Ei-function behaves roughly like
+`\mathrm{Ei}(x) \approx \exp(x) + \log(|x|)`.
+
+The Ei-function is related to the more general family of exponential
+integral functions denoted by `E_n`, which are available as :func:`~mpmath.expint`.
+
+**Basic examples**
+
+Some basic values and limits are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> ei(0)
+    -inf
+    >>> ei(1)
+    1.89511781635594
+    >>> ei(inf)
+    +inf
+    >>> ei(-inf)
+    0.0
+
+For `x < 0`, the defining integral can be evaluated
+numerically as a reference::
+
+    >>> ei(-4)
+    -0.00377935240984891
+    >>> quad(lambda t: exp(t)/t, [-inf, -4])
+    -0.00377935240984891
+
+:func:`~mpmath.ei` supports complex arguments and arbitrary
+precision evaluation::
+
+    >>> mp.dps = 50
+    >>> ei(pi)
+    10.928374389331410348638445906907535171566338835056
+    >>> mp.dps = 25
+    >>> ei(3+4j)
+    (-4.154091651642689822535359 + 4.294418620024357476985535j)
+
+**Related functions**
+
+The exponential integral is closely related to the logarithmic
+integral. See :func:`~mpmath.li` for additional information.
+
+The exponential integral is related to the hyperbolic
+and trigonometric integrals (see :func:`~mpmath.chi`, :func:`~mpmath.shi`,
+:func:`~mpmath.ci`, :func:`~mpmath.si`) similarly to how the ordinary
+exponential function is related to the hyperbolic and
+trigonometric functions::
+
+    >>> mp.dps = 15
+    >>> ei(3)
+    9.93383257062542
+    >>> chi(3) + shi(3)
+    9.93383257062542
+    >>> chop(ci(3j) - j*si(3j) - pi*j/2)
+    9.93383257062542
+
+Beware that logarithmic corrections, as in the last example
+above, are required to obtain the correct branch in general.
+For details, see [1].
+
+The exponential integral is also a special case of the
+hypergeometric function `\,_2F_2`::
+
+    >>> z = 0.6
+    >>> z*hyper([1,1],[2,2],z) + (ln(z)-ln(1/z))/2 + euler
+    0.769881289937359
+    >>> ei(z)
+    0.769881289937359
+
+**References**
+
+1. Relations between Ei and other functions:
+   http://functions.wolfram.com/GammaBetaErf/ExpIntegralEi/27/01/
+
+2. Abramowitz & Stegun, section 5:
+   http://people.math.sfu.ca/~cbm/aands/page_228.htm
+
+3. Asymptotic expansion for Ei:
+   http://mathworld.wolfram.com/En-Function.html
+"""
+
+li = r"""
+Computes the logarithmic integral or li-function
+`\mathrm{li}(x)`, defined by
+
+.. math ::
+
+    \mathrm{li}(x) = \int_0^x \frac{1}{\log t} \, dt
+
+The logarithmic integral has a singularity at `x = 1`.
+
+Alternatively, ``li(x, offset=True)`` computes the offset
+logarithmic integral (used in number theory)
+
+.. math ::
+
+    \mathrm{Li}(x) = \int_2^x \frac{1}{\log t} \, dt.
+
+These two functions are related via the simple identity
+`\mathrm{Li}(x) = \mathrm{li}(x) - \mathrm{li}(2)`.
+
+The logarithmic integral should also not be confused with
+the polylogarithm (also denoted by Li), which is implemented
+as :func:`~mpmath.polylog`.
+
+**Examples**
+
+Some basic values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 30; mp.pretty = True
+    >>> li(0)
+    0.0
+    >>> li(1)
+    -inf
+    >>> li(1)
+    -inf
+    >>> li(2)
+    1.04516378011749278484458888919
+    >>> findroot(li, 2)
+    1.45136923488338105028396848589
+    >>> li(inf)
+    +inf
+    >>> li(2, offset=True)
+    0.0
+    >>> li(1, offset=True)
+    -inf
+    >>> li(0, offset=True)
+    -1.04516378011749278484458888919
+    >>> li(10, offset=True)
+    5.12043572466980515267839286347
+
+The logarithmic integral can be evaluated for arbitrary
+complex arguments::
+
+    >>> mp.dps = 20
+    >>> li(3+4j)
+    (3.1343755504645775265 + 2.6769247817778742392j)
+
+The logarithmic integral is related to the exponential integral::
+
+    >>> ei(log(3))
+    2.1635885946671919729
+    >>> li(3)
+    2.1635885946671919729
+
+The logarithmic integral grows like `O(x/\log(x))`::
+
+    >>> mp.dps = 15
+    >>> x = 10**100
+    >>> x/log(x)
+    4.34294481903252e+97
+    >>> li(x)
+    4.3619719871407e+97
+
+The prime number theorem states that the number of primes less
+than `x` is asymptotic to `\mathrm{Li}(x)` (equivalently
+`\mathrm{li}(x)`). For example, it is known that there are
+exactly 1,925,320,391,606,803,968,923 prime numbers less than
+`10^{23}` [1]. The logarithmic integral provides a very
+accurate estimate::
+
+    >>> li(10**23, offset=True)
+    1.92532039161405e+21
+
+A definite integral is::
+
+    >>> quad(li, [0, 1])
+    -0.693147180559945
+    >>> -ln(2)
+    -0.693147180559945
+
+**References**
+
+1. http://mathworld.wolfram.com/PrimeCountingFunction.html
+
+2. http://mathworld.wolfram.com/LogarithmicIntegral.html
+
+"""
+
+ci = r"""
+Computes the cosine integral,
+
+.. math ::
+
+    \mathrm{Ci}(x) = -\int_x^{\infty} \frac{\cos t}{t}\,dt
+    = \gamma + \log x + \int_0^x \frac{\cos t - 1}{t}\,dt
+
+**Examples**
+
+Some values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> ci(0)
+    -inf
+    >>> ci(1)
+    0.3374039229009681346626462
+    >>> ci(pi)
+    0.07366791204642548599010096
+    >>> ci(inf)
+    0.0
+    >>> ci(-inf)
+    (0.0 + 3.141592653589793238462643j)
+    >>> ci(2+3j)
+    (1.408292501520849518759125 - 2.983617742029605093121118j)
+
+The cosine integral behaves roughly like the sinc function
+(see :func:`~mpmath.sinc`) for large real `x`::
+
+    >>> ci(10**10)
+    -4.875060251748226537857298e-11
+    >>> sinc(10**10)
+    -4.875060250875106915277943e-11
+    >>> chop(limit(ci, inf))
+    0.0
+
+It has infinitely many roots on the positive real axis::
+
+    >>> findroot(ci, 1)
+    0.6165054856207162337971104
+    >>> findroot(ci, 2)
+    3.384180422551186426397851
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+    >>> ci(10**6*(1+j))
+    (4.449410587611035724984376e+434287 + 9.75744874290013526417059e+434287j)
+
+We can evaluate the defining integral as a reference::
+
+    >>> mp.dps = 15
+    >>> -quadosc(lambda t: cos(t)/t, [5, inf], omega=1)
+    -0.190029749656644
+    >>> ci(5)
+    -0.190029749656644
+
+Some infinite series can be evaluated using the
+cosine integral::
+
+    >>> nsum(lambda k: (-1)**k/(fac(2*k)*(2*k)), [1,inf])
+    -0.239811742000565
+    >>> ci(1) - euler
+    -0.239811742000565
+
+"""
+
+si = r"""
+Computes the sine integral,
+
+.. math ::
+
+    \mathrm{Si}(x) = \int_0^x \frac{\sin t}{t}\,dt.
+
+The sine integral is thus the antiderivative of the sinc
+function (see :func:`~mpmath.sinc`).
+
+**Examples**
+
+Some values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> si(0)
+    0.0
+    >>> si(1)
+    0.9460830703671830149413533
+    >>> si(-1)
+    -0.9460830703671830149413533
+    >>> si(pi)
+    1.851937051982466170361053
+    >>> si(inf)
+    1.570796326794896619231322
+    >>> si(-inf)
+    -1.570796326794896619231322
+    >>> si(2+3j)
+    (4.547513889562289219853204 + 1.399196580646054789459839j)
+
+The sine integral approaches `\pi/2` for large real `x`::
+
+    >>> si(10**10)
+    1.570796326707584656968511
+    >>> pi/2
+    1.570796326794896619231322
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+    >>> si(10**6*(1+j))
+    (-9.75744874290013526417059e+434287 + 4.449410587611035724984376e+434287j)
+
+We can evaluate the defining integral as a reference::
+
+    >>> mp.dps = 15
+    >>> quad(sinc, [0, 5])
+    1.54993124494467
+    >>> si(5)
+    1.54993124494467
+
+Some infinite series can be evaluated using the
+sine integral::
+
+    >>> nsum(lambda k: (-1)**k/(fac(2*k+1)*(2*k+1)), [0,inf])
+    0.946083070367183
+    >>> si(1)
+    0.946083070367183
+
+"""
+
+chi = r"""
+Computes the hyperbolic cosine integral, defined
+in analogy with the cosine integral (see :func:`~mpmath.ci`) as
+
+.. math ::
+
+    \mathrm{Chi}(x) = -\int_x^{\infty} \frac{\cosh t}{t}\,dt
+    = \gamma + \log x + \int_0^x \frac{\cosh t - 1}{t}\,dt
+
+Some values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> chi(0)
+    -inf
+    >>> chi(1)
+    0.8378669409802082408946786
+    >>> chi(inf)
+    +inf
+    >>> findroot(chi, 0.5)
+    0.5238225713898644064509583
+    >>> chi(2+3j)
+    (-0.1683628683277204662429321 + 2.625115880451325002151688j)
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+    >>> chi(10**6*(1+j))
+    (4.449410587611035724984376e+434287 - 9.75744874290013526417059e+434287j)
+
+"""
+
+shi = r"""
+Computes the hyperbolic sine integral, defined
+in analogy with the sine integral (see :func:`~mpmath.si`) as
+
+.. math ::
+
+    \mathrm{Shi}(x) = \int_0^x \frac{\sinh t}{t}\,dt.
+
+Some values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> shi(0)
+    0.0
+    >>> shi(1)
+    1.057250875375728514571842
+    >>> shi(-1)
+    -1.057250875375728514571842
+    >>> shi(inf)
+    +inf
+    >>> shi(2+3j)
+    (-0.1931890762719198291678095 + 2.645432555362369624818525j)
+
+Evaluation is supported for `z` anywhere in the complex plane::
+
+    >>> shi(10**6*(1+j))
+    (4.449410587611035724984376e+434287 - 9.75744874290013526417059e+434287j)
+
+"""
+
+fresnels = r"""
+Computes the Fresnel sine integral
+
+.. math ::
+
+    S(x) = \int_0^x \sin\left(\frac{\pi t^2}{2}\right) \,dt
+
+Note that some sources define this function
+without the normalization factor `\pi/2`.
+
+**Examples**
+
+Some basic values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> fresnels(0)
+    0.0
+    >>> fresnels(inf)
+    0.5
+    >>> fresnels(-inf)
+    -0.5
+    >>> fresnels(1)
+    0.4382591473903547660767567
+    >>> fresnels(1+2j)
+    (36.72546488399143842838788 + 15.58775110440458732748279j)
+
+Comparing with the definition::
+
+    >>> fresnels(3)
+    0.4963129989673750360976123
+    >>> quad(lambda t: sin(pi*t**2/2), [0,3])
+    0.4963129989673750360976123
+"""
+
+fresnelc = r"""
+Computes the Fresnel cosine integral
+
+.. math ::
+
+    C(x) = \int_0^x \cos\left(\frac{\pi t^2}{2}\right) \,dt
+
+Note that some sources define this function
+without the normalization factor `\pi/2`.
+
+**Examples**
+
+Some basic values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> fresnelc(0)
+    0.0
+    >>> fresnelc(inf)
+    0.5
+    >>> fresnelc(-inf)
+    -0.5
+    >>> fresnelc(1)
+    0.7798934003768228294742064
+    >>> fresnelc(1+2j)
+    (16.08787137412548041729489 - 36.22568799288165021578758j)
+
+Comparing with the definition::
+
+    >>> fresnelc(3)
+    0.6057207892976856295561611
+    >>> quad(lambda t: cos(pi*t**2/2), [0,3])
+    0.6057207892976856295561611
+"""
+
+airyai = r"""
+Computes the Airy function `\operatorname{Ai}(z)`, which is
+the solution of the Airy differential equation `f''(z) - z f(z) = 0`
+with initial conditions
+
+.. math ::
+
+    \operatorname{Ai}(0) =
+        \frac{1}{3^{2/3}\Gamma\left(\frac{2}{3}\right)}
+
+    \operatorname{Ai}'(0) =
+        -\frac{1}{3^{1/3}\Gamma\left(\frac{1}{3}\right)}.
+
+Other common ways of defining the Ai-function include
+integrals such as
+
+.. math ::
+
+    \operatorname{Ai}(x) = \frac{1}{\pi}
+        \int_0^{\infty} \cos\left(\frac{1}{3}t^3+xt\right) dt
+        \qquad x \in \mathbb{R}
+
+    \operatorname{Ai}(z) = \frac{\sqrt{3}}{2\pi}
+        \int_0^{\infty}
+        \exp\left(-\frac{t^3}{3}-\frac{z^3}{3t^3}\right) dt.
+
+The Ai-function is an entire function with a turning point,
+behaving roughly like a slowly decaying sine wave for `z < 0` and
+like a rapidly decreasing exponential for `z > 0`.
+A second solution of the Airy differential equation
+is given by `\operatorname{Bi}(z)` (see :func:`~mpmath.airybi`).
+
+Optionally, with *derivative=alpha*, :func:`airyai` can compute the
+`\alpha`-th order fractional derivative with respect to `z`.
+For `\alpha = n = 1,2,3,\ldots` this gives the derivative
+`\operatorname{Ai}^{(n)}(z)`, and for `\alpha = -n = -1,-2,-3,\ldots`
+this gives the `n`-fold iterated integral
+
+.. math ::
+
+    f_0(z) = \operatorname{Ai}(z)
+
+    f_n(z) = \int_0^z f_{n-1}(t) dt.
+
+The Ai-function has infinitely many zeros, all located along the
+negative half of the real axis. They can be computed with
+:func:`~mpmath.airyaizero`.
+
+**Plots**
+
+.. literalinclude :: /plots/ai.py
+.. image :: /plots/ai.png
+.. literalinclude :: /plots/ai_c.py
+.. image :: /plots/ai_c.png
+
+**Basic examples**
+
+Limits and values include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> airyai(0); 1/(power(3,'2/3')*gamma('2/3'))
+    0.3550280538878172392600632
+    0.3550280538878172392600632
+    >>> airyai(1)
+    0.1352924163128814155241474
+    >>> airyai(-1)
+    0.5355608832923521187995166
+    >>> airyai(inf); airyai(-inf)
+    0.0
+    0.0
+
+Evaluation is supported for large magnitudes of the argument::
+
+    >>> airyai(-100)
+    0.1767533932395528780908311
+    >>> airyai(100)
+    2.634482152088184489550553e-291
+    >>> airyai(50+50j)
+    (-5.31790195707456404099817e-68 - 1.163588003770709748720107e-67j)
+    >>> airyai(-50+50j)
+    (1.041242537363167632587245e+158 + 3.347525544923600321838281e+157j)
+
+Huge arguments are also fine::
+
+    >>> airyai(10**10)
+    1.162235978298741779953693e-289529654602171
+    >>> airyai(-10**10)
+    0.0001736206448152818510510181
+    >>> w = airyai(10**10*(1+j))
+    >>> w.real
+    5.711508683721355528322567e-186339621747698
+    >>> w.imag
+    1.867245506962312577848166e-186339621747697
+
+The first root of the Ai-function is::
+
+    >>> findroot(airyai, -2)
+    -2.338107410459767038489197
+    >>> airyaizero(1)
+    -2.338107410459767038489197
+
+**Properties and relations**
+
+Verifying the Airy differential equation::
+
+    >>> for z in [-3.4, 0, 2.5, 1+2j]:
+    ...     chop(airyai(z,2) - z*airyai(z))
+    ...
+    0.0
+    0.0
+    0.0
+    0.0
+
+The first few terms of the Taylor series expansion around `z = 0`
+(every third term is zero)::
+
+    >>> nprint(taylor(airyai, 0, 5))
+    [0.355028, -0.258819, 0.0, 0.0591713, -0.0215683, 0.0]
+
+The Airy functions satisfy the Wronskian relation
+`\operatorname{Ai}(z) \operatorname{Bi}'(z) -
+\operatorname{Ai}'(z) \operatorname{Bi}(z) = 1/\pi`::
+
+    >>> z = -0.5
+    >>> airyai(z)*airybi(z,1) - airyai(z,1)*airybi(z)
+    0.3183098861837906715377675
+    >>> 1/pi
+    0.3183098861837906715377675
+
+The Airy functions can be expressed in terms of Bessel
+functions of order `\pm 1/3`. For `\Re[z] \le 0`, we have::
+
+    >>> z = -3
+    >>> airyai(z)
+    -0.3788142936776580743472439
+    >>> y = 2*power(-z,'3/2')/3
+    >>> (sqrt(-z) * (besselj('1/3',y) + besselj('-1/3',y)))/3
+    -0.3788142936776580743472439
+
+**Derivatives and integrals**
+
+Derivatives of the Ai-function (directly and using :func:`~mpmath.diff`)::
+
+    >>> airyai(-3,1); diff(airyai,-3)
+    0.3145837692165988136507873
+    0.3145837692165988136507873
+    >>> airyai(-3,2); diff(airyai,-3,2)
+    1.136442881032974223041732
+    1.136442881032974223041732
+    >>> airyai(1000,1); diff(airyai,1000)
+    -2.943133917910336090459748e-9156
+    -2.943133917910336090459748e-9156
+
+Several derivatives at `z = 0`::
+
+    >>> airyai(0,0); airyai(0,1); airyai(0,2)
+    0.3550280538878172392600632
+    -0.2588194037928067984051836
+    0.0
+    >>> airyai(0,3); airyai(0,4); airyai(0,5)
+    0.3550280538878172392600632
+    -0.5176388075856135968103671
+    0.0
+    >>> airyai(0,15); airyai(0,16); airyai(0,17)
+    1292.30211615165475090663
+    -3188.655054727379756351861
+    0.0
+
+The integral of the Ai-function::
+
+    >>> airyai(3,-1); quad(airyai, [0,3])
+    0.3299203760070217725002701
+    0.3299203760070217725002701
+    >>> airyai(-10,-1); quad(airyai, [0,-10])
+    -0.765698403134212917425148
+    -0.765698403134212917425148
+
+Integrals of high or fractional order::
+
+    >>> airyai(-2,0.5); differint(airyai,-2,0.5,0)
+    (0.0 + 0.2453596101351438273844725j)
+    (0.0 + 0.2453596101351438273844725j)
+    >>> airyai(-2,-4); differint(airyai,-2,-4,0)
+    0.2939176441636809580339365
+    0.2939176441636809580339365
+    >>> airyai(0,-1); airyai(0,-2); airyai(0,-3)
+    0.0
+    0.0
+    0.0
+
+Integrals of the Ai-function can be evaluated at limit points::
+
+    >>> airyai(-1000000,-1); airyai(-inf,-1)
+    -0.6666843728311539978751512
+    -0.6666666666666666666666667
+    >>> airyai(10,-1); airyai(+inf,-1)
+    0.3333333332991690159427932
+    0.3333333333333333333333333
+    >>> airyai(+inf,-2); airyai(+inf,-3)
+    +inf
+    +inf
+    >>> airyai(-1000000,-2); airyai(-inf,-2)
+    666666.4078472650651209742
+    +inf
+    >>> airyai(-1000000,-3); airyai(-inf,-3)
+    -333333074513.7520264995733
+    -inf
+
+**References**
+
+1. [DLMF]_ Chapter 9: Airy and Related Functions
+2. [WolframFunctions]_ section: Bessel-Type Functions
+
+"""
+
+airybi = r"""
+Computes the Airy function `\operatorname{Bi}(z)`, which is
+the solution of the Airy differential equation `f''(z) - z f(z) = 0`
+with initial conditions
+
+.. math ::
+
+    \operatorname{Bi}(0) =
+        \frac{1}{3^{1/6}\Gamma\left(\frac{2}{3}\right)}
+
+    \operatorname{Bi}'(0) =
+        \frac{3^{1/6}}{\Gamma\left(\frac{1}{3}\right)}.
+
+Like the Ai-function (see :func:`~mpmath.airyai`), the Bi-function
+is oscillatory for `z < 0`, but it grows rather than decreases
+for `z > 0`.
+
+Optionally, as for :func:`~mpmath.airyai`, derivatives, integrals
+and fractional derivatives can be computed with the *derivative*
+parameter.
+
+The Bi-function has infinitely many zeros along the negative
+half-axis, as well as complex zeros, which can all be computed
+with :func:`~mpmath.airybizero`.
+
+**Plots**
+
+.. literalinclude :: /plots/bi.py
+.. image :: /plots/bi.png
+.. literalinclude :: /plots/bi_c.py
+.. image :: /plots/bi_c.png
+
+**Basic examples**
+
+Limits and values include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> airybi(0); 1/(power(3,'1/6')*gamma('2/3'))
+    0.6149266274460007351509224
+    0.6149266274460007351509224
+    >>> airybi(1)
+    1.207423594952871259436379
+    >>> airybi(-1)
+    0.10399738949694461188869
+    >>> airybi(inf); airybi(-inf)
+    +inf
+    0.0
+
+Evaluation is supported for large magnitudes of the argument::
+
+    >>> airybi(-100)
+    0.02427388768016013160566747
+    >>> airybi(100)
+    6.041223996670201399005265e+288
+    >>> airybi(50+50j)
+    (-5.322076267321435669290334e+63 + 1.478450291165243789749427e+65j)
+    >>> airybi(-50+50j)
+    (-3.347525544923600321838281e+157 + 1.041242537363167632587245e+158j)
+
+Huge arguments::
+
+    >>> airybi(10**10)
+    1.369385787943539818688433e+289529654602165
+    >>> airybi(-10**10)
+    0.001775656141692932747610973
+    >>> w = airybi(10**10*(1+j))
+    >>> w.real
+    -6.559955931096196875845858e+186339621747689
+    >>> w.imag
+    -6.822462726981357180929024e+186339621747690
+
+The first real root of the Bi-function is::
+
+    >>> findroot(airybi, -1); airybizero(1)
+    -1.17371322270912792491998
+    -1.17371322270912792491998
+
+**Properties and relations**
+
+Verifying the Airy differential equation::
+
+    >>> for z in [-3.4, 0, 2.5, 1+2j]:
+    ...     chop(airybi(z,2) - z*airybi(z))
+    ...
+    0.0
+    0.0
+    0.0
+    0.0
+
+The first few terms of the Taylor series expansion around `z = 0`
+(every third term is zero)::
+
+    >>> nprint(taylor(airybi, 0, 5))
+    [0.614927, 0.448288, 0.0, 0.102488, 0.0373574, 0.0]
+
+The Airy functions can be expressed in terms of Bessel
+functions of order `\pm 1/3`. For `\Re[z] \le 0`, we have::
+
+    >>> z = -3
+    >>> airybi(z)
+    -0.1982896263749265432206449
+    >>> p = 2*power(-z,'3/2')/3
+    >>> sqrt(-mpf(z)/3)*(besselj('-1/3',p) - besselj('1/3',p))
+    -0.1982896263749265432206449
+
+**Derivatives and integrals**
+
+Derivatives of the Bi-function (directly and using :func:`~mpmath.diff`)::
+
+    >>> airybi(-3,1); diff(airybi,-3)
+    -0.675611222685258537668032
+    -0.675611222685258537668032
+    >>> airybi(-3,2); diff(airybi,-3,2)
+    0.5948688791247796296619346
+    0.5948688791247796296619346
+    >>> airybi(1000,1); diff(airybi,1000)
+    1.710055114624614989262335e+9156
+    1.710055114624614989262335e+9156
+
+Several derivatives at `z = 0`::
+
+    >>> airybi(0,0); airybi(0,1); airybi(0,2)
+    0.6149266274460007351509224
+    0.4482883573538263579148237
+    0.0
+    >>> airybi(0,3); airybi(0,4); airybi(0,5)
+    0.6149266274460007351509224
+    0.8965767147076527158296474
+    0.0
+    >>> airybi(0,15); airybi(0,16); airybi(0,17)
+    2238.332923903442675949357
+    5522.912562599140729510628
+    0.0
+
+The integral of the Bi-function::
+
+    >>> airybi(3,-1); quad(airybi, [0,3])
+    10.06200303130620056316655
+    10.06200303130620056316655
+    >>> airybi(-10,-1); quad(airybi, [0,-10])
+    -0.01504042480614002045135483
+    -0.01504042480614002045135483
+
+Integrals of high or fractional order::
+
+    >>> airybi(-2,0.5); differint(airybi, -2, 0.5, 0)
+    (0.0 + 0.5019859055341699223453257j)
+    (0.0 + 0.5019859055341699223453257j)
+    >>> airybi(-2,-4); differint(airybi,-2,-4,0)
+    0.2809314599922447252139092
+    0.2809314599922447252139092
+    >>> airybi(0,-1); airybi(0,-2); airybi(0,-3)
+    0.0
+    0.0
+    0.0
+
+Integrals of the Bi-function can be evaluated at limit points::
+
+    >>> airybi(-1000000,-1); airybi(-inf,-1)
+    0.000002191261128063434047966873
+    0.0
+    >>> airybi(10,-1); airybi(+inf,-1)
+    147809803.1074067161675853
+    +inf
+    >>> airybi(+inf,-2); airybi(+inf,-3)
+    +inf
+    +inf
+    >>> airybi(-1000000,-2); airybi(-inf,-2)
+    0.4482883750599908479851085
+    0.4482883573538263579148237
+    >>> gamma('2/3')*power(3,'2/3')/(2*pi)
+    0.4482883573538263579148237
+    >>> airybi(-100000,-3); airybi(-inf,-3)
+    -44828.52827206932872493133
+    -inf
+    >>> airybi(-100000,-4); airybi(-inf,-4)
+    2241411040.437759489540248
+    +inf
+
+"""
+
+airyaizero = r"""
+Gives the `k`-th zero of the Airy Ai-function,
+i.e. the `k`-th number `a_k` ordered by magnitude for which
+`\operatorname{Ai}(a_k) = 0`.
+
+Optionally, with *derivative=1*, the corresponding
+zero `a'_k` of the derivative function, i.e.
+`\operatorname{Ai}'(a'_k) = 0`, is computed.
+
+**Examples**
+
+Some values of `a_k`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> airyaizero(1)
+    -2.338107410459767038489197
+    >>> airyaizero(2)
+    -4.087949444130970616636989
+    >>> airyaizero(3)
+    -5.520559828095551059129856
+    >>> airyaizero(1000)
+    -281.0315196125215528353364
+
+Some values of `a'_k`::
+
+    >>> airyaizero(1,1)
+    -1.018792971647471089017325
+    >>> airyaizero(2,1)
+    -3.248197582179836537875424
+    >>> airyaizero(3,1)
+    -4.820099211178735639400616
+    >>> airyaizero(1000,1)
+    -280.9378080358935070607097
+
+Verification::
+
+    >>> chop(airyai(airyaizero(1)))
+    0.0
+    >>> chop(airyai(airyaizero(1,1),1))
+    0.0
+
+"""
+
+airybizero = r"""
+With *complex=False*, gives the `k`-th real zero of the Airy Bi-function,
+i.e. the `k`-th number `b_k` ordered by magnitude for which
+`\operatorname{Bi}(b_k) = 0`.
+
+With *complex=True*, gives the `k`-th complex zero in the upper
+half plane `\beta_k`. Also the conjugate `\overline{\beta_k}`
+is a zero.
+
+Optionally, with *derivative=1*, the corresponding
+zero `b'_k` or `\beta'_k` of the derivative function, i.e.
+`\operatorname{Bi}'(b'_k) = 0` or `\operatorname{Bi}'(\beta'_k) = 0`,
+is computed.
+
+**Examples**
+
+Some values of `b_k`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> airybizero(1)
+    -1.17371322270912792491998
+    >>> airybizero(2)
+    -3.271093302836352715680228
+    >>> airybizero(3)
+    -4.830737841662015932667709
+    >>> airybizero(1000)
+    -280.9378112034152401578834
+
+Some values of `b_k`::
+
+    >>> airybizero(1,1)
+    -2.294439682614123246622459
+    >>> airybizero(2,1)
+    -4.073155089071828215552369
+    >>> airybizero(3,1)
+    -5.512395729663599496259593
+    >>> airybizero(1000,1)
+    -281.0315164471118527161362
+
+Some values of `\beta_k`::
+
+    >>> airybizero(1,complex=True)
+    (0.9775448867316206859469927 + 2.141290706038744575749139j)
+    >>> airybizero(2,complex=True)
+    (1.896775013895336346627217 + 3.627291764358919410440499j)
+    >>> airybizero(3,complex=True)
+    (2.633157739354946595708019 + 4.855468179979844983174628j)
+    >>> airybizero(1000,complex=True)
+    (140.4978560578493018899793 + 243.3907724215792121244867j)
+
+Some values of `\beta'_k`::
+
+    >>> airybizero(1,1,complex=True)
+    (0.2149470745374305676088329 + 1.100600143302797880647194j)
+    >>> airybizero(2,1,complex=True)
+    (1.458168309223507392028211 + 2.912249367458445419235083j)
+    >>> airybizero(3,1,complex=True)
+    (2.273760763013482299792362 + 4.254528549217097862167015j)
+    >>> airybizero(1000,1,complex=True)
+    (140.4509972835270559730423 + 243.3096175398562811896208j)
+
+Verification::
+
+    >>> chop(airybi(airybizero(1)))
+    0.0
+    >>> chop(airybi(airybizero(1,1),1))
+    0.0
+    >>> u = airybizero(1,complex=True)
+    >>> chop(airybi(u))
+    0.0
+    >>> chop(airybi(conj(u)))
+    0.0
+
+The complex zeros (in the upper and lower half-planes respectively)
+asymptotically approach the rays `z = R \exp(\pm i \pi /3)`::
+
+    >>> arg(airybizero(1,complex=True))
+    1.142532510286334022305364
+    >>> arg(airybizero(1000,complex=True))
+    1.047271114786212061583917
+    >>> arg(airybizero(1000000,complex=True))
+    1.047197624741816183341355
+    >>> pi/3
+    1.047197551196597746154214
+
+"""
+
+
+ellipk = r"""
+Evaluates the complete elliptic integral of the first kind,
+`K(m)`, defined by
+
+.. math ::
+
+    K(m) = \int_0^{\pi/2} \frac{dt}{\sqrt{1-m \sin^2 t}} \, = \,
+    \frac{\pi}{2} \,_2F_1\left(\frac{1}{2}, \frac{1}{2}, 1, m\right).
+
+Note that the argument is the parameter `m = k^2`,
+not the modulus `k` which is sometimes used.
+
+**Plots**
+
+.. literalinclude :: /plots/ellipk.py
+.. image :: /plots/ellipk.png
+
+**Examples**
+
+Values and limits include::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> ellipk(0)
+    1.570796326794896619231322
+    >>> ellipk(inf)
+    (0.0 + 0.0j)
+    >>> ellipk(-inf)
+    0.0
+    >>> ellipk(1)
+    +inf
+    >>> ellipk(-1)
+    1.31102877714605990523242
+    >>> ellipk(2)
+    (1.31102877714605990523242 - 1.31102877714605990523242j)
+
+Verifying the defining integral and hypergeometric
+representation::
+
+    >>> ellipk(0.5)
+    1.85407467730137191843385
+    >>> quad(lambda t: (1-0.5*sin(t)**2)**-0.5, [0, pi/2])
+    1.85407467730137191843385
+    >>> pi/2*hyp2f1(0.5,0.5,1,0.5)
+    1.85407467730137191843385
+
+Evaluation is supported for arbitrary complex `m`::
+
+    >>> ellipk(3+4j)
+    (0.9111955638049650086562171 + 0.6313342832413452438845091j)
+
+A definite integral::
+
+    >>> quad(ellipk, [0, 1])
+    2.0
+"""
+
+agm = r"""
+``agm(a, b)`` computes the arithmetic-geometric mean of `a` and
+`b`, defined as the limit of the following iteration:
+
+.. math ::
+
+    a_0 = a
+
+    b_0 = b
+
+    a_{n+1} = \frac{a_n+b_n}{2}
+
+    b_{n+1} = \sqrt{a_n b_n}
+
+This function can be called with a single argument, computing
+`\mathrm{agm}(a,1) = \mathrm{agm}(1,a)`.
+
+**Examples**
+
+It is a well-known theorem that the geometric mean of
+two distinct positive numbers is less than the arithmetic
+mean. It follows that the arithmetic-geometric mean lies
+between the two means::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> a = mpf(3)
+    >>> b = mpf(4)
+    >>> sqrt(a*b)
+    3.46410161513775
+    >>> agm(a,b)
+    3.48202767635957
+    >>> (a+b)/2
+    3.5
+
+The arithmetic-geometric mean is scale-invariant::
+
+    >>> agm(10*e, 10*pi)
+    29.261085515723
+    >>> 10*agm(e, pi)
+    29.261085515723
+
+As an order-of-magnitude estimate, `\mathrm{agm}(1,x) \approx x`
+for large `x`::
+
+    >>> agm(10**10)
+    643448704.760133
+    >>> agm(10**50)
+    1.34814309345871e+48
+
+For tiny `x`, `\mathrm{agm}(1,x) \approx -\pi/(2 \log(x/4))`::
+
+    >>> agm('0.01')
+    0.262166887202249
+    >>> -pi/2/log('0.0025')
+    0.262172347753122
+
+The arithmetic-geometric mean can also be computed for complex
+numbers::
+
+    >>> agm(3, 2+j)
+    (2.51055133276184 + 0.547394054060638j)
+
+The AGM iteration converges very quickly (each step doubles
+the number of correct digits), so :func:`~mpmath.agm` supports efficient
+high-precision evaluation::
+
+    >>> mp.dps = 10000
+    >>> a = agm(1,2)
+    >>> str(a)[-10:]
+    '1679581912'
+
+**Mathematical relations**
+
+The arithmetic-geometric mean may be used to evaluate the
+following two parametric definite integrals:
+
+.. math ::
+
+  I_1 = \int_0^{\infty}
+    \frac{1}{\sqrt{(x^2+a^2)(x^2+b^2)}} \,dx
+
+  I_2 = \int_0^{\pi/2}
+    \frac{1}{\sqrt{a^2 \cos^2(x) + b^2 \sin^2(x)}} \,dx
+
+We have::
+
+    >>> mp.dps = 15
+    >>> a = 3
+    >>> b = 4
+    >>> f1 = lambda x: ((x**2+a**2)*(x**2+b**2))**-0.5
+    >>> f2 = lambda x: ((a*cos(x))**2 + (b*sin(x))**2)**-0.5
+    >>> quad(f1, [0, inf])
+    0.451115405388492
+    >>> quad(f2, [0, pi/2])
+    0.451115405388492
+    >>> pi/(2*agm(a,b))
+    0.451115405388492
+
+A formula for `\Gamma(1/4)`::
+
+    >>> gamma(0.25)
+    3.62560990822191
+    >>> sqrt(2*sqrt(2*pi**3)/agm(1,sqrt(2)))
+    3.62560990822191
+
+**Possible issues**
+
+The branch cut chosen for complex `a` and `b` is somewhat
+arbitrary.
+
+"""
+
+gegenbauer = r"""
+Evaluates the Gegenbauer polynomial, or ultraspherical polynomial,
+
+.. math ::
+
+    C_n^{(a)}(z) = {n+2a-1 \choose n} \,_2F_1\left(-n, n+2a;
+        a+\frac{1}{2}; \frac{1}{2}(1-z)\right).
+
+When `n` is a nonnegative integer, this formula gives a polynomial
+in `z` of degree `n`, but all parameters are permitted to be
+complex numbers. With `a = 1/2`, the Gegenbauer polynomial
+reduces to a Legendre polynomial.
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> gegenbauer(3, 0.5, -10)
+    -2485.0
+    >>> gegenbauer(1000, 10, 100)
+    3.012757178975667428359374e+2322
+    >>> gegenbauer(2+3j, -0.75, -1000j)
+    (-5038991.358609026523401901 + 9414549.285447104177860806j)
+
+Evaluation at negative integer orders::
+
+    >>> gegenbauer(-4, 2, 1.75)
+    -1.0
+    >>> gegenbauer(-4, 3, 1.75)
+    0.0
+    >>> gegenbauer(-4, 2j, 1.75)
+    0.0
+    >>> gegenbauer(-7, 0.5, 3)
+    8989.0
+
+The Gegenbauer polynomials solve the differential equation::
+
+    >>> n, a = 4.5, 1+2j
+    >>> f = lambda z: gegenbauer(n, a, z)
+    >>> for z in [0, 0.75, -0.5j]:
+    ...     chop((1-z**2)*diff(f,z,2) - (2*a+1)*z*diff(f,z) + n*(n+2*a)*f(z))
+    ...
+    0.0
+    0.0
+    0.0
+
+The Gegenbauer polynomials have generating function
+`(1-2zt+t^2)^{-a}`::
+
+    >>> a, z = 2.5, 1
+    >>> taylor(lambda t: (1-2*z*t+t**2)**(-a), 0, 3)
+    [1.0, 5.0, 15.0, 35.0]
+    >>> [gegenbauer(n,a,z) for n in range(4)]
+    [1.0, 5.0, 15.0, 35.0]
+
+The Gegenbauer polynomials are orthogonal on `[-1, 1]` with respect
+to the weight `(1-z^2)^{a-\frac{1}{2}}`::
+
+    >>> a, n, m = 2.5, 4, 5
+    >>> Cn = lambda z: gegenbauer(n, a, z, zeroprec=1000)
+    >>> Cm = lambda z: gegenbauer(m, a, z, zeroprec=1000)
+    >>> chop(quad(lambda z: Cn(z)*Cm(z)*(1-z**2)*(a-0.5), [-1, 1]))
+    0.0
+"""
+
+laguerre = r"""
+Gives the generalized (associated) Laguerre polynomial, defined by
+
+.. math ::
+
+    L_n^a(z) = \frac{\Gamma(n+b+1)}{\Gamma(b+1) \Gamma(n+1)}
+        \,_1F_1(-n, a+1, z).
+
+With `a = 0` and `n` a nonnegative integer, this reduces to an ordinary
+Laguerre polynomial, the sequence of which begins
+`L_0(z) = 1, L_1(z) = 1-z, L_2(z) = z^2-2z+1, \ldots`.
+
+The Laguerre polynomials are orthogonal with respect to the weight
+`z^a e^{-z}` on `[0, \infty)`.
+
+**Plots**
+
+.. literalinclude :: /plots/laguerre.py
+.. image :: /plots/laguerre.png
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> laguerre(5, 0, 0.25)
+    0.03726399739583333333333333
+    >>> laguerre(1+j, 0.5, 2+3j)
+    (4.474921610704496808379097 - 11.02058050372068958069241j)
+    >>> laguerre(2, 0, 10000)
+    49980001.0
+    >>> laguerre(2.5, 0, 10000)
+    -9.327764910194842158583189e+4328
+
+The first few Laguerre polynomials, normalized to have integer
+coefficients::
+
+    >>> for n in range(7):
+    ...     chop(taylor(lambda z: fac(n)*laguerre(n, 0, z), 0, n))
+    ...
+    [1.0]
+    [1.0, -1.0]
+    [2.0, -4.0, 1.0]
+    [6.0, -18.0, 9.0, -1.0]
+    [24.0, -96.0, 72.0, -16.0, 1.0]
+    [120.0, -600.0, 600.0, -200.0, 25.0, -1.0]
+    [720.0, -4320.0, 5400.0, -2400.0, 450.0, -36.0, 1.0]
+
+Verifying orthogonality::
+
+    >>> Lm = lambda t: laguerre(m,a,t)
+    >>> Ln = lambda t: laguerre(n,a,t)
+    >>> a, n, m = 2.5, 2, 3
+    >>> chop(quad(lambda t: exp(-t)*t**a*Lm(t)*Ln(t), [0,inf]))
+    0.0
+
+
+"""
+
+hermite = r"""
+Evaluates the Hermite polynomial `H_n(z)`, which may be defined using
+the recurrence
+
+.. math ::
+
+    H_0(z) = 1
+
+    H_1(z) = 2z
+
+    H_{n+1} = 2z H_n(z) - 2n H_{n-1}(z).
+
+The Hermite polynomials are orthogonal on `(-\infty, \infty)` with
+respect to the weight `e^{-z^2}`. More generally, allowing arbitrary complex
+values of `n`, the Hermite function `H_n(z)` is defined as
+
+.. math ::
+
+    H_n(z) = (2z)^n \,_2F_0\left(-\frac{n}{2}, \frac{1-n}{2},
+        -\frac{1}{z^2}\right)
+
+for `\Re{z} > 0`, or generally
+
+.. math ::
+
+    H_n(z) = 2^n \sqrt{\pi} \left(
+        \frac{1}{\Gamma\left(\frac{1-n}{2}\right)}
+        \,_1F_1\left(-\frac{n}{2}, \frac{1}{2}, z^2\right) -
+        \frac{2z}{\Gamma\left(-\frac{n}{2}\right)}
+        \,_1F_1\left(\frac{1-n}{2}, \frac{3}{2}, z^2\right)
+    \right).
+
+**Plots**
+
+.. literalinclude :: /plots/hermite.py
+.. image :: /plots/hermite.png
+
+**Examples**
+
+Evaluation for arbitrary arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hermite(0, 10)
+    1.0
+    >>> hermite(1, 10); hermite(2, 10)
+    20.0
+    398.0
+    >>> hermite(10000, 2)
+    4.950440066552087387515653e+19334
+    >>> hermite(3, -10**8)
+    -7999999999999998800000000.0
+    >>> hermite(-3, -10**8)
+    1.675159751729877682920301e+4342944819032534
+    >>> hermite(2+3j, -1+2j)
+    (-0.07652130602993513389421901 - 0.1084662449961914580276007j)
+
+Coefficients of the first few Hermite polynomials are::
+
+    >>> for n in range(7):
+    ...     chop(taylor(lambda z: hermite(n, z), 0, n))
+    ...
+    [1.0]
+    [0.0, 2.0]
+    [-2.0, 0.0, 4.0]
+    [0.0, -12.0, 0.0, 8.0]
+    [12.0, 0.0, -48.0, 0.0, 16.0]
+    [0.0, 120.0, 0.0, -160.0, 0.0, 32.0]
+    [-120.0, 0.0, 720.0, 0.0, -480.0, 0.0, 64.0]
+
+Values at `z = 0`::
+
+    >>> for n in range(-5, 9):
+    ...     hermite(n, 0)
+    ...
+    0.02769459142039868792653387
+    0.08333333333333333333333333
+    0.2215567313631895034122709
+    0.5
+    0.8862269254527580136490837
+    1.0
+    0.0
+    -2.0
+    0.0
+    12.0
+    0.0
+    -120.0
+    0.0
+    1680.0
+
+Hermite functions satisfy the differential equation::
+
+    >>> n = 4
+    >>> f = lambda z: hermite(n, z)
+    >>> z = 1.5
+    >>> chop(diff(f,z,2) - 2*z*diff(f,z) + 2*n*f(z))
+    0.0
+
+Verifying orthogonality::
+
+    >>> chop(quad(lambda t: hermite(2,t)*hermite(4,t)*exp(-t**2), [-inf,inf]))
+    0.0
+
+"""
+
+jacobi = r"""
+``jacobi(n, a, b, x)`` evaluates the Jacobi polynomial
+`P_n^{(a,b)}(x)`. The Jacobi polynomials are a special
+case of the hypergeometric function `\,_2F_1` given by:
+
+.. math ::
+
+    P_n^{(a,b)}(x) = {n+a \choose n}
+      \,_2F_1\left(-n,1+a+b+n,a+1,\frac{1-x}{2}\right).
+
+Note that this definition generalizes to nonintegral values
+of `n`. When `n` is an integer, the hypergeometric series
+terminates after a finite number of terms, giving
+a polynomial in `x`.
+
+**Evaluation of Jacobi polynomials**
+
+A special evaluation is `P_n^{(a,b)}(1) = {n+a \choose n}`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> jacobi(4, 0.5, 0.25, 1)
+    2.4609375
+    >>> binomial(4+0.5, 4)
+    2.4609375
+
+A Jacobi polynomial of degree `n` is equal to its
+Taylor polynomial of degree `n`. The explicit
+coefficients of Jacobi polynomials can therefore
+be recovered easily using :func:`~mpmath.taylor`::
+
+    >>> for n in range(5):
+    ...     nprint(taylor(lambda x: jacobi(n,1,2,x), 0, n))
+    ...
+    [1.0]
+    [-0.5, 2.5]
+    [-0.75, -1.5, 5.25]
+    [0.5, -3.5, -3.5, 10.5]
+    [0.625, 2.5, -11.25, -7.5, 20.625]
+
+For nonintegral `n`, the Jacobi "polynomial" is no longer
+a polynomial::
+
+    >>> nprint(taylor(lambda x: jacobi(0.5,1,2,x), 0, 4))
+    [0.309983, 1.84119, -1.26933, 1.26699, -1.34808]
+
+**Orthogonality**
+
+The Jacobi polynomials are orthogonal on the interval
+`[-1, 1]` with respect to the weight function
+`w(x) = (1-x)^a (1+x)^b`. That is,
+`w(x) P_n^{(a,b)}(x) P_m^{(a,b)}(x)` integrates to
+zero if `m \ne n` and to a nonzero number if `m = n`.
+
+The orthogonality is easy to verify using numerical
+quadrature::
+
+    >>> P = jacobi
+    >>> f = lambda x: (1-x)**a * (1+x)**b * P(m,a,b,x) * P(n,a,b,x)
+    >>> a = 2
+    >>> b = 3
+    >>> m, n = 3, 4
+    >>> chop(quad(f, [-1, 1]), 1)
+    0.0
+    >>> m, n = 4, 4
+    >>> quad(f, [-1, 1])
+    1.9047619047619
+
+**Differential equation**
+
+The Jacobi polynomials are solutions of the differential
+equation
+
+.. math ::
+
+  (1-x^2) y'' + (b-a-(a+b+2)x) y' + n (n+a+b+1) y = 0.
+
+We can verify that :func:`~mpmath.jacobi` approximately satisfies
+this equation::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15
+    >>> a = 2.5
+    >>> b = 4
+    >>> n = 3
+    >>> y = lambda x: jacobi(n,a,b,x)
+    >>> x = pi
+    >>> A0 = n*(n+a+b+1)*y(x)
+    >>> A1 = (b-a-(a+b+2)*x)*diff(y,x)
+    >>> A2 = (1-x**2)*diff(y,x,2)
+    >>> nprint(A2 + A1 + A0, 1)
+    4.0e-12
+
+The difference of order `10^{-12}` is as close to zero as
+it could be at 15-digit working precision, since the terms
+are large::
+
+    >>> A0, A1, A2
+    (26560.2328981879, -21503.7641037294, -5056.46879445852)
+
+"""
+
+legendre = r"""
+``legendre(n, x)`` evaluates the Legendre polynomial `P_n(x)`.
+The Legendre polynomials are given by the formula
+
+.. math ::
+
+    P_n(x) = \frac{1}{2^n n!} \frac{d^n}{dx^n} (x^2 -1)^n.
+
+Alternatively, they can be computed recursively using
+
+.. math ::
+
+    P_0(x) = 1
+
+    P_1(x) = x
+
+    (n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x).
+
+A third definition is in terms of the hypergeometric function
+`\,_2F_1`, whereby they can be generalized to arbitrary `n`:
+
+.. math ::
+
+    P_n(x) = \,_2F_1\left(-n, n+1, 1, \frac{1-x}{2}\right)
+
+**Plots**
+
+.. literalinclude :: /plots/legendre.py
+.. image :: /plots/legendre.png
+
+**Basic evaluation**
+
+The Legendre polynomials assume fixed values at the points
+`x = -1` and `x = 1`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> nprint([legendre(n, 1) for n in range(6)])
+    [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+    >>> nprint([legendre(n, -1) for n in range(6)])
+    [1.0, -1.0, 1.0, -1.0, 1.0, -1.0]
+
+The coefficients of Legendre polynomials can be recovered
+using degree-`n` Taylor expansion::
+
+    >>> for n in range(5):
+    ...     nprint(chop(taylor(lambda x: legendre(n, x), 0, n)))
+    ...
+    [1.0]
+    [0.0, 1.0]
+    [-0.5, 0.0, 1.5]
+    [0.0, -1.5, 0.0, 2.5]
+    [0.375, 0.0, -3.75, 0.0, 4.375]
+
+The roots of Legendre polynomials are located symmetrically
+on the interval `[-1, 1]`::
+
+    >>> for n in range(5):
+    ...     nprint(polyroots(taylor(lambda x: legendre(n, x), 0, n)[::-1]))
+    ...
+    []
+    [0.0]
+    [-0.57735, 0.57735]
+    [-0.774597, 0.0, 0.774597]
+    [-0.861136, -0.339981, 0.339981, 0.861136]
+
+An example of an evaluation for arbitrary `n`::
+
+    >>> legendre(0.75, 2+4j)
+    (1.94952805264875 + 2.1071073099422j)
+
+**Orthogonality**
+
+The Legendre polynomials are orthogonal on `[-1, 1]` with respect
+to the trivial weight `w(x) = 1`. That is, `P_m(x) P_n(x)`
+integrates to zero if `m \ne n` and to `2/(2n+1)` if `m = n`::
+
+    >>> m, n = 3, 4
+    >>> quad(lambda x: legendre(m,x)*legendre(n,x), [-1, 1])
+    0.0
+    >>> m, n = 4, 4
+    >>> quad(lambda x: legendre(m,x)*legendre(n,x), [-1, 1])
+    0.222222222222222
+
+**Differential equation**
+
+The Legendre polynomials satisfy the differential equation
+
+.. math ::
+
+    ((1-x^2) y')' + n(n+1) y' = 0.
+
+We can verify this numerically::
+
+    >>> n = 3.6
+    >>> x = 0.73
+    >>> P = legendre
+    >>> A = diff(lambda t: (1-t**2)*diff(lambda u: P(n,u), t), x)
+    >>> B = n*(n+1)*P(n,x)
+    >>> nprint(A+B,1)
+    9.0e-16
+
+"""
+
+
+legenp = r"""
+Calculates the (associated) Legendre function of the first kind of
+degree *n* and order *m*, `P_n^m(z)`. Taking `m = 0` gives the ordinary
+Legendre function of the first kind, `P_n(z)`. The parameters may be
+complex numbers.
+
+In terms of the Gauss hypergeometric function, the (associated) Legendre
+function is defined as
+
+.. math ::
+
+    P_n^m(z) = \frac{1}{\Gamma(1-m)} \frac{(1+z)^{m/2}}{(1-z)^{m/2}}
+        \,_2F_1\left(-n, n+1, 1-m, \frac{1-z}{2}\right).
+
+With *type=3* instead of *type=2*, the alternative
+definition
+
+.. math ::
+
+    \hat{P}_n^m(z) = \frac{1}{\Gamma(1-m)} \frac{(z+1)^{m/2}}{(z-1)^{m/2}}
+        \,_2F_1\left(-n, n+1, 1-m, \frac{1-z}{2}\right).
+
+is used. These functions correspond respectively to ``LegendreP[n,m,2,z]``
+and ``LegendreP[n,m,3,z]`` in Mathematica.
+
+The general solution of the (associated) Legendre differential equation
+
+.. math ::
+
+    (1-z^2) f''(z) - 2zf'(z) + \left(n(n+1)-\frac{m^2}{1-z^2}\right)f(z) = 0
+
+is given by `C_1 P_n^m(z) + C_2 Q_n^m(z)` for arbitrary constants
+`C_1`, `C_2`, where `Q_n^m(z)` is a Legendre function of the
+second kind as implemented by :func:`~mpmath.legenq`.
+
+**Examples**
+
+Evaluation for arbitrary parameters and arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> legenp(2, 0, 10); legendre(2, 10)
+    149.5
+    149.5
+    >>> legenp(-2, 0.5, 2.5)
+    (1.972260393822275434196053 - 1.972260393822275434196053j)
+    >>> legenp(2+3j, 1-j, -0.5+4j)
+    (-3.335677248386698208736542 - 5.663270217461022307645625j)
+    >>> chop(legenp(3, 2, -1.5, type=2))
+    28.125
+    >>> chop(legenp(3, 2, -1.5, type=3))
+    -28.125
+
+Verifying the associated Legendre differential equation::
+
+    >>> n, m = 2, -0.5
+    >>> C1, C2 = 1, -3
+    >>> f = lambda z: C1*legenp(n,m,z) + C2*legenq(n,m,z)
+    >>> deq = lambda z: (1-z**2)*diff(f,z,2) - 2*z*diff(f,z) + \
+    ...     (n*(n+1)-m**2/(1-z**2))*f(z)
+    >>> for z in [0, 2, -1.5, 0.5+2j]:
+    ...     chop(deq(mpmathify(z)))
+    ...
+    0.0
+    0.0
+    0.0
+    0.0
+"""
+
+legenq = r"""
+Calculates the (associated) Legendre function of the second kind of
+degree *n* and order *m*, `Q_n^m(z)`. Taking `m = 0` gives the ordinary
+Legendre function of the second kind, `Q_n(z)`. The parameters may be
+complex numbers.
+
+The Legendre functions of the second kind give a second set of
+solutions to the (associated) Legendre differential equation.
+(See :func:`~mpmath.legenp`.)
+Unlike the Legendre functions of the first kind, they are not
+polynomials of `z` for integer `n`, `m` but rational or logarithmic
+functions with poles at `z = \pm 1`.
+
+There are various ways to define Legendre functions of
+the second kind, giving rise to different complex structure.
+A version can be selected using the *type* keyword argument.
+The *type=2* and *type=3* functions are given respectively by
+
+.. math ::
+
+    Q_n^m(z) = \frac{\pi}{2 \sin(\pi m)}
+        \left( \cos(\pi m) P_n^m(z) -
+        \frac{\Gamma(1+m+n)}{\Gamma(1-m+n)} P_n^{-m}(z)\right)
+
+    \hat{Q}_n^m(z) = \frac{\pi}{2 \sin(\pi m)} e^{\pi i m}
+        \left( \hat{P}_n^m(z) -
+        \frac{\Gamma(1+m+n)}{\Gamma(1-m+n)} \hat{P}_n^{-m}(z)\right)
+
+where `P` and `\hat{P}` are the *type=2* and *type=3* Legendre functions
+of the first kind. The formulas above should be understood as limits
+when `m` is an integer.
+
+These functions correspond to ``LegendreQ[n,m,2,z]`` (or ``LegendreQ[n,m,z]``)
+and ``LegendreQ[n,m,3,z]`` in Mathematica. The *type=3* function
+is essentially the same as the function defined in
+Abramowitz & Stegun (eq. 8.1.3) but with `(z+1)^{m/2}(z-1)^{m/2}` instead
+of `(z^2-1)^{m/2}`, giving slightly different branches.
+
+**Examples**
+
+Evaluation for arbitrary parameters and arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> legenq(2, 0, 0.5)
+    -0.8186632680417568557122028
+    >>> legenq(-1.5, -2, 2.5)
+    (0.6655964618250228714288277 + 0.3937692045497259717762649j)
+    >>> legenq(2-j, 3+4j, -6+5j)
+    (-10001.95256487468541686564 - 6011.691337610097577791134j)
+
+Different versions of the function::
+
+    >>> legenq(2, 1, 0.5)
+    0.7298060598018049369381857
+    >>> legenq(2, 1, 1.5)
+    (-7.902916572420817192300921 + 0.1998650072605976600724502j)
+    >>> legenq(2, 1, 0.5, type=3)
+    (2.040524284763495081918338 - 0.7298060598018049369381857j)
+    >>> chop(legenq(2, 1, 1.5, type=3))
+    -0.1998650072605976600724502
+
+"""
+
+chebyt = r"""
+``chebyt(n, x)`` evaluates the Chebyshev polynomial of the first
+kind `T_n(x)`, defined by the identity
+
+.. math ::
+
+    T_n(\cos x) = \cos(n x).
+
+The Chebyshev polynomials of the first kind are a special
+case of the Jacobi polynomials, and by extension of the
+hypergeometric function `\,_2F_1`. They can thus also be
+evaluated for nonintegral `n`.
+
+**Plots**
+
+.. literalinclude :: /plots/chebyt.py
+.. image :: /plots/chebyt.png
+
+**Basic evaluation**
+
+The coefficients of the `n`-th polynomial can be recovered
+using using degree-`n` Taylor expansion::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(5):
+    ...     nprint(chop(taylor(lambda x: chebyt(n, x), 0, n)))
+    ...
+    [1.0]
+    [0.0, 1.0]
+    [-1.0, 0.0, 2.0]
+    [0.0, -3.0, 0.0, 4.0]
+    [1.0, 0.0, -8.0, 0.0, 8.0]
+
+**Orthogonality**
+
+The Chebyshev polynomials of the first kind are orthogonal
+on the interval `[-1, 1]` with respect to the weight
+function `w(x) = 1/\sqrt{1-x^2}`::
+
+    >>> f = lambda x: chebyt(m,x)*chebyt(n,x)/sqrt(1-x**2)
+    >>> m, n = 3, 4
+    >>> nprint(quad(f, [-1, 1]),1)
+    0.0
+    >>> m, n = 4, 4
+    >>> quad(f, [-1, 1])
+    1.57079632596448
+
+"""
+
+chebyu = r"""
+``chebyu(n, x)`` evaluates the Chebyshev polynomial of the second
+kind `U_n(x)`, defined by the identity
+
+.. math ::
+
+    U_n(\cos x) = \frac{\sin((n+1)x)}{\sin(x)}.
+
+The Chebyshev polynomials of the second kind are a special
+case of the Jacobi polynomials, and by extension of the
+hypergeometric function `\,_2F_1`. They can thus also be
+evaluated for nonintegral `n`.
+
+**Plots**
+
+.. literalinclude :: /plots/chebyu.py
+.. image :: /plots/chebyu.png
+
+**Basic evaluation**
+
+The coefficients of the `n`-th polynomial can be recovered
+using using degree-`n` Taylor expansion::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(5):
+    ...     nprint(chop(taylor(lambda x: chebyu(n, x), 0, n)))
+    ...
+    [1.0]
+    [0.0, 2.0]
+    [-1.0, 0.0, 4.0]
+    [0.0, -4.0, 0.0, 8.0]
+    [1.0, 0.0, -12.0, 0.0, 16.0]
+
+**Orthogonality**
+
+The Chebyshev polynomials of the second kind are orthogonal
+on the interval `[-1, 1]` with respect to the weight
+function `w(x) = \sqrt{1-x^2}`::
+
+    >>> f = lambda x: chebyu(m,x)*chebyu(n,x)*sqrt(1-x**2)
+    >>> m, n = 3, 4
+    >>> quad(f, [-1, 1])
+    0.0
+    >>> m, n = 4, 4
+    >>> quad(f, [-1, 1])
+    1.5707963267949
+"""
+
+besselj = r"""
+``besselj(n, x, derivative=0)`` gives the Bessel function of the first kind
+`J_n(x)`. Bessel functions of the first kind are defined as
+solutions of the differential equation
+
+.. math ::
+
+    x^2 y'' + x y' + (x^2 - n^2) y = 0
+
+which appears, among other things, when solving the radial
+part of Laplace's equation in cylindrical coordinates. This
+equation has two solutions for given `n`, where the
+`J_n`-function is the solution that is nonsingular at `x = 0`.
+For positive integer `n`, `J_n(x)` behaves roughly like a sine
+(odd `n`) or cosine (even `n`) multiplied by a magnitude factor
+that decays slowly as `x \to \pm\infty`.
+
+Generally, `J_n` is a special case of the hypergeometric
+function `\,_0F_1`:
+
+.. math ::
+
+    J_n(x) = \frac{x^n}{2^n \Gamma(n+1)}
+             \,_0F_1\left(n+1,-\frac{x^2}{4}\right)
+
+With *derivative* = `m \ne 0`, the `m`-th derivative
+
+.. math ::
+
+    \frac{d^m}{dx^m} J_n(x)
+
+is computed.
+
+**Plots**
+
+.. literalinclude :: /plots/besselj.py
+.. image :: /plots/besselj.png
+.. literalinclude :: /plots/besselj_c.py
+.. image :: /plots/besselj_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary arguments, and at
+arbitrary precision::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> besselj(2, 1000)
+    -0.024777229528606
+    >>> besselj(4, 0.75)
+    0.000801070086542314
+    >>> besselj(2, 1000j)
+    (-2.48071721019185e+432 + 6.41567059811949e-437j)
+    >>> mp.dps = 25
+    >>> besselj(0.75j, 3+4j)
+    (-2.778118364828153309919653 - 1.5863603889018621585533j)
+    >>> mp.dps = 50
+    >>> besselj(1, pi)
+    0.28461534317975275734531059968613140570981118184947
+
+Arguments may be large::
+
+    >>> mp.dps = 25
+    >>> besselj(0, 10000)
+    -0.007096160353388801477265164
+    >>> besselj(0, 10**10)
+    0.000002175591750246891726859055
+    >>> besselj(2, 10**100)
+    7.337048736538615712436929e-51
+    >>> besselj(2, 10**5*j)
+    (-3.540725411970948860173735e+43426 + 4.4949812409615803110051e-43433j)
+
+The Bessel functions of the first kind satisfy simple
+symmetries around `x = 0`::
+
+    >>> mp.dps = 15
+    >>> nprint([besselj(n,0) for n in range(5)])
+    [1.0, 0.0, 0.0, 0.0, 0.0]
+    >>> nprint([besselj(n,pi) for n in range(5)])
+    [-0.304242, 0.284615, 0.485434, 0.333458, 0.151425]
+    >>> nprint([besselj(n,-pi) for n in range(5)])
+    [-0.304242, -0.284615, 0.485434, -0.333458, 0.151425]
+
+Roots of Bessel functions are often used::
+
+    >>> nprint([findroot(j0, k) for k in [2, 5, 8, 11, 14]])
+    [2.40483, 5.52008, 8.65373, 11.7915, 14.9309]
+    >>> nprint([findroot(j1, k) for k in [3, 7, 10, 13, 16]])
+    [3.83171, 7.01559, 10.1735, 13.3237, 16.4706]
+
+The roots are not periodic, but the distance between successive
+roots asymptotically approaches `2 \pi`. Bessel functions of
+the first kind have the following normalization::
+
+    >>> quadosc(j0, [0, inf], period=2*pi)
+    1.0
+    >>> quadosc(j1, [0, inf], period=2*pi)
+    1.0
+
+For `n = 1/2` or `n = -1/2`, the Bessel function reduces to a
+trigonometric function::
+
+    >>> x = 10
+    >>> besselj(0.5, x), sqrt(2/(pi*x))*sin(x)
+    (-0.13726373575505, -0.13726373575505)
+    >>> besselj(-0.5, x), sqrt(2/(pi*x))*cos(x)
+    (-0.211708866331398, -0.211708866331398)
+
+Derivatives of any order can be computed (negative orders
+correspond to integration)::
+
+    >>> mp.dps = 25
+    >>> besselj(0, 7.5, 1)
+    -0.1352484275797055051822405
+    >>> diff(lambda x: besselj(0,x), 7.5)
+    -0.1352484275797055051822405
+    >>> besselj(0, 7.5, 10)
+    -0.1377811164763244890135677
+    >>> diff(lambda x: besselj(0,x), 7.5, 10)
+    -0.1377811164763244890135677
+    >>> besselj(0,7.5,-1) - besselj(0,3.5,-1)
+    -0.1241343240399987693521378
+    >>> quad(j0, [3.5, 7.5])
+    -0.1241343240399987693521378
+
+Differentiation with a noninteger order gives the fractional derivative
+in the sense of the Riemann-Liouville differintegral, as computed by
+:func:`~mpmath.differint`::
+
+    >>> mp.dps = 15
+    >>> besselj(1, 3.5, 0.75)
+    -0.385977722939384
+    >>> differint(lambda x: besselj(1, x), 3.5, 0.75)
+    -0.385977722939384
+
+"""
+
+besseli = r"""
+``besseli(n, x, derivative=0)`` gives the modified Bessel function of the
+first kind,
+
+.. math ::
+
+    I_n(x) = i^{-n} J_n(ix).
+
+With *derivative* = `m \ne 0`, the `m`-th derivative
+
+.. math ::
+
+    \frac{d^m}{dx^m} I_n(x)
+
+is computed.
+
+**Plots**
+
+.. literalinclude :: /plots/besseli.py
+.. image :: /plots/besseli.png
+.. literalinclude :: /plots/besseli_c.py
+.. image :: /plots/besseli_c.png
+
+**Examples**
+
+Some values of `I_n(x)`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> besseli(0,0)
+    1.0
+    >>> besseli(1,0)
+    0.0
+    >>> besseli(0,1)
+    1.266065877752008335598245
+    >>> besseli(3.5, 2+3j)
+    (-0.2904369752642538144289025 - 0.4469098397654815837307006j)
+
+Arguments may be large::
+
+    >>> besseli(2, 1000)
+    2.480717210191852440616782e+432
+    >>> besseli(2, 10**10)
+    4.299602851624027900335391e+4342944813
+    >>> besseli(2, 6000+10000j)
+    (-2.114650753239580827144204e+2603 + 4.385040221241629041351886e+2602j)
+
+For integers `n`, the following integral representation holds::
+
+    >>> mp.dps = 15
+    >>> n = 3
+    >>> x = 2.3
+    >>> quad(lambda t: exp(x*cos(t))*cos(n*t), [0,pi])/pi
+    0.349223221159309
+    >>> besseli(n,x)
+    0.349223221159309
+
+Derivatives and antiderivatives of any order can be computed::
+
+    >>> mp.dps = 25
+    >>> besseli(2, 7.5, 1)
+    195.8229038931399062565883
+    >>> diff(lambda x: besseli(2,x), 7.5)
+    195.8229038931399062565883
+    >>> besseli(2, 7.5, 10)
+    153.3296508971734525525176
+    >>> diff(lambda x: besseli(2,x), 7.5, 10)
+    153.3296508971734525525176
+    >>> besseli(2,7.5,-1) - besseli(2,3.5,-1)
+    202.5043900051930141956876
+    >>> quad(lambda x: besseli(2,x), [3.5, 7.5])
+    202.5043900051930141956876
+
+"""
+
+bessely = r"""
+``bessely(n, x, derivative=0)`` gives the Bessel function of the second kind,
+
+.. math ::
+
+    Y_n(x) = \frac{J_n(x) \cos(\pi n) - J_{-n}(x)}{\sin(\pi n)}.
+
+For `n` an integer, this formula should be understood as a
+limit. With *derivative* = `m \ne 0`, the `m`-th derivative
+
+.. math ::
+
+    \frac{d^m}{dx^m} Y_n(x)
+
+is computed.
+
+**Plots**
+
+.. literalinclude :: /plots/bessely.py
+.. image :: /plots/bessely.png
+.. literalinclude :: /plots/bessely_c.py
+.. image :: /plots/bessely_c.png
+
+**Examples**
+
+Some values of `Y_n(x)`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> bessely(0,0), bessely(1,0), bessely(2,0)
+    (-inf, -inf, -inf)
+    >>> bessely(1, pi)
+    0.3588729167767189594679827
+    >>> bessely(0.5, 3+4j)
+    (9.242861436961450520325216 - 3.085042824915332562522402j)
+
+Arguments may be large::
+
+    >>> bessely(0, 10000)
+    0.00364780555898660588668872
+    >>> bessely(2.5, 10**50)
+    -4.8952500412050989295774e-26
+    >>> bessely(2.5, -10**50)
+    (0.0 + 4.8952500412050989295774e-26j)
+
+Derivatives and antiderivatives of any order can be computed::
+
+    >>> bessely(2, 3.5, 1)
+    0.3842618820422660066089231
+    >>> diff(lambda x: bessely(2, x), 3.5)
+    0.3842618820422660066089231
+    >>> bessely(0.5, 3.5, 1)
+    -0.2066598304156764337900417
+    >>> diff(lambda x: bessely(0.5, x), 3.5)
+    -0.2066598304156764337900417
+    >>> diff(lambda x: bessely(2, x), 0.5, 10)
+    -208173867409.5547350101511
+    >>> bessely(2, 0.5, 10)
+    -208173867409.5547350101511
+    >>> bessely(2, 100.5, 100)
+    0.02668487547301372334849043
+    >>> quad(lambda x: bessely(2,x), [1,3])
+    -1.377046859093181969213262
+    >>> bessely(2,3,-1) - bessely(2,1,-1)
+    -1.377046859093181969213262
+
+"""
+
+besselk = r"""
+``besselk(n, x)`` gives the modified Bessel function of the
+second kind,
+
+.. math ::
+
+    K_n(x) = \frac{\pi}{2} \frac{I_{-n}(x)-I_{n}(x)}{\sin(\pi n)}
+
+For `n` an integer, this formula should be understood as a
+limit.
+
+**Plots**
+
+.. literalinclude :: /plots/besselk.py
+.. image :: /plots/besselk.png
+.. literalinclude :: /plots/besselk_c.py
+.. image :: /plots/besselk_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> besselk(0,1)
+    0.4210244382407083333356274
+    >>> besselk(0, -1)
+    (0.4210244382407083333356274 - 3.97746326050642263725661j)
+    >>> besselk(3.5, 2+3j)
+    (-0.02090732889633760668464128 + 0.2464022641351420167819697j)
+    >>> besselk(2+3j, 0.5)
+    (0.9615816021726349402626083 + 0.1918250181801757416908224j)
+
+Arguments may be large::
+
+    >>> besselk(0, 100)
+    4.656628229175902018939005e-45
+    >>> besselk(1, 10**6)
+    4.131967049321725588398296e-434298
+    >>> besselk(1, 10**6*j)
+    (0.001140348428252385844876706 - 0.0005200017201681152909000961j)
+    >>> besselk(4.5, fmul(10**50, j, exact=True))
+    (1.561034538142413947789221e-26 + 1.243554598118700063281496e-25j)
+
+The point `x = 0` is a singularity (logarithmic if `n = 0`)::
+
+    >>> besselk(0,0)
+    +inf
+    >>> besselk(1,0)
+    +inf
+    >>> for n in range(-4, 5):
+    ...     print(besselk(n, '1e-1000'))
+    ...
+    4.8e+4001
+    8.0e+3000
+    2.0e+2000
+    1.0e+1000
+    2302.701024509704096466802
+    1.0e+1000
+    2.0e+2000
+    8.0e+3000
+    4.8e+4001
+
+"""
+
+hankel1 = r"""
+``hankel1(n,x)`` computes the Hankel function of the first kind,
+which is the complex combination of Bessel functions given by
+
+.. math ::
+
+    H_n^{(1)}(x) = J_n(x) + i Y_n(x).
+
+**Plots**
+
+.. literalinclude :: /plots/hankel1.py
+.. image :: /plots/hankel1.png
+.. literalinclude :: /plots/hankel1_c.py
+.. image :: /plots/hankel1_c.png
+
+**Examples**
+
+The Hankel function is generally complex-valued::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hankel1(2, pi)
+    (0.4854339326315091097054957 - 0.0999007139290278787734903j)
+    >>> hankel1(3.5, pi)
+    (0.2340002029630507922628888 - 0.6419643823412927142424049j)
+"""
+
+hankel2 = r"""
+``hankel2(n,x)`` computes the Hankel function of the second kind,
+which is the complex combination of Bessel functions given by
+
+.. math ::
+
+    H_n^{(2)}(x) = J_n(x) - i Y_n(x).
+
+**Plots**
+
+.. literalinclude :: /plots/hankel2.py
+.. image :: /plots/hankel2.png
+.. literalinclude :: /plots/hankel2_c.py
+.. image :: /plots/hankel2_c.png
+
+**Examples**
+
+The Hankel function is generally complex-valued::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> hankel2(2, pi)
+    (0.4854339326315091097054957 + 0.0999007139290278787734903j)
+    >>> hankel2(3.5, pi)
+    (0.2340002029630507922628888 + 0.6419643823412927142424049j)
+"""
+
+lambertw = r"""
+The Lambert W function `W(z)` is defined as the inverse function
+of `w \exp(w)`. In other words, the value of `W(z)` is such that
+`z = W(z) \exp(W(z))` for any complex number `z`.
+
+The Lambert W function is a multivalued function with infinitely
+many branches `W_k(z)`, indexed by `k \in \mathbb{Z}`. Each branch
+gives a different solution `w` of the equation `z = w \exp(w)`.
+All branches are supported by :func:`~mpmath.lambertw`:
+
+* ``lambertw(z)`` gives the principal solution (branch 0)
+
+* ``lambertw(z, k)`` gives the solution on branch `k`
+
+The Lambert W function has two partially real branches: the
+principal branch (`k = 0`) is real for real `z > -1/e`, and the
+`k = -1` branch is real for `-1/e < z < 0`. All branches except
+`k = 0` have a logarithmic singularity at `z = 0`.
+
+The definition, implementation and choice of branches
+is based on [Corless]_.
+
+**Plots**
+
+.. literalinclude :: /plots/lambertw.py
+.. image :: /plots/lambertw.png
+.. literalinclude :: /plots/lambertw_c.py
+.. image :: /plots/lambertw_c.png
+
+**Basic examples**
+
+The Lambert W function is the inverse of `w \exp(w)`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> w = lambertw(1)
+    >>> w
+    0.5671432904097838729999687
+    >>> w*exp(w)
+    1.0
+
+Any branch gives a valid inverse::
+
+    >>> w = lambertw(1, k=3)
+    >>> w
+    (-2.853581755409037807206819 + 17.11353553941214591260783j)
+    >>> w = lambertw(1, k=25)
+    >>> w
+    (-5.047020464221569709378686 + 155.4763860949415867162066j)
+    >>> chop(w*exp(w))
+    1.0
+
+**Applications to equation-solving**
+
+The Lambert W function may be used to solve various kinds of
+equations, such as finding the value of the infinite power
+tower `z^{z^{z^{\ldots}}}`::
+
+    >>> def tower(z, n):
+    ...     if n == 0:
+    ...         return z
+    ...     return z ** tower(z, n-1)
+    ...
+    >>> tower(mpf(0.5), 100)
+    0.6411857445049859844862005
+    >>> -lambertw(-log(0.5))/log(0.5)
+    0.6411857445049859844862005
+
+**Properties**
+
+The Lambert W function grows roughly like the natural logarithm
+for large arguments::
+
+    >>> lambertw(1000); log(1000)
+    5.249602852401596227126056
+    6.907755278982137052053974
+    >>> lambertw(10**100); log(10**100)
+    224.8431064451185015393731
+    230.2585092994045684017991
+
+The principal branch of the Lambert W function has a rational
+Taylor series expansion around `z = 0`::
+
+    >>> nprint(taylor(lambertw, 0, 6), 10)
+    [0.0, 1.0, -1.0, 1.5, -2.666666667, 5.208333333, -10.8]
+
+Some special values and limits are::
+
+    >>> lambertw(0)
+    0.0
+    >>> lambertw(1)
+    0.5671432904097838729999687
+    >>> lambertw(e)
+    1.0
+    >>> lambertw(inf)
+    +inf
+    >>> lambertw(0, k=-1)
+    -inf
+    >>> lambertw(0, k=3)
+    -inf
+    >>> lambertw(inf, k=2)
+    (+inf + 12.56637061435917295385057j)
+    >>> lambertw(inf, k=3)
+    (+inf + 18.84955592153875943077586j)
+    >>> lambertw(-inf, k=3)
+    (+inf + 21.9911485751285526692385j)
+
+The `k = 0` and `k = -1` branches join at `z = -1/e` where
+`W(z) = -1` for both branches. Since `-1/e` can only be represented
+approximately with binary floating-point numbers, evaluating the
+Lambert W function at this point only gives `-1` approximately::
+
+    >>> lambertw(-1/e, 0)
+    -0.9999999999998371330228251
+    >>> lambertw(-1/e, -1)
+    -1.000000000000162866977175
+
+If `-1/e` happens to round in the negative direction, there might be
+a small imaginary part::
+
+    >>> mp.dps = 15
+    >>> lambertw(-1/e)
+    (-1.0 + 8.22007971483662e-9j)
+    >>> lambertw(-1/e+eps)
+    -0.999999966242188
+
+**References**
+
+1. [Corless]_
+"""
+
+barnesg = r"""
+Evaluates the Barnes G-function, which generalizes the
+superfactorial (:func:`~mpmath.superfac`) and by extension also the
+hyperfactorial (:func:`~mpmath.hyperfac`) to the complex numbers
+in an analogous way to how the gamma function generalizes
+the ordinary factorial.
+
+The Barnes G-function may be defined in terms of a Weierstrass
+product:
+
+.. math ::
+
+    G(z+1) = (2\pi)^{z/2} e^{-[z(z+1)+\gamma z^2]/2}
+    \prod_{n=1}^\infty
+    \left[\left(1+\frac{z}{n}\right)^ne^{-z+z^2/(2n)}\right]
+
+For positive integers `n`, we have have relation to superfactorials
+`G(n) = \mathrm{sf}(n-2) = 0! \cdot 1! \cdots (n-2)!`.
+
+**Examples**
+
+Some elementary values and limits of the Barnes G-function::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> barnesg(1), barnesg(2), barnesg(3)
+    (1.0, 1.0, 1.0)
+    >>> barnesg(4)
+    2.0
+    >>> barnesg(5)
+    12.0
+    >>> barnesg(6)
+    288.0
+    >>> barnesg(7)
+    34560.0
+    >>> barnesg(8)
+    24883200.0
+    >>> barnesg(inf)
+    +inf
+    >>> barnesg(0), barnesg(-1), barnesg(-2)
+    (0.0, 0.0, 0.0)
+
+Closed-form values are known for some rational arguments::
+
+    >>> barnesg('1/2')
+    0.603244281209446
+    >>> sqrt(exp(0.25+log(2)/12)/sqrt(pi)/glaisher**3)
+    0.603244281209446
+    >>> barnesg('1/4')
+    0.29375596533861
+    >>> nthroot(exp('3/8')/exp(catalan/pi)/
+    ...      gamma(0.25)**3/sqrt(glaisher)**9, 4)
+    0.29375596533861
+
+The Barnes G-function satisfies the functional equation
+`G(z+1) = \Gamma(z) G(z)`::
+
+    >>> z = pi
+    >>> barnesg(z+1)
+    2.39292119327948
+    >>> gamma(z)*barnesg(z)
+    2.39292119327948
+
+The asymptotic growth rate of the Barnes G-function is related to
+the Glaisher-Kinkelin constant::
+
+    >>> limit(lambda n: barnesg(n+1)/(n**(n**2/2-mpf(1)/12)*
+    ...     (2*pi)**(n/2)*exp(-3*n**2/4)), inf)
+    0.847536694177301
+    >>> exp('1/12')/glaisher
+    0.847536694177301
+
+The Barnes G-function can be differentiated in closed form::
+
+    >>> z = 3
+    >>> diff(barnesg, z)
+    0.264507203401607
+    >>> barnesg(z)*((z-1)*psi(0,z)-z+(log(2*pi)+1)/2)
+    0.264507203401607
+
+Evaluation is supported for arbitrary arguments and at arbitrary
+precision::
+
+    >>> barnesg(6.5)
+    2548.7457695685
+    >>> barnesg(-pi)
+    0.00535976768353037
+    >>> barnesg(3+4j)
+    (-0.000676375932234244 - 4.42236140124728e-5j)
+    >>> mp.dps = 50
+    >>> barnesg(1/sqrt(2))
+    0.81305501090451340843586085064413533788206204124732
+    >>> q = barnesg(10j)
+    >>> q.real
+    0.000000000021852360840356557241543036724799812371995850552234
+    >>> q.imag
+    -0.00000000000070035335320062304849020654215545839053210041457588
+    >>> mp.dps = 15
+    >>> barnesg(100)
+    3.10361006263698e+6626
+    >>> barnesg(-101)
+    0.0
+    >>> barnesg(-10.5)
+    5.94463017605008e+25
+    >>> barnesg(-10000.5)
+    -6.14322868174828e+167480422
+    >>> barnesg(1000j)
+    (5.21133054865546e-1173597 + 4.27461836811016e-1173597j)
+    >>> barnesg(-1000+1000j)
+    (2.43114569750291e+1026623 + 2.24851410674842e+1026623j)
+
+
+**References**
+
+1. Whittaker & Watson, *A Course of Modern Analysis*,
+   Cambridge University Press, 4th edition (1927), p.264
+2. http://en.wikipedia.org/wiki/Barnes_G-function
+3. http://mathworld.wolfram.com/BarnesG-Function.html
+
+"""
+
+superfac = r"""
+Computes the superfactorial, defined as the product of
+consecutive factorials
+
+.. math ::
+
+    \mathrm{sf}(n) = \prod_{k=1}^n k!
+
+For general complex `z`, `\mathrm{sf}(z)` is defined
+in terms of the Barnes G-function (see :func:`~mpmath.barnesg`).
+
+**Examples**
+
+The first few superfactorials are (OEIS A000178)::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(10):
+    ...     print("%s %s" % (n, superfac(n)))
+    ...
+    0 1.0
+    1 1.0
+    2 2.0
+    3 12.0
+    4 288.0
+    5 34560.0
+    6 24883200.0
+    7 125411328000.0
+    8 5.05658474496e+15
+    9 1.83493347225108e+21
+
+Superfactorials grow very rapidly::
+
+    >>> superfac(1000)
+    3.24570818422368e+1177245
+    >>> superfac(10**10)
+    2.61398543581249e+467427913956904067453
+
+Evaluation is supported for arbitrary arguments::
+
+    >>> mp.dps = 25
+    >>> superfac(pi)
+    17.20051550121297985285333
+    >>> superfac(2+3j)
+    (-0.005915485633199789627466468 + 0.008156449464604044948738263j)
+    >>> diff(superfac, 1)
+    0.2645072034016070205673056
+
+**References**
+
+1. http://oeis.org/A000178
+
+"""
+
+
+hyperfac = r"""
+Computes the hyperfactorial, defined for integers as the product
+
+.. math ::
+
+    H(n) = \prod_{k=1}^n k^k.
+
+
+The hyperfactorial satisfies the recurrence formula `H(z) = z^z H(z-1)`.
+It can be defined more generally in terms of the Barnes G-function (see
+:func:`~mpmath.barnesg`) and the gamma function by the formula
+
+.. math ::
+
+    H(z) = \frac{\Gamma(z+1)^z}{G(z)}.
+
+The extension to complex numbers can also be done via
+the integral representation
+
+.. math ::
+
+    H(z) = (2\pi)^{-z/2} \exp \left[
+        {z+1 \choose 2} + \int_0^z \log(t!)\,dt
+        \right].
+
+**Examples**
+
+The rapidly-growing sequence of hyperfactorials begins
+(OEIS A002109)::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(10):
+    ...     print("%s %s" % (n, hyperfac(n)))
+    ...
+    0 1.0
+    1 1.0
+    2 4.0
+    3 108.0
+    4 27648.0
+    5 86400000.0
+    6 4031078400000.0
+    7 3.3197663987712e+18
+    8 5.56964379417266e+25
+    9 2.15779412229419e+34
+
+Some even larger hyperfactorials are::
+
+    >>> hyperfac(1000)
+    5.46458120882585e+1392926
+    >>> hyperfac(10**10)
+    4.60408207642219e+489142638002418704309
+
+The hyperfactorial can be evaluated for arbitrary arguments::
+
+    >>> hyperfac(0.5)
+    0.880449235173423
+    >>> diff(hyperfac, 1)
+    0.581061466795327
+    >>> hyperfac(pi)
+    205.211134637462
+    >>> hyperfac(-10+1j)
+    (3.01144471378225e+46 - 2.45285242480185e+46j)
+
+The recurrence property of the hyperfactorial holds
+generally::
+
+    >>> z = 3-4*j
+    >>> hyperfac(z)
+    (-4.49795891462086e-7 - 6.33262283196162e-7j)
+    >>> z**z * hyperfac(z-1)
+    (-4.49795891462086e-7 - 6.33262283196162e-7j)
+    >>> z = mpf(-0.6)
+    >>> chop(z**z * hyperfac(z-1))
+    1.28170142849352
+    >>> hyperfac(z)
+    1.28170142849352
+
+The hyperfactorial may also be computed using the integral
+definition::
+
+    >>> z = 2.5
+    >>> hyperfac(z)
+    15.9842119922237
+    >>> (2*pi)**(-z/2)*exp(binomial(z+1,2) +
+    ...     quad(lambda t: loggamma(t+1), [0, z]))
+    15.9842119922237
+
+:func:`~mpmath.hyperfac` supports arbitrary-precision evaluation::
+
+    >>> mp.dps = 50
+    >>> hyperfac(10)
+    215779412229418562091680268288000000000000000.0
+    >>> hyperfac(1/sqrt(2))
+    0.89404818005227001975423476035729076375705084390942
+
+**References**
+
+1. http://oeis.org/A002109
+2. http://mathworld.wolfram.com/Hyperfactorial.html
+
+"""
+
+rgamma = r"""
+Computes the reciprocal of the gamma function, `1/\Gamma(z)`. This
+function evaluates to zero at the poles
+of the gamma function, `z = 0, -1, -2, \ldots`.
+
+**Examples**
+
+Basic examples::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> rgamma(1)
+    1.0
+    >>> rgamma(4)
+    0.1666666666666666666666667
+    >>> rgamma(0); rgamma(-1)
+    0.0
+    0.0
+    >>> rgamma(1000)
+    2.485168143266784862783596e-2565
+    >>> rgamma(inf)
+    0.0
+
+A definite integral that can be evaluated in terms of elementary
+integrals::
+
+    >>> quad(rgamma, [0,inf])
+    2.807770242028519365221501
+    >>> e + quad(lambda t: exp(-t)/(pi**2+log(t)**2), [0,inf])
+    2.807770242028519365221501
+"""
+
+loggamma = r"""
+Computes the principal branch of the log-gamma function,
+`\ln \Gamma(z)`. Unlike `\ln(\Gamma(z))`, which has infinitely many
+complex branch cuts, the principal log-gamma function only has a single
+branch cut along the negative half-axis. The principal branch
+continuously matches the asymptotic Stirling expansion
+
+.. math ::
+
+    \ln \Gamma(z) \sim \frac{\ln(2 \pi)}{2} +
+        \left(z-\frac{1}{2}\right) \ln(z) - z + O(z^{-1}).
+
+The real parts of both functions agree, but their imaginary
+parts generally differ by `2 n \pi` for some `n \in \mathbb{Z}`.
+They coincide for `z \in \mathbb{R}, z > 0`.
+
+Computationally, it is advantageous to use :func:`~mpmath.loggamma`
+instead of :func:`~mpmath.gamma` for extremely large arguments.
+
+**Examples**
+
+Comparing with `\ln(\Gamma(z))`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> loggamma('13.2'); log(gamma('13.2'))
+    20.49400419456603678498394
+    20.49400419456603678498394
+    >>> loggamma(3+4j)
+    (-1.756626784603784110530604 + 4.742664438034657928194889j)
+    >>> log(gamma(3+4j))
+    (-1.756626784603784110530604 - 1.540520869144928548730397j)
+    >>> log(gamma(3+4j)) + 2*pi*j
+    (-1.756626784603784110530604 + 4.742664438034657928194889j)
+
+Note the imaginary parts for negative arguments::
+
+    >>> loggamma(-0.5); loggamma(-1.5); loggamma(-2.5)
+    (1.265512123484645396488946 - 3.141592653589793238462643j)
+    (0.8600470153764810145109327 - 6.283185307179586476925287j)
+    (-0.05624371649767405067259453 - 9.42477796076937971538793j)
+
+Some special values::
+
+    >>> loggamma(1); loggamma(2)
+    0.0
+    0.0
+    >>> loggamma(3); +ln2
+    0.6931471805599453094172321
+    0.6931471805599453094172321
+    >>> loggamma(3.5); log(15*sqrt(pi)/8)
+    1.200973602347074224816022
+    1.200973602347074224816022
+    >>> loggamma(inf)
+    +inf
+
+Huge arguments are permitted::
+
+    >>> loggamma('1e30')
+    6.807755278982137052053974e+31
+    >>> loggamma('1e300')
+    6.897755278982137052053974e+302
+    >>> loggamma('1e3000')
+    6.906755278982137052053974e+3003
+    >>> loggamma('1e100000000000000000000')
+    2.302585092994045684007991e+100000000000000000020
+    >>> loggamma('1e30j')
+    (-1.570796326794896619231322e+30 + 6.807755278982137052053974e+31j)
+    >>> loggamma('1e300j')
+    (-1.570796326794896619231322e+300 + 6.897755278982137052053974e+302j)
+    >>> loggamma('1e3000j')
+    (-1.570796326794896619231322e+3000 + 6.906755278982137052053974e+3003j)
+
+The log-gamma function can be integrated analytically
+on any interval of unit length::
+
+    >>> z = 0
+    >>> quad(loggamma, [z,z+1]); log(2*pi)/2
+    0.9189385332046727417803297
+    0.9189385332046727417803297
+    >>> z = 3+4j
+    >>> quad(loggamma, [z,z+1]); (log(z)-1)*z + log(2*pi)/2
+    (-0.9619286014994750641314421 + 5.219637303741238195688575j)
+    (-0.9619286014994750641314421 + 5.219637303741238195688575j)
+
+The derivatives of the log-gamma function are given by the
+polygamma function (:func:`~mpmath.psi`)::
+
+    >>> diff(loggamma, -4+3j); psi(0, -4+3j)
+    (1.688493531222971393607153 + 2.554898911356806978892748j)
+    (1.688493531222971393607153 + 2.554898911356806978892748j)
+    >>> diff(loggamma, -4+3j, 2); psi(1, -4+3j)
+    (-0.1539414829219882371561038 - 0.1020485197430267719746479j)
+    (-0.1539414829219882371561038 - 0.1020485197430267719746479j)
+
+The log-gamma function satisfies an additive form of the
+recurrence relation for the ordinary gamma function::
+
+    >>> z = 2+3j
+    >>> loggamma(z); loggamma(z+1) - log(z)
+    (-2.092851753092733349564189 + 2.302396543466867626153708j)
+    (-2.092851753092733349564189 + 2.302396543466867626153708j)
+
+"""
+
+siegeltheta = r"""
+Computes the Riemann-Siegel theta function,
+
+.. math ::
+
+    \theta(t) = \frac{
+    \log\Gamma\left(\frac{1+2it}{4}\right) -
+    \log\Gamma\left(\frac{1-2it}{4}\right)
+    }{2i} - \frac{\log \pi}{2} t.
+
+The Riemann-Siegel theta function is important in
+providing the phase factor for the Z-function
+(see :func:`~mpmath.siegelz`). Evaluation is supported for real and
+complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> siegeltheta(0)
+    0.0
+    >>> siegeltheta(inf)
+    +inf
+    >>> siegeltheta(-inf)
+    -inf
+    >>> siegeltheta(1)
+    -1.767547952812290388302216
+    >>> siegeltheta(10+0.25j)
+    (-3.068638039426838572528867 + 0.05804937947429712998395177j)
+
+Arbitrary derivatives may be computed with derivative = k
+
+    >>> siegeltheta(1234, derivative=2)
+    0.0004051864079114053109473741
+    >>> diff(siegeltheta, 1234, n=2)
+    0.0004051864079114053109473741
+
+
+The Riemann-Siegel theta function has odd symmetry around `t = 0`,
+two local extreme points and three real roots including 0 (located
+symmetrically)::
+
+    >>> nprint(chop(taylor(siegeltheta, 0, 5)))
+    [0.0, -2.68609, 0.0, 2.69433, 0.0, -6.40218]
+    >>> findroot(diffun(siegeltheta), 7)
+    6.28983598883690277966509
+    >>> findroot(siegeltheta, 20)
+    17.84559954041086081682634
+
+For large `t`, there is a famous asymptotic formula
+for `\theta(t)`, to first order given by::
+
+    >>> t = mpf(10**6)
+    >>> siegeltheta(t)
+    5488816.353078403444882823
+    >>> -t*log(2*pi/t)/2-t/2
+    5488816.745777464310273645
+"""
+
+grampoint = r"""
+Gives the `n`-th Gram point `g_n`, defined as the solution
+to the equation `\theta(g_n) = \pi n` where `\theta(t)`
+is the Riemann-Siegel theta function (:func:`~mpmath.siegeltheta`).
+
+The first few Gram points are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> grampoint(0)
+    17.84559954041086081682634
+    >>> grampoint(1)
+    23.17028270124630927899664
+    >>> grampoint(2)
+    27.67018221781633796093849
+    >>> grampoint(3)
+    31.71797995476405317955149
+
+Checking the definition::
+
+    >>> siegeltheta(grampoint(3))
+    9.42477796076937971538793
+    >>> 3*pi
+    9.42477796076937971538793
+
+A large Gram point::
+
+    >>> grampoint(10**10)
+    3293531632.728335454561153
+
+Gram points are useful when studying the Z-function
+(:func:`~mpmath.siegelz`). See the documentation of that function
+for additional examples.
+
+:func:`~mpmath.grampoint` can solve the defining equation for
+nonintegral `n`. There is a fixed point where `g(x) = x`::
+
+    >>> findroot(lambda x: grampoint(x) - x, 10000)
+    9146.698193171459265866198
+
+**References**
+
+1. http://mathworld.wolfram.com/GramPoint.html
+
+"""
+
+siegelz = r"""
+Computes the Z-function, also known as the Riemann-Siegel Z function,
+
+.. math ::
+
+    Z(t) = e^{i \theta(t)} \zeta(1/2+it)
+
+where `\zeta(s)` is the Riemann zeta function (:func:`~mpmath.zeta`)
+and where `\theta(t)` denotes the Riemann-Siegel theta function
+(see :func:`~mpmath.siegeltheta`).
+
+Evaluation is supported for real and complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> siegelz(1)
+    -0.7363054628673177346778998
+    >>> siegelz(3+4j)
+    (-0.1852895764366314976003936 - 0.2773099198055652246992479j)
+
+The first four derivatives are supported, using the
+optional *derivative* keyword argument::
+
+    >>> siegelz(1234567, derivative=3)
+    56.89689348495089294249178
+    >>> diff(siegelz, 1234567, n=3)
+    56.89689348495089294249178
+
+
+The Z-function has a Maclaurin expansion::
+
+    >>> nprint(chop(taylor(siegelz, 0, 4)))
+    [-1.46035, 0.0, 2.73588, 0.0, -8.39357]
+
+The Z-function `Z(t)` is equal to `\pm |\zeta(s)|` on the
+critical line `s = 1/2+it` (i.e. for real arguments `t`
+to `Z`).  Its zeros coincide with those of the Riemann zeta
+function::
+
+    >>> findroot(siegelz, 14)
+    14.13472514173469379045725
+    >>> findroot(siegelz, 20)
+    21.02203963877155499262848
+    >>> findroot(zeta, 0.5+14j)
+    (0.5 + 14.13472514173469379045725j)
+    >>> findroot(zeta, 0.5+20j)
+    (0.5 + 21.02203963877155499262848j)
+
+Since the Z-function is real-valued on the critical line
+(and unlike `|\zeta(s)|` analytic), it is useful for
+investigating the zeros of the Riemann zeta function.
+For example, one can use a root-finding algorithm based
+on sign changes::
+
+    >>> findroot(siegelz, [100, 200], solver='bisect')
+    176.4414342977104188888926
+
+To locate roots, Gram points `g_n` which can be computed
+by :func:`~mpmath.grampoint` are useful. If `(-1)^n Z(g_n)` is
+positive for two consecutive `n`, then `Z(t)` must have
+a zero between those points::
+
+    >>> g10 = grampoint(10)
+    >>> g11 = grampoint(11)
+    >>> (-1)**10 * siegelz(g10) > 0
+    True
+    >>> (-1)**11 * siegelz(g11) > 0
+    True
+    >>> findroot(siegelz, [g10, g11], solver='bisect')
+    56.44624769706339480436776
+    >>> g10, g11
+    (54.67523744685325626632663, 57.54516517954725443703014)
+
+"""
+
+riemannr = r"""
+Evaluates the Riemann R function, a smooth approximation of the
+prime counting function `\pi(x)` (see :func:`~mpmath.primepi`). The Riemann
+R function gives a fast numerical approximation useful e.g. to
+roughly estimate the number of primes in a given interval.
+
+The Riemann R function is computed using the rapidly convergent Gram
+series,
+
+.. math ::
+
+    R(x) = 1 + \sum_{k=1}^{\infty}
+        \frac{\log^k x}{k k! \zeta(k+1)}.
+
+From the Gram series, one sees that the Riemann R function is a
+well-defined analytic function (except for a branch cut along
+the negative real half-axis); it can be evaluated for arbitrary
+real or complex arguments.
+
+The Riemann R function gives a very accurate approximation
+of the prime counting function. For example, it is wrong by at
+most 2 for `x < 1000`, and for `x = 10^9` differs from the exact
+value of `\pi(x)` by 79, or less than two parts in a million.
+It is about 10 times more accurate than the logarithmic integral
+estimate (see :func:`~mpmath.li`), which however is even faster to evaluate.
+It is orders of magnitude more accurate than the extremely
+fast `x/\log x` estimate.
+
+**Examples**
+
+For small arguments, the Riemann R function almost exactly
+gives the prime counting function if rounded to the nearest
+integer::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> primepi(50), riemannr(50)
+    (15, 14.9757023241462)
+    >>> max(abs(primepi(n)-int(round(riemannr(n)))) for n in range(100))
+    1
+    >>> max(abs(primepi(n)-int(round(riemannr(n)))) for n in range(300))
+    2
+
+The Riemann R function can be evaluated for arguments far too large
+for exact determination of `\pi(x)` to be computationally
+feasible with any presently known algorithm::
+
+    >>> riemannr(10**30)
+    1.46923988977204e+28
+    >>> riemannr(10**100)
+    4.3619719871407e+97
+    >>> riemannr(10**1000)
+    4.3448325764012e+996
+
+A comparison of the Riemann R function and logarithmic integral estimates
+for `\pi(x)` using exact values of `\pi(10^n)` up to `n = 9`.
+The fractional error is shown in parentheses::
+
+    >>> exact = [4,25,168,1229,9592,78498,664579,5761455,50847534]
+    >>> for n, p in enumerate(exact):
+    ...     n += 1
+    ...     r, l = riemannr(10**n), li(10**n)
+    ...     rerr, lerr = nstr((r-p)/p,3), nstr((l-p)/p,3)
+    ...     print("%i %i %s(%s) %s(%s)" % (n, p, r, rerr, l, lerr))
+    ...
+    1 4 4.56458314100509(0.141) 6.1655995047873(0.541)
+    2 25 25.6616332669242(0.0265) 30.1261415840796(0.205)
+    3 168 168.359446281167(0.00214) 177.609657990152(0.0572)
+    4 1229 1226.93121834343(-0.00168) 1246.13721589939(0.0139)
+    5 9592 9587.43173884197(-0.000476) 9629.8090010508(0.00394)
+    6 78498 78527.3994291277(0.000375) 78627.5491594622(0.00165)
+    7 664579 664667.447564748(0.000133) 664918.405048569(0.000511)
+    8 5761455 5761551.86732017(1.68e-5) 5762209.37544803(0.000131)
+    9 50847534 50847455.4277214(-1.55e-6) 50849234.9570018(3.35e-5)
+
+The derivative of the Riemann R function gives the approximate
+probability for a number of magnitude `x` to be prime::
+
+    >>> diff(riemannr, 1000)
+    0.141903028110784
+    >>> mpf(primepi(1050) - primepi(950)) / 100
+    0.15
+
+Evaluation is supported for arbitrary arguments and at arbitrary
+precision::
+
+    >>> mp.dps = 30
+    >>> riemannr(7.5)
+    3.72934743264966261918857135136
+    >>> riemannr(-4+2j)
+    (-0.551002208155486427591793957644 + 2.16966398138119450043195899746j)
+
+"""
+
+primepi = r"""
+Evaluates the prime counting function, `\pi(x)`, which gives
+the number of primes less than or equal to `x`. The argument
+`x` may be fractional.
+
+The prime counting function is very expensive to evaluate
+precisely for large `x`, and the present implementation is
+not optimized in any way. For numerical approximation of the
+prime counting function, it is better to use :func:`~mpmath.primepi2`
+or :func:`~mpmath.riemannr`.
+
+Some values of the prime counting function::
+
+    >>> from mpmath import *
+    >>> [primepi(k) for k in range(20)]
+    [0, 0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8]
+    >>> primepi(3.5)
+    2
+    >>> primepi(100000)
+    9592
+
+"""
+
+primepi2 = r"""
+Returns an interval (as an ``mpi`` instance) providing bounds
+for the value of the prime counting function `\pi(x)`. For small
+`x`, :func:`~mpmath.primepi2` returns an exact interval based on
+the output of :func:`~mpmath.primepi`. For `x > 2656`, a loose interval
+based on Schoenfeld's inequality
+
+.. math ::
+
+    |\pi(x) - \mathrm{li}(x)| < \frac{\sqrt x \log x}{8 \pi}
+
+is returned. This estimate is rigorous assuming the truth of
+the Riemann hypothesis, and can be computed very quickly.
+
+**Examples**
+
+Exact values of the prime counting function for small `x`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> iv.dps = 15; iv.pretty = True
+    >>> primepi2(10)
+    [4.0, 4.0]
+    >>> primepi2(100)
+    [25.0, 25.0]
+    >>> primepi2(1000)
+    [168.0, 168.0]
+
+Loose intervals are generated for moderately large `x`:
+
+    >>> primepi2(10000), primepi(10000)
+    ([1209.0, 1283.0], 1229)
+    >>> primepi2(50000), primepi(50000)
+    ([5070.0, 5263.0], 5133)
+
+As `x` increases, the absolute error gets worse while the relative
+error improves. The exact value of `\pi(10^{23})` is
+1925320391606803968923, and :func:`~mpmath.primepi2` gives 9 significant
+digits::
+
+    >>> p = primepi2(10**23)
+    >>> p
+    [1.9253203909477020467e+21, 1.925320392280406229e+21]
+    >>> mpf(p.delta) / mpf(p.a)
+    6.9219865355293e-10
+
+A more precise, nonrigorous estimate for `\pi(x)` can be
+obtained using the Riemann R function (:func:`~mpmath.riemannr`).
+For large enough `x`, the value returned by :func:`~mpmath.primepi2`
+essentially amounts to a small perturbation of the value returned by
+:func:`~mpmath.riemannr`::
+
+    >>> primepi2(10**100)
+    [4.3619719871407024816e+97, 4.3619719871407032404e+97]
+    >>> riemannr(10**100)
+    4.3619719871407e+97
+"""
+
+primezeta = r"""
+Computes the prime zeta function, which is defined
+in analogy with the Riemann zeta function (:func:`~mpmath.zeta`)
+as
+
+.. math ::
+
+    P(s) = \sum_p \frac{1}{p^s}
+
+where the sum is taken over all prime numbers `p`. Although
+this sum only converges for `\mathrm{Re}(s) > 1`, the
+function is defined by analytic continuation in the
+half-plane `\mathrm{Re}(s) > 0`.
+
+**Examples**
+
+Arbitrary-precision evaluation for real and complex arguments is
+supported::
+
+    >>> from mpmath import *
+    >>> mp.dps = 30; mp.pretty = True
+    >>> primezeta(2)
+    0.452247420041065498506543364832
+    >>> primezeta(pi)
+    0.15483752698840284272036497397
+    >>> mp.dps = 50
+    >>> primezeta(3)
+    0.17476263929944353642311331466570670097541212192615
+    >>> mp.dps = 20
+    >>> primezeta(3+4j)
+    (-0.12085382601645763295 - 0.013370403397787023602j)
+
+The prime zeta function has a logarithmic pole at `s = 1`,
+with residue equal to the difference of the Mertens and
+Euler constants::
+
+    >>> primezeta(1)
+    +inf
+    >>> extradps(25)(lambda x: primezeta(1+x)+log(x))(+eps)
+    -0.31571845205389007685
+    >>> mertens-euler
+    -0.31571845205389007685
+
+The analytic continuation to `0 < \mathrm{Re}(s) \le 1`
+is implemented. In this strip the function exhibits
+very complex behavior; on the unit interval, it has poles at
+`1/n` for every squarefree integer `n`::
+
+    >>> primezeta(0.5)         # Pole at s = 1/2
+    (-inf + 3.1415926535897932385j)
+    >>> primezeta(0.25)
+    (-1.0416106801757269036 + 0.52359877559829887308j)
+    >>> primezeta(0.5+10j)
+    (0.54892423556409790529 + 0.45626803423487934264j)
+
+Although evaluation works in principle for any `\mathrm{Re}(s) > 0`,
+it should be noted that the evaluation time increases exponentially
+as `s` approaches the imaginary axis.
+
+For large `\mathrm{Re}(s)`, `P(s)` is asymptotic to `2^{-s}`::
+
+    >>> primezeta(inf)
+    0.0
+    >>> primezeta(10), mpf(2)**-10
+    (0.00099360357443698021786, 0.0009765625)
+    >>> primezeta(1000)
+    9.3326361850321887899e-302
+    >>> primezeta(1000+1000j)
+    (-3.8565440833654995949e-302 - 8.4985390447553234305e-302j)
+
+**References**
+
+Carl-Erik Froberg, "On the prime zeta function",
+BIT 8 (1968), pp. 187-202.
+
+"""
+
+bernpoly = r"""
+Evaluates the Bernoulli polynomial `B_n(z)`.
+
+The first few Bernoulli polynomials are::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(6):
+    ...     nprint(chop(taylor(lambda x: bernpoly(n,x), 0, n)))
+    ...
+    [1.0]
+    [-0.5, 1.0]
+    [0.166667, -1.0, 1.0]
+    [0.0, 0.5, -1.5, 1.0]
+    [-0.0333333, 0.0, 1.0, -2.0, 1.0]
+    [0.0, -0.166667, 0.0, 1.66667, -2.5, 1.0]
+
+At `z = 0`, the Bernoulli polynomial evaluates to a
+Bernoulli number (see :func:`~mpmath.bernoulli`)::
+
+    >>> bernpoly(12, 0), bernoulli(12)
+    (-0.253113553113553, -0.253113553113553)
+    >>> bernpoly(13, 0), bernoulli(13)
+    (0.0, 0.0)
+
+Evaluation is accurate for large `n` and small `z`::
+
+    >>> mp.dps = 25
+    >>> bernpoly(100, 0.5)
+    2.838224957069370695926416e+78
+    >>> bernpoly(1000, 10.5)
+    5.318704469415522036482914e+1769
+
+"""
+
+polylog = r"""
+Computes the polylogarithm, defined by the sum
+
+.. math ::
+
+    \mathrm{Li}_s(z) = \sum_{k=1}^{\infty} \frac{z^k}{k^s}.
+
+This series is convergent only for `|z| < 1`, so elsewhere
+the analytic continuation is implied.
+
+The polylogarithm should not be confused with the logarithmic
+integral (also denoted by Li or li), which is implemented
+as :func:`~mpmath.li`.
+
+**Examples**
+
+The polylogarithm satisfies a huge number of functional identities.
+A sample of polylogarithm evaluations is shown below::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> polylog(1,0.5), log(2)
+    (0.693147180559945, 0.693147180559945)
+    >>> polylog(2,0.5), (pi**2-6*log(2)**2)/12
+    (0.582240526465012, 0.582240526465012)
+    >>> polylog(2,-phi), -log(phi)**2-pi**2/10
+    (-1.21852526068613, -1.21852526068613)
+    >>> polylog(3,0.5), 7*zeta(3)/8-pi**2*log(2)/12+log(2)**3/6
+    (0.53721319360804, 0.53721319360804)
+
+:func:`~mpmath.polylog` can evaluate the analytic continuation of the
+polylogarithm when `s` is an integer::
+
+    >>> polylog(2, 10)
+    (0.536301287357863 - 7.23378441241546j)
+    >>> polylog(2, -10)
+    -4.1982778868581
+    >>> polylog(2, 10j)
+    (-3.05968879432873 + 3.71678149306807j)
+    >>> polylog(-2, 10)
+    -0.150891632373114
+    >>> polylog(-2, -10)
+    0.067618332081142
+    >>> polylog(-2, 10j)
+    (0.0384353698579347 + 0.0912451798066779j)
+
+Some more examples, with arguments on the unit circle (note that
+the series definition cannot be used for computation here)::
+
+    >>> polylog(2,j)
+    (-0.205616758356028 + 0.915965594177219j)
+    >>> j*catalan-pi**2/48
+    (-0.205616758356028 + 0.915965594177219j)
+    >>> polylog(3,exp(2*pi*j/3))
+    (-0.534247512515375 + 0.765587078525922j)
+    >>> -4*zeta(3)/9 + 2*j*pi**3/81
+    (-0.534247512515375 + 0.765587078525921j)
+
+Polylogarithms of different order are related by integration
+and differentiation::
+
+    >>> s, z = 3, 0.5
+    >>> polylog(s+1, z)
+    0.517479061673899
+    >>> quad(lambda t: polylog(s,t)/t, [0, z])
+    0.517479061673899
+    >>> z*diff(lambda t: polylog(s+2,t), z)
+    0.517479061673899
+
+Taylor series expansions around `z = 0` are::
+
+    >>> for n in range(-3, 4):
+    ...     nprint(taylor(lambda x: polylog(n,x), 0, 5))
+    ...
+    [0.0, 1.0, 8.0, 27.0, 64.0, 125.0]
+    [0.0, 1.0, 4.0, 9.0, 16.0, 25.0]
+    [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
+    [0.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+    [0.0, 1.0, 0.5, 0.333333, 0.25, 0.2]
+    [0.0, 1.0, 0.25, 0.111111, 0.0625, 0.04]
+    [0.0, 1.0, 0.125, 0.037037, 0.015625, 0.008]
+
+The series defining the polylogarithm is simultaneously
+a Taylor series and an L-series. For certain values of `z`, the
+polylogarithm reduces to a pure zeta function::
+
+    >>> polylog(pi, 1), zeta(pi)
+    (1.17624173838258, 1.17624173838258)
+    >>> polylog(pi, -1), -altzeta(pi)
+    (-0.909670702980385, -0.909670702980385)
+
+Evaluation for arbitrary, nonintegral `s` is supported
+for `z` within the unit circle:
+
+    >>> polylog(3+4j, 0.25)
+    (0.24258605789446 - 0.00222938275488344j)
+    >>> nsum(lambda k: 0.25**k / k**(3+4j), [1,inf])
+    (0.24258605789446 - 0.00222938275488344j)
+
+It is also supported outside of the unit circle::
+
+    >>> polylog(1+j, 20+40j)
+    (-7.1421172179728 - 3.92726697721369j)
+    >>> polylog(1+j, 200+400j)
+    (-5.41934747194626 - 9.94037752563927j)
+
+**References**
+
+1. Richard Crandall, "Note on fast polylogarithm computation"
+   http://www.reed.edu/physics/faculty/crandall/papers/Polylog.pdf
+2. http://en.wikipedia.org/wiki/Polylogarithm
+3. http://mathworld.wolfram.com/Polylogarithm.html
+
+"""
+
+bell = r"""
+For `n` a nonnegative integer, ``bell(n,x)`` evaluates the Bell
+polynomial `B_n(x)`, the first few of which are
+
+.. math ::
+
+    B_0(x) = 1
+
+    B_1(x) = x
+
+    B_2(x) = x^2+x
+
+    B_3(x) = x^3+3x^2+x
+
+If `x = 1` or :func:`~mpmath.bell` is called with only one argument, it
+gives the `n`-th Bell number `B_n`, which is the number of
+partitions of a set with `n` elements. By setting the precision to
+at least `\log_{10} B_n` digits, :func:`~mpmath.bell` provides fast
+calculation of exact Bell numbers.
+
+In general, :func:`~mpmath.bell` computes
+
+.. math ::
+
+    B_n(x) = e^{-x} \left(\mathrm{sinc}(\pi n) + E_n(x)\right)
+
+where `E_n(x)` is the generalized exponential function implemented
+by :func:`~mpmath.polyexp`. This is an extension of Dobinski's formula [1],
+where the modification is the sinc term ensuring that `B_n(x)` is
+continuous in `n`; :func:`~mpmath.bell` can thus be evaluated,
+differentiated, etc for arbitrary complex arguments.
+
+**Examples**
+
+Simple evaluations::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> bell(0, 2.5)
+    1.0
+    >>> bell(1, 2.5)
+    2.5
+    >>> bell(2, 2.5)
+    8.75
+
+Evaluation for arbitrary complex arguments::
+
+    >>> bell(5.75+1j, 2-3j)
+    (-10767.71345136587098445143 - 15449.55065599872579097221j)
+
+The first few Bell polynomials::
+
+    >>> for k in range(7):
+    ...     nprint(taylor(lambda x: bell(k,x), 0, k))
+    ...
+    [1.0]
+    [0.0, 1.0]
+    [0.0, 1.0, 1.0]
+    [0.0, 1.0, 3.0, 1.0]
+    [0.0, 1.0, 7.0, 6.0, 1.0]
+    [0.0, 1.0, 15.0, 25.0, 10.0, 1.0]
+    [0.0, 1.0, 31.0, 90.0, 65.0, 15.0, 1.0]
+
+The first few Bell numbers and complementary Bell numbers::
+
+    >>> [int(bell(k)) for k in range(10)]
+    [1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147]
+    >>> [int(bell(k,-1)) for k in range(10)]
+    [1, -1, 0, 1, 1, -2, -9, -9, 50, 267]
+
+Large Bell numbers::
+
+    >>> mp.dps = 50
+    >>> bell(50)
+    185724268771078270438257767181908917499221852770.0
+    >>> bell(50,-1)
+    -29113173035759403920216141265491160286912.0
+
+Some even larger values::
+
+    >>> mp.dps = 25
+    >>> bell(1000,-1)
+    -1.237132026969293954162816e+1869
+    >>> bell(1000)
+    2.989901335682408421480422e+1927
+    >>> bell(1000,2)
+    6.591553486811969380442171e+1987
+    >>> bell(1000,100.5)
+    9.101014101401543575679639e+2529
+
+A determinant identity satisfied by Bell numbers::
+
+    >>> mp.dps = 15
+    >>> N = 8
+    >>> det([[bell(k+j) for j in range(N)] for k in range(N)])
+    125411328000.0
+    >>> superfac(N-1)
+    125411328000.0
+
+**References**
+
+1. http://mathworld.wolfram.com/DobinskisFormula.html
+
+"""
+
+polyexp = r"""
+Evaluates the polyexponential function, defined for arbitrary
+complex `s`, `z` by the series
+
+.. math ::
+
+    E_s(z) = \sum_{k=1}^{\infty} \frac{k^s}{k!} z^k.
+
+`E_s(z)` is constructed from the exponential function analogously
+to how the polylogarithm is constructed from the ordinary
+logarithm; as a function of `s` (with `z` fixed), `E_s` is an L-series
+It is an entire function of both `s` and `z`.
+
+The polyexponential function provides a generalization of the
+Bell polynomials `B_n(x)` (see :func:`~mpmath.bell`) to noninteger orders `n`.
+In terms of the Bell polynomials,
+
+.. math ::
+
+    E_s(z) = e^z B_s(z) - \mathrm{sinc}(\pi s).
+
+Note that `B_n(x)` and `e^{-x} E_n(x)` are identical if `n`
+is a nonzero integer, but not otherwise. In particular, they differ
+at `n = 0`.
+
+**Examples**
+
+Evaluating a series::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> nsum(lambda k: sqrt(k)/fac(k), [1,inf])
+    2.101755547733791780315904
+    >>> polyexp(0.5,1)
+    2.101755547733791780315904
+
+Evaluation for arbitrary arguments::
+
+    >>> polyexp(-3-4j, 2.5+2j)
+    (2.351660261190434618268706 + 1.202966666673054671364215j)
+
+Evaluation is accurate for tiny function values::
+
+    >>> polyexp(4, -100)
+    3.499471750566824369520223e-36
+
+If `n` is a nonpositive integer, `E_n` reduces to a special
+instance of the hypergeometric function `\,_pF_q`::
+
+    >>> n = 3
+    >>> x = pi
+    >>> polyexp(-n,x)
+    4.042192318847986561771779
+    >>> x*hyper([1]*(n+1), [2]*(n+1), x)
+    4.042192318847986561771779
+
+"""
+
+cyclotomic = r"""
+Evaluates the cyclotomic polynomial `\Phi_n(x)`, defined by
+
+.. math ::
+
+    \Phi_n(x) = \prod_{\zeta} (x - \zeta)
+
+where `\zeta` ranges over all primitive `n`-th roots of unity
+(see :func:`~mpmath.unitroots`). An equivalent representation, used
+for computation, is
+
+.. math ::
+
+    \Phi_n(x) = \prod_{d\mid n}(x^d-1)^{\mu(n/d)} = \Phi_n(x)
+
+where `\mu(m)` denotes the Moebius function. The cyclotomic
+polynomials are integer polynomials, the first of which can be
+written explicitly as
+
+.. math ::
+
+    \Phi_0(x) = 1
+
+    \Phi_1(x) = x - 1
+
+    \Phi_2(x) = x + 1
+
+    \Phi_3(x) = x^3 + x^2 + 1
+
+    \Phi_4(x) = x^2 + 1
+
+    \Phi_5(x) = x^4 + x^3 + x^2 + x + 1
+
+    \Phi_6(x) = x^2 - x + 1
+
+**Examples**
+
+The coefficients of low-order cyclotomic polynomials can be recovered
+using Taylor expansion::
+
+    >>> from mpmath import *
+    >>> mp.dps = 15; mp.pretty = True
+    >>> for n in range(9):
+    ...     p = chop(taylor(lambda x: cyclotomic(n,x), 0, 10))
+    ...     print("%s %s" % (n, nstr(p[:10+1-p[::-1].index(1)])))
+    ...
+    0 [1.0]
+    1 [-1.0, 1.0]
+    2 [1.0, 1.0]
+    3 [1.0, 1.0, 1.0]
+    4 [1.0, 0.0, 1.0]
+    5 [1.0, 1.0, 1.0, 1.0, 1.0]
+    6 [1.0, -1.0, 1.0]
+    7 [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+    8 [1.0, 0.0, 0.0, 0.0, 1.0]
+
+The definition as a product over primitive roots may be checked
+by computing the product explicitly (for a real argument, this
+method will generally introduce numerical noise in the imaginary
+part)::
+
+    >>> mp.dps = 25
+    >>> z = 3+4j
+    >>> cyclotomic(10, z)
+    (-419.0 - 360.0j)
+    >>> fprod(z-r for r in unitroots(10, primitive=True))
+    (-419.0 - 360.0j)
+    >>> z = 3
+    >>> cyclotomic(10, z)
+    61.0
+    >>> fprod(z-r for r in unitroots(10, primitive=True))
+    (61.0 - 3.146045605088568607055454e-25j)
+
+Up to permutation, the roots of a given cyclotomic polynomial
+can be checked to agree with the list of primitive roots::
+
+    >>> p = taylor(lambda x: cyclotomic(6,x), 0, 6)[:3]
+    >>> for r in polyroots(p[::-1]):
+    ...     print(r)
+    ...
+    (0.5 - 0.8660254037844386467637232j)
+    (0.5 + 0.8660254037844386467637232j)
+    >>>
+    >>> for r in unitroots(6, primitive=True):
+    ...     print(r)
+    ...
+    (0.5 + 0.8660254037844386467637232j)
+    (0.5 - 0.8660254037844386467637232j)
+
+"""
+
+meijerg = r"""
+Evaluates the Meijer G-function, defined as
+
+.. math ::
+
+    G^{m,n}_{p,q} \left( \left. \begin{matrix}
+         a_1, \dots, a_n ; a_{n+1} \dots a_p \\
+         b_1, \dots, b_m ; b_{m+1} \dots b_q
+    \end{matrix}\; \right| \; z ; r \right) =
+    \frac{1}{2 \pi i} \int_L
+    \frac{\prod_{j=1}^m \Gamma(b_j+s) \prod_{j=1}^n\Gamma(1-a_j-s)}
+         {\prod_{j=n+1}^{p}\Gamma(a_j+s) \prod_{j=m+1}^q \Gamma(1-b_j-s)}
+         z^{-s/r} ds
+
+for an appropriate choice of the contour `L` (see references).
+
+There are `p` elements `a_j`.
+The argument *a_s* should be a pair of lists, the first containing the
+`n` elements `a_1, \ldots, a_n` and the second containing
+the `p-n` elements `a_{n+1}, \ldots a_p`.
+
+There are `q` elements `b_j`.
+The argument *b_s* should be a pair of lists, the first containing the
+`m` elements `b_1, \ldots, b_m` and the second containing
+the `q-m` elements `b_{m+1}, \ldots b_q`.
+
+The implicit tuple `(m, n, p, q)` constitutes the order or degree of the
+Meijer G-function, and is determined by the lengths of the coefficient
+vectors. Confusingly, the indices in this tuple appear in a different order
+from the coefficients, but this notation is standard. The many examples
+given below should hopefully clear up any potential confusion.
+
+**Algorithm**
+
+The Meijer G-function is evaluated as a combination of hypergeometric series.
+There are two versions of the function, which can be selected with
+the optional *series* argument.
+
+*series=1* uses a sum of `m` `\,_pF_{q-1}` functions of `z`
+
+*series=2* uses a sum of `n` `\,_qF_{p-1}` functions of `1/z`
+
+The default series is chosen based on the degree and `|z|` in order
+to be consistent with Mathematica's. This definition of the Meijer G-function
+has a discontinuity at `|z| = 1` for some orders, which can
+be avoided by explicitly specifying a series.
+
+Keyword arguments are forwarded to :func:`~mpmath.hypercomb`.
+
+**Examples**
+
+Many standard functions are special cases of the Meijer G-function
+(possibly rescaled and/or with branch cut corrections). We define
+some test parameters::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> a = mpf(0.75)
+    >>> b = mpf(1.5)
+    >>> z = mpf(2.25)
+
+The exponential function:
+`e^z = G^{1,0}_{0,1} \left( \left. \begin{matrix} - \\ 0 \end{matrix} \;
+\right| \; -z \right)`
+
+    >>> meijerg([[],[]], [[0],[]], -z)
+    9.487735836358525720550369
+    >>> exp(z)
+    9.487735836358525720550369
+
+The natural logarithm:
+`\log(1+z) = G^{1,2}_{2,2} \left( \left. \begin{matrix} 1, 1 \\ 1, 0
+\end{matrix} \; \right| \; -z \right)`
+
+    >>> meijerg([[1,1],[]], [[1],[0]], z)
+    1.178654996341646117219023
+    >>> log(1+z)
+    1.178654996341646117219023
+
+A rational function:
+`\frac{z}{z+1} = G^{1,2}_{2,2} \left( \left. \begin{matrix} 1, 1 \\ 1, 1
+\end{matrix} \; \right| \; z \right)`
+
+    >>> meijerg([[1,1],[]], [[1],[1]], z)
+    0.6923076923076923076923077
+    >>> z/(z+1)
+    0.6923076923076923076923077
+
+The sine and cosine functions:
+
+`\frac{1}{\sqrt \pi} \sin(2 \sqrt z) = G^{1,0}_{0,2} \left( \left. \begin{matrix}
+- \\ \frac{1}{2}, 0 \end{matrix} \; \right| \; z \right)`
+
+`\frac{1}{\sqrt \pi} \cos(2 \sqrt z) = G^{1,0}_{0,2} \left( \left. \begin{matrix}
+- \\ 0, \frac{1}{2} \end{matrix} \; \right| \; z \right)`
+
+    >>> meijerg([[],[]], [[0.5],[0]], (z/2)**2)
+    0.4389807929218676682296453
+    >>> sin(z)/sqrt(pi)
+    0.4389807929218676682296453
+    >>> meijerg([[],[]], [[0],[0.5]], (z/2)**2)
+    -0.3544090145996275423331762
+    >>> cos(z)/sqrt(pi)
+    -0.3544090145996275423331762
+
+Bessel functions:
+
+`J_a(2 \sqrt z) = G^{1,0}_{0,2} \left( \left.
+\begin{matrix} - \\ \frac{a}{2}, -\frac{a}{2}
+\end{matrix} \; \right| \; z \right)`
+
+`Y_a(2 \sqrt z) = G^{2,0}_{1,3} \left( \left.
+\begin{matrix} \frac{-a-1}{2} \\ \frac{a}{2}, -\frac{a}{2}, \frac{-a-1}{2}
+\end{matrix} \; \right| \; z \right)`
+
+`(-z)^{a/2} z^{-a/2} I_a(2 \sqrt z) = G^{1,0}_{0,2} \left( \left.
+\begin{matrix} - \\ \frac{a}{2}, -\frac{a}{2}
+\end{matrix} \; \right| \; -z \right)`
+
+`2 K_a(2 \sqrt z) = G^{2,0}_{0,2} \left( \left.
+\begin{matrix} - \\ \frac{a}{2}, -\frac{a}{2}
+\end{matrix} \; \right| \; z \right)`
+
+As the example with the Bessel *I* function shows, a branch
+factor is required for some arguments when inverting the square root.
+
+    >>> meijerg([[],[]], [[a/2],[-a/2]], (z/2)**2)
+    0.5059425789597154858527264
+    >>> besselj(a,z)
+    0.5059425789597154858527264
+    >>> meijerg([[],[(-a-1)/2]], [[a/2,-a/2],[(-a-1)/2]], (z/2)**2)
+    0.1853868950066556941442559
+    >>> bessely(a, z)
+    0.1853868950066556941442559
+    >>> meijerg([[],[]], [[a/2],[-a/2]], -(z/2)**2)
+    (0.8685913322427653875717476 + 2.096964974460199200551738j)
+    >>> (-z)**(a/2) / z**(a/2) * besseli(a, z)
+    (0.8685913322427653875717476 + 2.096964974460199200551738j)
+    >>> 0.5*meijerg([[],[]], [[a/2,-a/2],[]], (z/2)**2)
+    0.09334163695597828403796071
+    >>> besselk(a,z)
+    0.09334163695597828403796071
+
+Error functions:
+
+`\sqrt{\pi} z^{2(a-1)} \mathrm{erfc}(z) = G^{2,0}_{1,2} \left( \left.
+\begin{matrix} a \\ a-1, a-\frac{1}{2}
+\end{matrix} \; \right| \; z, \frac{1}{2} \right)`
+
+    >>> meijerg([[],[a]], [[a-1,a-0.5],[]], z, 0.5)
+    0.00172839843123091957468712
+    >>> sqrt(pi) * z**(2*a-2) * erfc(z)
+    0.00172839843123091957468712
+
+A Meijer G-function of higher degree, (1,1,2,3):
+
+    >>> meijerg([[a],[b]], [[a],[b,a-1]], z)
+    1.55984467443050210115617
+    >>> sin((b-a)*pi)/pi*(exp(z)-1)*z**(a-1)
+    1.55984467443050210115617
+
+A Meijer G-function of still higher degree, (4,1,2,4), that can
+be expanded as a messy combination of exponential integrals:
+
+    >>> meijerg([[a],[2*b-a]], [[b,a,b-0.5,-1-a+2*b],[]], z)
+    0.3323667133658557271898061
+    >>> chop(4**(a-b+1)*sqrt(pi)*gamma(2*b-2*a)*z**a*\
+    ...     expint(2*b-2*a, -2*sqrt(-z))*expint(2*b-2*a, 2*sqrt(-z)))
+    0.3323667133658557271898061
+
+In the following case, different series give different values::
+
+    >>> chop(meijerg([[1],[0.25]],[[3],[0.5]],-2))
+    -0.06417628097442437076207337
+    >>> meijerg([[1],[0.25]],[[3],[0.5]],-2,series=1)
+    0.1428699426155117511873047
+    >>> chop(meijerg([[1],[0.25]],[[3],[0.5]],-2,series=2))
+    -0.06417628097442437076207337
+
+**References**
+
+1. http://en.wikipedia.org/wiki/Meijer_G-function
+
+2. http://mathworld.wolfram.com/MeijerG-Function.html
+
+3. http://functions.wolfram.com/HypergeometricFunctions/MeijerG/
+
+4. http://functions.wolfram.com/HypergeometricFunctions/MeijerG1/
+
+"""
+
+clsin = r"""
+Computes the Clausen sine function, defined formally by the series
+
+.. math ::
+
+    \mathrm{Cl}_s(z) = \sum_{k=1}^{\infty} \frac{\sin(kz)}{k^s}.
+
+The special case `\mathrm{Cl}_2(z)` (i.e. ``clsin(2,z)``) is the classical
+"Clausen function". More generally, the Clausen function is defined for
+complex `s` and `z`, even when the series does not converge. The
+Clausen function is related to the polylogarithm (:func:`~mpmath.polylog`) as
+
+.. math ::
+
+    \mathrm{Cl}_s(z) = \frac{1}{2i}\left(\mathrm{Li}_s\left(e^{iz}\right) -
+                       \mathrm{Li}_s\left(e^{-iz}\right)\right)
+
+    = \mathrm{Im}\left[\mathrm{Li}_s(e^{iz})\right] \quad (s, z \in \mathbb{R}),
+
+and this representation can be taken to provide the analytic continuation of the
+series. The complementary function :func:`~mpmath.clcos` gives the corresponding
+cosine sum.
+
+**Examples**
+
+Evaluation for arbitrarily chosen `s` and `z`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> s, z = 3, 4
+    >>> clsin(s, z); nsum(lambda k: sin(z*k)/k**s, [1,inf])
+    -0.6533010136329338746275795
+    -0.6533010136329338746275795
+
+Using `z + \pi` instead of `z` gives an alternating series::
+
+    >>> clsin(s, z+pi)
+    0.8860032351260589402871624
+    >>> nsum(lambda k: (-1)**k*sin(z*k)/k**s, [1,inf])
+    0.8860032351260589402871624
+
+With `s = 1`, the sum can be expressed in closed form
+using elementary functions::
+
+    >>> z = 1 + sqrt(3)
+    >>> clsin(1, z)
+    0.2047709230104579724675985
+    >>> chop((log(1-exp(-j*z)) - log(1-exp(j*z)))/(2*j))
+    0.2047709230104579724675985
+    >>> nsum(lambda k: sin(k*z)/k, [1,inf])
+    0.2047709230104579724675985
+
+The classical Clausen function `\mathrm{Cl}_2(\theta)` gives the
+value of the integral `\int_0^{\theta} -\ln(2\sin(x/2)) dx` for
+`0 < \theta < 2 \pi`::
+
+    >>> cl2 = lambda t: clsin(2, t)
+    >>> cl2(3.5)
+    -0.2465045302347694216534255
+    >>> -quad(lambda x: ln(2*sin(0.5*x)), [0, 3.5])
+    -0.2465045302347694216534255
+
+This function is symmetric about `\theta = \pi` with zeros and extreme
+points::
+
+    >>> cl2(0); cl2(pi/3); chop(cl2(pi)); cl2(5*pi/3); chop(cl2(2*pi))
+    0.0
+    1.014941606409653625021203
+    0.0
+    -1.014941606409653625021203
+    0.0
+
+Catalan's constant is a special value::
+
+    >>> cl2(pi/2)
+    0.9159655941772190150546035
+    >>> +catalan
+    0.9159655941772190150546035
+
+The Clausen sine function can be expressed in closed form when
+`s` is an odd integer (becoming zero when `s` < 0)::
+
+    >>> z = 1 + sqrt(2)
+    >>> clsin(1, z); (pi-z)/2
+    0.3636895456083490948304773
+    0.3636895456083490948304773
+    >>> clsin(3, z); pi**2/6*z - pi*z**2/4 + z**3/12
+    0.5661751584451144991707161
+    0.5661751584451144991707161
+    >>> clsin(-1, z)
+    0.0
+    >>> clsin(-3, z)
+    0.0
+
+It can also be expressed in closed form for even integer `s \le 0`,
+providing a finite sum for series such as
+`\sin(z) + \sin(2z) + \sin(3z) + \ldots`::
+
+    >>> z = 1 + sqrt(2)
+    >>> clsin(0, z)
+    0.1903105029507513881275865
+    >>> cot(z/2)/2
+    0.1903105029507513881275865
+    >>> clsin(-2, z)
+    -0.1089406163841548817581392
+    >>> -cot(z/2)*csc(z/2)**2/4
+    -0.1089406163841548817581392
+
+Call with ``pi=True`` to multiply `z` by `\pi` exactly::
+
+    >>> clsin(3, 3*pi)
+    -8.892316224968072424732898e-26
+    >>> clsin(3, 3, pi=True)
+    0.0
+
+Evaluation for complex `s`, `z` in a nonconvergent case::
+
+    >>> s, z = -1-j, 1+2j
+    >>> clsin(s, z)
+    (-0.593079480117379002516034 + 0.9038644233367868273362446j)
+    >>> extraprec(20)(nsum)(lambda k: sin(k*z)/k**s, [1,inf])
+    (-0.593079480117379002516034 + 0.9038644233367868273362446j)
+
+"""
+
+clcos = r"""
+Computes the Clausen cosine function, defined formally by the series
+
+.. math ::
+
+    \mathrm{\widetilde{Cl}}_s(z) = \sum_{k=1}^{\infty} \frac{\cos(kz)}{k^s}.
+
+This function is complementary to the Clausen sine function
+:func:`~mpmath.clsin`. In terms of the polylogarithm,
+
+.. math ::
+
+    \mathrm{\widetilde{Cl}}_s(z) =
+        \frac{1}{2}\left(\mathrm{Li}_s\left(e^{iz}\right) +
+        \mathrm{Li}_s\left(e^{-iz}\right)\right)
+
+    = \mathrm{Re}\left[\mathrm{Li}_s(e^{iz})\right] \quad (s, z \in \mathbb{R}).
+
+**Examples**
+
+Evaluation for arbitrarily chosen `s` and `z`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> s, z = 3, 4
+    >>> clcos(s, z); nsum(lambda k: cos(z*k)/k**s, [1,inf])
+    -0.6518926267198991308332759
+    -0.6518926267198991308332759
+
+Using `z + \pi` instead of `z` gives an alternating series::
+
+    >>> s, z = 3, 0.5
+    >>> clcos(s, z+pi)
+    -0.8155530586502260817855618
+    >>> nsum(lambda k: (-1)**k*cos(z*k)/k**s, [1,inf])
+    -0.8155530586502260817855618
+
+With `s = 1`, the sum can be expressed in closed form
+using elementary functions::
+
+    >>> z = 1 + sqrt(3)
+    >>> clcos(1, z)
+    -0.6720334373369714849797918
+    >>> chop(-0.5*(log(1-exp(j*z))+log(1-exp(-j*z))))
+    -0.6720334373369714849797918
+    >>> -log(abs(2*sin(0.5*z)))    # Equivalent to above when z is real
+    -0.6720334373369714849797918
+    >>> nsum(lambda k: cos(k*z)/k, [1,inf])
+    -0.6720334373369714849797918
+
+It can also be expressed in closed form when `s` is an even integer.
+For example,
+
+    >>> clcos(2,z)
+    -0.7805359025135583118863007
+    >>> pi**2/6 - pi*z/2 + z**2/4
+    -0.7805359025135583118863007
+
+The case `s = 0` gives the renormalized sum of
+`\cos(z) + \cos(2z) + \cos(3z) + \ldots` (which happens to be the same for
+any value of `z`)::
+
+    >>> clcos(0, z)
+    -0.5
+    >>> nsum(lambda k: cos(k*z), [1,inf])
+    -0.5
+
+Also the sums
+
+.. math ::
+
+    \cos(z) + 2\cos(2z) + 3\cos(3z) + \ldots
+
+and
+
+.. math ::
+
+    \cos(z) + 2^n \cos(2z) + 3^n \cos(3z) + \ldots
+
+for higher integer powers `n = -s` can be done in closed form. They are zero
+when `n` is positive and even (`s` negative and even)::
+
+    >>> clcos(-1, z); 1/(2*cos(z)-2)
+    -0.2607829375240542480694126
+    -0.2607829375240542480694126
+    >>> clcos(-3, z); (2+cos(z))*csc(z/2)**4/8
+    0.1472635054979944390848006
+    0.1472635054979944390848006
+    >>> clcos(-2, z); clcos(-4, z); clcos(-6, z)
+    0.0
+    0.0
+    0.0
+
+With `z = \pi`, the series reduces to that of the Riemann zeta function
+(more generally, if `z = p \pi/q`, it is a finite sum over Hurwitz zeta
+function values)::
+
+    >>> clcos(2.5, 0); zeta(2.5)
+    1.34148725725091717975677
+    1.34148725725091717975677
+    >>> clcos(2.5, pi); -altzeta(2.5)
+    -0.8671998890121841381913472
+    -0.8671998890121841381913472
+
+Call with ``pi=True`` to multiply `z` by `\pi` exactly::
+
+    >>> clcos(-3, 2*pi)
+    2.997921055881167659267063e+102
+    >>> clcos(-3, 2, pi=True)
+    0.008333333333333333333333333
+
+Evaluation for complex `s`, `z` in a nonconvergent case::
+
+    >>> s, z = -1-j, 1+2j
+    >>> clcos(s, z)
+    (0.9407430121562251476136807 + 0.715826296033590204557054j)
+    >>> extraprec(20)(nsum)(lambda k: cos(k*z)/k**s, [1,inf])
+    (0.9407430121562251476136807 + 0.715826296033590204557054j)
+
+"""
+
+whitm = r"""
+Evaluates the Whittaker function `M(k,m,z)`, which gives a solution
+to the Whittaker differential equation
+
+.. math ::
+
+    \frac{d^2f}{dz^2} + \left(-\frac{1}{4}+\frac{k}{z}+
+      \frac{(\frac{1}{4}-m^2)}{z^2}\right) f = 0.
+
+A second solution is given by :func:`~mpmath.whitw`.
+
+The Whittaker functions are defined in Abramowitz & Stegun, section 13.1.
+They are alternate forms of the confluent hypergeometric functions
+`\,_1F_1` and `U`:
+
+.. math ::
+
+    M(k,m,z) = e^{-\frac{1}{2}z} z^{\frac{1}{2}+m}
+        \,_1F_1(\tfrac{1}{2}+m-k, 1+2m, z)
+
+    W(k,m,z) = e^{-\frac{1}{2}z} z^{\frac{1}{2}+m}
+        U(\tfrac{1}{2}+m-k, 1+2m, z).
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments is supported::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> whitm(1, 1, 1)
+    0.7302596799460411820509668
+    >>> whitm(1, 1, -1)
+    (0.0 - 1.417977827655098025684246j)
+    >>> whitm(j, j/2, 2+3j)
+    (3.245477713363581112736478 - 0.822879187542699127327782j)
+    >>> whitm(2, 3, 100000)
+    4.303985255686378497193063e+21707
+
+Evaluation at zero::
+
+    >>> whitm(1,-1,0); whitm(1,-0.5,0); whitm(1,0,0)
+    +inf
+    nan
+    0.0
+
+We can verify that :func:`~mpmath.whitm` numerically satisfies the
+differential equation for arbitrarily chosen values::
+
+    >>> k = mpf(0.25)
+    >>> m = mpf(1.5)
+    >>> f = lambda z: whitm(k,m,z)
+    >>> for z in [-1, 2.5, 3, 1+2j]:
+    ...     chop(diff(f,z,2) + (-0.25 + k/z + (0.25-m**2)/z**2)*f(z))
+    ...
+    0.0
+    0.0
+    0.0
+    0.0
+
+An integral involving both :func:`~mpmath.whitm` and :func:`~mpmath.whitw`,
+verifying evaluation along the real axis::
+
+    >>> quad(lambda x: exp(-x)*whitm(3,2,x)*whitw(1,-2,x), [0,inf])
+    3.438869842576800225207341
+    >>> 128/(21*sqrt(pi))
+    3.438869842576800225207341
+
+"""
+
+whitw = r"""
+Evaluates the Whittaker function `W(k,m,z)`, which gives a second
+solution to the Whittaker differential equation. (See :func:`~mpmath.whitm`.)
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments is supported::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> whitw(1, 1, 1)
+    1.19532063107581155661012
+    >>> whitw(1, 1, -1)
+    (-0.9424875979222187313924639 - 0.2607738054097702293308689j)
+    >>> whitw(j, j/2, 2+3j)
+    (0.1782899315111033879430369 - 0.01609578360403649340169406j)
+    >>> whitw(2, 3, 100000)
+    1.887705114889527446891274e-21705
+    >>> whitw(-1, -1, 100)
+    1.905250692824046162462058e-24
+
+Evaluation at zero::
+
+    >>> for m in [-1, -0.5, 0, 0.5, 1]:
+    ...     whitw(1, m, 0)
+    ...
+    +inf
+    nan
+    0.0
+    nan
+    +inf
+
+We can verify that :func:`~mpmath.whitw` numerically satisfies the
+differential equation for arbitrarily chosen values::
+
+    >>> k = mpf(0.25)
+    >>> m = mpf(1.5)
+    >>> f = lambda z: whitw(k,m,z)
+    >>> for z in [-1, 2.5, 3, 1+2j]:
+    ...     chop(diff(f,z,2) + (-0.25 + k/z + (0.25-m**2)/z**2)*f(z))
+    ...
+    0.0
+    0.0
+    0.0
+    0.0
+
+"""
+
+ber = r"""
+Computes the Kelvin function ber, which for real arguments gives the real part
+of the Bessel J function of a rotated argument
+
+.. math ::
+
+    J_n\left(x e^{3\pi i/4}\right) = \mathrm{ber}_n(x) + i \mathrm{bei}_n(x).
+
+The imaginary part is given by :func:`~mpmath.bei`.
+
+**Plots**
+
+.. literalinclude :: /plots/ber.py
+.. image :: /plots/ber.png
+
+**Examples**
+
+Verifying the defining relation::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> n, x = 2, 3.5
+    >>> ber(n,x)
+    1.442338852571888752631129
+    >>> bei(n,x)
+    -0.948359035324558320217678
+    >>> besselj(n, x*root(1,8,3))
+    (1.442338852571888752631129 - 0.948359035324558320217678j)
+
+The ber and bei functions are also defined by analytic continuation
+for complex arguments::
+
+    >>> ber(1+j, 2+3j)
+    (4.675445984756614424069563 - 15.84901771719130765656316j)
+    >>> bei(1+j, 2+3j)
+    (15.83886679193707699364398 + 4.684053288183046528703611j)
+
+"""
+
+bei = r"""
+Computes the Kelvin function bei, which for real arguments gives the
+imaginary part of the Bessel J function of a rotated argument.
+See :func:`~mpmath.ber`.
+"""
+
+ker = r"""
+Computes the Kelvin function ker, which for real arguments gives the real part
+of the (rescaled) Bessel K function of a rotated argument
+
+.. math ::
+
+    e^{-\pi i/2} K_n\left(x e^{3\pi i/4}\right) = \mathrm{ker}_n(x) + i \mathrm{kei}_n(x).
+
+The imaginary part is given by :func:`~mpmath.kei`.
+
+**Plots**
+
+.. literalinclude :: /plots/ker.py
+.. image :: /plots/ker.png
+
+**Examples**
+
+Verifying the defining relation::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> n, x = 2, 4.5
+    >>> ker(n,x)
+    0.02542895201906369640249801
+    >>> kei(n,x)
+    -0.02074960467222823237055351
+    >>> exp(-n*pi*j/2) * besselk(n, x*root(1,8,1))
+    (0.02542895201906369640249801 - 0.02074960467222823237055351j)
+
+The ker and kei functions are also defined by analytic continuation
+for complex arguments::
+
+    >>> ker(1+j, 3+4j)
+    (1.586084268115490421090533 - 2.939717517906339193598719j)
+    >>> kei(1+j, 3+4j)
+    (-2.940403256319453402690132 - 1.585621643835618941044855j)
+
+"""
+
+kei = r"""
+Computes the Kelvin function kei, which for real arguments gives the
+imaginary part of the (rescaled) Bessel K function of a rotated argument.
+See :func:`~mpmath.ker`.
+"""
+
+struveh = r"""
+Gives the Struve function
+
+.. math ::
+
+    \,\mathbf{H}_n(z) =
+    \sum_{k=0}^\infty \frac{(-1)^k}{\Gamma(k+\frac{3}{2})
+        \Gamma(k+n+\frac{3}{2})} {\left({\frac{z}{2}}\right)}^{2k+n+1}
+
+which is a solution to the Struve differential equation
+
+.. math ::
+
+    z^2 f''(z) + z f'(z) + (z^2-n^2) f(z) = \frac{2 z^{n+1}}{\pi (2n-1)!!}.
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> struveh(0, 3.5)
+    0.3608207733778295024977797
+    >>> struveh(-1, 10)
+    -0.255212719726956768034732
+    >>> struveh(1, -100.5)
+    0.5819566816797362287502246
+    >>> struveh(2.5, 10000000000000)
+    3153915652525200060.308937
+    >>> struveh(2.5, -10000000000000)
+    (0.0 - 3153915652525200060.308937j)
+    >>> struveh(1+j, 1000000+4000000j)
+    (-3.066421087689197632388731e+1737173 - 1.596619701076529803290973e+1737173j)
+
+A Struve function of half-integer order is elementary; for example:
+
+    >>> z = 3
+    >>> struveh(0.5, 3)
+    0.9167076867564138178671595
+    >>> sqrt(2/(pi*z))*(1-cos(z))
+    0.9167076867564138178671595
+
+Numerically verifying the differential equation::
+
+    >>> z = mpf(4.5)
+    >>> n = 3
+    >>> f = lambda z: struveh(n,z)
+    >>> lhs = z**2*diff(f,z,2) + z*diff(f,z) + (z**2-n**2)*f(z)
+    >>> rhs = 2*z**(n+1)/fac2(2*n-1)/pi
+    >>> lhs
+    17.40359302709875496632744
+    >>> rhs
+    17.40359302709875496632744
+
+"""
+
+struvel = r"""
+Gives the modified Struve function
+
+.. math ::
+
+    \,\mathbf{L}_n(z) = -i e^{-n\pi i/2} \mathbf{H}_n(i z)
+
+which solves to the modified Struve differential equation
+
+.. math ::
+
+    z^2 f''(z) + z f'(z) - (z^2+n^2) f(z) = \frac{2 z^{n+1}}{\pi (2n-1)!!}.
+
+**Examples**
+
+Evaluation for arbitrary real and complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> struvel(0, 3.5)
+    7.180846515103737996249972
+    >>> struvel(-1, 10)
+    2670.994904980850550721511
+    >>> struvel(1, -100.5)
+    1.757089288053346261497686e+42
+    >>> struvel(2.5, 10000000000000)
+    4.160893281017115450519948e+4342944819025
+    >>> struvel(2.5, -10000000000000)
+    (0.0 - 4.160893281017115450519948e+4342944819025j)
+    >>> struvel(1+j, 700j)
+    (-0.1721150049480079451246076 + 0.1240770953126831093464055j)
+    >>> struvel(1+j, 1000000+4000000j)
+    (-2.973341637511505389128708e+434290 - 5.164633059729968297147448e+434290j)
+
+Numerically verifying the differential equation::
+
+    >>> z = mpf(3.5)
+    >>> n = 3
+    >>> f = lambda z: struvel(n,z)
+    >>> lhs = z**2*diff(f,z,2) + z*diff(f,z) - (z**2+n**2)*f(z)
+    >>> rhs = 2*z**(n+1)/fac2(2*n-1)/pi
+    >>> lhs
+    6.368850306060678353018165
+    >>> rhs
+    6.368850306060678353018165
+"""
+
+appellf1 = r"""
+Gives the Appell F1 hypergeometric function of two variables,
+
+.. math ::
+
+    F_1(a,b_1,b_2,c,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+        \frac{(a)_{m+n} (b_1)_m (b_2)_n}{(c)_{m+n}}
+        \frac{x^m y^n}{m! n!}.
+
+This series is only generally convergent when `|x| < 1` and `|y| < 1`,
+although :func:`~mpmath.appellf1` can evaluate an analytic continuation
+with respecto to either variable, and sometimes both.
+
+**Examples**
+
+Evaluation is supported for real and complex parameters::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> appellf1(1,0,0.5,1,0.5,0.25)
+    1.154700538379251529018298
+    >>> appellf1(1,1+j,0.5,1,0.5,0.5j)
+    (1.138403860350148085179415 + 1.510544741058517621110615j)
+
+For some integer parameters, the F1 series reduces to a polynomial::
+
+    >>> appellf1(2,-4,-3,1,2,5)
+    -816.0
+    >>> appellf1(-5,1,2,1,4,5)
+    -20528.0
+
+The analytic continuation with respect to either `x` or `y`,
+and sometimes with respect to both, can be evaluated::
+
+    >>> appellf1(2,3,4,5,100,0.5)
+    (0.0006231042714165329279738662 + 0.0000005769149277148425774499857j)
+    >>> appellf1('1.1', '0.3', '0.2+2j', '0.4', '0.2', 1.5+3j)
+    (-0.1782604566893954897128702 + 0.002472407104546216117161499j)
+    >>> appellf1(1,2,3,4,10,12)
+    -0.07122993830066776374929313
+
+For certain arguments, F1 reduces to an ordinary hypergeometric function::
+
+    >>> appellf1(1,2,3,5,0.5,0.25)
+    1.547902270302684019335555
+    >>> 4*hyp2f1(1,2,5,'1/3')/3
+    1.547902270302684019335555
+    >>> appellf1(1,2,3,4,0,1.5)
+    (-1.717202506168937502740238 - 2.792526803190927323077905j)
+    >>> hyp2f1(1,3,4,1.5)
+    (-1.717202506168937502740238 - 2.792526803190927323077905j)
+
+The F1 function satisfies a system of partial differential equations::
+
+    >>> a,b1,b2,c,x,y = map(mpf, [1,0.5,0.25,1.125,0.25,-0.25])
+    >>> F = lambda x,y: appellf1(a,b1,b2,c,x,y)
+    >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) +
+    ...      y*(1-x)*diff(F,(x,y),(1,1)) +
+    ...      (c-(a+b1+1)*x)*diff(F,(x,y),(1,0)) -
+    ...      b1*y*diff(F,(x,y),(0,1)) -
+    ...      a*b1*F(x,y))
+    0.0
+    >>>
+    >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) +
+    ...      x*(1-y)*diff(F,(x,y),(1,1)) +
+    ...      (c-(a+b2+1)*y)*diff(F,(x,y),(0,1)) -
+    ...      b2*x*diff(F,(x,y),(1,0)) -
+    ...      a*b2*F(x,y))
+    0.0
+
+The Appell F1 function allows for closed-form evaluation of various
+integrals, such as any integral of the form
+`\int x^r (x+a)^p (x+b)^q dx`::
+
+    >>> def integral(a,b,p,q,r,x1,x2):
+    ...     a,b,p,q,r,x1,x2 = map(mpmathify, [a,b,p,q,r,x1,x2])
+    ...     f = lambda x: x**r * (x+a)**p * (x+b)**q
+    ...     def F(x):
+    ...         v = x**(r+1)/(r+1) * (a+x)**p * (b+x)**q
+    ...         v *= (1+x/a)**(-p)
+    ...         v *= (1+x/b)**(-q)
+    ...         v *= appellf1(r+1,-p,-q,2+r,-x/a,-x/b)
+    ...         return v
+    ...     print("Num. quad: %s" % quad(f, [x1,x2]))
+    ...     print("Appell F1: %s" % (F(x2)-F(x1)))
+    ...
+    >>> integral('1/5','4/3','-2','3','1/2',0,1)
+    Num. quad: 9.073335358785776206576981
+    Appell F1: 9.073335358785776206576981
+    >>> integral('3/2','4/3','-2','3','1/2',0,1)
+    Num. quad: 1.092829171999626454344678
+    Appell F1: 1.092829171999626454344678
+    >>> integral('3/2','4/3','-2','3','1/2',12,25)
+    Num. quad: 1106.323225040235116498927
+    Appell F1: 1106.323225040235116498927
+
+Also incomplete elliptic integrals fall into this category [1]::
+
+    >>> def E(z, m):
+    ...     if (pi/2).ae(z):
+    ...         return ellipe(m)
+    ...     return 2*round(re(z)/pi)*ellipe(m) + mpf(-1)**round(re(z)/pi)*\
+    ...         sin(z)*appellf1(0.5,0.5,-0.5,1.5,sin(z)**2,m*sin(z)**2)
+    ...
+    >>> z, m = 1, 0.5
+    >>> E(z,m); quad(lambda t: sqrt(1-m*sin(t)**2), [0,pi/4,3*pi/4,z])
+    0.9273298836244400669659042
+    0.9273298836244400669659042
+    >>> z, m = 3, 2
+    >>> E(z,m); quad(lambda t: sqrt(1-m*sin(t)**2), [0,pi/4,3*pi/4,z])
+    (1.057495752337234229715836 + 1.198140234735592207439922j)
+    (1.057495752337234229715836 + 1.198140234735592207439922j)
+
+**References**
+
+1. [WolframFunctions]_ http://functions.wolfram.com/EllipticIntegrals/EllipticE2/26/01/
+2. [SrivastavaKarlsson]_
+3. [CabralRosetti]_
+4. [Vidunas]_
+5. [Slater]_
+
+"""
+
+angerj = r"""
+Gives the Anger function
+
+.. math ::
+
+    \mathbf{J}_{\nu}(z) = \frac{1}{\pi}
+        \int_0^{\pi} \cos(\nu t - z \sin t) dt
+
+which is an entire function of both the parameter `\nu` and
+the argument `z`. It solves the inhomogeneous Bessel differential
+equation
+
+.. math ::
+
+    f''(z) + \frac{1}{z}f'(z) + \left(1-\frac{\nu^2}{z^2}\right) f(z)
+        = \frac{(z-\nu)}{\pi z^2} \sin(\pi \nu).
+
+**Examples**
+
+Evaluation for real and complex parameter and argument::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> angerj(2,3)
+    0.4860912605858910769078311
+    >>> angerj(-3+4j, 2+5j)
+    (-5033.358320403384472395612 + 585.8011892476145118551756j)
+    >>> angerj(3.25, 1e6j)
+    (4.630743639715893346570743e+434290 - 1.117960409887505906848456e+434291j)
+    >>> angerj(-1.5, 1e6)
+    0.0002795719747073879393087011
+
+The Anger function coincides with the Bessel J-function when `\nu`
+is an integer::
+
+    >>> angerj(1,3); besselj(1,3)
+    0.3390589585259364589255146
+    0.3390589585259364589255146
+    >>> angerj(1.5,3); besselj(1.5,3)
+    0.4088969848691080859328847
+    0.4777182150870917715515015
+
+Verifying the differential equation::
+
+    >>> v,z = mpf(2.25), 0.75
+    >>> f = lambda z: angerj(v,z)
+    >>> diff(f,z,2) + diff(f,z)/z + (1-(v/z)**2)*f(z)
+    -0.6002108774380707130367995
+    >>> (z-v)/(pi*z**2) * sinpi(v)
+    -0.6002108774380707130367995
+
+Verifying the integral representation::
+
+    >>> angerj(v,z)
+    0.1145380759919333180900501
+    >>> quad(lambda t: cos(v*t-z*sin(t))/pi, [0,pi])
+    0.1145380759919333180900501
+
+**References**
+
+1. [DLMF]_ section 11.10: Anger-Weber Functions
+"""
+
+webere = r"""
+Gives the Weber function
+
+.. math ::
+
+    \mathbf{E}_{\nu}(z) = \frac{1}{\pi}
+        \int_0^{\pi} \sin(\nu t - z \sin t) dt
+
+which is an entire function of both the parameter `\nu` and
+the argument `z`. It solves the inhomogeneous Bessel differential
+equation
+
+.. math ::
+
+    f''(z) + \frac{1}{z}f'(z) + \left(1-\frac{\nu^2}{z^2}\right) f(z)
+        = -\frac{1}{\pi z^2} (z+\nu+(z-\nu)\cos(\pi \nu)).
+
+**Examples**
+
+Evaluation for real and complex parameter and argument::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> webere(2,3)
+    -0.1057668973099018425662646
+    >>> webere(-3+4j, 2+5j)
+    (-585.8081418209852019290498 - 5033.314488899926921597203j)
+    >>> webere(3.25, 1e6j)
+    (-1.117960409887505906848456e+434291 - 4.630743639715893346570743e+434290j)
+    >>> webere(3.25, 1e6)
+    -0.00002812518265894315604914453
+
+Up to addition of a rational function of `z`, the Weber function coincides
+with the Struve H-function when `\nu` is an integer::
+
+    >>> webere(1,3); 2/pi-struveh(1,3)
+    -0.3834897968188690177372881
+    -0.3834897968188690177372881
+    >>> webere(5,3); 26/(35*pi)-struveh(5,3)
+    0.2009680659308154011878075
+    0.2009680659308154011878075
+
+Verifying the differential equation::
+
+    >>> v,z = mpf(2.25), 0.75
+    >>> f = lambda z: webere(v,z)
+    >>> diff(f,z,2) + diff(f,z)/z + (1-(v/z)**2)*f(z)
+    -1.097441848875479535164627
+    >>> -(z+v+(z-v)*cospi(v))/(pi*z**2)
+    -1.097441848875479535164627
+
+Verifying the integral representation::
+
+    >>> webere(v,z)
+    0.1486507351534283744485421
+    >>> quad(lambda t: sin(v*t-z*sin(t))/pi, [0,pi])
+    0.1486507351534283744485421
+
+**References**
+
+1. [DLMF]_ section 11.10: Anger-Weber Functions
+"""
+
+lommels1 = r"""
+Gives the Lommel function `s_{\mu,\nu}` or `s^{(1)}_{\mu,\nu}`
+
+.. math ::
+
+    s_{\mu,\nu}(z) = \frac{z^{\mu+1}}{(\mu-\nu+1)(\mu+\nu+1)}
+        \,_1F_2\left(1; \frac{\mu-\nu+3}{2}, \frac{\mu+\nu+3}{2};
+        -\frac{z^2}{4} \right)
+
+which solves the inhomogeneous Bessel equation
+
+.. math ::
+
+    z^2 f''(z) + z f'(z) + (z^2-\nu^2) f(z) = z^{\mu+1}.
+
+A second solution is given by :func:`~mpmath.lommels2`.
+
+**Plots**
+
+.. literalinclude :: /plots/lommels1.py
+.. image :: /plots/lommels1.png
+
+**Examples**
+
+An integral representation::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> u,v,z = 0.25, 0.125, mpf(0.75)
+    >>> lommels1(u,v,z)
+    0.4276243877565150372999126
+    >>> (bessely(v,z)*quad(lambda t: t**u*besselj(v,t), [0,z]) - \
+    ...  besselj(v,z)*quad(lambda t: t**u*bessely(v,t), [0,z]))*(pi/2)
+    0.4276243877565150372999126
+
+A special value::
+
+    >>> lommels1(v,v,z)
+    0.5461221367746048054932553
+    >>> gamma(v+0.5)*sqrt(pi)*power(2,v-1)*struveh(v,z)
+    0.5461221367746048054932553
+
+Verifying the differential equation::
+
+    >>> f = lambda z: lommels1(u,v,z)
+    >>> z**2*diff(f,z,2) + z*diff(f,z) + (z**2-v**2)*f(z)
+    0.6979536443265746992059141
+    >>> z**(u+1)
+    0.6979536443265746992059141
+
+**References**
+
+1. [GradshteynRyzhik]_
+2. [Weisstein]_ http://mathworld.wolfram.com/LommelFunction.html
+"""
+
+lommels2 = r"""
+Gives the second Lommel function `S_{\mu,\nu}` or `s^{(2)}_{\mu,\nu}`
+
+.. math ::
+
+    S_{\mu,\nu}(z) = s_{\mu,\nu}(z) + 2^{\mu-1}
+        \Gamma\left(\tfrac{1}{2}(\mu-\nu+1)\right)
+        \Gamma\left(\tfrac{1}{2}(\mu+\nu+1)\right) \times
+
+        \left[\sin(\tfrac{1}{2}(\mu-\nu)\pi) J_{\nu}(z) -
+              \cos(\tfrac{1}{2}(\mu-\nu)\pi) Y_{\nu}(z)
+        \right]
+
+which solves the same differential equation as
+:func:`~mpmath.lommels1`.
+
+**Plots**
+
+.. literalinclude :: /plots/lommels2.py
+.. image :: /plots/lommels2.png
+
+**Examples**
+
+For large `|z|`, `S_{\mu,\nu} \sim z^{\mu-1}`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> lommels2(10,2,30000)
+    1.968299831601008419949804e+40
+    >>> power(30000,9)
+    1.9683e+40
+
+A special value::
+
+    >>> u,v,z = 0.5, 0.125, mpf(0.75)
+    >>> lommels2(v,v,z)
+    0.9589683199624672099969765
+    >>> (struveh(v,z)-bessely(v,z))*power(2,v-1)*sqrt(pi)*gamma(v+0.5)
+    0.9589683199624672099969765
+
+Verifying the differential equation::
+
+    >>> f = lambda z: lommels2(u,v,z)
+    >>> z**2*diff(f,z,2) + z*diff(f,z) + (z**2-v**2)*f(z)
+    0.6495190528383289850727924
+    >>> z**(u+1)
+    0.6495190528383289850727924
+
+**References**
+
+1. [GradshteynRyzhik]_
+2. [Weisstein]_ http://mathworld.wolfram.com/LommelFunction.html
+"""
+
+appellf2 = r"""
+Gives the Appell F2 hypergeometric function of two variables
+
+.. math ::
+
+    F_2(a,b_1,b_2,c_1,c_2,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+        \frac{(a)_{m+n} (b_1)_m (b_2)_n}{(c_1)_m (c_2)_n}
+        \frac{x^m y^n}{m! n!}.
+
+The series is generally absolutely convergent for `|x| + |y| < 1`.
+
+**Examples**
+
+Evaluation for real and complex arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> appellf2(1,2,3,4,5,0.25,0.125)
+    1.257417193533135344785602
+    >>> appellf2(1,-3,-4,2,3,2,3)
+    -42.8
+    >>> appellf2(0.5,0.25,-0.25,2,3,0.25j,0.25)
+    (0.9880539519421899867041719 + 0.01497616165031102661476978j)
+    >>> chop(appellf2(1,1+j,1-j,3j,-3j,0.25,0.25))
+    1.201311219287411337955192
+    >>> appellf2(1,1,1,4,6,0.125,16)
+    (-0.09455532250274744282125152 - 0.7647282253046207836769297j)
+
+A transformation formula::
+
+    >>> a,b1,b2,c1,c2,x,y = map(mpf, [1,2,0.5,0.25,1.625,-0.125,0.125])
+    >>> appellf2(a,b1,b2,c1,c2,x,y)
+    0.2299211717841180783309688
+    >>> (1-x)**(-a)*appellf2(a,c1-b1,b2,c1,c2,x/(x-1),y/(1-x))
+    0.2299211717841180783309688
+
+A system of partial differential equations satisfied by F2::
+
+    >>> a,b1,b2,c1,c2,x,y = map(mpf, [1,0.5,0.25,1.125,1.5,0.0625,-0.0625])
+    >>> F = lambda x,y: appellf2(a,b1,b2,c1,c2,x,y)
+    >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) -
+    ...      x*y*diff(F,(x,y),(1,1)) +
+    ...      (c1-(a+b1+1)*x)*diff(F,(x,y),(1,0)) -
+    ...      b1*y*diff(F,(x,y),(0,1)) -
+    ...      a*b1*F(x,y))
+    0.0
+    >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) -
+    ...      x*y*diff(F,(x,y),(1,1)) +
+    ...      (c2-(a+b2+1)*y)*diff(F,(x,y),(0,1)) -
+    ...      b2*x*diff(F,(x,y),(1,0)) -
+    ...      a*b2*F(x,y))
+    0.0
+
+**References**
+
+See references for :func:`~mpmath.appellf1`.
+"""
+
+appellf3 = r"""
+Gives the Appell F3 hypergeometric function of two variables
+
+.. math ::
+
+    F_3(a_1,a_2,b_1,b_2,c,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+        \frac{(a_1)_m (a_2)_n (b_1)_m (b_2)_n}{(c)_{m+n}}
+        \frac{x^m y^n}{m! n!}.
+
+The series is generally absolutely convergent for `|x| < 1, |y| < 1`.
+
+**Examples**
+
+Evaluation for various parameters and variables::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> appellf3(1,2,3,4,5,0.5,0.25)
+    2.221557778107438938158705
+    >>> appellf3(1,2,3,4,5,6,0); hyp2f1(1,3,5,6)
+    (-0.5189554589089861284537389 - 0.1454441043328607980769742j)
+    (-0.5189554589089861284537389 - 0.1454441043328607980769742j)
+    >>> appellf3(1,-2,-3,1,1,4,6)
+    -17.4
+    >>> appellf3(1,2,-3,1,1,4,6)
+    (17.7876136773677356641825 + 19.54768762233649126154534j)
+    >>> appellf3(1,2,-3,1,1,6,4)
+    (85.02054175067929402953645 + 148.4402528821177305173599j)
+    >>> chop(appellf3(1+j,2,1-j,2,3,0.25,0.25))
+    1.719992169545200286696007
+
+Many transformations and evaluations for special combinations
+of the parameters are possible, e.g.:
+
+    >>> a,b,c,x,y = map(mpf, [0.5,0.25,0.125,0.125,-0.125])
+    >>> appellf3(a,c-a,b,c-b,c,x,y)
+    1.093432340896087107444363
+    >>> (1-y)**(a+b-c)*hyp2f1(a,b,c,x+y-x*y)
+    1.093432340896087107444363
+    >>> x**2*appellf3(1,1,1,1,3,x,-x)
+    0.01568646277445385390945083
+    >>> polylog(2,x**2)
+    0.01568646277445385390945083
+    >>> a1,a2,b1,b2,c,x = map(mpf, [0.5,0.25,0.125,0.5,4.25,0.125])
+    >>> appellf3(a1,a2,b1,b2,c,x,1)
+    1.03947361709111140096947
+    >>> gammaprod([c,c-a2-b2],[c-a2,c-b2])*hyp3f2(a1,b1,c-a2-b2,c-a2,c-b2,x)
+    1.03947361709111140096947
+
+The Appell F3 function satisfies a pair of partial
+differential equations::
+
+    >>> a1,a2,b1,b2,c,x,y = map(mpf, [0.5,0.25,0.125,0.5,0.625,0.0625,-0.0625])
+    >>> F = lambda x,y: appellf3(a1,a2,b1,b2,c,x,y)
+    >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) +
+    ...      y*diff(F,(x,y),(1,1)) +
+    ...     (c-(a1+b1+1)*x)*diff(F,(x,y),(1,0)) -
+    ...     a1*b1*F(x,y))
+    0.0
+    >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) +
+    ...     x*diff(F,(x,y),(1,1)) +
+    ...     (c-(a2+b2+1)*y)*diff(F,(x,y),(0,1)) -
+    ...     a2*b2*F(x,y))
+    0.0
+
+**References**
+
+See references for :func:`~mpmath.appellf1`.
+"""
+
+appellf4 = r"""
+Gives the Appell F4 hypergeometric function of two variables
+
+.. math ::
+
+    F_4(a,b,c_1,c_2,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+        \frac{(a)_{m+n} (b)_{m+n}}{(c_1)_m (c_2)_n}
+        \frac{x^m y^n}{m! n!}.
+
+The series is generally absolutely convergent for
+`\sqrt{|x|} + \sqrt{|y|} < 1`.
+
+**Examples**
+
+Evaluation for various parameters and arguments::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> appellf4(1,1,2,2,0.25,0.125)
+    1.286182069079718313546608
+    >>> appellf4(-2,-3,4,5,4,5)
+    34.8
+    >>> appellf4(5,4,2,3,0.25j,-0.125j)
+    (-0.2585967215437846642163352 + 2.436102233553582711818743j)
+
+Reduction to `\,_2F_1` in a special case::
+
+    >>> a,b,c,x,y = map(mpf, [0.5,0.25,0.125,0.125,-0.125])
+    >>> appellf4(a,b,c,a+b-c+1,x*(1-y),y*(1-x))
+    1.129143488466850868248364
+    >>> hyp2f1(a,b,c,x)*hyp2f1(a,b,a+b-c+1,y)
+    1.129143488466850868248364
+
+A system of partial differential equations satisfied by F4::
+
+    >>> a,b,c1,c2,x,y = map(mpf, [1,0.5,0.25,1.125,0.0625,-0.0625])
+    >>> F = lambda x,y: appellf4(a,b,c1,c2,x,y)
+    >>> chop(x*(1-x)*diff(F,(x,y),(2,0)) -
+    ...      y**2*diff(F,(x,y),(0,2)) -
+    ...      2*x*y*diff(F,(x,y),(1,1)) +
+    ...      (c1-(a+b+1)*x)*diff(F,(x,y),(1,0)) -
+    ...      ((a+b+1)*y)*diff(F,(x,y),(0,1)) -
+    ...      a*b*F(x,y))
+    0.0
+    >>> chop(y*(1-y)*diff(F,(x,y),(0,2)) -
+    ...      x**2*diff(F,(x,y),(2,0)) -
+    ...      2*x*y*diff(F,(x,y),(1,1)) +
+    ...      (c2-(a+b+1)*y)*diff(F,(x,y),(0,1)) -
+    ...      ((a+b+1)*x)*diff(F,(x,y),(1,0)) -
+    ...      a*b*F(x,y))
+    0.0
+
+**References**
+
+See references for :func:`~mpmath.appellf1`.
+"""
+
+zeta = r"""
+Computes the Riemann zeta function
+
+.. math ::
+
+  \zeta(s) = 1+\frac{1}{2^s}+\frac{1}{3^s}+\frac{1}{4^s}+\ldots
+
+or, with `a \ne 1`, the more general Hurwitz zeta function
+
+.. math ::
+
+    \zeta(s,a) = \sum_{k=0}^\infty \frac{1}{(a+k)^s}.
+
+Optionally, ``zeta(s, a, n)`` computes the `n`-th derivative with
+respect to `s`,
+
+.. math ::
+
+    \zeta^{(n)}(s,a) = (-1)^n \sum_{k=0}^\infty \frac{\log^n(a+k)}{(a+k)^s}.
+
+Although these series only converge for `\Re(s) > 1`, the Riemann and Hurwitz
+zeta functions are defined through analytic continuation for arbitrary
+complex `s \ne 1` (`s = 1` is a pole).
+
+The implementation uses three algorithms: the Borwein algorithm for
+the Riemann zeta function when `s` is close to the real line;
+the Riemann-Siegel formula for the Riemann zeta function when `s` is
+large imaginary, and Euler-Maclaurin summation in all other cases.
+The reflection formula for `\Re(s) < 0` is implemented in some cases.
+The algorithm can be chosen with ``method = 'borwein'``,
+``method='riemann-siegel'`` or ``method = 'euler-maclaurin'``.
+
+The parameter `a` is usually a rational number `a = p/q`, and may be specified
+as such by passing an integer tuple `(p, q)`. Evaluation is supported for
+arbitrary complex `a`, but may be slow and/or inaccurate when `\Re(s) < 0` for
+nonrational `a` or when computing derivatives.
+
+**Examples**
+
+Some values of the Riemann zeta function::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> zeta(2); pi**2 / 6
+    1.644934066848226436472415
+    1.644934066848226436472415
+    >>> zeta(0)
+    -0.5
+    >>> zeta(-1)
+    -0.08333333333333333333333333
+    >>> zeta(-2)
+    0.0
+
+For large positive `s`, `\zeta(s)` rapidly approaches 1::
+
+    >>> zeta(50)
+    1.000000000000000888178421
+    >>> zeta(100)
+    1.0
+    >>> zeta(inf)
+    1.0
+    >>> 1-sum((zeta(k)-1)/k for k in range(2,85)); +euler
+    0.5772156649015328606065121
+    0.5772156649015328606065121
+    >>> nsum(lambda k: zeta(k)-1, [2, inf])
+    1.0
+
+Evaluation is supported for complex `s` and `a`:
+
+    >>> zeta(-3+4j)
+    (-0.03373057338827757067584698 + 0.2774499251557093745297677j)
+    >>> zeta(2+3j, -1+j)
+    (389.6841230140842816370741 + 295.2674610150305334025962j)
+
+The Riemann zeta function has so-called nontrivial zeros on
+the critical line `s = 1/2 + it`::
+
+    >>> findroot(zeta, 0.5+14j); zetazero(1)
+    (0.5 + 14.13472514173469379045725j)
+    (0.5 + 14.13472514173469379045725j)
+    >>> findroot(zeta, 0.5+21j); zetazero(2)
+    (0.5 + 21.02203963877155499262848j)
+    (0.5 + 21.02203963877155499262848j)
+    >>> findroot(zeta, 0.5+25j); zetazero(3)
+    (0.5 + 25.01085758014568876321379j)
+    (0.5 + 25.01085758014568876321379j)
+    >>> chop(zeta(zetazero(10)))
+    0.0
+
+Evaluation on and near the critical line is supported for large
+heights `t` by means of the Riemann-Siegel formula (currently
+for `a = 1`, `n \le 4`)::
+
+    >>> zeta(0.5+100000j)
+    (1.073032014857753132114076 + 5.780848544363503984261041j)
+    >>> zeta(0.75+1000000j)
+    (0.9535316058375145020351559 + 0.9525945894834273060175651j)
+    >>> zeta(0.5+10000000j)
+    (11.45804061057709254500227 - 8.643437226836021723818215j)
+    >>> zeta(0.5+100000000j, derivative=1)
+    (51.12433106710194942681869 + 43.87221167872304520599418j)
+    >>> zeta(0.5+100000000j, derivative=2)
+    (-444.2760822795430400549229 - 896.3789978119185981665403j)
+    >>> zeta(0.5+100000000j, derivative=3)
+    (3230.72682687670422215339 + 14374.36950073615897616781j)
+    >>> zeta(0.5+100000000j, derivative=4)
+    (-11967.35573095046402130602 - 218945.7817789262839266148j)
+    >>> zeta(1+10000000j)    # off the line
+    (2.859846483332530337008882 + 0.491808047480981808903986j)
+    >>> zeta(1+10000000j, derivative=1)
+    (-4.333835494679647915673205 - 0.08405337962602933636096103j)
+    >>> zeta(1+10000000j, derivative=4)
+    (453.2764822702057701894278 - 581.963625832768189140995j)
+
+For investigation of the zeta function zeros, the Riemann-Siegel
+Z-function is often more convenient than working with the Riemann
+zeta function directly (see :func:`~mpmath.siegelz`).
+
+Some values of the Hurwitz zeta function::
+
+    >>> zeta(2, 3); -5./4 + pi**2/6
+    0.3949340668482264364724152
+    0.3949340668482264364724152
+    >>> zeta(2, (3,4)); pi**2 - 8*catalan
+    2.541879647671606498397663
+    2.541879647671606498397663
+
+For positive integer values of `s`, the Hurwitz zeta function is
+equivalent to a polygamma function (except for a normalizing factor)::
+
+    >>> zeta(4, (1,5)); psi(3, '1/5')/6
+    625.5408324774542966919938
+    625.5408324774542966919938
+
+Evaluation of derivatives::
+
+    >>> zeta(0, 3+4j, 1); loggamma(3+4j) - ln(2*pi)/2
+    (-2.675565317808456852310934 + 4.742664438034657928194889j)
+    (-2.675565317808456852310934 + 4.742664438034657928194889j)
+    >>> zeta(2, 1, 20)
+    2432902008176640000.000242
+    >>> zeta(3+4j, 5.5+2j, 4)
+    (-0.140075548947797130681075 - 0.3109263360275413251313634j)
+    >>> zeta(0.5+100000j, 1, 4)
+    (-10407.16081931495861539236 + 13777.78669862804508537384j)
+    >>> zeta(-100+0.5j, (1,3), derivative=4)
+    (4.007180821099823942702249e+79 + 4.916117957092593868321778e+78j)
+
+Generating a Taylor series at `s = 2` using derivatives::
+
+    >>> for k in range(11): print("%s * (s-2)^%i" % (zeta(2,1,k)/fac(k), k))
+    ...
+    1.644934066848226436472415 * (s-2)^0
+    -0.9375482543158437537025741 * (s-2)^1
+    0.9946401171494505117104293 * (s-2)^2
+    -1.000024300473840810940657 * (s-2)^3
+    1.000061933072352565457512 * (s-2)^4
+    -1.000006869443931806408941 * (s-2)^5
+    1.000000173233769531820592 * (s-2)^6
+    -0.9999999569989868493432399 * (s-2)^7
+    0.9999999937218844508684206 * (s-2)^8
+    -0.9999999996355013916608284 * (s-2)^9
+    1.000000000004610645020747 * (s-2)^10
+
+Evaluation at zero and for negative integer `s`::
+
+    >>> zeta(0, 10)
+    -9.5
+    >>> zeta(-2, (2,3)); mpf(1)/81
+    0.01234567901234567901234568
+    0.01234567901234567901234568
+    >>> zeta(-3+4j, (5,4))
+    (0.2899236037682695182085988 + 0.06561206166091757973112783j)
+    >>> zeta(-3.25, 1/pi)
+    -0.0005117269627574430494396877
+    >>> zeta(-3.5, pi, 1)
+    11.156360390440003294709
+    >>> zeta(-100.5, (8,3))
+    -4.68162300487989766727122e+77
+    >>> zeta(-10.5, (-8,3))
+    (-0.01521913704446246609237979 + 29907.72510874248161608216j)
+    >>> zeta(-1000.5, (-8,3))
+    (1.031911949062334538202567e+1770 + 1.519555750556794218804724e+426j)
+    >>> zeta(-1+j, 3+4j)
+    (-16.32988355630802510888631 - 22.17706465801374033261383j)
+    >>> zeta(-1+j, 3+4j, 2)
+    (32.48985276392056641594055 - 51.11604466157397267043655j)
+    >>> diff(lambda s: zeta(s, 3+4j), -1+j, 2)
+    (32.48985276392056641594055 - 51.11604466157397267043655j)
+
+**References**
+
+1. http://mathworld.wolfram.com/RiemannZetaFunction.html
+
+2. http://mathworld.wolfram.com/HurwitzZetaFunction.html
+
+3. [BorweinZeta]_
+
+"""
+
+dirichlet = r"""
+Evaluates the Dirichlet L-function
+
+.. math ::
+
+    L(s,\chi) = \sum_{k=1}^\infty \frac{\chi(k)}{k^s}.
+
+where `\chi` is a periodic sequence of length `q` which should be supplied
+in the form of a list `[\chi(0), \chi(1), \ldots, \chi(q-1)]`.
+Strictly, `\chi` should be a Dirichlet character, but any periodic
+sequence will work.
+
+For example, ``dirichlet(s, [1])`` gives the ordinary
+Riemann zeta function and ``dirichlet(s, [-1,1])`` gives
+the alternating zeta function (Dirichlet eta function).
+
+Also the derivative with respect to `s` (currently only a first
+derivative) can be evaluated.
+
+**Examples**
+
+The ordinary Riemann zeta function::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> dirichlet(3, [1]); zeta(3)
+    1.202056903159594285399738
+    1.202056903159594285399738
+    >>> dirichlet(1, [1])
+    +inf
+
+The alternating zeta function::
+
+    >>> dirichlet(1, [-1,1]); ln(2)
+    0.6931471805599453094172321
+    0.6931471805599453094172321
+
+The following defines the Dirichlet beta function
+`\beta(s) = \sum_{k=0}^\infty \frac{(-1)^k}{(2k+1)^s}` and verifies
+several values of this function::
+
+    >>> B = lambda s, d=0: dirichlet(s, [0, 1, 0, -1], d)
+    >>> B(0); 1./2
+    0.5
+    0.5
+    >>> B(1); pi/4
+    0.7853981633974483096156609
+    0.7853981633974483096156609
+    >>> B(2); +catalan
+    0.9159655941772190150546035
+    0.9159655941772190150546035
+    >>> B(2,1); diff(B, 2)
+    0.08158073611659279510291217
+    0.08158073611659279510291217
+    >>> B(-1,1); 2*catalan/pi
+    0.5831218080616375602767689
+    0.5831218080616375602767689
+    >>> B(0,1); log(gamma(0.25)**2/(2*pi*sqrt(2)))
+    0.3915943927068367764719453
+    0.3915943927068367764719454
+    >>> B(1,1); 0.25*pi*(euler+2*ln2+3*ln(pi)-4*ln(gamma(0.25)))
+    0.1929013167969124293631898
+    0.1929013167969124293631898
+
+A custom L-series of period 3::
+
+    >>> dirichlet(2, [2,0,1])
+    0.7059715047839078092146831
+    >>> 2*nsum(lambda k: (3*k)**-2, [1,inf]) + \
+    ...   nsum(lambda k: (3*k+2)**-2, [0,inf])
+    0.7059715047839078092146831
+
+"""
+
+coulombf = r"""
+Calculates the regular Coulomb wave function
+
+.. math ::
+
+    F_l(\eta,z) = C_l(\eta) z^{l+1} e^{-iz} \,_1F_1(l+1-i\eta, 2l+2, 2iz)
+
+where the normalization constant `C_l(\eta)` is as calculated by
+:func:`~mpmath.coulombc`. This function solves the differential equation
+
+.. math ::
+
+    f''(z) + \left(1-\frac{2\eta}{z}-\frac{l(l+1)}{z^2}\right) f(z) = 0.
+
+A second linearly independent solution is given by the irregular
+Coulomb wave function `G_l(\eta,z)` (see :func:`~mpmath.coulombg`)
+and thus the general solution is
+`f(z) = C_1 F_l(\eta,z) + C_2 G_l(\eta,z)` for arbitrary
+constants `C_1`, `C_2`.
+Physically, the Coulomb wave functions give the radial solution
+to the Schrodinger equation for a point particle in a `1/z` potential; `z` is
+then the radius and `l`, `\eta` are quantum numbers.
+
+The Coulomb wave functions with real parameters are defined
+in Abramowitz & Stegun, section 14. However, all parameters are permitted
+to be complex in this implementation (see references).
+
+**Plots**
+
+.. literalinclude :: /plots/coulombf.py
+.. image :: /plots/coulombf.png
+.. literalinclude :: /plots/coulombf_c.py
+.. image :: /plots/coulombf_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary magnitudes of `z`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> coulombf(2, 1.5, 3.5)
+    0.4080998961088761187426445
+    >>> coulombf(-2, 1.5, 3.5)
+    0.7103040849492536747533465
+    >>> coulombf(2, 1.5, '1e-10')
+    4.143324917492256448770769e-33
+    >>> coulombf(2, 1.5, 1000)
+    0.4482623140325567050716179
+    >>> coulombf(2, 1.5, 10**10)
+    -0.066804196437694360046619
+
+Verifying the differential equation::
+
+    >>> l, eta, z = 2, 3, mpf(2.75)
+    >>> A, B = 1, 2
+    >>> f = lambda z: A*coulombf(l,eta,z) + B*coulombg(l,eta,z)
+    >>> chop(diff(f,z,2) + (1-2*eta/z - l*(l+1)/z**2)*f(z))
+    0.0
+
+A Wronskian relation satisfied by the Coulomb wave functions::
+
+    >>> l = 2
+    >>> eta = 1.5
+    >>> F = lambda z: coulombf(l,eta,z)
+    >>> G = lambda z: coulombg(l,eta,z)
+    >>> for z in [3.5, -1, 2+3j]:
+    ...     chop(diff(F,z)*G(z) - F(z)*diff(G,z))
+    ...
+    1.0
+    1.0
+    1.0
+
+Another Wronskian relation::
+
+    >>> F = coulombf
+    >>> G = coulombg
+    >>> for z in [3.5, -1, 2+3j]:
+    ...     chop(F(l-1,eta,z)*G(l,eta,z)-F(l,eta,z)*G(l-1,eta,z) - l/sqrt(l**2+eta**2))
+    ...
+    0.0
+    0.0
+    0.0
+
+An integral identity connecting the regular and irregular wave functions::
+
+    >>> l, eta, z = 4+j, 2-j, 5+2j
+    >>> coulombf(l,eta,z) + j*coulombg(l,eta,z)
+    (0.7997977752284033239714479 + 0.9294486669502295512503127j)
+    >>> g = lambda t: exp(-t)*t**(l-j*eta)*(t+2*j*z)**(l+j*eta)
+    >>> j*exp(-j*z)*z**(-l)/fac(2*l+1)/coulombc(l,eta)*quad(g, [0,inf])
+    (0.7997977752284033239714479 + 0.9294486669502295512503127j)
+
+Some test case with complex parameters, taken from Michel [2]::
+
+    >>> mp.dps = 15
+    >>> coulombf(1+0.1j, 50+50j, 100.156)
+    (-1.02107292320897e+15 - 2.83675545731519e+15j)
+    >>> coulombg(1+0.1j, 50+50j, 100.156)
+    (2.83675545731519e+15 - 1.02107292320897e+15j)
+    >>> coulombf(1e-5j, 10+1e-5j, 0.1+1e-6j)
+    (4.30566371247811e-14 - 9.03347835361657e-19j)
+    >>> coulombg(1e-5j, 10+1e-5j, 0.1+1e-6j)
+    (778709182061.134 + 18418936.2660553j)
+
+The following reproduces a table in Abramowitz & Stegun, at twice
+the precision::
+
+    >>> mp.dps = 10
+    >>> eta = 2; z = 5
+    >>> for l in [5, 4, 3, 2, 1, 0]:
+    ...     print("%s %s %s" % (l, coulombf(l,eta,z),
+    ...         diff(lambda z: coulombf(l,eta,z), z)))
+    ...
+    5 0.09079533488 0.1042553261
+    4 0.2148205331 0.2029591779
+    3 0.4313159311 0.320534053
+    2 0.7212774133 0.3952408216
+    1 0.9935056752 0.3708676452
+    0 1.143337392 0.2937960375
+
+**References**
+
+1. I.J. Thompson & A.R. Barnett, "Coulomb and Bessel Functions of Complex
+   Arguments and Order", J. Comp. Phys., vol 64, no. 2, June 1986.
+
+2. N. Michel, "Precise Coulomb wave functions for a wide range of
+   complex `l`, `\eta` and `z`", http://arxiv.org/abs/physics/0702051v1
+
+"""
+
+coulombg = r"""
+Calculates the irregular Coulomb wave function
+
+.. math ::
+
+    G_l(\eta,z) = \frac{F_l(\eta,z) \cos(\chi) - F_{-l-1}(\eta,z)}{\sin(\chi)}
+
+where `\chi = \sigma_l - \sigma_{-l-1} - (l+1/2) \pi`
+and `\sigma_l(\eta) = (\ln \Gamma(1+l+i\eta)-\ln \Gamma(1+l-i\eta))/(2i)`.
+
+See :func:`~mpmath.coulombf` for additional information.
+
+**Plots**
+
+.. literalinclude :: /plots/coulombg.py
+.. image :: /plots/coulombg.png
+.. literalinclude :: /plots/coulombg_c.py
+.. image :: /plots/coulombg_c.png
+
+**Examples**
+
+Evaluation is supported for arbitrary magnitudes of `z`::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> coulombg(-2, 1.5, 3.5)
+    1.380011900612186346255524
+    >>> coulombg(2, 1.5, 3.5)
+    1.919153700722748795245926
+    >>> coulombg(-2, 1.5, '1e-10')
+    201126715824.7329115106793
+    >>> coulombg(-2, 1.5, 1000)
+    0.1802071520691149410425512
+    >>> coulombg(-2, 1.5, 10**10)
+    0.652103020061678070929794
+
+The following reproduces a table in Abramowitz & Stegun,
+at twice the precision::
+
+    >>> mp.dps = 10
+    >>> eta = 2; z = 5
+    >>> for l in [1, 2, 3, 4, 5]:
+    ...     print("%s %s %s" % (l, coulombg(l,eta,z),
+    ...         -diff(lambda z: coulombg(l,eta,z), z)))
+    ...
+    1 1.08148276 0.6028279961
+    2 1.496877075 0.5661803178
+    3 2.048694714 0.7959909551
+    4 3.09408669 1.731802374
+    5 5.629840456 4.549343289
+
+Evaluation close to the singularity at `z = 0`::
+
+    >>> mp.dps = 15
+    >>> coulombg(0,10,1)
+    3088184933.67358
+    >>> coulombg(0,10,'1e-10')
+    5554866000719.8
+    >>> coulombg(0,10,'1e-100')
+    5554866221524.1
+
+Evaluation with a half-integer value for `l`::
+
+    >>> coulombg(1.5, 1, 10)
+    0.852320038297334
+"""
+
+coulombc = r"""
+Gives the normalizing Gamow constant for Coulomb wave functions,
+
+.. math ::
+
+    C_l(\eta) = 2^l \exp\left(-\pi \eta/2 + [\ln \Gamma(1+l+i\eta) +
+        \ln \Gamma(1+l-i\eta)]/2 - \ln \Gamma(2l+2)\right),
+
+where the log gamma function with continuous imaginary part
+away from the negative half axis (see :func:`~mpmath.loggamma`) is implied.
+
+This function is used internally for the calculation of
+Coulomb wave functions, and automatically cached to make multiple
+evaluations with fixed `l`, `\eta` fast.
+"""
+
+ellipfun = r"""
+Computes any of the Jacobi elliptic functions, defined
+in terms of Jacobi theta functions as
+
+.. math ::
+
+    \mathrm{sn}(u,m) = \frac{\vartheta_3(0,q)}{\vartheta_2(0,q)}
+        \frac{\vartheta_1(t,q)}{\vartheta_4(t,q)}
+
+    \mathrm{cn}(u,m) = \frac{\vartheta_4(0,q)}{\vartheta_2(0,q)}
+        \frac{\vartheta_2(t,q)}{\vartheta_4(t,q)}
+
+    \mathrm{dn}(u,m) = \frac{\vartheta_4(0,q)}{\vartheta_3(0,q)}
+        \frac{\vartheta_3(t,q)}{\vartheta_4(t,q)},
+
+or more generally computes a ratio of two such functions. Here
+`t = u/\vartheta_3(0,q)^2`, and `q = q(m)` denotes the nome (see
+:func:`~mpmath.nome`). Optionally, you can specify the nome directly
+instead of `m` by passing ``q=<value>``, or you can directly
+specify the elliptic parameter `k` with ``k=<value>``.
+
+The first argument should be a two-character string specifying the
+function using any combination of ``'s'``, ``'c'``, ``'d'``, ``'n'``. These
+letters respectively denote the basic functions
+`\mathrm{sn}(u,m)`, `\mathrm{cn}(u,m)`, `\mathrm{dn}(u,m)`, and `1`.
+The identifier specifies the ratio of two such functions.
+For example, ``'ns'`` identifies the function
+
+.. math ::
+
+    \mathrm{ns}(u,m) = \frac{1}{\mathrm{sn}(u,m)}
+
+and ``'cd'`` identifies the function
+
+.. math ::
+
+    \mathrm{cd}(u,m) = \frac{\mathrm{cn}(u,m)}{\mathrm{dn}(u,m)}.
+
+If called with only the first argument, a function object
+evaluating the chosen function for given arguments is returned.
+
+**Examples**
+
+Basic evaluation::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> ellipfun('cd', 3.5, 0.5)
+    -0.9891101840595543931308394
+    >>> ellipfun('cd', 3.5, q=0.25)
+    0.07111979240214668158441418
+
+The sn-function is doubly periodic in the complex plane with periods
+`4 K(m)` and `2 i K(1-m)` (see :func:`~mpmath.ellipk`)::
+
+    >>> sn = ellipfun('sn')
+    >>> sn(2, 0.25)
+    0.9628981775982774425751399
+    >>> sn(2+4*ellipk(0.25), 0.25)
+    0.9628981775982774425751399
+    >>> chop(sn(2+2*j*ellipk(1-0.25), 0.25))
+    0.9628981775982774425751399
+
+The cn-function is doubly periodic with periods `4 K(m)` and `2 K(m) + 2 i K(1-m)`::
+
+    >>> cn = ellipfun('cn')
+    >>> cn(2, 0.25)
+    -0.2698649654510865792581416
+    >>> cn(2+4*ellipk(0.25), 0.25)
+    -0.2698649654510865792581416
+    >>> chop(cn(2+2*ellipk(0.25)+2*j*ellipk(1-0.25), 0.25))
+    -0.2698649654510865792581416
+
+The dn-function is doubly periodic with periods `2 K(m)` and `4 i K(1-m)`::
+
+    >>> dn = ellipfun('dn')
+    >>> dn(2, 0.25)
+    0.8764740583123262286931578
+    >>> dn(2+2*ellipk(0.25), 0.25)
+    0.8764740583123262286931578
+    >>> chop(dn(2+4*j*ellipk(1-0.25), 0.25))
+    0.8764740583123262286931578
+
+"""
+
+
+jtheta = r"""
+Computes the Jacobi theta function `\vartheta_n(z, q)`, where
+`n = 1, 2, 3, 4`, defined by the infinite series:
+
+.. math ::
+
+  \vartheta_1(z,q) = 2 q^{1/4} \sum_{n=0}^{\infty}
+    (-1)^n q^{n^2+n\,} \sin((2n+1)z)
+
+  \vartheta_2(z,q) = 2 q^{1/4} \sum_{n=0}^{\infty}
+    q^{n^{2\,} + n} \cos((2n+1)z)
+
+  \vartheta_3(z,q) = 1 + 2 \sum_{n=1}^{\infty}
+    q^{n^2\,} \cos(2 n z)
+
+  \vartheta_4(z,q) = 1 + 2 \sum_{n=1}^{\infty}
+    (-q)^{n^2\,} \cos(2 n z)
+
+The theta functions are functions of two variables:
+
+* `z` is the *argument*, an arbitrary real or complex number
+
+* `q` is the *nome*, which must be a real or complex number
+  in the unit disk (i.e. `|q| < 1`). For `|q| \ll 1`, the
+  series converge very quickly, so the Jacobi theta functions
+  can efficiently be evaluated to high precision.
+
+The compact notations `\vartheta_n(q) = \vartheta_n(0,q)`
+and `\vartheta_n = \vartheta_n(0,q)` are also frequently
+encountered. Finally, Jacobi theta functions are frequently
+considered as functions of the half-period ratio `\tau`
+and then usually denoted by `\vartheta_n(z|\tau)`.
+
+Optionally, ``jtheta(n, z, q, derivative=d)`` with `d > 0` computes
+a `d`-th derivative with respect to `z`.
+
+**Examples and basic properties**
+
+Considered as functions of `z`, the Jacobi theta functions may be
+viewed as generalizations of the ordinary trigonometric functions
+cos and sin. They are periodic functions::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> jtheta(1, 0.25, '0.2')
+    0.2945120798627300045053104
+    >>> jtheta(1, 0.25 + 2*pi, '0.2')
+    0.2945120798627300045053104
+
+Indeed, the series defining the theta functions are essentially
+trigonometric Fourier series. The coefficients can be retrieved
+using :func:`~mpmath.fourier`::
+
+    >>> mp.dps = 10
+    >>> nprint(fourier(lambda x: jtheta(2, x, 0.5), [-pi, pi], 4))
+    ([0.0, 1.68179, 0.0, 0.420448, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0])
+
+The Jacobi theta functions are also so-called quasiperiodic
+functions of `z` and `\tau`, meaning that for fixed `\tau`,
+`\vartheta_n(z, q)` and `\vartheta_n(z+\pi \tau, q)` are the same
+except for an exponential factor::
+
+    >>> mp.dps = 25
+    >>> tau = 3*j/10
+    >>> q = exp(pi*j*tau)
+    >>> z = 10
+    >>> jtheta(4, z+tau*pi, q)
+    (-0.682420280786034687520568 + 1.526683999721399103332021j)
+    >>> -exp(-2*j*z)/q * jtheta(4, z, q)
+    (-0.682420280786034687520568 + 1.526683999721399103332021j)
+
+The Jacobi theta functions satisfy a huge number of other
+functional equations, such as the following identity (valid for
+any `q`)::
+
+    >>> q = mpf(3)/10
+    >>> jtheta(3,0,q)**4
+    6.823744089352763305137427
+    >>> jtheta(2,0,q)**4 + jtheta(4,0,q)**4
+    6.823744089352763305137427
+
+Extensive listings of identities satisfied by the Jacobi theta
+functions can be found in standard reference works.
+
+The Jacobi theta functions are related to the gamma function
+for special arguments::
+
+    >>> jtheta(3, 0, exp(-pi))
+    1.086434811213308014575316
+    >>> pi**(1/4.) / gamma(3/4.)
+    1.086434811213308014575316
+
+:func:`~mpmath.jtheta` supports arbitrary precision evaluation and complex
+arguments::
+
+    >>> mp.dps = 50
+    >>> jtheta(4, sqrt(2), 0.5)
+    2.0549510717571539127004115835148878097035750653737
+    >>> mp.dps = 25
+    >>> jtheta(4, 1+2j, (1+j)/5)
+    (7.180331760146805926356634 - 1.634292858119162417301683j)
+
+Evaluation of derivatives::
+
+    >>> mp.dps = 25
+    >>> jtheta(1, 7, 0.25, 1); diff(lambda z: jtheta(1, z, 0.25), 7)
+    1.209857192844475388637236
+    1.209857192844475388637236
+    >>> jtheta(1, 7, 0.25, 2); diff(lambda z: jtheta(1, z, 0.25), 7, 2)
+    -0.2598718791650217206533052
+    -0.2598718791650217206533052
+    >>> jtheta(2, 7, 0.25, 1); diff(lambda z: jtheta(2, z, 0.25), 7)
+    -1.150231437070259644461474
+    -1.150231437070259644461474
+    >>> jtheta(2, 7, 0.25, 2); diff(lambda z: jtheta(2, z, 0.25), 7, 2)
+    -0.6226636990043777445898114
+    -0.6226636990043777445898114
+    >>> jtheta(3, 7, 0.25, 1); diff(lambda z: jtheta(3, z, 0.25), 7)
+    -0.9990312046096634316587882
+    -0.9990312046096634316587882
+    >>> jtheta(3, 7, 0.25, 2); diff(lambda z: jtheta(3, z, 0.25), 7, 2)
+    -0.1530388693066334936151174
+    -0.1530388693066334936151174
+    >>> jtheta(4, 7, 0.25, 1); diff(lambda z: jtheta(4, z, 0.25), 7)
+    0.9820995967262793943571139
+    0.9820995967262793943571139
+    >>> jtheta(4, 7, 0.25, 2); diff(lambda z: jtheta(4, z, 0.25), 7, 2)
+    0.3936902850291437081667755
+    0.3936902850291437081667755
+
+**Possible issues**
+
+For `|q| \ge 1` or `\Im(\tau) \le 0`, :func:`~mpmath.jtheta` raises
+``ValueError``. This exception is also raised for `|q|` extremely
+close to 1 (or equivalently `\tau` very close to 0), since the
+series would converge too slowly::
+
+    >>> jtheta(1, 10, 0.99999999 * exp(0.5*j))
+    Traceback (most recent call last):
+      ...
+    ValueError: abs(q) > THETA_Q_LIM = 1.000000
+
+"""
+
+eulernum = r"""
+Gives the `n`-th Euler number, defined as the `n`-th derivative of
+`\mathrm{sech}(t) = 1/\cosh(t)` evaluated at `t = 0`. Equivalently, the
+Euler numbers give the coefficients of the Taylor series
+
+.. math ::
+
+    \mathrm{sech}(t) = \sum_{n=0}^{\infty} \frac{E_n}{n!} t^n.
+
+The Euler numbers are closely related to Bernoulli numbers
+and Bernoulli polynomials. They can also be evaluated in terms of
+Euler polynomials (see :func:`~mpmath.eulerpoly`) as `E_n = 2^n E_n(1/2)`.
+
+**Examples**
+
+Computing the first few Euler numbers and verifying that they
+agree with the Taylor series::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> [eulernum(n) for n in range(11)]
+    [1.0, 0.0, -1.0, 0.0, 5.0, 0.0, -61.0, 0.0, 1385.0, 0.0, -50521.0]
+    >>> chop(diffs(sech, 0, 10))
+    [1.0, 0.0, -1.0, 0.0, 5.0, 0.0, -61.0, 0.0, 1385.0, 0.0, -50521.0]
+
+Euler numbers grow very rapidly. :func:`~mpmath.eulernum` efficiently
+computes numerical approximations for large indices::
+
+    >>> eulernum(50)
+    -6.053285248188621896314384e+54
+    >>> eulernum(1000)
+    3.887561841253070615257336e+2371
+    >>> eulernum(10**20)
+    4.346791453661149089338186e+1936958564106659551331
+
+Comparing with an asymptotic formula for the Euler numbers::
+
+    >>> n = 10**5
+    >>> (-1)**(n//2) * 8 * sqrt(n/(2*pi)) * (2*n/(pi*e))**n
+    3.69919063017432362805663e+436961
+    >>> eulernum(n)
+    3.699193712834466537941283e+436961
+
+Pass ``exact=True`` to obtain exact values of Euler numbers as integers::
+
+    >>> print(eulernum(50, exact=True))
+    -6053285248188621896314383785111649088103498225146815121
+    >>> print(eulernum(200, exact=True) % 10**10)
+    1925859625
+    >>> eulernum(1001, exact=True)
+    0
+"""
+
+eulerpoly = r"""
+Evaluates the Euler polynomial `E_n(z)`, defined by the generating function
+representation
+
+.. math ::
+
+    \frac{2e^{zt}}{e^t+1} = \sum_{n=0}^\infty E_n(z) \frac{t^n}{n!}.
+
+The Euler polynomials may also be represented in terms of
+Bernoulli polynomials (see :func:`~mpmath.bernpoly`) using various formulas, for
+example
+
+.. math ::
+
+    E_n(z) = \frac{2}{n+1} \left(
+        B_n(z)-2^{n+1}B_n\left(\frac{z}{2}\right)
+    \right).
+
+Special values include the Euler numbers `E_n = 2^n E_n(1/2)` (see
+:func:`~mpmath.eulernum`).
+
+**Examples**
+
+Computing the coefficients of the first few Euler polynomials::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> for n in range(6):
+    ...     chop(taylor(lambda z: eulerpoly(n,z), 0, n))
+    ...
+    [1.0]
+    [-0.5, 1.0]
+    [0.0, -1.0, 1.0]
+    [0.25, 0.0, -1.5, 1.0]
+    [0.0, 1.0, 0.0, -2.0, 1.0]
+    [-0.5, 0.0, 2.5, 0.0, -2.5, 1.0]
+
+Evaluation for arbitrary `z`::
+
+    >>> eulerpoly(2,3)
+    6.0
+    >>> eulerpoly(5,4)
+    423.5
+    >>> eulerpoly(35, 11111111112)
+    3.994957561486776072734601e+351
+    >>> eulerpoly(4, 10+20j)
+    (-47990.0 - 235980.0j)
+    >>> eulerpoly(2, '-3.5e-5')
+    0.000035001225
+    >>> eulerpoly(3, 0.5)
+    0.0
+    >>> eulerpoly(55, -10**80)
+    -1.0e+4400
+    >>> eulerpoly(5, -inf)
+    -inf
+    >>> eulerpoly(6, -inf)
+    +inf
+
+Computing Euler numbers::
+
+    >>> 2**26 * eulerpoly(26,0.5)
+    -4087072509293123892361.0
+    >>> eulernum(26)
+    -4087072509293123892361.0
+
+Evaluation is accurate for large `n` and small `z`::
+
+    >>> eulerpoly(100, 0.5)
+    2.29047999988194114177943e+108
+    >>> eulerpoly(1000, 10.5)
+    3.628120031122876847764566e+2070
+    >>> eulerpoly(10000, 10.5)
+    1.149364285543783412210773e+30688
+"""
+
+spherharm = r"""
+Evaluates the spherical harmonic `Y_l^m(\theta,\phi)`,
+
+.. math ::
+
+    Y_l^m(\theta,\phi) = \sqrt{\frac{2l+1}{4\pi}\frac{(l-m)!}{(l+m)!}}
+        P_l^m(\cos \theta) e^{i m \phi}
+
+where `P_l^m` is an associated Legendre function (see :func:`~mpmath.legenp`).
+
+Here `\theta \in [0, \pi]` denotes the polar coordinate (ranging
+from the north pole to the south pole) and `\phi \in [0, 2 \pi]` denotes the
+azimuthal coordinate on a sphere. Care should be used since many different
+conventions for spherical coordinate variables are used.
+
+Usually spherical harmonics are considered for `l \in \mathbb{N}`,
+`m \in \mathbb{Z}`, `|m| \le l`. More generally, `l,m,\theta,\phi`
+are permitted to be complex numbers.
+
+.. note ::
+
+    :func:`~mpmath.spherharm` returns a complex number, even if the value is
+    purely real.
+
+**Plots**
+
+.. literalinclude :: /plots/spherharm40.py
+
+`Y_{4,0}`:
+
+.. image :: /plots/spherharm40.png
+
+`Y_{4,1}`:
+
+.. image :: /plots/spherharm41.png
+
+`Y_{4,2}`:
+
+.. image :: /plots/spherharm42.png
+
+`Y_{4,3}`:
+
+.. image :: /plots/spherharm43.png
+
+`Y_{4,4}`:
+
+.. image :: /plots/spherharm44.png
+
+**Examples**
+
+Some low-order spherical harmonics with reference values::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> theta = pi/4
+    >>> phi = pi/3
+    >>> spherharm(0,0,theta,phi); 0.5*sqrt(1/pi)*expj(0)
+    (0.2820947917738781434740397 + 0.0j)
+    (0.2820947917738781434740397 + 0.0j)
+    >>> spherharm(1,-1,theta,phi); 0.5*sqrt(3/(2*pi))*expj(-phi)*sin(theta)
+    (0.1221506279757299803965962 - 0.2115710938304086076055298j)
+    (0.1221506279757299803965962 - 0.2115710938304086076055298j)
+    >>> spherharm(1,0,theta,phi); 0.5*sqrt(3/pi)*cos(theta)*expj(0)
+    (0.3454941494713354792652446 + 0.0j)
+    (0.3454941494713354792652446 + 0.0j)
+    >>> spherharm(1,1,theta,phi); -0.5*sqrt(3/(2*pi))*expj(phi)*sin(theta)
+    (-0.1221506279757299803965962 - 0.2115710938304086076055298j)
+    (-0.1221506279757299803965962 - 0.2115710938304086076055298j)
+
+With the normalization convention used, the spherical harmonics are orthonormal
+on the unit sphere::
+
+    >>> sphere = [0,pi], [0,2*pi]
+    >>> dS = lambda t,p: fp.sin(t)   # differential element
+    >>> Y1 = lambda t,p: fp.spherharm(l1,m1,t,p)
+    >>> Y2 = lambda t,p: fp.conj(fp.spherharm(l2,m2,t,p))
+    >>> l1 = l2 = 3; m1 = m2 = 2
+    >>> fp.chop(fp.quad(lambda t,p: Y1(t,p)*Y2(t,p)*dS(t,p), *sphere))
+    1.0000000000000007
+    >>> m2 = 1    # m1 != m2
+    >>> print(fp.chop(fp.quad(lambda t,p: Y1(t,p)*Y2(t,p)*dS(t,p), *sphere)))
+    0.0
+
+Evaluation is accurate for large orders::
+
+    >>> spherharm(1000,750,0.5,0.25)
+    (3.776445785304252879026585e-102 - 5.82441278771834794493484e-102j)
+
+Evaluation works with complex parameter values::
+
+    >>> spherharm(1+j, 2j, 2+3j, -0.5j)
+    (64.44922331113759992154992 + 1981.693919841408089681743j)
+"""
+
+scorergi = r"""
+Evaluates the Scorer function
+
+.. math ::
+
+    \operatorname{Gi}(z) =
+    \operatorname{Ai}(z) \int_0^z \operatorname{Bi}(t) dt +
+    \operatorname{Bi}(z) \int_z^{\infty} \operatorname{Ai}(t) dt
+
+which gives a particular solution to the inhomogeneous Airy
+differential equation `f''(z) - z f(z) = 1/\pi`. Another
+particular solution is given by the Scorer Hi-function
+(:func:`~mpmath.scorerhi`). The two functions are related as
+`\operatorname{Gi}(z) + \operatorname{Hi}(z) = \operatorname{Bi}(z)`.
+
+**Plots**
+
+.. literalinclude :: /plots/gi.py
+.. image :: /plots/gi.png
+.. literalinclude :: /plots/gi_c.py
+.. image :: /plots/gi_c.png
+
+**Examples**
+
+Some values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> scorergi(0); 1/(power(3,'7/6')*gamma('2/3'))
+    0.2049755424820002450503075
+    0.2049755424820002450503075
+    >>> diff(scorergi, 0); 1/(power(3,'5/6')*gamma('1/3'))
+    0.1494294524512754526382746
+    0.1494294524512754526382746
+    >>> scorergi(+inf); scorergi(-inf)
+    0.0
+    0.0
+    >>> scorergi(1)
+    0.2352184398104379375986902
+    >>> scorergi(-1)
+    -0.1166722172960152826494198
+
+Evaluation for large arguments::
+
+    >>> scorergi(10)
+    0.03189600510067958798062034
+    >>> scorergi(100)
+    0.003183105228162961476590531
+    >>> scorergi(1000000)
+    0.0000003183098861837906721743873
+    >>> 1/(pi*1000000)
+    0.0000003183098861837906715377675
+    >>> scorergi(-1000)
+    -0.08358288400262780392338014
+    >>> scorergi(-100000)
+    0.02886866118619660226809581
+    >>> scorergi(50+10j)
+    (0.0061214102799778578790984 - 0.001224335676457532180747917j)
+    >>> scorergi(-50-10j)
+    (5.236047850352252236372551e+29 - 3.08254224233701381482228e+29j)
+    >>> scorergi(100000j)
+    (-8.806659285336231052679025e+6474077 + 8.684731303500835514850962e+6474077j)
+
+Verifying the connection between Gi and Hi::
+
+    >>> z = 0.25
+    >>> scorergi(z) + scorerhi(z)
+    0.7287469039362150078694543
+    >>> airybi(z)
+    0.7287469039362150078694543
+
+Verifying the differential equation::
+
+    >>> for z in [-3.4, 0, 2.5, 1+2j]:
+    ...     chop(diff(scorergi,z,2) - z*scorergi(z))
+    ...
+    -0.3183098861837906715377675
+    -0.3183098861837906715377675
+    -0.3183098861837906715377675
+    -0.3183098861837906715377675
+
+Verifying the integral representation::
+
+    >>> z = 0.5
+    >>> scorergi(z)
+    0.2447210432765581976910539
+    >>> Ai,Bi = airyai,airybi
+    >>> Bi(z)*(Ai(inf,-1)-Ai(z,-1)) + Ai(z)*(Bi(z,-1)-Bi(0,-1))
+    0.2447210432765581976910539
+
+**References**
+
+1. [DLMF]_ section 9.12: Scorer Functions
+
+"""
+
+scorerhi = r"""
+Evaluates the second Scorer function
+
+.. math ::
+
+    \operatorname{Hi}(z) =
+    \operatorname{Bi}(z) \int_{-\infty}^z \operatorname{Ai}(t) dt -
+    \operatorname{Ai}(z) \int_{-\infty}^z \operatorname{Bi}(t) dt
+
+which gives a particular solution to the inhomogeneous Airy
+differential equation `f''(z) - z f(z) = 1/\pi`. See also
+:func:`~mpmath.scorergi`.
+
+**Plots**
+
+.. literalinclude :: /plots/hi.py
+.. image :: /plots/hi.png
+.. literalinclude :: /plots/hi_c.py
+.. image :: /plots/hi_c.png
+
+**Examples**
+
+Some values and limits::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> scorerhi(0); 2/(power(3,'7/6')*gamma('2/3'))
+    0.4099510849640004901006149
+    0.4099510849640004901006149
+    >>> diff(scorerhi,0); 2/(power(3,'5/6')*gamma('1/3'))
+    0.2988589049025509052765491
+    0.2988589049025509052765491
+    >>> scorerhi(+inf); scorerhi(-inf)
+    +inf
+    0.0
+    >>> scorerhi(1)
+    0.9722051551424333218376886
+    >>> scorerhi(-1)
+    0.2206696067929598945381098
+
+Evaluation for large arguments::
+
+    >>> scorerhi(10)
+    455641153.5163291358991077
+    >>> scorerhi(100)
+    6.041223996670201399005265e+288
+    >>> scorerhi(1000000)
+    7.138269638197858094311122e+289529652
+    >>> scorerhi(-10)
+    0.0317685352825022727415011
+    >>> scorerhi(-100)
+    0.003183092495767499864680483
+    >>> scorerhi(100j)
+    (-6.366197716545672122983857e-9 + 0.003183098861710582761688475j)
+    >>> scorerhi(50+50j)
+    (-5.322076267321435669290334e+63 + 1.478450291165243789749427e+65j)
+    >>> scorerhi(-1000-1000j)
+    (0.0001591549432510502796565538 - 0.000159154943091895334973109j)
+
+Verifying the differential equation::
+
+    >>> for z in [-3.4, 0, 2, 1+2j]:
+    ...     chop(diff(scorerhi,z,2) - z*scorerhi(z))
+    ...
+    0.3183098861837906715377675
+    0.3183098861837906715377675
+    0.3183098861837906715377675
+    0.3183098861837906715377675
+
+Verifying the integral representation::
+
+    >>> z = 0.5
+    >>> scorerhi(z)
+    0.6095559998265972956089949
+    >>> Ai,Bi = airyai,airybi
+    >>> Bi(z)*(Ai(z,-1)-Ai(-inf,-1)) - Ai(z)*(Bi(z,-1)-Bi(-inf,-1))
+    0.6095559998265972956089949
+
+"""
+
+
+stirling1 = r"""
+Gives the Stirling number of the first kind `s(n,k)`, defined by
+
+.. math ::
+
+    x(x-1)(x-2)\cdots(x-n+1) = \sum_{k=0}^n s(n,k) x^k.
+
+The value is computed using an integer recurrence. The implementation
+is not optimized for approximating large values quickly.
+
+**Examples**
+
+Comparing with the generating function::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> taylor(lambda x: ff(x, 5), 0, 5)
+    [0.0, 24.0, -50.0, 35.0, -10.0, 1.0]
+    >>> [stirling1(5, k) for k in range(6)]
+    [0.0, 24.0, -50.0, 35.0, -10.0, 1.0]
+
+Recurrence relation::
+
+    >>> n, k = 5, 3
+    >>> stirling1(n+1,k) + n*stirling1(n,k) - stirling1(n,k-1)
+    0.0
+
+The matrices of Stirling numbers of first and second kind are inverses
+of each other::
+
+    >>> A = matrix(5, 5); B = matrix(5, 5)
+    >>> for n in range(5):
+    ...     for k in range(5):
+    ...         A[n,k] = stirling1(n,k)
+    ...         B[n,k] = stirling2(n,k)
+    ...
+    >>> A * B
+    [1.0  0.0  0.0  0.0  0.0]
+    [0.0  1.0  0.0  0.0  0.0]
+    [0.0  0.0  1.0  0.0  0.0]
+    [0.0  0.0  0.0  1.0  0.0]
+    [0.0  0.0  0.0  0.0  1.0]
+
+Pass ``exact=True`` to obtain exact values of Stirling numbers as integers::
+
+    >>> stirling1(42, 5)
+    -2.864498971768501633736628e+50
+    >>> print(stirling1(42, 5, exact=True))
+    -286449897176850163373662803014001546235808317440000
+
+"""
+
+stirling2 = r"""
+Gives the Stirling number of the second kind `S(n,k)`, defined by
+
+.. math ::
+
+    x^n = \sum_{k=0}^n S(n,k) x(x-1)(x-2)\cdots(x-k+1)
+
+The value is computed using integer arithmetic to evaluate a power sum.
+The implementation is not optimized for approximating large values quickly.
+
+**Examples**
+
+Comparing with the generating function::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> taylor(lambda x: sum(stirling2(5,k) * ff(x,k) for k in range(6)), 0, 5)
+    [0.0, 0.0, 0.0, 0.0, 0.0, 1.0]
+
+Recurrence relation::
+
+    >>> n, k = 5, 3
+    >>> stirling2(n+1,k) - k*stirling2(n,k) - stirling2(n,k-1)
+    0.0
+
+Pass ``exact=True`` to obtain exact values of Stirling numbers as integers::
+
+    >>> stirling2(52, 10)
+    2.641822121003543906807485e+45
+    >>> print(stirling2(52, 10, exact=True))
+    2641822121003543906807485307053638921722527655
+
+
+"""
+
+squarew = r"""
+Computes the square wave function using the definition:
+
+.. math::
+    x(t) = A(-1)^{\left\lfloor{2t / P}\right\rfloor}
+
+where `P` is the period of the wave and `A` is the amplitude.
+
+**Examples**
+
+Square wave with period = 2, amplitude = 1 ::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> squarew(0,1,2)
+    1.0
+    >>> squarew(0.5,1,2)
+    1.0
+    >>> squarew(1,1,2)
+    -1.0
+    >>> squarew(1.5,1,2)
+    -1.0
+    >>> squarew(2,1,2)
+    1.0
+"""
+
+trianglew = r"""
+Computes the triangle wave function using the definition:
+
+.. math::
+    x(t) = 2A\left(\frac{1}{2}-\left|1-2 \operatorname{frac}\left(\frac{x}{P}+\frac{1}{4}\right)\right|\right)
+
+where :math:`\operatorname{frac}\left(\frac{t}{T}\right) = \frac{t}{T}-\left\lfloor{\frac{t}{T}}\right\rfloor`
+, `P` is the period of the wave, and `A` is the amplitude.
+
+**Examples**
+
+Triangle wave with period = 2, amplitude = 1 ::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> trianglew(0,1,2)
+    0.0
+    >>> trianglew(0.25,1,2)
+    0.5
+    >>> trianglew(0.5,1,2)
+    1.0
+    >>> trianglew(1,1,2)
+    0.0
+    >>> trianglew(1.5,1,2)
+    -1.0
+    >>> trianglew(2,1,2)
+    0.0
+"""
+
+sawtoothw = r"""
+Computes the sawtooth wave function using the definition:
+
+.. math::
+    x(t) = A\operatorname{frac}\left(\frac{t}{T}\right)
+
+where :math:`\operatorname{frac}\left(\frac{t}{T}\right) = \frac{t}{T}-\left\lfloor{\frac{t}{T}}\right\rfloor`,
+`P` is the period of the wave, and `A` is the amplitude.
+
+**Examples**
+
+Sawtooth wave with period = 2, amplitude = 1 ::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> sawtoothw(0,1,2)
+    0.0
+    >>> sawtoothw(0.5,1,2)
+    0.25
+    >>> sawtoothw(1,1,2)
+    0.5
+    >>> sawtoothw(1.5,1,2)
+    0.75
+    >>> sawtoothw(2,1,2)
+    0.0
+"""
+
+unit_triangle = r"""
+Computes the unit triangle using the definition:
+
+.. math::
+    x(t) = A(-\left| t \right| + 1)
+
+where `A` is the amplitude.
+
+**Examples**
+
+Unit triangle with amplitude = 1 ::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> unit_triangle(-1,1)
+    0.0
+    >>> unit_triangle(-0.5,1)
+    0.5
+    >>> unit_triangle(0,1)
+    1.0
+    >>> unit_triangle(0.5,1)
+    0.5
+    >>> unit_triangle(1,1)
+    0.0
+"""
+
+sigmoid = r"""
+Computes the sigmoid function using the definition:
+
+.. math::
+    x(t) = \frac{A}{1 + e^{-t}}
+
+where `A` is the amplitude.
+
+**Examples**
+
+Sigmoid function with amplitude = 1 ::
+
+    >>> from mpmath import *
+    >>> mp.dps = 25; mp.pretty = True
+    >>> sigmoid(-1,1)
+    0.2689414213699951207488408
+    >>> sigmoid(-0.5,1)
+    0.3775406687981454353610994
+    >>> sigmoid(0,1)
+    0.5
+    >>> sigmoid(0.5,1)
+    0.6224593312018545646389006
+    >>> sigmoid(1,1)
+    0.7310585786300048792511592
+
+"""
diff --git a/lib/python3.11/site-packages/mpmath/functions/__init__.py b/lib/python3.11/site-packages/mpmath/functions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5896ed0579eceab086dc5c67eaa649b6061a53dc
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/__init__.py
@@ -0,0 +1,14 @@
+from . import functions
+# Hack to update methods
+from . import factorials
+from . import hypergeometric
+from . import expintegrals
+from . import bessel
+from . import orthogonal
+from . import theta
+from . import elliptic
+from . import signals
+from . import zeta
+from . import rszeta
+from . import zetazeros
+from . import qfunctions
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f0fb58e1b1d82c4bd0a2a5cd8bb5e0249b61a03
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/bessel.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/bessel.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc491faace0a180cb50501a39ec483eaf5940af2
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/bessel.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/elliptic.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/elliptic.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..18279b8bd9cc3e9931bdfc74aa68799409cf23cd
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/elliptic.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/expintegrals.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/expintegrals.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfeb7dd99b0793aba245b89d51a4426b3d9fd9a2
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/expintegrals.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/factorials.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/factorials.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa57224694a0c6632ca46267b19f6530d1d4ac91
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/factorials.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/functions.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/functions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ed6f5f1db7e0cbf069cc5577d5e0bbec5802f77
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/functions.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/hypergeometric.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/hypergeometric.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6d98e09c0dc57d57a55bf1027cee1e9c1b37dfd
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/hypergeometric.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/orthogonal.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/orthogonal.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1226e2b0d93d2f10b8a8a651415ab584a44ec5a6
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/orthogonal.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/qfunctions.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/qfunctions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64f6147e67cb2f197da65fda80957583d582dcbe
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/qfunctions.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/rszeta.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/rszeta.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..afa85ff62e9d34ad5fcad85f82ffef82c518e7a7
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/rszeta.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/signals.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/signals.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf4277f3bf00e50032803e169ac416e531d815d2
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/signals.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/theta.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/theta.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b11ed6d7a82d952ffe7c69174c187bfbd792b461
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/theta.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/zeta.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/zeta.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fd4e4f4462c047c20e65080690e1de0a8b9604a2
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/zeta.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/__pycache__/zetazeros.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/functions/__pycache__/zetazeros.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4f7ec09aadd91bd620aac5cbad28250ef396ea3
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/functions/__pycache__/zetazeros.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/functions/bessel.py b/lib/python3.11/site-packages/mpmath/functions/bessel.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b41d87bb0118de61d5561433dabcb181f872f84
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/bessel.py
@@ -0,0 +1,1108 @@
+from .functions import defun, defun_wrapped
+
+@defun
+def j0(ctx, x):
+    """Computes the Bessel function `J_0(x)`. See :func:`~mpmath.besselj`."""
+    return ctx.besselj(0, x)
+
+@defun
+def j1(ctx, x):
+    """Computes the Bessel function `J_1(x)`.  See :func:`~mpmath.besselj`."""
+    return ctx.besselj(1, x)
+
+@defun
+def besselj(ctx, n, z, derivative=0, **kwargs):
+    if type(n) is int:
+        n_isint = True
+    else:
+        n = ctx.convert(n)
+        n_isint = ctx.isint(n)
+        if n_isint:
+            n = int(ctx._re(n))
+    if n_isint and n < 0:
+        return (-1)**n * ctx.besselj(-n, z, derivative, **kwargs)
+    z = ctx.convert(z)
+    M = ctx.mag(z)
+    if derivative:
+        d = ctx.convert(derivative)
+        # TODO: the integer special-casing shouldn't be necessary.
+        # However, the hypergeometric series gets inaccurate for large d
+        # because of inaccurate pole cancellation at a pole far from
+        # zero (needs to be fixed in hypercomb or hypsum)
+        if ctx.isint(d) and d >= 0:
+            d = int(d)
+            orig = ctx.prec
+            try:
+                ctx.prec += 15
+                v = ctx.fsum((-1)**k * ctx.binomial(d,k) * ctx.besselj(2*k+n-d,z)
+                    for k in range(d+1))
+            finally:
+                ctx.prec = orig
+            v *= ctx.mpf(2)**(-d)
+        else:
+            def h(n,d):
+                r = ctx.fmul(ctx.fmul(z, z, prec=ctx.prec+M), -0.25, exact=True)
+                B = [0.5*(n-d+1), 0.5*(n-d+2)]
+                T = [([2,ctx.pi,z],[d-2*n,0.5,n-d],[],B,[(n+1)*0.5,(n+2)*0.5],B+[n+1],r)]
+                return T
+            v = ctx.hypercomb(h, [n,d], **kwargs)
+    else:
+        # Fast case: J_n(x), n int, appropriate magnitude for fixed-point calculation
+        if (not derivative) and n_isint and abs(M) < 10 and abs(n) < 20:
+            try:
+                return ctx._besselj(n, z)
+            except NotImplementedError:
+                pass
+        if not z:
+            if not n:
+                v = ctx.one + n+z
+            elif ctx.re(n) > 0:
+                v = n*z
+            else:
+                v = ctx.inf + z + n
+        else:
+            #v = 0
+            orig = ctx.prec
+            try:
+                # XXX: workaround for accuracy in low level hypergeometric series
+                # when alternating, large arguments
+                ctx.prec += min(3*abs(M), ctx.prec)
+                w = ctx.fmul(z, 0.5, exact=True)
+                def h(n):
+                    r = ctx.fneg(ctx.fmul(w, w, prec=max(0,ctx.prec+M)), exact=True)
+                    return [([w], [n], [], [n+1], [], [n+1], r)]
+                v = ctx.hypercomb(h, [n], **kwargs)
+            finally:
+                ctx.prec = orig
+        v = +v
+    return v
+
+@defun
+def besseli(ctx, n, z, derivative=0, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    if not z:
+        if derivative:
+            raise ValueError
+        if not n:
+            # I(0,0) = 1
+            return 1+n+z
+        if ctx.isint(n):
+            return 0*(n+z)
+        r = ctx.re(n)
+        if r == 0:
+            return ctx.nan*(n+z)
+        elif r > 0:
+            return 0*(n+z)
+        else:
+            return ctx.inf+(n+z)
+    M = ctx.mag(z)
+    if derivative:
+        d = ctx.convert(derivative)
+        def h(n,d):
+            r = ctx.fmul(ctx.fmul(z, z, prec=ctx.prec+M), 0.25, exact=True)
+            B = [0.5*(n-d+1), 0.5*(n-d+2), n+1]
+            T = [([2,ctx.pi,z],[d-2*n,0.5,n-d],[n+1],B,[(n+1)*0.5,(n+2)*0.5],B,r)]
+            return T
+        v = ctx.hypercomb(h, [n,d], **kwargs)
+    else:
+        def h(n):
+            w = ctx.fmul(z, 0.5, exact=True)
+            r = ctx.fmul(w, w, prec=max(0,ctx.prec+M))
+            return [([w], [n], [], [n+1], [], [n+1], r)]
+        v = ctx.hypercomb(h, [n], **kwargs)
+    return v
+
+@defun_wrapped
+def bessely(ctx, n, z, derivative=0, **kwargs):
+    if not z:
+        if derivative:
+            # Not implemented
+            raise ValueError
+        if not n:
+            # ~ log(z/2)
+            return -ctx.inf + (n+z)
+        if ctx.im(n):
+            return ctx.nan * (n+z)
+        r = ctx.re(n)
+        q = n+0.5
+        if ctx.isint(q):
+            if n > 0:
+                return -ctx.inf + (n+z)
+            else:
+                return 0 * (n+z)
+        if r < 0 and int(ctx.floor(q)) % 2:
+            return ctx.inf + (n+z)
+        else:
+            return ctx.ninf + (n+z)
+    # XXX: use hypercomb
+    ctx.prec += 10
+    m, d = ctx.nint_distance(n)
+    if d < -ctx.prec:
+        h = +ctx.eps
+        ctx.prec *= 2
+        n += h
+    elif d < 0:
+        ctx.prec -= d
+    # TODO: avoid cancellation for imaginary arguments
+    cos, sin = ctx.cospi_sinpi(n)
+    return (ctx.besselj(n,z,derivative,**kwargs)*cos - \
+        ctx.besselj(-n,z,derivative,**kwargs))/sin
+
+@defun_wrapped
+def besselk(ctx, n, z, **kwargs):
+    if not z:
+        return ctx.inf
+    M = ctx.mag(z)
+    if M < 1:
+        # Represent as limit definition
+        def h(n):
+            r = (z/2)**2
+            T1 = [z, 2], [-n, n-1], [n], [], [], [1-n], r
+            T2 = [z, 2], [n, -n-1], [-n], [], [], [1+n], r
+            return T1, T2
+    # We could use the limit definition always, but it leads
+    # to very bad cancellation (of exponentially large terms)
+    # for large real z
+    # Instead represent in terms of 2F0
+    else:
+        ctx.prec += M
+        def h(n):
+            return [([ctx.pi/2, z, ctx.exp(-z)], [0.5,-0.5,1], [], [], \
+                [n+0.5, 0.5-n], [], -1/(2*z))]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun_wrapped
+def hankel1(ctx,n,x,**kwargs):
+    return ctx.besselj(n,x,**kwargs) + ctx.j*ctx.bessely(n,x,**kwargs)
+
+@defun_wrapped
+def hankel2(ctx,n,x,**kwargs):
+    return ctx.besselj(n,x,**kwargs) - ctx.j*ctx.bessely(n,x,**kwargs)
+
+@defun_wrapped
+def whitm(ctx,k,m,z,**kwargs):
+    if z == 0:
+        # M(k,m,z) = 0^(1/2+m)
+        if ctx.re(m) > -0.5:
+            return z
+        elif ctx.re(m) < -0.5:
+            return ctx.inf + z
+        else:
+            return ctx.nan * z
+    x = ctx.fmul(-0.5, z, exact=True)
+    y = 0.5+m
+    return ctx.exp(x) * z**y * ctx.hyp1f1(y-k, 1+2*m, z, **kwargs)
+
+@defun_wrapped
+def whitw(ctx,k,m,z,**kwargs):
+    if z == 0:
+        g = abs(ctx.re(m))
+        if g < 0.5:
+            return z
+        elif g > 0.5:
+            return ctx.inf + z
+        else:
+            return ctx.nan * z
+    x = ctx.fmul(-0.5, z, exact=True)
+    y = 0.5+m
+    return ctx.exp(x) * z**y * ctx.hyperu(y-k, 1+2*m, z, **kwargs)
+
+@defun
+def hyperu(ctx, a, b, z, **kwargs):
+    a, atype = ctx._convert_param(a)
+    b, btype = ctx._convert_param(b)
+    z = ctx.convert(z)
+    if not z:
+        if ctx.re(b) <= 1:
+            return ctx.gammaprod([1-b],[a-b+1])
+        else:
+            return ctx.inf + z
+    bb = 1+a-b
+    bb, bbtype = ctx._convert_param(bb)
+    try:
+        orig = ctx.prec
+        try:
+            ctx.prec += 10
+            v = ctx.hypsum(2, 0, (atype, bbtype), [a, bb], -1/z, maxterms=ctx.prec)
+            return v / z**a
+        finally:
+            ctx.prec = orig
+    except ctx.NoConvergence:
+        pass
+    def h(a,b):
+        w = ctx.sinpi(b)
+        T1 = ([ctx.pi,w],[1,-1],[],[a-b+1,b],[a],[b],z)
+        T2 = ([-ctx.pi,w,z],[1,-1,1-b],[],[a,2-b],[a-b+1],[2-b],z)
+        return T1, T2
+    return ctx.hypercomb(h, [a,b], **kwargs)
+
+@defun
+def struveh(ctx,n,z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/StruveH/26/01/02/
+    def h(n):
+        return [([z/2, 0.5*ctx.sqrt(ctx.pi)], [n+1, -1], [], [n+1.5], [1], [1.5, n+1.5], -(z/2)**2)]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def struvel(ctx,n,z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/StruveL/26/01/02/
+    def h(n):
+        return [([z/2, 0.5*ctx.sqrt(ctx.pi)], [n+1, -1], [], [n+1.5], [1], [1.5, n+1.5], (z/2)**2)]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+def _anger(ctx,which,v,z,**kwargs):
+    v = ctx._convert_param(v)[0]
+    z = ctx.convert(z)
+    def h(v):
+        b = ctx.mpq_1_2
+        u = v*b
+        m = b*3
+        a1,a2,b1,b2 = m-u, m+u, 1-u, 1+u
+        c, s = ctx.cospi_sinpi(u)
+        if which == 0:
+            A, B = [b*z, s], [c]
+        if which == 1:
+            A, B = [b*z, -c], [s]
+        w = ctx.square_exp_arg(z, mult=-0.25)
+        T1 = A, [1, 1], [], [a1,a2], [1], [a1,a2], w
+        T2 = B, [1], [], [b1,b2], [1], [b1,b2], w
+        return T1, T2
+    return ctx.hypercomb(h, [v], **kwargs)
+
+@defun
+def angerj(ctx, v, z, **kwargs):
+    return _anger(ctx, 0, v, z, **kwargs)
+
+@defun
+def webere(ctx, v, z, **kwargs):
+    return _anger(ctx, 1, v, z, **kwargs)
+
+@defun
+def lommels1(ctx, u, v, z, **kwargs):
+    u = ctx._convert_param(u)[0]
+    v = ctx._convert_param(v)[0]
+    z = ctx.convert(z)
+    def h(u,v):
+        b = ctx.mpq_1_2
+        w = ctx.square_exp_arg(z, mult=-0.25)
+        return ([u-v+1, u+v+1, z], [-1, -1, u+1], [], [], [1], \
+            [b*(u-v+3),b*(u+v+3)], w),
+    return ctx.hypercomb(h, [u,v], **kwargs)
+
+@defun
+def lommels2(ctx, u, v, z, **kwargs):
+    u = ctx._convert_param(u)[0]
+    v = ctx._convert_param(v)[0]
+    z = ctx.convert(z)
+    # Asymptotic expansion (GR p. 947) -- need to be careful
+    # not to use for small arguments
+    # def h(u,v):
+    #    b = ctx.mpq_1_2
+    #    w = -(z/2)**(-2)
+    #    return ([z], [u-1], [], [], [b*(1-u+v)], [b*(1-u-v)], w),
+    def h(u,v):
+        b = ctx.mpq_1_2
+        w = ctx.square_exp_arg(z, mult=-0.25)
+        T1 = [u-v+1, u+v+1, z], [-1, -1, u+1], [], [], [1], [b*(u-v+3),b*(u+v+3)], w
+        T2 = [2, z], [u+v-1, -v], [v, b*(u+v+1)], [b*(v-u+1)], [], [1-v], w
+        T3 = [2, z], [u-v-1, v], [-v, b*(u-v+1)], [b*(1-u-v)], [], [1+v], w
+        #c1 = ctx.cospi((u-v)*b)
+        #c2 = ctx.cospi((u+v)*b)
+        #s = ctx.sinpi(v)
+        #r1 = (u-v+1)*b
+        #r2 = (u+v+1)*b
+        #T2 = [c1, s, z, 2], [1, -1, -v, v], [], [-v+1], [], [-v+1], w
+        #T3 = [-c2, s, z, 2], [1, -1, v, -v], [], [v+1], [], [v+1], w
+        #T2 = [c1, s, z, 2], [1, -1, -v, v+u-1], [r1, r2], [-v+1], [], [-v+1], w
+        #T3 = [-c2, s, z, 2], [1, -1, v, -v+u-1], [r1, r2], [v+1], [], [v+1], w
+        return T1, T2, T3
+    return ctx.hypercomb(h, [u,v], **kwargs)
+
+@defun
+def ber(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinBer2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos, sin = ctx.cospi_sinpi(-0.75*n)
+        T1 = [cos, z/2], [1, n], [], [n+1], [], [0.5, 0.5*(n+1), 0.5*n+1], r
+        T2 = [sin, z/2], [1, n+2], [], [n+2], [], [1.5, 0.5*(n+3), 0.5*n+1], r
+        return T1, T2
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def bei(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinBei2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos, sin = ctx.cospi_sinpi(0.75*n)
+        T1 = [cos, z/2], [1, n+2], [], [n+2], [], [1.5, 0.5*(n+3), 0.5*n+1], r
+        T2 = [sin, z/2], [1, n], [], [n+1], [], [0.5, 0.5*(n+1), 0.5*n+1], r
+        return T1, T2
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def ker(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinKer2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos1, sin1 = ctx.cospi_sinpi(0.25*n)
+        cos2, sin2 = ctx.cospi_sinpi(0.75*n)
+        T1 = [2, z, 4*cos1], [-n-3, n, 1], [-n], [], [], [0.5, 0.5*(1+n), 0.5*(n+2)], r
+        T2 = [2, z, -sin1], [-n-3, 2+n, 1], [-n-1], [], [], [1.5, 0.5*(3+n), 0.5*(n+2)], r
+        T3 = [2, z, 4*cos2], [n-3, -n, 1], [n], [], [], [0.5, 0.5*(1-n), 1-0.5*n], r
+        T4 = [2, z, -sin2], [n-3, 2-n, 1], [n-1], [], [], [1.5, 0.5*(3-n), 1-0.5*n], r
+        return T1, T2, T3, T4
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun
+def kei(ctx, n, z, **kwargs):
+    n = ctx.convert(n)
+    z = ctx.convert(z)
+    # http://functions.wolfram.com/Bessel-TypeFunctions/KelvinKei2/26/01/02/0001/
+    def h(n):
+        r = -(z/4)**4
+        cos1, sin1 = ctx.cospi_sinpi(0.75*n)
+        cos2, sin2 = ctx.cospi_sinpi(0.25*n)
+        T1 = [-cos1, 2, z], [1, n-3, 2-n], [n-1], [], [], [1.5, 0.5*(3-n), 1-0.5*n], r
+        T2 = [-sin1, 2, z], [1, n-1, -n], [n], [], [], [0.5, 0.5*(1-n), 1-0.5*n], r
+        T3 = [-sin2, 2, z], [1, -n-1, n], [-n], [], [], [0.5, 0.5*(n+1), 0.5*(n+2)], r
+        T4 = [-cos2, 2, z], [1, -n-3, n+2], [-n-1], [], [], [1.5, 0.5*(n+3), 0.5*(n+2)], r
+        return T1, T2, T3, T4
+    return ctx.hypercomb(h, [n], **kwargs)
+
+# TODO: do this more generically?
+def c_memo(f):
+    name = f.__name__
+    def f_wrapped(ctx):
+        cache = ctx._misc_const_cache
+        prec = ctx.prec
+        p,v = cache.get(name, (-1,0))
+        if p >= prec:
+            return +v
+        else:
+            cache[name] = (prec, f(ctx))
+            return cache[name][1]
+    return f_wrapped
+
+@c_memo
+def _airyai_C1(ctx):
+    return 1 / (ctx.cbrt(9) * ctx.gamma(ctx.mpf(2)/3))
+
+@c_memo
+def _airyai_C2(ctx):
+    return -1 / (ctx.cbrt(3) * ctx.gamma(ctx.mpf(1)/3))
+
+@c_memo
+def _airybi_C1(ctx):
+    return 1 / (ctx.nthroot(3,6) * ctx.gamma(ctx.mpf(2)/3))
+
+@c_memo
+def _airybi_C2(ctx):
+    return ctx.nthroot(3,6) / ctx.gamma(ctx.mpf(1)/3)
+
+def _airybi_n2_inf(ctx):
+    prec = ctx.prec
+    try:
+        v = ctx.power(3,'2/3')*ctx.gamma('2/3')/(2*ctx.pi)
+    finally:
+        ctx.prec = prec
+    return +v
+
+# Derivatives at z = 0
+# TODO: could be expressed more elegantly using triple factorials
+def _airyderiv_0(ctx, z, n, ntype, which):
+    if ntype == 'Z':
+        if n < 0:
+            return z
+        r = ctx.mpq_1_3
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            v = ctx.gamma((n+1)*r) * ctx.power(3,n*r) / ctx.pi
+            if which == 0:
+                v *= ctx.sinpi(2*(n+1)*r)
+                v /= ctx.power(3,'2/3')
+            else:
+                v *= abs(ctx.sinpi(2*(n+1)*r))
+                v /= ctx.power(3,'1/6')
+        finally:
+            ctx.prec = prec
+        return +v + z
+    else:
+        # singular (does the limit exist?)
+        raise NotImplementedError
+
+@defun
+def airyai(ctx, z, derivative=0, **kwargs):
+    z = ctx.convert(z)
+    if derivative:
+        n, ntype = ctx._convert_param(derivative)
+    else:
+        n = 0
+    # Values at infinities
+    if not ctx.isnormal(z) and z:
+        if n and ntype == 'Z':
+            if n == -1:
+                if z == ctx.inf:
+                    return ctx.mpf(1)/3 + 1/z
+                if z == ctx.ninf:
+                    return ctx.mpf(-2)/3 + 1/z
+            if n < -1:
+                if z == ctx.inf:
+                    return z
+                if z == ctx.ninf:
+                    return (-1)**n * (-z)
+        if (not n) and z == ctx.inf or z == ctx.ninf:
+            return 1/z
+        # TODO: limits
+        raise ValueError("essential singularity of Ai(z)")
+    # Account for exponential scaling
+    if z:
+        extraprec = max(0, int(1.5*ctx.mag(z)))
+    else:
+        extraprec = 0
+    if n:
+        if n == 1:
+            def h():
+                # http://functions.wolfram.com/03.07.06.0005.01
+                if ctx._re(z) > 4:
+                    ctx.prec += extraprec
+                    w = z**1.5; r = -0.75/w; u = -2*w/3
+                    ctx.prec -= extraprec
+                    C = -ctx.exp(u)/(2*ctx.sqrt(ctx.pi))*ctx.nthroot(z,4)
+                    return ([C],[1],[],[],[(-1,6),(7,6)],[],r),
+                # http://functions.wolfram.com/03.07.26.0001.01
+                else:
+                    ctx.prec += extraprec
+                    w = z**3 / 9
+                    ctx.prec -= extraprec
+                    C1 = _airyai_C1(ctx) * 0.5
+                    C2 = _airyai_C2(ctx)
+                    T1 = [C1,z],[1,2],[],[],[],[ctx.mpq_5_3],w
+                    T2 = [C2],[1],[],[],[],[ctx.mpq_1_3],w
+                    return T1, T2
+            return ctx.hypercomb(h, [], **kwargs)
+        else:
+            if z == 0:
+                return _airyderiv_0(ctx, z, n, ntype, 0)
+            # http://functions.wolfram.com/03.05.20.0004.01
+            def h(n):
+                ctx.prec += extraprec
+                w = z**3/9
+                ctx.prec -= extraprec
+                q13,q23,q43 = ctx.mpq_1_3, ctx.mpq_2_3, ctx.mpq_4_3
+                a1=q13; a2=1; b1=(1-n)*q13; b2=(2-n)*q13; b3=1-n*q13
+                T1 = [3, z], [n-q23, -n], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                a1=q23; b1=(2-n)*q13; b2=1-n*q13; b3=(4-n)*q13
+                T2 = [3, z, -z], [n-q43, -n, 1], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                return T1, T2
+            v = ctx.hypercomb(h, [n], **kwargs)
+            if ctx._is_real_type(z) and ctx.isint(n):
+                v = ctx._re(v)
+            return v
+    else:
+        def h():
+            if ctx._re(z) > 4:
+                # We could use 1F1, but it results in huge cancellation;
+                # the following expansion is better.
+                # TODO: asymptotic series for derivatives
+                ctx.prec += extraprec
+                w = z**1.5; r = -0.75/w; u = -2*w/3
+                ctx.prec -= extraprec
+                C = ctx.exp(u)/(2*ctx.sqrt(ctx.pi)*ctx.nthroot(z,4))
+                return ([C],[1],[],[],[(1,6),(5,6)],[],r),
+            else:
+                ctx.prec += extraprec
+                w = z**3 / 9
+                ctx.prec -= extraprec
+                C1 = _airyai_C1(ctx)
+                C2 = _airyai_C2(ctx)
+                T1 = [C1],[1],[],[],[],[ctx.mpq_2_3],w
+                T2 = [z*C2],[1],[],[],[],[ctx.mpq_4_3],w
+                return T1, T2
+        return ctx.hypercomb(h, [], **kwargs)
+
+@defun
+def airybi(ctx, z, derivative=0, **kwargs):
+    z = ctx.convert(z)
+    if derivative:
+        n, ntype = ctx._convert_param(derivative)
+    else:
+        n = 0
+    # Values at infinities
+    if not ctx.isnormal(z) and z:
+        if n and ntype == 'Z':
+            if z == ctx.inf:
+                return z
+            if z == ctx.ninf:
+                if n == -1:
+                    return 1/z
+                if n == -2:
+                    return _airybi_n2_inf(ctx)
+                if n < -2:
+                    return (-1)**n * (-z)
+        if not n:
+            if z == ctx.inf:
+                return z
+            if z == ctx.ninf:
+                return 1/z
+        # TODO: limits
+        raise ValueError("essential singularity of Bi(z)")
+    if z:
+        extraprec = max(0, int(1.5*ctx.mag(z)))
+    else:
+        extraprec = 0
+    if n:
+        if n == 1:
+            # http://functions.wolfram.com/03.08.26.0001.01
+            def h():
+                ctx.prec += extraprec
+                w = z**3 / 9
+                ctx.prec -= extraprec
+                C1 = _airybi_C1(ctx)*0.5
+                C2 = _airybi_C2(ctx)
+                T1 = [C1,z],[1,2],[],[],[],[ctx.mpq_5_3],w
+                T2 = [C2],[1],[],[],[],[ctx.mpq_1_3],w
+                return T1, T2
+            return ctx.hypercomb(h, [], **kwargs)
+        else:
+            if z == 0:
+                return _airyderiv_0(ctx, z, n, ntype, 1)
+            def h(n):
+                ctx.prec += extraprec
+                w = z**3/9
+                ctx.prec -= extraprec
+                q13,q23,q43 = ctx.mpq_1_3, ctx.mpq_2_3, ctx.mpq_4_3
+                q16 = ctx.mpq_1_6
+                q56 = ctx.mpq_5_6
+                a1=q13; a2=1; b1=(1-n)*q13; b2=(2-n)*q13; b3=1-n*q13
+                T1 = [3, z], [n-q16, -n], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                a1=q23; b1=(2-n)*q13; b2=1-n*q13; b3=(4-n)*q13
+                T2 = [3, z], [n-q56, 1-n], [a1], [b1,b2,b3], \
+                    [a1,a2], [b1,b2,b3], w
+                return T1, T2
+            v = ctx.hypercomb(h, [n], **kwargs)
+            if ctx._is_real_type(z) and ctx.isint(n):
+                v = ctx._re(v)
+            return v
+    else:
+        def h():
+            ctx.prec += extraprec
+            w = z**3 / 9
+            ctx.prec -= extraprec
+            C1 = _airybi_C1(ctx)
+            C2 = _airybi_C2(ctx)
+            T1 = [C1],[1],[],[],[],[ctx.mpq_2_3],w
+            T2 = [z*C2],[1],[],[],[],[ctx.mpq_4_3],w
+            return T1, T2
+        return ctx.hypercomb(h, [], **kwargs)
+
+def _airy_zero(ctx, which, k, derivative, complex=False):
+    # Asymptotic formulas are given in DLMF section 9.9
+    def U(t): return t**(2/3.)*(1-7/(t**2*48))
+    def T(t): return t**(2/3.)*(1+5/(t**2*48))
+    k = int(k)
+    if k < 1:
+        raise ValueError("k cannot be less than 1")
+    if not derivative in (0,1):
+        raise ValueError("Derivative should lie between 0 and 1")
+    if which == 0:
+        if derivative:
+            return ctx.findroot(lambda z: ctx.airyai(z,1),
+                -U(3*ctx.pi*(4*k-3)/8))
+        return ctx.findroot(ctx.airyai, -T(3*ctx.pi*(4*k-1)/8))
+    if which == 1 and complex == False:
+        if derivative:
+            return ctx.findroot(lambda z: ctx.airybi(z,1),
+                -U(3*ctx.pi*(4*k-1)/8))
+        return ctx.findroot(ctx.airybi, -T(3*ctx.pi*(4*k-3)/8))
+    if which == 1 and complex == True:
+        if derivative:
+            t = 3*ctx.pi*(4*k-3)/8 + 0.75j*ctx.ln2
+            s = ctx.expjpi(ctx.mpf(1)/3) * T(t)
+            return ctx.findroot(lambda z: ctx.airybi(z,1), s)
+        t = 3*ctx.pi*(4*k-1)/8 + 0.75j*ctx.ln2
+        s = ctx.expjpi(ctx.mpf(1)/3) * U(t)
+        return ctx.findroot(ctx.airybi, s)
+
+@defun
+def airyaizero(ctx, k, derivative=0):
+    return _airy_zero(ctx, 0, k, derivative, False)
+
+@defun
+def airybizero(ctx, k, derivative=0, complex=False):
+    return _airy_zero(ctx, 1, k, derivative, complex)
+
+def _scorer(ctx, z, which, kwargs):
+    z = ctx.convert(z)
+    if ctx.isinf(z):
+        if z == ctx.inf:
+            if which == 0: return 1/z
+            if which == 1: return z
+        if z == ctx.ninf:
+            return 1/z
+        raise ValueError("essential singularity")
+    if z:
+        extraprec = max(0, int(1.5*ctx.mag(z)))
+    else:
+        extraprec = 0
+    if kwargs.get('derivative'):
+        raise NotImplementedError
+    # Direct asymptotic expansions, to avoid
+    # exponentially large cancellation
+    try:
+        if ctx.mag(z) > 3:
+            if which == 0 and abs(ctx.arg(z)) < ctx.pi/3 * 0.999:
+                def h():
+                    return (([ctx.pi,z],[-1,-1],[],[],[(1,3),(2,3),1],[],9/z**3),)
+                return ctx.hypercomb(h, [], maxterms=ctx.prec, force_series=True)
+            if which == 1 and abs(ctx.arg(-z)) < 2*ctx.pi/3 * 0.999:
+                def h():
+                    return (([-ctx.pi,z],[-1,-1],[],[],[(1,3),(2,3),1],[],9/z**3),)
+                return ctx.hypercomb(h, [], maxterms=ctx.prec, force_series=True)
+    except ctx.NoConvergence:
+        pass
+    def h():
+        A = ctx.airybi(z, **kwargs)/3
+        B = -2*ctx.pi
+        if which == 1:
+            A *= 2
+            B *= -1
+        ctx.prec += extraprec
+        w = z**3/9
+        ctx.prec -= extraprec
+        T1 = [A], [1], [], [], [], [], 0
+        T2 = [B,z], [-1,2], [], [], [1], [ctx.mpq_4_3,ctx.mpq_5_3], w
+        return T1, T2
+    return ctx.hypercomb(h, [], **kwargs)
+
+@defun
+def scorergi(ctx, z, **kwargs):
+    return _scorer(ctx, z, 0, kwargs)
+
+@defun
+def scorerhi(ctx, z, **kwargs):
+    return _scorer(ctx, z, 1, kwargs)
+
+@defun_wrapped
+def coulombc(ctx, l, eta, _cache={}):
+    if (l, eta) in _cache and _cache[l,eta][0] >= ctx.prec:
+        return +_cache[l,eta][1]
+    G3 = ctx.loggamma(2*l+2)
+    G1 = ctx.loggamma(1+l+ctx.j*eta)
+    G2 = ctx.loggamma(1+l-ctx.j*eta)
+    v = 2**l * ctx.exp((-ctx.pi*eta+G1+G2)/2 - G3)
+    if not (ctx.im(l) or ctx.im(eta)):
+        v = ctx.re(v)
+    _cache[l,eta] = (ctx.prec, v)
+    return v
+
+@defun_wrapped
+def coulombf(ctx, l, eta, z, w=1, chop=True, **kwargs):
+    # Regular Coulomb wave function
+    # Note: w can be either 1 or -1; the other may be better in some cases
+    # TODO: check that chop=True chops when and only when it should
+    #ctx.prec += 10
+    def h(l, eta):
+        try:
+            jw = ctx.j*w
+            jwz = ctx.fmul(jw, z, exact=True)
+            jwz2 = ctx.fmul(jwz, -2, exact=True)
+            C = ctx.coulombc(l, eta)
+            T1 = [C, z, ctx.exp(jwz)], [1, l+1, 1], [], [], [1+l+jw*eta], \
+                [2*l+2], jwz2
+        except ValueError:
+            T1 = [0], [-1], [], [], [], [], 0
+        return (T1,)
+    v = ctx.hypercomb(h, [l,eta], **kwargs)
+    if chop and (not ctx.im(l)) and (not ctx.im(eta)) and (not ctx.im(z)) and \
+        (ctx.re(z) >= 0):
+        v = ctx.re(v)
+    return v
+
+@defun_wrapped
+def _coulomb_chi(ctx, l, eta, _cache={}):
+    if (l, eta) in _cache and _cache[l,eta][0] >= ctx.prec:
+        return _cache[l,eta][1]
+    def terms():
+        l2 = -l-1
+        jeta = ctx.j*eta
+        return [ctx.loggamma(1+l+jeta) * (-0.5j),
+            ctx.loggamma(1+l-jeta) * (0.5j),
+            ctx.loggamma(1+l2+jeta) * (0.5j),
+            ctx.loggamma(1+l2-jeta) * (-0.5j),
+            -(l+0.5)*ctx.pi]
+    v = ctx.sum_accurately(terms, 1)
+    _cache[l,eta] = (ctx.prec, v)
+    return v
+
+@defun_wrapped
+def coulombg(ctx, l, eta, z, w=1, chop=True, **kwargs):
+    # Irregular Coulomb wave function
+    # Note: w can be either 1 or -1; the other may be better in some cases
+    # TODO: check that chop=True chops when and only when it should
+    if not ctx._im(l):
+        l = ctx._re(l)  # XXX: for isint
+    def h(l, eta):
+        # Force perturbation for integers and half-integers
+        if ctx.isint(l*2):
+            T1 = [0], [-1], [], [], [], [], 0
+            return (T1,)
+        l2 = -l-1
+        try:
+            chi = ctx._coulomb_chi(l, eta)
+            jw = ctx.j*w
+            s = ctx.sin(chi); c = ctx.cos(chi)
+            C1 = ctx.coulombc(l,eta)
+            C2 = ctx.coulombc(l2,eta)
+            u = ctx.exp(jw*z)
+            x = -2*jw*z
+            T1 = [s, C1, z, u, c], [-1, 1, l+1, 1, 1], [], [], \
+                [1+l+jw*eta], [2*l+2], x
+            T2 = [-s, C2, z, u],   [-1, 1, l2+1, 1],    [], [], \
+                [1+l2+jw*eta], [2*l2+2], x
+            return T1, T2
+        except ValueError:
+            T1 = [0], [-1], [], [], [], [], 0
+            return (T1,)
+    v = ctx.hypercomb(h, [l,eta], **kwargs)
+    if chop and (not ctx._im(l)) and (not ctx._im(eta)) and (not ctx._im(z)) and \
+        (ctx._re(z) >= 0):
+        v = ctx._re(v)
+    return v
+
+def mcmahon(ctx,kind,prime,v,m):
+    """
+    Computes an estimate for the location of the Bessel function zero
+    j_{v,m}, y_{v,m}, j'_{v,m} or y'_{v,m} using McMahon's asymptotic
+    expansion (Abramowitz & Stegun 9.5.12-13, DLMF 20.21(vi)).
+
+    Returns (r,err) where r is the estimated location of the root
+    and err is a positive number estimating the error of the
+    asymptotic expansion.
+    """
+    u = 4*v**2
+    if kind == 1 and not prime: b = (4*m+2*v-1)*ctx.pi/4
+    if kind == 2 and not prime: b = (4*m+2*v-3)*ctx.pi/4
+    if kind == 1 and prime: b = (4*m+2*v-3)*ctx.pi/4
+    if kind == 2 and prime: b = (4*m+2*v-1)*ctx.pi/4
+    if not prime:
+        s1 = b
+        s2 = -(u-1)/(8*b)
+        s3 = -4*(u-1)*(7*u-31)/(3*(8*b)**3)
+        s4 = -32*(u-1)*(83*u**2-982*u+3779)/(15*(8*b)**5)
+        s5 = -64*(u-1)*(6949*u**3-153855*u**2+1585743*u-6277237)/(105*(8*b)**7)
+    if prime:
+        s1 = b
+        s2 = -(u+3)/(8*b)
+        s3 = -4*(7*u**2+82*u-9)/(3*(8*b)**3)
+        s4 = -32*(83*u**3+2075*u**2-3039*u+3537)/(15*(8*b)**5)
+        s5 = -64*(6949*u**4+296492*u**3-1248002*u**2+7414380*u-5853627)/(105*(8*b)**7)
+    terms = [s1,s2,s3,s4,s5]
+    s = s1
+    err = 0.0
+    for i in range(1,len(terms)):
+        if abs(terms[i]) < abs(terms[i-1]):
+            s += terms[i]
+        else:
+            err = abs(terms[i])
+    if i == len(terms)-1:
+        err = abs(terms[-1])
+    return s, err
+
+def generalized_bisection(ctx,f,a,b,n):
+    """
+    Given f known to have exactly n simple roots within [a,b],
+    return a list of n intervals isolating the roots
+    and having opposite signs at the endpoints.
+
+    TODO: this can be optimized, e.g. by reusing evaluation points.
+    """
+    if n < 1:
+        raise ValueError("n cannot be less than 1")
+    N = n+1
+    points = []
+    signs = []
+    while 1:
+        points = ctx.linspace(a,b,N)
+        signs = [ctx.sign(f(x)) for x in points]
+        ok_intervals = [(points[i],points[i+1]) for i in range(N-1) \
+            if signs[i]*signs[i+1] == -1]
+        if len(ok_intervals) == n:
+            return ok_intervals
+        N = N*2
+
+def find_in_interval(ctx, f, ab):
+    return ctx.findroot(f, ab, solver='illinois', verify=False)
+
+def bessel_zero(ctx, kind, prime, v, m, isoltol=0.01, _interval_cache={}):
+    prec = ctx.prec
+    workprec = max(prec, ctx.mag(v), ctx.mag(m))+10
+    try:
+        ctx.prec = workprec
+        v = ctx.mpf(v)
+        m = int(m)
+        prime = int(prime)
+        if v < 0:
+            raise ValueError("v cannot be negative")
+        if m < 1:
+            raise ValueError("m cannot be less than 1")
+        if not prime in (0,1):
+            raise ValueError("prime should lie between 0 and 1")
+        if kind == 1:
+            if prime: f = lambda x: ctx.besselj(v,x,derivative=1)
+            else:     f = lambda x: ctx.besselj(v,x)
+        if kind == 2:
+            if prime: f = lambda x: ctx.bessely(v,x,derivative=1)
+            else:     f = lambda x: ctx.bessely(v,x)
+        # The first root of J' is very close to 0 for small
+        # orders, and this needs to be special-cased
+        if kind == 1 and prime and m == 1:
+            if v == 0:
+                return ctx.zero
+            if v <= 1:
+                # TODO: use v <= j'_{v,1} < y_{v,1}?
+                r = 2*ctx.sqrt(v*(1+v)/(v+2))
+                return find_in_interval(ctx, f, (r/10, 2*r))
+        if (kind,prime,v,m) in _interval_cache:
+            return find_in_interval(ctx, f, _interval_cache[kind,prime,v,m])
+        r, err = mcmahon(ctx, kind, prime, v, m)
+        if err < isoltol:
+            return find_in_interval(ctx, f, (r-isoltol, r+isoltol))
+        # An x such that 0 < x < r_{v,1}
+        if kind == 1 and not prime: low = 2.4
+        if kind == 1 and prime: low = 1.8
+        if kind == 2 and not prime: low = 0.8
+        if kind == 2 and prime: low = 2.0
+        n = m+1
+        while 1:
+            r1, err = mcmahon(ctx, kind, prime, v, n)
+            if err < isoltol:
+                r2, err2 = mcmahon(ctx, kind, prime, v, n+1)
+                intervals = generalized_bisection(ctx, f, low, 0.5*(r1+r2), n)
+                for k, ab in enumerate(intervals):
+                    _interval_cache[kind,prime,v,k+1] = ab
+                return find_in_interval(ctx, f, intervals[m-1])
+            else:
+                n = n*2
+    finally:
+        ctx.prec = prec
+
+@defun
+def besseljzero(ctx, v, m, derivative=0):
+    r"""
+    For a real order `\nu \ge 0` and a positive integer `m`, returns
+    `j_{\nu,m}`, the `m`-th positive zero of the Bessel function of the
+    first kind `J_{\nu}(z)` (see :func:`~mpmath.besselj`). Alternatively,
+    with *derivative=1*, gives the first nonnegative simple zero
+    `j'_{\nu,m}` of `J'_{\nu}(z)`.
+
+    The indexing convention is that used by Abramowitz & Stegun
+    and the DLMF. Note the special case `j'_{0,1} = 0`, while all other
+    zeros are positive. In effect, only simple zeros are counted
+    (all zeros of Bessel functions are simple except possibly `z = 0`)
+    and `j_{\nu,m}` becomes a monotonic function of both `\nu`
+    and `m`.
+
+    The zeros are interlaced according to the inequalities
+
+    .. math ::
+
+        j'_{\nu,k} < j_{\nu,k} < j'_{\nu,k+1}
+
+        j_{\nu,1} < j_{\nu+1,2} < j_{\nu,2} < j_{\nu+1,2} < j_{\nu,3} < \cdots
+
+    **Examples**
+
+    Initial zeros of the Bessel functions `J_0(z), J_1(z), J_2(z)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> besseljzero(0,1); besseljzero(0,2); besseljzero(0,3)
+        2.404825557695772768621632
+        5.520078110286310649596604
+        8.653727912911012216954199
+        >>> besseljzero(1,1); besseljzero(1,2); besseljzero(1,3)
+        3.831705970207512315614436
+        7.01558666981561875353705
+        10.17346813506272207718571
+        >>> besseljzero(2,1); besseljzero(2,2); besseljzero(2,3)
+        5.135622301840682556301402
+        8.417244140399864857783614
+        11.61984117214905942709415
+
+    Initial zeros of `J'_0(z), J'_1(z), J'_2(z)`::
+
+        0.0
+        3.831705970207512315614436
+        7.01558666981561875353705
+        >>> besseljzero(1,1,1); besseljzero(1,2,1); besseljzero(1,3,1)
+        1.84118378134065930264363
+        5.331442773525032636884016
+        8.536316366346285834358961
+        >>> besseljzero(2,1,1); besseljzero(2,2,1); besseljzero(2,3,1)
+        3.054236928227140322755932
+        6.706133194158459146634394
+        9.969467823087595793179143
+
+    Zeros with large index::
+
+        >>> besseljzero(0,100); besseljzero(0,1000); besseljzero(0,10000)
+        313.3742660775278447196902
+        3140.807295225078628895545
+        31415.14114171350798533666
+        >>> besseljzero(5,100); besseljzero(5,1000); besseljzero(5,10000)
+        321.1893195676003157339222
+        3148.657306813047523500494
+        31422.9947255486291798943
+        >>> besseljzero(0,100,1); besseljzero(0,1000,1); besseljzero(0,10000,1)
+        311.8018681873704508125112
+        3139.236339643802482833973
+        31413.57032947022399485808
+
+    Zeros of functions with large order::
+
+        >>> besseljzero(50,1)
+        57.11689916011917411936228
+        >>> besseljzero(50,2)
+        62.80769876483536093435393
+        >>> besseljzero(50,100)
+        388.6936600656058834640981
+        >>> besseljzero(50,1,1)
+        52.99764038731665010944037
+        >>> besseljzero(50,2,1)
+        60.02631933279942589882363
+        >>> besseljzero(50,100,1)
+        387.1083151608726181086283
+
+    Zeros of functions with fractional order::
+
+        >>> besseljzero(0.5,1); besseljzero(1.5,1); besseljzero(2.25,4)
+        3.141592653589793238462643
+        4.493409457909064175307881
+        15.15657692957458622921634
+
+    Both `J_{\nu}(z)` and `J'_{\nu}(z)` can be expressed as infinite
+    products over their zeros::
+
+        >>> v,z = 2, mpf(1)
+        >>> (z/2)**v/gamma(v+1) * \
+        ...     nprod(lambda k: 1-(z/besseljzero(v,k))**2, [1,inf])
+        ...
+        0.1149034849319004804696469
+        >>> besselj(v,z)
+        0.1149034849319004804696469
+        >>> (z/2)**(v-1)/2/gamma(v) * \
+        ...     nprod(lambda k: 1-(z/besseljzero(v,k,1))**2, [1,inf])
+        ...
+        0.2102436158811325550203884
+        >>> besselj(v,z,1)
+        0.2102436158811325550203884
+
+    """
+    return +bessel_zero(ctx, 1, derivative, v, m)
+
+@defun
+def besselyzero(ctx, v, m, derivative=0):
+    r"""
+    For a real order `\nu \ge 0` and a positive integer `m`, returns
+    `y_{\nu,m}`, the `m`-th positive zero of the Bessel function of the
+    second kind `Y_{\nu}(z)` (see :func:`~mpmath.bessely`). Alternatively,
+    with *derivative=1*, gives the first positive zero `y'_{\nu,m}` of
+    `Y'_{\nu}(z)`.
+
+    The zeros are interlaced according to the inequalities
+
+    .. math ::
+
+        y_{\nu,k} < y'_{\nu,k} < y_{\nu,k+1}
+
+        y_{\nu,1} < y_{\nu+1,2} < y_{\nu,2} < y_{\nu+1,2} < y_{\nu,3} < \cdots
+
+    **Examples**
+
+    Initial zeros of the Bessel functions `Y_0(z), Y_1(z), Y_2(z)`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> besselyzero(0,1); besselyzero(0,2); besselyzero(0,3)
+        0.8935769662791675215848871
+        3.957678419314857868375677
+        7.086051060301772697623625
+        >>> besselyzero(1,1); besselyzero(1,2); besselyzero(1,3)
+        2.197141326031017035149034
+        5.429681040794135132772005
+        8.596005868331168926429606
+        >>> besselyzero(2,1); besselyzero(2,2); besselyzero(2,3)
+        3.384241767149593472701426
+        6.793807513268267538291167
+        10.02347797936003797850539
+
+    Initial zeros of `Y'_0(z), Y'_1(z), Y'_2(z)`::
+
+        >>> besselyzero(0,1,1); besselyzero(0,2,1); besselyzero(0,3,1)
+        2.197141326031017035149034
+        5.429681040794135132772005
+        8.596005868331168926429606
+        >>> besselyzero(1,1,1); besselyzero(1,2,1); besselyzero(1,3,1)
+        3.683022856585177699898967
+        6.941499953654175655751944
+        10.12340465543661307978775
+        >>> besselyzero(2,1,1); besselyzero(2,2,1); besselyzero(2,3,1)
+        5.002582931446063945200176
+        8.350724701413079526349714
+        11.57419546521764654624265
+
+    Zeros with large index::
+
+        >>> besselyzero(0,100); besselyzero(0,1000); besselyzero(0,10000)
+        311.8034717601871549333419
+        3139.236498918198006794026
+        31413.57034538691205229188
+        >>> besselyzero(5,100); besselyzero(5,1000); besselyzero(5,10000)
+        319.6183338562782156235062
+        3147.086508524556404473186
+        31421.42392920214673402828
+        >>> besselyzero(0,100,1); besselyzero(0,1000,1); besselyzero(0,10000,1)
+        313.3726705426359345050449
+        3140.807136030340213610065
+        31415.14112579761578220175
+
+    Zeros of functions with large order::
+
+        >>> besselyzero(50,1)
+        53.50285882040036394680237
+        >>> besselyzero(50,2)
+        60.11244442774058114686022
+        >>> besselyzero(50,100)
+        387.1096509824943957706835
+        >>> besselyzero(50,1,1)
+        56.96290427516751320063605
+        >>> besselyzero(50,2,1)
+        62.74888166945933944036623
+        >>> besselyzero(50,100,1)
+        388.6923300548309258355475
+
+    Zeros of functions with fractional order::
+
+        >>> besselyzero(0.5,1); besselyzero(1.5,1); besselyzero(2.25,4)
+        1.570796326794896619231322
+        2.798386045783887136720249
+        13.56721208770735123376018
+
+    """
+    return +bessel_zero(ctx, 2, derivative, v, m)
diff --git a/lib/python3.11/site-packages/mpmath/functions/elliptic.py b/lib/python3.11/site-packages/mpmath/functions/elliptic.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e198697fa042b7cc8bcba9e9e770f5c8106dad6
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/elliptic.py
@@ -0,0 +1,1431 @@
+r"""
+Elliptic functions historically comprise the elliptic integrals
+and their inverses, and originate from the problem of computing the
+arc length of an ellipse. From a more modern point of view,
+an elliptic function is defined as a doubly periodic function, i.e.
+a function which satisfies
+
+.. math ::
+
+    f(z + 2 \omega_1) = f(z + 2 \omega_2) = f(z)
+
+for some half-periods `\omega_1, \omega_2` with
+`\mathrm{Im}[\omega_1 / \omega_2] > 0`. The canonical elliptic
+functions are the Jacobi elliptic functions. More broadly, this section
+includes  quasi-doubly periodic functions (such as the Jacobi theta
+functions) and other functions useful in the study of elliptic functions.
+
+Many different conventions for the arguments of
+elliptic functions are in use. It is even standard to use
+different parameterizations for different functions in the same
+text or software (and mpmath is no exception).
+The usual parameters are the elliptic nome `q`, which usually
+must satisfy `|q| < 1`; the elliptic parameter `m` (an arbitrary
+complex number); the elliptic modulus `k` (an arbitrary complex
+number); and the half-period ratio `\tau`, which usually must
+satisfy `\mathrm{Im}[\tau] > 0`.
+These quantities can be expressed in terms of each other
+using the following relations:
+
+.. math ::
+
+    m = k^2
+
+.. math ::
+
+    \tau = i \frac{K(1-m)}{K(m)}
+
+.. math ::
+
+    q = e^{i \pi \tau}
+
+.. math ::
+
+    k = \frac{\vartheta_2^2(q)}{\vartheta_3^2(q)}
+
+In addition, an alternative definition is used for the nome in
+number theory, which we here denote by q-bar:
+
+.. math ::
+
+    \bar{q} = q^2 = e^{2 i \pi \tau}
+
+For convenience, mpmath provides functions to convert
+between the various parameters (:func:`~mpmath.qfrom`, :func:`~mpmath.mfrom`,
+:func:`~mpmath.kfrom`, :func:`~mpmath.taufrom`, :func:`~mpmath.qbarfrom`).
+
+**References**
+
+1. [AbramowitzStegun]_
+
+2. [WhittakerWatson]_
+
+"""
+
+from .functions import defun, defun_wrapped
+
+@defun_wrapped
+def eta(ctx, tau):
+    r"""
+    Returns the Dedekind eta function of tau in the upper half-plane.
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> eta(1j); gamma(0.25) / (2*pi**0.75)
+        (0.7682254223260566590025942 + 0.0j)
+        0.7682254223260566590025942
+        >>> tau = sqrt(2) + sqrt(5)*1j
+        >>> eta(-1/tau); sqrt(-1j*tau) * eta(tau)
+        (0.9022859908439376463573294 + 0.07985093673948098408048575j)
+        (0.9022859908439376463573295 + 0.07985093673948098408048575j)
+        >>> eta(tau+1); exp(pi*1j/12) * eta(tau)
+        (0.4493066139717553786223114 + 0.3290014793877986663915939j)
+        (0.4493066139717553786223114 + 0.3290014793877986663915939j)
+        >>> f = lambda z: diff(eta, z) / eta(z)
+        >>> chop(36*diff(f,tau)**2 - 24*diff(f,tau,2)*f(tau) + diff(f,tau,3))
+        0.0
+
+    """
+    if ctx.im(tau) <= 0.0:
+        raise ValueError("eta is only defined in the upper half-plane")
+    q = ctx.expjpi(tau/12)
+    return q * ctx.qp(q**24)
+
+def nome(ctx, m):
+    m = ctx.convert(m)
+    if not m:
+        return m
+    if m == ctx.one:
+        return m
+    if ctx.isnan(m):
+        return m
+    if ctx.isinf(m):
+        if m == ctx.ninf:
+            return type(m)(-1)
+        else:
+            return ctx.mpc(-1)
+    a = ctx.ellipk(ctx.one-m)
+    b = ctx.ellipk(m)
+    v = ctx.exp(-ctx.pi*a/b)
+    if not ctx._im(m) and ctx._re(m) < 1:
+        if ctx._is_real_type(m):
+            return v.real
+        else:
+            return v.real + 0j
+    elif m == 2:
+        v = ctx.mpc(0, v.imag)
+    return v
+
+@defun_wrapped
+def qfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic nome `q`, given any of `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qfrom(q=0.25)
+        0.25
+        >>> qfrom(m=mfrom(q=0.25))
+        0.25
+        >>> qfrom(k=kfrom(q=0.25))
+        0.25
+        >>> qfrom(tau=taufrom(q=0.25))
+        (0.25 + 0.0j)
+        >>> qfrom(qbar=qbarfrom(q=0.25))
+        0.25
+
+    """
+    if q is not None:
+        return ctx.convert(q)
+    if m is not None:
+        return nome(ctx, m)
+    if k is not None:
+        return nome(ctx, ctx.convert(k)**2)
+    if tau is not None:
+        return ctx.expjpi(tau)
+    if qbar is not None:
+        return ctx.sqrt(qbar)
+
+@defun_wrapped
+def qbarfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the number-theoretic nome `\bar q`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qbarfrom(qbar=0.25)
+        0.25
+        >>> qbarfrom(q=qfrom(qbar=0.25))
+        0.25
+        >>> qbarfrom(m=extraprec(20)(mfrom)(qbar=0.25))  # ill-conditioned
+        0.25
+        >>> qbarfrom(k=extraprec(20)(kfrom)(qbar=0.25))  # ill-conditioned
+        0.25
+        >>> qbarfrom(tau=taufrom(qbar=0.25))
+        (0.25 + 0.0j)
+
+    """
+    if qbar is not None:
+        return ctx.convert(qbar)
+    if q is not None:
+        return ctx.convert(q) ** 2
+    if m is not None:
+        return nome(ctx, m) ** 2
+    if k is not None:
+        return nome(ctx, ctx.convert(k)**2) ** 2
+    if tau is not None:
+        return ctx.expjpi(2*tau)
+
+@defun_wrapped
+def taufrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic half-period ratio `\tau`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> taufrom(tau=0.5j)
+        (0.0 + 0.5j)
+        >>> taufrom(q=qfrom(tau=0.5j))
+        (0.0 + 0.5j)
+        >>> taufrom(m=mfrom(tau=0.5j))
+        (0.0 + 0.5j)
+        >>> taufrom(k=kfrom(tau=0.5j))
+        (0.0 + 0.5j)
+        >>> taufrom(qbar=qbarfrom(tau=0.5j))
+        (0.0 + 0.5j)
+
+    """
+    if tau is not None:
+        return ctx.convert(tau)
+    if m is not None:
+        m = ctx.convert(m)
+        return ctx.j*ctx.ellipk(1-m)/ctx.ellipk(m)
+    if k is not None:
+        k = ctx.convert(k)
+        return ctx.j*ctx.ellipk(1-k**2)/ctx.ellipk(k**2)
+    if q is not None:
+        return ctx.log(q) / (ctx.pi*ctx.j)
+    if qbar is not None:
+        qbar = ctx.convert(qbar)
+        return ctx.log(qbar) / (2*ctx.pi*ctx.j)
+
+@defun_wrapped
+def kfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic modulus `k`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> kfrom(k=0.25)
+        0.25
+        >>> kfrom(m=mfrom(k=0.25))
+        0.25
+        >>> kfrom(q=qfrom(k=0.25))
+        0.25
+        >>> kfrom(tau=taufrom(k=0.25))
+        (0.25 + 0.0j)
+        >>> kfrom(qbar=qbarfrom(k=0.25))
+        0.25
+
+    As `q \to 1` and `q \to -1`, `k` rapidly approaches
+    `1` and `i \infty` respectively::
+
+        >>> kfrom(q=0.75)
+        0.9999999999999899166471767
+        >>> kfrom(q=-0.75)
+        (0.0 + 7041781.096692038332790615j)
+        >>> kfrom(q=1)
+        1
+        >>> kfrom(q=-1)
+        (0.0 + +infj)
+    """
+    if k is not None:
+        return ctx.convert(k)
+    if m is not None:
+        return ctx.sqrt(m)
+    if tau is not None:
+        q = ctx.expjpi(tau)
+    if qbar is not None:
+        q = ctx.sqrt(qbar)
+    if q == 1:
+        return q
+    if q == -1:
+        return ctx.mpc(0,'inf')
+    return (ctx.jtheta(2,0,q)/ctx.jtheta(3,0,q))**2
+
+@defun_wrapped
+def mfrom(ctx, q=None, m=None, k=None, tau=None, qbar=None):
+    r"""
+    Returns the elliptic parameter `m`, given any of
+    `q, m, k, \tau, \bar{q}`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> mfrom(m=0.25)
+        0.25
+        >>> mfrom(q=qfrom(m=0.25))
+        0.25
+        >>> mfrom(k=kfrom(m=0.25))
+        0.25
+        >>> mfrom(tau=taufrom(m=0.25))
+        (0.25 + 0.0j)
+        >>> mfrom(qbar=qbarfrom(m=0.25))
+        0.25
+
+    As `q \to 1` and `q \to -1`, `m` rapidly approaches
+    `1` and `-\infty` respectively::
+
+        >>> mfrom(q=0.75)
+        0.9999999999999798332943533
+        >>> mfrom(q=-0.75)
+        -49586681013729.32611558353
+        >>> mfrom(q=1)
+        1.0
+        >>> mfrom(q=-1)
+        -inf
+
+    The inverse nome as a function of `q` has an integer
+    Taylor series expansion::
+
+        >>> taylor(lambda q: mfrom(q), 0, 7)
+        [0.0, 16.0, -128.0, 704.0, -3072.0, 11488.0, -38400.0, 117632.0]
+
+    """
+    if m is not None:
+        return m
+    if k is not None:
+        return k**2
+    if tau is not None:
+        q = ctx.expjpi(tau)
+    if qbar is not None:
+        q = ctx.sqrt(qbar)
+    if q == 1:
+        return ctx.convert(q)
+    if q == -1:
+        return q*ctx.inf
+    v = (ctx.jtheta(2,0,q)/ctx.jtheta(3,0,q))**4
+    if ctx._is_real_type(q) and q < 0:
+        v = v.real
+    return v
+
+jacobi_spec = {
+  'sn' : ([3],[2],[1],[4], 'sin', 'tanh'),
+  'cn' : ([4],[2],[2],[4], 'cos', 'sech'),
+  'dn' : ([4],[3],[3],[4], '1', 'sech'),
+  'ns' : ([2],[3],[4],[1], 'csc', 'coth'),
+  'nc' : ([2],[4],[4],[2], 'sec', 'cosh'),
+  'nd' : ([3],[4],[4],[3], '1', 'cosh'),
+  'sc' : ([3],[4],[1],[2], 'tan', 'sinh'),
+  'sd' : ([3,3],[2,4],[1],[3], 'sin', 'sinh'),
+  'cd' : ([3],[2],[2],[3], 'cos', '1'),
+  'cs' : ([4],[3],[2],[1], 'cot', 'csch'),
+  'dc' : ([2],[3],[3],[2], 'sec', '1'),
+  'ds' : ([2,4],[3,3],[3],[1], 'csc', 'csch'),
+  'cc' : None,
+  'ss' : None,
+  'nn' : None,
+  'dd' : None
+}
+
+@defun
+def ellipfun(ctx, kind, u=None, m=None, q=None, k=None, tau=None):
+    try:
+        S = jacobi_spec[kind]
+    except KeyError:
+        raise ValueError("First argument must be a two-character string "
+            "containing 's', 'c', 'd' or 'n', e.g.: 'sn'")
+    if u is None:
+        def f(*args, **kwargs):
+            return ctx.ellipfun(kind, *args, **kwargs)
+        f.__name__ = kind
+        return f
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        u = ctx.convert(u)
+        q = ctx.qfrom(m=m, q=q, k=k, tau=tau)
+        if S is None:
+            v = ctx.one + 0*q*u
+        elif q == ctx.zero:
+            if S[4] == '1': v = ctx.one
+            else:           v = getattr(ctx, S[4])(u)
+            v += 0*q*u
+        elif q == ctx.one:
+            if S[5] == '1': v = ctx.one
+            else:           v = getattr(ctx, S[5])(u)
+            v += 0*q*u
+        else:
+            t = u / ctx.jtheta(3, 0, q)**2
+            v = ctx.one
+            for a in S[0]: v *= ctx.jtheta(a, 0, q)
+            for b in S[1]: v /= ctx.jtheta(b, 0, q)
+            for c in S[2]: v *= ctx.jtheta(c, t, q)
+            for d in S[3]: v /= ctx.jtheta(d, t, q)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun_wrapped
+def kleinj(ctx, tau=None, **kwargs):
+    r"""
+    Evaluates the Klein j-invariant, which is a modular function defined for
+    `\tau` in the upper half-plane as
+
+    .. math ::
+
+        J(\tau) = \frac{g_2^3(\tau)}{g_2^3(\tau) - 27 g_3^2(\tau)}
+
+    where `g_2` and `g_3` are the modular invariants of the Weierstrass
+    elliptic function,
+
+    .. math ::
+
+        g_2(\tau) = 60 \sum_{(m,n) \in \mathbb{Z}^2 \setminus (0,0)} (m \tau+n)^{-4}
+
+        g_3(\tau) = 140 \sum_{(m,n) \in \mathbb{Z}^2 \setminus (0,0)} (m \tau+n)^{-6}.
+
+    An alternative, common notation is that of the j-function
+    `j(\tau) = 1728 J(\tau)`.
+
+    **Plots**
+
+    .. literalinclude :: /plots/kleinj.py
+    .. image :: /plots/kleinj.png
+    .. literalinclude :: /plots/kleinj2.py
+    .. image :: /plots/kleinj2.png
+
+    **Examples**
+
+    Verifying the functional equation `J(\tau) = J(\tau+1) = J(-\tau^{-1})`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> tau = 0.625+0.75*j
+        >>> tau = 0.625+0.75*j
+        >>> kleinj(tau)
+        (-0.1507492166511182267125242 + 0.07595948379084571927228948j)
+        >>> kleinj(tau+1)
+        (-0.1507492166511182267125242 + 0.07595948379084571927228948j)
+        >>> kleinj(-1/tau)
+        (-0.1507492166511182267125242 + 0.07595948379084571927228946j)
+
+    The j-function has a famous Laurent series expansion in terms of the nome
+    `\bar{q}`, `j(\tau) = \bar{q}^{-1} + 744 + 196884\bar{q} + \ldots`::
+
+        >>> mp.dps = 15
+        >>> taylor(lambda q: 1728*q*kleinj(qbar=q), 0, 5, singular=True)
+        [1.0, 744.0, 196884.0, 21493760.0, 864299970.0, 20245856256.0]
+
+    The j-function admits exact evaluation at special algebraic points
+    related to the Heegner numbers 1, 2, 3, 7, 11, 19, 43, 67, 163::
+
+        >>> @extraprec(10)
+        ... def h(n):
+        ...     v = (1+sqrt(n)*j)
+        ...     if n > 2:
+        ...         v *= 0.5
+        ...     return v
+        ...
+        >>> mp.dps = 25
+        >>> for n in [1,2,3,7,11,19,43,67,163]:
+        ...     n, chop(1728*kleinj(h(n)))
+        ...
+        (1, 1728.0)
+        (2, 8000.0)
+        (3, 0.0)
+        (7, -3375.0)
+        (11, -32768.0)
+        (19, -884736.0)
+        (43, -884736000.0)
+        (67, -147197952000.0)
+        (163, -262537412640768000.0)
+
+    Also at other special points, the j-function assumes explicit
+    algebraic values, e.g.::
+
+        >>> chop(1728*kleinj(j*sqrt(5)))
+        1264538.909475140509320227
+        >>> identify(cbrt(_))      # note: not simplified
+        '((100+sqrt(13520))/2)'
+        >>> (50+26*sqrt(5))**3
+        1264538.909475140509320227
+
+    """
+    q = ctx.qfrom(tau=tau, **kwargs)
+    t2 = ctx.jtheta(2,0,q)
+    t3 = ctx.jtheta(3,0,q)
+    t4 = ctx.jtheta(4,0,q)
+    P = (t2**8 + t3**8 + t4**8)**3
+    Q = 54*(t2*t3*t4)**8
+    return P/Q
+
+
+def RF_calc(ctx, x, y, z, r):
+    if y == z: return RC_calc(ctx, x, y, r)
+    if x == z: return RC_calc(ctx, y, x, r)
+    if x == y: return RC_calc(ctx, z, x, r)
+    if not (ctx.isnormal(x) and ctx.isnormal(y) and ctx.isnormal(z)):
+        if ctx.isnan(x) or ctx.isnan(y) or ctx.isnan(z):
+            return x*y*z
+        if ctx.isinf(x) or ctx.isinf(y) or ctx.isinf(z):
+            return ctx.zero
+    xm,ym,zm = x,y,z
+    A0 = Am = (x+y+z)/3
+    Q = ctx.root(3*r, -6) * max(abs(A0-x),abs(A0-y),abs(A0-z))
+    g = ctx.mpf(0.25)
+    pow4 = ctx.one
+    while 1:
+        xs = ctx.sqrt(xm)
+        ys = ctx.sqrt(ym)
+        zs = ctx.sqrt(zm)
+        lm = xs*ys + xs*zs + ys*zs
+        Am1 = (Am+lm)*g
+        xm, ym, zm = (xm+lm)*g, (ym+lm)*g, (zm+lm)*g
+        if pow4 * Q < abs(Am):
+            break
+        Am = Am1
+        pow4 *= g
+    t = pow4/Am
+    X = (A0-x)*t
+    Y = (A0-y)*t
+    Z = -X-Y
+    E2 = X*Y-Z**2
+    E3 = X*Y*Z
+    return ctx.power(Am,-0.5) * (9240-924*E2+385*E2**2+660*E3-630*E2*E3)/9240
+
+def RC_calc(ctx, x, y, r, pv=True):
+    if not (ctx.isnormal(x) and ctx.isnormal(y)):
+        if ctx.isinf(x) or ctx.isinf(y):
+            return 1/(x*y)
+        if y == 0:
+            return ctx.inf
+        if x == 0:
+            return ctx.pi / ctx.sqrt(y) / 2
+        raise ValueError
+    # Cauchy principal value
+    if pv and ctx._im(y) == 0 and ctx._re(y) < 0:
+        return ctx.sqrt(x/(x-y)) * RC_calc(ctx, x-y, -y, r)
+    if x == y:
+        return 1/ctx.sqrt(x)
+    extraprec = 2*max(0,-ctx.mag(x-y)+ctx.mag(x))
+    ctx.prec += extraprec
+    if ctx._is_real_type(x) and ctx._is_real_type(y):
+        x = ctx._re(x)
+        y = ctx._re(y)
+        a = ctx.sqrt(x/y)
+        if x < y:
+            b = ctx.sqrt(y-x)
+            v = ctx.acos(a)/b
+        else:
+            b = ctx.sqrt(x-y)
+            v = ctx.acosh(a)/b
+    else:
+        sx = ctx.sqrt(x)
+        sy = ctx.sqrt(y)
+        v = ctx.acos(sx/sy)/(ctx.sqrt((1-x/y))*sy)
+    ctx.prec -= extraprec
+    return v
+
+def RJ_calc(ctx, x, y, z, p, r, integration):
+    """
+    With integration == 0, computes RJ only using Carlson's algorithm
+    (may be wrong for some values).
+    With integration == 1, uses an initial integration to make sure
+    Carlson's algorithm is correct.
+    With integration == 2, uses only integration.
+    """
+    if not (ctx.isnormal(x) and ctx.isnormal(y) and \
+        ctx.isnormal(z) and ctx.isnormal(p)):
+        if ctx.isnan(x) or ctx.isnan(y) or ctx.isnan(z) or ctx.isnan(p):
+            return x*y*z
+        if ctx.isinf(x) or ctx.isinf(y) or ctx.isinf(z) or ctx.isinf(p):
+            return ctx.zero
+    if not p:
+        return ctx.inf
+    if (not x) + (not y) + (not z) > 1:
+        return ctx.inf
+    # Check conditions and fall back on integration for argument
+    # reduction if needed. The following conditions might be needlessly
+    # restrictive.
+    initial_integral = ctx.zero
+    if integration >= 1:
+        ok = (x.real >= 0 and y.real >= 0 and z.real >= 0 and p.real > 0)
+        if not ok:
+            if x == p or y == p or z == p:
+                ok = True
+        if not ok:
+            if p.imag != 0 or p.real >= 0:
+                if (x.imag == 0 and x.real >= 0 and ctx.conj(y) == z):
+                    ok = True
+                if (y.imag == 0 and y.real >= 0 and ctx.conj(x) == z):
+                    ok = True
+                if (z.imag == 0 and z.real >= 0 and ctx.conj(x) == y):
+                    ok = True
+        if not ok or (integration == 2):
+            N = ctx.ceil(-min(x.real, y.real, z.real, p.real)) + 1
+            # Integrate around any singularities
+            if all((t.imag >= 0 or t.real > 0) for t in [x, y, z, p]):
+                margin = ctx.j
+            elif all((t.imag < 0 or t.real > 0) for t in [x, y, z, p]):
+                margin = -ctx.j
+            else:
+                margin = 1
+                # Go through the upper half-plane, but low enough that any
+                # parameter starting in the lower plane doesn't cross the
+                # branch cut
+                for t in [x, y, z, p]:
+                    if t.imag >= 0 or t.real > 0:
+                        continue
+                    margin = min(margin, abs(t.imag) * 0.5)
+                margin *= ctx.j
+            N += margin
+            F = lambda t: 1/(ctx.sqrt(t+x)*ctx.sqrt(t+y)*ctx.sqrt(t+z)*(t+p))
+            if integration == 2:
+                return 1.5 * ctx.quadsubdiv(F, [0, N, ctx.inf])
+            initial_integral = 1.5 * ctx.quadsubdiv(F, [0, N])
+            x += N; y += N; z += N; p += N
+    xm,ym,zm,pm = x,y,z,p
+    A0 = Am = (x + y + z + 2*p)/5
+    delta = (p-x)*(p-y)*(p-z)
+    Q = ctx.root(0.25*r, -6) * max(abs(A0-x),abs(A0-y),abs(A0-z),abs(A0-p))
+    g = ctx.mpf(0.25)
+    pow4 = ctx.one
+    S = 0
+    while 1:
+        sx = ctx.sqrt(xm)
+        sy = ctx.sqrt(ym)
+        sz = ctx.sqrt(zm)
+        sp = ctx.sqrt(pm)
+        lm = sx*sy + sx*sz + sy*sz
+        Am1 = (Am+lm)*g
+        xm = (xm+lm)*g; ym = (ym+lm)*g; zm = (zm+lm)*g; pm = (pm+lm)*g
+        dm = (sp+sx) * (sp+sy) * (sp+sz)
+        em = delta * pow4**3 / dm**2
+        if pow4 * Q < abs(Am):
+            break
+        T = RC_calc(ctx, ctx.one, ctx.one+em, r) * pow4 / dm
+        S += T
+        pow4 *= g
+        Am = Am1
+    t = pow4 / Am
+    X = (A0-x)*t
+    Y = (A0-y)*t
+    Z = (A0-z)*t
+    P = (-X-Y-Z)/2
+    E2 = X*Y + X*Z + Y*Z - 3*P**2
+    E3 = X*Y*Z + 2*E2*P + 4*P**3
+    E4 = (2*X*Y*Z + E2*P + 3*P**3)*P
+    E5 = X*Y*Z*P**2
+    P = 24024 - 5148*E2 + 2457*E2**2 + 4004*E3 - 4158*E2*E3 - 3276*E4 + 2772*E5
+    Q = 24024
+    v1 = pow4 * ctx.power(Am, -1.5) * P/Q
+    v2 = 6*S
+    return initial_integral + v1 + v2
+
+@defun
+def elliprf(ctx, x, y, z):
+    r"""
+    Evaluates the Carlson symmetric elliptic integral of the first kind
+
+    .. math ::
+
+        R_F(x,y,z) = \frac{1}{2}
+            \int_0^{\infty} \frac{dt}{\sqrt{(t+x)(t+y)(t+z)}}
+
+    which is defined for `x,y,z \notin (-\infty,0)`, and with
+    at most one of `x,y,z` being zero.
+
+    For real `x,y,z \ge 0`, the principal square root is taken in the integrand.
+    For complex `x,y,z`, the principal square root is taken as `t \to \infty`
+    and as `t \to 0` non-principal branches are chosen as necessary so as to
+    make the integrand continuous.
+
+    **Examples**
+
+    Some basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprf(0,1,1); pi/2
+        1.570796326794896619231322
+        1.570796326794896619231322
+        >>> elliprf(0,1,inf)
+        0.0
+        >>> elliprf(1,1,1)
+        1.0
+        >>> elliprf(2,2,2)**2
+        0.5
+        >>> elliprf(1,0,0); elliprf(0,0,1); elliprf(0,1,0); elliprf(0,0,0)
+        +inf
+        +inf
+        +inf
+        +inf
+
+    Representing complete elliptic integrals in terms of `R_F`::
+
+        >>> m = mpf(0.75)
+        >>> ellipk(m); elliprf(0,1-m,1)
+        2.156515647499643235438675
+        2.156515647499643235438675
+        >>> ellipe(m); elliprf(0,1-m,1)-m*elliprd(0,1-m,1)/3
+        1.211056027568459524803563
+        1.211056027568459524803563
+
+    Some symmetries and argument transformations::
+
+        >>> x,y,z = 2,3,4
+        >>> elliprf(x,y,z); elliprf(y,x,z); elliprf(z,y,x)
+        0.5840828416771517066928492
+        0.5840828416771517066928492
+        0.5840828416771517066928492
+        >>> k = mpf(100000)
+        >>> elliprf(k*x,k*y,k*z); k**(-0.5) * elliprf(x,y,z)
+        0.001847032121923321253219284
+        0.001847032121923321253219284
+        >>> l = sqrt(x*y) + sqrt(y*z) + sqrt(z*x)
+        >>> elliprf(x,y,z); 2*elliprf(x+l,y+l,z+l)
+        0.5840828416771517066928492
+        0.5840828416771517066928492
+        >>> elliprf((x+l)/4,(y+l)/4,(z+l)/4)
+        0.5840828416771517066928492
+
+    Comparing with numerical integration::
+
+        >>> x,y,z = 2,3,4
+        >>> elliprf(x,y,z)
+        0.5840828416771517066928492
+        >>> f = lambda t: 0.5*((t+x)*(t+y)*(t+z))**(-0.5)
+        >>> q = extradps(25)(quad)
+        >>> q(f, [0,inf])
+        0.5840828416771517066928492
+
+    With the following arguments, the square root in the integrand becomes
+    discontinuous at `t = 1/2` if the principal branch is used. To obtain
+    the right value, `-\sqrt{r}` must be taken instead of `\sqrt{r}`
+    on `t \in (0, 1/2)`::
+
+        >>> x,y,z = j-1,j,0
+        >>> elliprf(x,y,z)
+        (0.7961258658423391329305694 - 1.213856669836495986430094j)
+        >>> -q(f, [0,0.5]) + q(f, [0.5,inf])
+        (0.7961258658423391329305694 - 1.213856669836495986430094j)
+
+    The so-called *first lemniscate constant*, a transcendental number::
+
+        >>> elliprf(0,1,2)
+        1.31102877714605990523242
+        >>> extradps(25)(quad)(lambda t: 1/sqrt(1-t**4), [0,1])
+        1.31102877714605990523242
+        >>> gamma('1/4')**2/(4*sqrt(2*pi))
+        1.31102877714605990523242
+
+    **References**
+
+    1. [Carlson]_
+    2. [DLMF]_ Chapter 19. Elliptic Integrals
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    z = ctx.convert(z)
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+        tol = ctx.eps * 2**10
+        v = RF_calc(ctx, x, y, z, tol)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun
+def elliprc(ctx, x, y, pv=True):
+    r"""
+    Evaluates the degenerate Carlson symmetric elliptic integral
+    of the first kind
+
+    .. math ::
+
+        R_C(x,y) = R_F(x,y,y) =
+            \frac{1}{2} \int_0^{\infty} \frac{dt}{(t+y) \sqrt{(t+x)}}.
+
+    If `y \in (-\infty,0)`, either a value defined by continuity,
+    or with *pv=True* the Cauchy principal value, can be computed.
+
+    If `x \ge 0, y > 0`, the value can be expressed in terms of
+    elementary functions as
+
+    .. math ::
+
+        R_C(x,y) =
+        \begin{cases}
+          \dfrac{1}{\sqrt{y-x}}
+            \cos^{-1}\left(\sqrt{\dfrac{x}{y}}\right),   & x < y \\
+          \dfrac{1}{\sqrt{y}},                          & x = y \\
+          \dfrac{1}{\sqrt{x-y}}
+            \cosh^{-1}\left(\sqrt{\dfrac{x}{y}}\right),  & x > y \\
+        \end{cases}.
+
+    **Examples**
+
+    Some special values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprc(1,2)*4; elliprc(0,1)*2; +pi
+        3.141592653589793238462643
+        3.141592653589793238462643
+        3.141592653589793238462643
+        >>> elliprc(1,0)
+        +inf
+        >>> elliprc(5,5)**2
+        0.2
+        >>> elliprc(1,inf); elliprc(inf,1); elliprc(inf,inf)
+        0.0
+        0.0
+        0.0
+
+    Comparing with the elementary closed-form solution::
+
+        >>> elliprc('1/3', '1/5'); sqrt(7.5)*acosh(sqrt('5/3'))
+        2.041630778983498390751238
+        2.041630778983498390751238
+        >>> elliprc('1/5', '1/3'); sqrt(7.5)*acos(sqrt('3/5'))
+        1.875180765206547065111085
+        1.875180765206547065111085
+
+    Comparing with numerical integration::
+
+        >>> q = extradps(25)(quad)
+        >>> elliprc(2, -3, pv=True)
+        0.3333969101113672670749334
+        >>> elliprc(2, -3, pv=False)
+        (0.3333969101113672670749334 + 0.7024814731040726393156375j)
+        >>> 0.5*q(lambda t: 1/(sqrt(t+2)*(t-3)), [0,3-j,6,inf])
+        (0.3333969101113672670749334 + 0.7024814731040726393156375j)
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+        tol = ctx.eps * 2**10
+        v = RC_calc(ctx, x, y, tol, pv)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun
+def elliprj(ctx, x, y, z, p, integration=1):
+    r"""
+    Evaluates the Carlson symmetric elliptic integral of the third kind
+
+    .. math ::
+
+        R_J(x,y,z,p) = \frac{3}{2}
+            \int_0^{\infty} \frac{dt}{(t+p)\sqrt{(t+x)(t+y)(t+z)}}.
+
+    Like :func:`~mpmath.elliprf`, the branch of the square root in the integrand
+    is defined so as to be continuous along the path of integration for
+    complex values of the arguments.
+
+    **Examples**
+
+    Some values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprj(1,1,1,1)
+        1.0
+        >>> elliprj(2,2,2,2); 1/(2*sqrt(2))
+        0.3535533905932737622004222
+        0.3535533905932737622004222
+        >>> elliprj(0,1,2,2)
+        1.067937989667395702268688
+        >>> 3*(2*gamma('5/4')**2-pi**2/gamma('1/4')**2)/(sqrt(2*pi))
+        1.067937989667395702268688
+        >>> elliprj(0,1,1,2); 3*pi*(2-sqrt(2))/4
+        1.380226776765915172432054
+        1.380226776765915172432054
+        >>> elliprj(1,3,2,0); elliprj(0,1,1,0); elliprj(0,0,0,0)
+        +inf
+        +inf
+        +inf
+        >>> elliprj(1,inf,1,0); elliprj(1,1,1,inf)
+        0.0
+        0.0
+        >>> chop(elliprj(1+j, 1-j, 1, 1))
+        0.8505007163686739432927844
+
+    Scale transformation::
+
+        >>> x,y,z,p = 2,3,4,5
+        >>> k = mpf(100000)
+        >>> elliprj(k*x,k*y,k*z,k*p); k**(-1.5)*elliprj(x,y,z,p)
+        4.521291677592745527851168e-9
+        4.521291677592745527851168e-9
+
+    Comparing with numerical integration::
+
+        >>> elliprj(1,2,3,4)
+        0.2398480997495677621758617
+        >>> f = lambda t: 1/((t+4)*sqrt((t+1)*(t+2)*(t+3)))
+        >>> 1.5*quad(f, [0,inf])
+        0.2398480997495677621758617
+        >>> elliprj(1,2+1j,3,4-2j)
+        (0.216888906014633498739952 + 0.04081912627366673332369512j)
+        >>> f = lambda t: 1/((t+4-2j)*sqrt((t+1)*(t+2+1j)*(t+3)))
+        >>> 1.5*quad(f, [0,inf])
+        (0.216888906014633498739952 + 0.04081912627366673332369511j)
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    z = ctx.convert(z)
+    p = ctx.convert(p)
+    prec = ctx.prec
+    try:
+        ctx.prec += 20
+        tol = ctx.eps * 2**10
+        v = RJ_calc(ctx, x, y, z, p, tol, integration)
+    finally:
+        ctx.prec = prec
+    return +v
+
+@defun
+def elliprd(ctx, x, y, z):
+    r"""
+    Evaluates the degenerate Carlson symmetric elliptic integral
+    of the third kind or Carlson elliptic integral of the
+    second kind `R_D(x,y,z) = R_J(x,y,z,z)`.
+
+    See :func:`~mpmath.elliprj` for additional information.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprd(1,2,3)
+        0.2904602810289906442326534
+        >>> elliprj(1,2,3,3)
+        0.2904602810289906442326534
+
+    The so-called *second lemniscate constant*, a transcendental number::
+
+        >>> elliprd(0,2,1)/3
+        0.5990701173677961037199612
+        >>> extradps(25)(quad)(lambda t: t**2/sqrt(1-t**4), [0,1])
+        0.5990701173677961037199612
+        >>> gamma('3/4')**2/sqrt(2*pi)
+        0.5990701173677961037199612
+
+    """
+    return ctx.elliprj(x,y,z,z)
+
+@defun
+def elliprg(ctx, x, y, z):
+    r"""
+    Evaluates the Carlson completely symmetric elliptic integral
+    of the second kind
+
+    .. math ::
+
+        R_G(x,y,z) = \frac{1}{4} \int_0^{\infty}
+            \frac{t}{\sqrt{(t+x)(t+y)(t+z)}}
+            \left( \frac{x}{t+x} + \frac{y}{t+y} + \frac{z}{t+z}\right) dt.
+
+    **Examples**
+
+    Evaluation for real and complex arguments::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> elliprg(0,1,1)*4; +pi
+        3.141592653589793238462643
+        3.141592653589793238462643
+        >>> elliprg(0,0.5,1)
+        0.6753219405238377512600874
+        >>> chop(elliprg(1+j, 1-j, 2))
+        1.172431327676416604532822
+
+    A double integral that can be evaluated in terms of `R_G`::
+
+        >>> x,y,z = 2,3,4
+        >>> def f(t,u):
+        ...     st = fp.sin(t); ct = fp.cos(t)
+        ...     su = fp.sin(u); cu = fp.cos(u)
+        ...     return (x*(st*cu)**2 + y*(st*su)**2 + z*ct**2)**0.5 * st
+        ...
+        >>> nprint(mpf(fp.quad(f, [0,fp.pi], [0,2*fp.pi])/(4*fp.pi)), 13)
+        1.725503028069
+        >>> nprint(elliprg(x,y,z), 13)
+        1.725503028069
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    z = ctx.convert(z)
+    zeros = (not x) + (not y) + (not z)
+    if zeros == 3:
+        return (x+y+z)*0
+    if zeros == 2:
+        if x: return 0.5*ctx.sqrt(x)
+        if y: return 0.5*ctx.sqrt(y)
+        return 0.5*ctx.sqrt(z)
+    if zeros == 1:
+        if not z:
+            x, z = z, x
+    def terms():
+        T1 = 0.5*z*ctx.elliprf(x,y,z)
+        T2 = -0.5*(x-z)*(y-z)*ctx.elliprd(x,y,z)/3
+        T3 = 0.5*ctx.sqrt(x)*ctx.sqrt(y)/ctx.sqrt(z)
+        return T1,T2,T3
+    return ctx.sum_accurately(terms)
+
+
+@defun_wrapped
+def ellipf(ctx, phi, m):
+    r"""
+    Evaluates the Legendre incomplete elliptic integral of the first kind
+
+     .. math ::
+
+        F(\phi,m) = \int_0^{\phi} \frac{dt}{\sqrt{1-m \sin^2 t}}
+
+    or equivalently
+
+    .. math ::
+
+        F(\phi,m) = \int_0^{\sin \phi}
+        \frac{dt}{\left(\sqrt{1-t^2}\right)\left(\sqrt{1-mt^2}\right)}.
+
+    The function reduces to a complete elliptic integral of the first kind
+    (see :func:`~mpmath.ellipk`) when `\phi = \frac{\pi}{2}`; that is,
+
+    .. math ::
+
+        F\left(\frac{\pi}{2}, m\right) = K(m).
+
+    In the defining integral, it is assumed that the principal branch
+    of the square root is taken and that the path of integration avoids
+    crossing any branch cuts. Outside `-\pi/2 \le \Re(\phi) \le \pi/2`,
+    the function extends quasi-periodically as
+
+    .. math ::
+
+        F(\phi + n \pi, m) = 2 n K(m) + F(\phi,m), n \in \mathbb{Z}.
+
+    **Plots**
+
+    .. literalinclude :: /plots/ellipf.py
+    .. image :: /plots/ellipf.png
+
+    **Examples**
+
+    Basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> ellipf(0,1)
+        0.0
+        >>> ellipf(0,0)
+        0.0
+        >>> ellipf(1,0); ellipf(2+3j,0)
+        1.0
+        (2.0 + 3.0j)
+        >>> ellipf(1,1); log(sec(1)+tan(1))
+        1.226191170883517070813061
+        1.226191170883517070813061
+        >>> ellipf(pi/2, -0.5); ellipk(-0.5)
+        1.415737208425956198892166
+        1.415737208425956198892166
+        >>> ellipf(pi/2+eps, 1); ellipf(-pi/2-eps, 1)
+        +inf
+        +inf
+        >>> ellipf(1.5, 1)
+        3.340677542798311003320813
+
+    Comparing with numerical integration::
+
+        >>> z,m = 0.5, 1.25
+        >>> ellipf(z,m)
+        0.5287219202206327872978255
+        >>> quad(lambda t: (1-m*sin(t)**2)**(-0.5), [0,z])
+        0.5287219202206327872978255
+
+    The arguments may be complex numbers::
+
+        >>> ellipf(3j, 0.5)
+        (0.0 + 1.713602407841590234804143j)
+        >>> ellipf(3+4j, 5-6j)
+        (1.269131241950351323305741 - 0.3561052815014558335412538j)
+        >>> z,m = 2+3j, 1.25
+        >>> k = 1011
+        >>> ellipf(z+pi*k,m); ellipf(z,m) + 2*k*ellipk(m)
+        (4086.184383622179764082821 - 3003.003538923749396546871j)
+        (4086.184383622179764082821 - 3003.003538923749396546871j)
+
+    For `|\Re(z)| < \pi/2`, the function can be expressed as a
+    hypergeometric series of two variables
+    (see :func:`~mpmath.appellf1`)::
+
+        >>> z,m = 0.5, 0.25
+        >>> ellipf(z,m)
+        0.5050887275786480788831083
+        >>> sin(z)*appellf1(0.5,0.5,0.5,1.5,sin(z)**2,m*sin(z)**2)
+        0.5050887275786480788831083
+
+    """
+    z = phi
+    if not (ctx.isnormal(z) and ctx.isnormal(m)):
+        if m == 0:
+            return z + m
+        if z == 0:
+            return z * m
+        if m == ctx.inf or m == ctx.ninf: return z/m
+        raise ValueError
+    x = z.real
+    ctx.prec += max(0, ctx.mag(x))
+    pi = +ctx.pi
+    away = abs(x) > pi/2
+    if m == 1:
+        if away:
+            return ctx.inf
+    if away:
+        d = ctx.nint(x/pi)
+        z = z-pi*d
+        P = 2*d*ctx.ellipk(m)
+    else:
+        P = 0
+    c, s = ctx.cos_sin(z)
+    return s * ctx.elliprf(c**2, 1-m*s**2, 1) + P
+
+@defun_wrapped
+def ellipe(ctx, *args):
+    r"""
+    Called with a single argument `m`, evaluates the Legendre complete
+    elliptic integral of the second kind, `E(m)`, defined by
+
+        .. math :: E(m) = \int_0^{\pi/2} \sqrt{1-m \sin^2 t} \, dt \,=\,
+            \frac{\pi}{2}
+            \,_2F_1\left(\frac{1}{2}, -\frac{1}{2}, 1, m\right).
+
+    Called with two arguments `\phi, m`, evaluates the incomplete elliptic
+    integral of the second kind
+
+     .. math ::
+
+        E(\phi,m) = \int_0^{\phi} \sqrt{1-m \sin^2 t} \, dt =
+                    \int_0^{\sin z}
+                    \frac{\sqrt{1-mt^2}}{\sqrt{1-t^2}} \, dt.
+
+    The incomplete integral reduces to a complete integral when
+    `\phi = \frac{\pi}{2}`; that is,
+
+    .. math ::
+
+        E\left(\frac{\pi}{2}, m\right) = E(m).
+
+    In the defining integral, it is assumed that the principal branch
+    of the square root is taken and that the path of integration avoids
+    crossing any branch cuts. Outside `-\pi/2 \le \Re(z) \le \pi/2`,
+    the function extends quasi-periodically as
+
+    .. math ::
+
+        E(\phi + n \pi, m) = 2 n E(m) + E(\phi,m), n \in \mathbb{Z}.
+
+    **Plots**
+
+    .. literalinclude :: /plots/ellipe.py
+    .. image :: /plots/ellipe.png
+
+    **Examples for the complete integral**
+
+    Basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> ellipe(0)
+        1.570796326794896619231322
+        >>> ellipe(1)
+        1.0
+        >>> ellipe(-1)
+        1.910098894513856008952381
+        >>> ellipe(2)
+        (0.5990701173677961037199612 + 0.5990701173677961037199612j)
+        >>> ellipe(inf)
+        (0.0 + +infj)
+        >>> ellipe(-inf)
+        +inf
+
+    Verifying the defining integral and hypergeometric
+    representation::
+
+        >>> ellipe(0.5)
+        1.350643881047675502520175
+        >>> quad(lambda t: sqrt(1-0.5*sin(t)**2), [0, pi/2])
+        1.350643881047675502520175
+        >>> pi/2*hyp2f1(0.5,-0.5,1,0.5)
+        1.350643881047675502520175
+
+    Evaluation is supported for arbitrary complex `m`::
+
+        >>> ellipe(0.5+0.25j)
+        (1.360868682163129682716687 - 0.1238733442561786843557315j)
+        >>> ellipe(3+4j)
+        (1.499553520933346954333612 - 1.577879007912758274533309j)
+
+    A definite integral::
+
+        >>> quad(ellipe, [0,1])
+        1.333333333333333333333333
+
+    **Examples for the incomplete integral**
+
+    Basic values and limits::
+
+        >>> ellipe(0,1)
+        0.0
+        >>> ellipe(0,0)
+        0.0
+        >>> ellipe(1,0)
+        1.0
+        >>> ellipe(2+3j,0)
+        (2.0 + 3.0j)
+        >>> ellipe(1,1); sin(1)
+        0.8414709848078965066525023
+        0.8414709848078965066525023
+        >>> ellipe(pi/2, -0.5); ellipe(-0.5)
+        1.751771275694817862026502
+        1.751771275694817862026502
+        >>> ellipe(pi/2, 1); ellipe(-pi/2, 1)
+        1.0
+        -1.0
+        >>> ellipe(1.5, 1)
+        0.9974949866040544309417234
+
+    Comparing with numerical integration::
+
+        >>> z,m = 0.5, 1.25
+        >>> ellipe(z,m)
+        0.4740152182652628394264449
+        >>> quad(lambda t: sqrt(1-m*sin(t)**2), [0,z])
+        0.4740152182652628394264449
+
+    The arguments may be complex numbers::
+
+        >>> ellipe(3j, 0.5)
+        (0.0 + 7.551991234890371873502105j)
+        >>> ellipe(3+4j, 5-6j)
+        (24.15299022574220502424466 + 75.2503670480325997418156j)
+        >>> k = 35
+        >>> z,m = 2+3j, 1.25
+        >>> ellipe(z+pi*k,m); ellipe(z,m) + 2*k*ellipe(m)
+        (48.30138799412005235090766 + 17.47255216721987688224357j)
+        (48.30138799412005235090766 + 17.47255216721987688224357j)
+
+    For `|\Re(z)| < \pi/2`, the function can be expressed as a
+    hypergeometric series of two variables
+    (see :func:`~mpmath.appellf1`)::
+
+        >>> z,m = 0.5, 0.25
+        >>> ellipe(z,m)
+        0.4950017030164151928870375
+        >>> sin(z)*appellf1(0.5,0.5,-0.5,1.5,sin(z)**2,m*sin(z)**2)
+        0.4950017030164151928870376
+
+    """
+    if len(args) == 1:
+        return ctx._ellipe(args[0])
+    else:
+        phi, m = args
+    z = phi
+    if not (ctx.isnormal(z) and ctx.isnormal(m)):
+        if m == 0:
+            return z + m
+        if z == 0:
+            return z * m
+        if m == ctx.inf or m == ctx.ninf:
+            return ctx.inf
+        raise ValueError
+    x = z.real
+    ctx.prec += max(0, ctx.mag(x))
+    pi = +ctx.pi
+    away = abs(x) > pi/2
+    if away:
+        d = ctx.nint(x/pi)
+        z = z-pi*d
+        P = 2*d*ctx.ellipe(m)
+    else:
+        P = 0
+    def terms():
+        c, s = ctx.cos_sin(z)
+        x = c**2
+        y = 1-m*s**2
+        RF = ctx.elliprf(x, y, 1)
+        RD = ctx.elliprd(x, y, 1)
+        return s*RF, -m*s**3*RD/3
+    return ctx.sum_accurately(terms) + P
+
+@defun_wrapped
+def ellippi(ctx, *args):
+    r"""
+    Called with three arguments `n, \phi, m`, evaluates the Legendre
+    incomplete elliptic integral of the third kind
+
+    .. math ::
+
+        \Pi(n; \phi, m) = \int_0^{\phi}
+            \frac{dt}{(1-n \sin^2 t) \sqrt{1-m \sin^2 t}} =
+            \int_0^{\sin \phi}
+            \frac{dt}{(1-nt^2) \sqrt{1-t^2} \sqrt{1-mt^2}}.
+
+    Called with two arguments `n, m`, evaluates the complete
+    elliptic integral of the third kind
+    `\Pi(n,m) = \Pi(n; \frac{\pi}{2},m)`.
+
+    In the defining integral, it is assumed that the principal branch
+    of the square root is taken and that the path of integration avoids
+    crossing any branch cuts. Outside `-\pi/2 \le \Re(\phi) \le \pi/2`,
+    the function extends quasi-periodically as
+
+    .. math ::
+
+        \Pi(n,\phi+k\pi,m) = 2k\Pi(n,m) + \Pi(n,\phi,m), k \in \mathbb{Z}.
+
+    **Plots**
+
+    .. literalinclude :: /plots/ellippi.py
+    .. image :: /plots/ellippi.png
+
+    **Examples for the complete integral**
+
+    Some basic values and limits::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> ellippi(0,-5); ellipk(-5)
+        0.9555039270640439337379334
+        0.9555039270640439337379334
+        >>> ellippi(inf,2)
+        0.0
+        >>> ellippi(2,inf)
+        0.0
+        >>> abs(ellippi(1,5))
+        +inf
+        >>> abs(ellippi(0.25,1))
+        +inf
+
+    Evaluation in terms of simpler functions::
+
+        >>> ellippi(0.25,0.25); ellipe(0.25)/(1-0.25)
+        1.956616279119236207279727
+        1.956616279119236207279727
+        >>> ellippi(3,0); pi/(2*sqrt(-2))
+        (0.0 - 1.11072073453959156175397j)
+        (0.0 - 1.11072073453959156175397j)
+        >>> ellippi(-3,0); pi/(2*sqrt(4))
+        0.7853981633974483096156609
+        0.7853981633974483096156609
+
+    **Examples for the incomplete integral**
+
+    Basic values and limits::
+
+        >>> ellippi(0.25,-0.5); ellippi(0.25,pi/2,-0.5)
+        1.622944760954741603710555
+        1.622944760954741603710555
+        >>> ellippi(1,0,1)
+        0.0
+        >>> ellippi(inf,0,1)
+        0.0
+        >>> ellippi(0,0.25,0.5); ellipf(0.25,0.5)
+        0.2513040086544925794134591
+        0.2513040086544925794134591
+        >>> ellippi(1,1,1); (log(sec(1)+tan(1))+sec(1)*tan(1))/2
+        2.054332933256248668692452
+        2.054332933256248668692452
+        >>> ellippi(0.25, 53*pi/2, 0.75); 53*ellippi(0.25,0.75)
+        135.240868757890840755058
+        135.240868757890840755058
+        >>> ellippi(0.5,pi/4,0.5); 2*ellipe(pi/4,0.5)-1/sqrt(3)
+        0.9190227391656969903987269
+        0.9190227391656969903987269
+
+    Complex arguments are supported::
+
+        >>> ellippi(0.5, 5+6j-2*pi, -7-8j)
+        (-0.3612856620076747660410167 + 0.5217735339984807829755815j)
+
+    Some degenerate cases::
+
+        >>> ellippi(1,1)
+        +inf
+        >>> ellippi(1,0)
+        +inf
+        >>> ellippi(1,2,0)
+        +inf
+        >>> ellippi(1,2,1)
+        +inf
+        >>> ellippi(1,0,1)
+        0.0
+
+    """
+    if len(args) == 2:
+        n, m = args
+        complete = True
+        z = phi = ctx.pi/2
+    else:
+        n, phi, m = args
+        complete = False
+        z = phi
+    if not (ctx.isnormal(n) and ctx.isnormal(z) and ctx.isnormal(m)):
+        if ctx.isnan(n) or ctx.isnan(z) or ctx.isnan(m):
+            raise ValueError
+        if complete:
+            if m == 0:
+                if n == 1:
+                    return ctx.inf
+                return ctx.pi/(2*ctx.sqrt(1-n))
+            if n == 0: return ctx.ellipk(m)
+            if ctx.isinf(n) or ctx.isinf(m): return ctx.zero
+        else:
+            if z == 0: return z
+            if ctx.isinf(n): return ctx.zero
+            if ctx.isinf(m): return ctx.zero
+        if ctx.isinf(n) or ctx.isinf(z) or ctx.isinf(m):
+            raise ValueError
+    if complete:
+        if m == 1:
+            if n == 1:
+                return ctx.inf
+            return -ctx.inf/ctx.sign(n-1)
+        away = False
+    else:
+        x = z.real
+        ctx.prec += max(0, ctx.mag(x))
+        pi = +ctx.pi
+        away = abs(x) > pi/2
+    if away:
+        d = ctx.nint(x/pi)
+        z = z-pi*d
+        P = 2*d*ctx.ellippi(n,m)
+        if ctx.isinf(P):
+            return ctx.inf
+    else:
+        P = 0
+    def terms():
+        if complete:
+            c, s = ctx.zero, ctx.one
+        else:
+            c, s = ctx.cos_sin(z)
+        x = c**2
+        y = 1-m*s**2
+        RF = ctx.elliprf(x, y, 1)
+        RJ = ctx.elliprj(x, y, 1, 1-n*s**2)
+        return s*RF, n*s**3*RJ/3
+    return ctx.sum_accurately(terms) + P
diff --git a/lib/python3.11/site-packages/mpmath/functions/expintegrals.py b/lib/python3.11/site-packages/mpmath/functions/expintegrals.py
new file mode 100644
index 0000000000000000000000000000000000000000..0dee8356c0386819d8f0421fded476ee77229359
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/expintegrals.py
@@ -0,0 +1,425 @@
+from .functions import defun, defun_wrapped
+
+@defun_wrapped
+def _erf_complex(ctx, z):
+    z2 = ctx.square_exp_arg(z, -1)
+    #z2 = -z**2
+    v = (2/ctx.sqrt(ctx.pi))*z * ctx.hyp1f1((1,2),(3,2), z2)
+    if not ctx._re(z):
+        v = ctx._im(v)*ctx.j
+    return v
+
+@defun_wrapped
+def _erfc_complex(ctx, z):
+    if ctx.re(z) > 2:
+        z2 = ctx.square_exp_arg(z)
+        nz2 = ctx.fneg(z2, exact=True)
+        v = ctx.exp(nz2)/ctx.sqrt(ctx.pi) * ctx.hyperu((1,2),(1,2), z2)
+    else:
+        v = 1 - ctx._erf_complex(z)
+    if not ctx._re(z):
+        v = 1+ctx._im(v)*ctx.j
+    return v
+
+@defun
+def erf(ctx, z):
+    z = ctx.convert(z)
+    if ctx._is_real_type(z):
+        try:
+            return ctx._erf(z)
+        except NotImplementedError:
+            pass
+    if ctx._is_complex_type(z) and not z.imag:
+        try:
+            return type(z)(ctx._erf(z.real))
+        except NotImplementedError:
+            pass
+    return ctx._erf_complex(z)
+
+@defun
+def erfc(ctx, z):
+    z = ctx.convert(z)
+    if ctx._is_real_type(z):
+        try:
+            return ctx._erfc(z)
+        except NotImplementedError:
+            pass
+    if ctx._is_complex_type(z) and not z.imag:
+        try:
+            return type(z)(ctx._erfc(z.real))
+        except NotImplementedError:
+            pass
+    return ctx._erfc_complex(z)
+
+@defun
+def square_exp_arg(ctx, z, mult=1, reciprocal=False):
+    prec = ctx.prec*4+20
+    if reciprocal:
+        z2 = ctx.fmul(z, z, prec=prec)
+        z2 = ctx.fdiv(ctx.one, z2, prec=prec)
+    else:
+        z2 = ctx.fmul(z, z, prec=prec)
+    if mult != 1:
+        z2 = ctx.fmul(z2, mult, exact=True)
+    return z2
+
+@defun_wrapped
+def erfi(ctx, z):
+    if not z:
+        return z
+    z2 = ctx.square_exp_arg(z)
+    v = (2/ctx.sqrt(ctx.pi)*z) * ctx.hyp1f1((1,2), (3,2), z2)
+    if not ctx._re(z):
+        v = ctx._im(v)*ctx.j
+    return v
+
+@defun_wrapped
+def erfinv(ctx, x):
+    xre = ctx._re(x)
+    if (xre != x) or (xre < -1) or (xre > 1):
+        return ctx.bad_domain("erfinv(x) is defined only for -1 <= x <= 1")
+    x = xre
+    #if ctx.isnan(x): return x
+    if not x: return x
+    if x == 1: return ctx.inf
+    if x == -1: return ctx.ninf
+    if abs(x) < 0.9:
+        a = 0.53728*x**3 + 0.813198*x
+    else:
+        # An asymptotic formula
+        u = ctx.ln(2/ctx.pi/(abs(x)-1)**2)
+        a = ctx.sign(x) * ctx.sqrt(u - ctx.ln(u))/ctx.sqrt(2)
+    ctx.prec += 10
+    return ctx.findroot(lambda t: ctx.erf(t)-x, a)
+
+@defun_wrapped
+def npdf(ctx, x, mu=0, sigma=1):
+    sigma = ctx.convert(sigma)
+    return ctx.exp(-(x-mu)**2/(2*sigma**2)) / (sigma*ctx.sqrt(2*ctx.pi))
+
+@defun_wrapped
+def ncdf(ctx, x, mu=0, sigma=1):
+    a = (x-mu)/(sigma*ctx.sqrt(2))
+    if a < 0:
+        return ctx.erfc(-a)/2
+    else:
+        return (1+ctx.erf(a))/2
+
+@defun_wrapped
+def betainc(ctx, a, b, x1=0, x2=1, regularized=False):
+    if x1 == x2:
+        v = 0
+    elif not x1:
+        if x1 == 0 and x2 == 1:
+            v = ctx.beta(a, b)
+        else:
+            v = x2**a * ctx.hyp2f1(a, 1-b, a+1, x2) / a
+    else:
+        m, d = ctx.nint_distance(a)
+        if m <= 0:
+            if d < -ctx.prec:
+                h = +ctx.eps
+                ctx.prec *= 2
+                a += h
+            elif d < -4:
+                ctx.prec -= d
+        s1 = x2**a * ctx.hyp2f1(a,1-b,a+1,x2)
+        s2 = x1**a * ctx.hyp2f1(a,1-b,a+1,x1)
+        v = (s1 - s2) / a
+    if regularized:
+        v /= ctx.beta(a,b)
+    return v
+
+@defun
+def gammainc(ctx, z, a=0, b=None, regularized=False):
+    regularized = bool(regularized)
+    z = ctx.convert(z)
+    if a is None:
+        a = ctx.zero
+        lower_modified = False
+    else:
+        a = ctx.convert(a)
+        lower_modified = a != ctx.zero
+    if b is None:
+        b = ctx.inf
+        upper_modified = False
+    else:
+        b = ctx.convert(b)
+        upper_modified = b != ctx.inf
+    # Complete gamma function
+    if not (upper_modified or lower_modified):
+        if regularized:
+            if ctx.re(z) < 0:
+                return ctx.inf
+            elif ctx.re(z) > 0:
+                return ctx.one
+            else:
+                return ctx.nan
+        return ctx.gamma(z)
+    if a == b:
+        return ctx.zero
+    # Standardize
+    if ctx.re(a) > ctx.re(b):
+        return -ctx.gammainc(z, b, a, regularized)
+    # Generalized gamma
+    if upper_modified and lower_modified:
+        return +ctx._gamma3(z, a, b, regularized)
+    # Upper gamma
+    elif lower_modified:
+        return ctx._upper_gamma(z, a, regularized)
+    # Lower gamma
+    elif upper_modified:
+        return ctx._lower_gamma(z, b, regularized)
+
+@defun
+def _lower_gamma(ctx, z, b, regularized=False):
+    # Pole
+    if ctx.isnpint(z):
+        return type(z)(ctx.inf)
+    G = [z] * regularized
+    negb = ctx.fneg(b, exact=True)
+    def h(z):
+        T1 = [ctx.exp(negb), b, z], [1, z, -1], [], G, [1], [1+z], b
+        return (T1,)
+    return ctx.hypercomb(h, [z])
+
+@defun
+def _upper_gamma(ctx, z, a, regularized=False):
+    # Fast integer case, when available
+    if ctx.isint(z):
+        try:
+            if regularized:
+                # Gamma pole
+                if ctx.isnpint(z):
+                    return type(z)(ctx.zero)
+                orig = ctx.prec
+                try:
+                    ctx.prec += 10
+                    return ctx._gamma_upper_int(z, a) / ctx.gamma(z)
+                finally:
+                    ctx.prec = orig
+            else:
+                return ctx._gamma_upper_int(z, a)
+        except NotImplementedError:
+            pass
+    # hypercomb is unable to detect the exact zeros, so handle them here
+    if z == 2 and a == -1:
+        return (z+a)*0
+    if z == 3 and (a == -1-1j or a == -1+1j):
+        return (z+a)*0
+    nega = ctx.fneg(a, exact=True)
+    G = [z] * regularized
+    # Use 2F0 series when possible; fall back to lower gamma representation
+    try:
+        def h(z):
+            r = z-1
+            return [([ctx.exp(nega), a], [1, r], [], G, [1, -r], [], 1/nega)]
+        return ctx.hypercomb(h, [z], force_series=True)
+    except ctx.NoConvergence:
+        def h(z):
+            T1 = [], [1, z-1], [z], G, [], [], 0
+            T2 = [-ctx.exp(nega), a, z], [1, z, -1], [], G, [1], [1+z], a
+            return T1, T2
+        return ctx.hypercomb(h, [z])
+
+@defun
+def _gamma3(ctx, z, a, b, regularized=False):
+    pole = ctx.isnpint(z)
+    if regularized and pole:
+        return ctx.zero
+    try:
+        ctx.prec += 15
+        # We don't know in advance whether it's better to write as a difference
+        # of lower or upper gamma functions, so try both
+        T1 = ctx.gammainc(z, a, regularized=regularized)
+        T2 = ctx.gammainc(z, b, regularized=regularized)
+        R = T1 - T2
+        if ctx.mag(R) - max(ctx.mag(T1), ctx.mag(T2)) > -10:
+            return R
+        if not pole:
+            T1 = ctx.gammainc(z, 0, b, regularized=regularized)
+            T2 = ctx.gammainc(z, 0, a, regularized=regularized)
+            R = T1 - T2
+            # May be ok, but should probably at least print a warning
+            # about possible cancellation
+            if 1: #ctx.mag(R) - max(ctx.mag(T1), ctx.mag(T2)) > -10:
+                return R
+    finally:
+        ctx.prec -= 15
+    raise NotImplementedError
+
+@defun_wrapped
+def expint(ctx, n, z):
+    if ctx.isint(n) and ctx._is_real_type(z):
+        try:
+            return ctx._expint_int(n, z)
+        except NotImplementedError:
+            pass
+    if ctx.isnan(n) or ctx.isnan(z):
+        return z*n
+    if z == ctx.inf:
+        return 1/z
+    if z == 0:
+        # integral from 1 to infinity of t^n
+        if ctx.re(n) <= 1:
+            # TODO: reasonable sign of infinity
+            return type(z)(ctx.inf)
+        else:
+            return ctx.one/(n-1)
+    if n == 0:
+        return ctx.exp(-z)/z
+    if n == -1:
+        return ctx.exp(-z)*(z+1)/z**2
+    return z**(n-1) * ctx.gammainc(1-n, z)
+
+@defun_wrapped
+def li(ctx, z, offset=False):
+    if offset:
+        if z == 2:
+            return ctx.zero
+        return ctx.ei(ctx.ln(z)) - ctx.ei(ctx.ln2)
+    if not z:
+        return z
+    if z == 1:
+        return ctx.ninf
+    return ctx.ei(ctx.ln(z))
+
+@defun
+def ei(ctx, z):
+    try:
+        return ctx._ei(z)
+    except NotImplementedError:
+        return ctx._ei_generic(z)
+
+@defun_wrapped
+def _ei_generic(ctx, z):
+    # Note: the following is currently untested because mp and fp
+    # both use special-case ei code
+    if z == ctx.inf:
+        return z
+    if z == ctx.ninf:
+        return ctx.zero
+    if ctx.mag(z) > 1:
+        try:
+            r = ctx.one/z
+            v = ctx.exp(z)*ctx.hyper([1,1],[],r,
+                maxterms=ctx.prec, force_series=True)/z
+            im = ctx._im(z)
+            if im > 0:
+                v += ctx.pi*ctx.j
+            if im < 0:
+                v -= ctx.pi*ctx.j
+            return v
+        except ctx.NoConvergence:
+            pass
+    v = z*ctx.hyp2f2(1,1,2,2,z) + ctx.euler
+    if ctx._im(z):
+        v += 0.5*(ctx.log(z) - ctx.log(ctx.one/z))
+    else:
+        v += ctx.log(abs(z))
+    return v
+
+@defun
+def e1(ctx, z):
+    try:
+        return ctx._e1(z)
+    except NotImplementedError:
+        return ctx.expint(1, z)
+
+@defun
+def ci(ctx, z):
+    try:
+        return ctx._ci(z)
+    except NotImplementedError:
+        return ctx._ci_generic(z)
+
+@defun_wrapped
+def _ci_generic(ctx, z):
+    if ctx.isinf(z):
+        if z == ctx.inf: return ctx.zero
+        if z == ctx.ninf: return ctx.pi*1j
+    jz = ctx.fmul(ctx.j,z,exact=True)
+    njz = ctx.fneg(jz,exact=True)
+    v = 0.5*(ctx.ei(jz) + ctx.ei(njz))
+    zreal = ctx._re(z)
+    zimag = ctx._im(z)
+    if zreal == 0:
+        if zimag > 0: v += ctx.pi*0.5j
+        if zimag < 0: v -= ctx.pi*0.5j
+    if zreal < 0:
+        if zimag >= 0: v += ctx.pi*1j
+        if zimag <  0: v -= ctx.pi*1j
+    if ctx._is_real_type(z) and zreal > 0:
+        v = ctx._re(v)
+    return v
+
+@defun
+def si(ctx, z):
+    try:
+        return ctx._si(z)
+    except NotImplementedError:
+        return ctx._si_generic(z)
+
+@defun_wrapped
+def _si_generic(ctx, z):
+    if ctx.isinf(z):
+        if z == ctx.inf: return 0.5*ctx.pi
+        if z == ctx.ninf: return -0.5*ctx.pi
+    # Suffers from cancellation near 0
+    if ctx.mag(z) >= -1:
+        jz = ctx.fmul(ctx.j,z,exact=True)
+        njz = ctx.fneg(jz,exact=True)
+        v = (-0.5j)*(ctx.ei(jz) - ctx.ei(njz))
+        zreal = ctx._re(z)
+        if zreal > 0:
+            v -= 0.5*ctx.pi
+        if zreal < 0:
+            v += 0.5*ctx.pi
+        if ctx._is_real_type(z):
+            v = ctx._re(v)
+        return v
+    else:
+        return z*ctx.hyp1f2((1,2),(3,2),(3,2),-0.25*z*z)
+
+@defun_wrapped
+def chi(ctx, z):
+    nz = ctx.fneg(z, exact=True)
+    v = 0.5*(ctx.ei(z) + ctx.ei(nz))
+    zreal = ctx._re(z)
+    zimag = ctx._im(z)
+    if zimag > 0:
+        v += ctx.pi*0.5j
+    elif zimag < 0:
+        v -= ctx.pi*0.5j
+    elif zreal < 0:
+        v += ctx.pi*1j
+    return v
+
+@defun_wrapped
+def shi(ctx, z):
+    # Suffers from cancellation near 0
+    if ctx.mag(z) >= -1:
+        nz = ctx.fneg(z, exact=True)
+        v = 0.5*(ctx.ei(z) - ctx.ei(nz))
+        zimag = ctx._im(z)
+        if zimag > 0: v -= 0.5j*ctx.pi
+        if zimag < 0: v += 0.5j*ctx.pi
+        return v
+    else:
+        return z * ctx.hyp1f2((1,2),(3,2),(3,2),0.25*z*z)
+
+@defun_wrapped
+def fresnels(ctx, z):
+    if z == ctx.inf:
+        return ctx.mpf(0.5)
+    if z == ctx.ninf:
+        return ctx.mpf(-0.5)
+    return ctx.pi*z**3/6*ctx.hyp1f2((3,4),(3,2),(7,4),-ctx.pi**2*z**4/16)
+
+@defun_wrapped
+def fresnelc(ctx, z):
+    if z == ctx.inf:
+        return ctx.mpf(0.5)
+    if z == ctx.ninf:
+        return ctx.mpf(-0.5)
+    return z*ctx.hyp1f2((1,4),(1,2),(5,4),-ctx.pi**2*z**4/16)
diff --git a/lib/python3.11/site-packages/mpmath/functions/factorials.py b/lib/python3.11/site-packages/mpmath/functions/factorials.py
new file mode 100644
index 0000000000000000000000000000000000000000..9259e40b95bf1c908a7ad98b59bbb33528606b07
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/factorials.py
@@ -0,0 +1,187 @@
+from ..libmp.backend import xrange
+from .functions import defun, defun_wrapped
+
+@defun
+def gammaprod(ctx, a, b, _infsign=False):
+    a = [ctx.convert(x) for x in a]
+    b = [ctx.convert(x) for x in b]
+    poles_num = []
+    poles_den = []
+    regular_num = []
+    regular_den = []
+    for x in a: [regular_num, poles_num][ctx.isnpint(x)].append(x)
+    for x in b: [regular_den, poles_den][ctx.isnpint(x)].append(x)
+    # One more pole in numerator or denominator gives 0 or inf
+    if len(poles_num) < len(poles_den): return ctx.zero
+    if len(poles_num) > len(poles_den):
+        # Get correct sign of infinity for x+h, h -> 0 from above
+        # XXX: hack, this should be done properly
+        if _infsign:
+            a = [x and x*(1+ctx.eps) or x+ctx.eps for x in poles_num]
+            b = [x and x*(1+ctx.eps) or x+ctx.eps for x in poles_den]
+            return ctx.sign(ctx.gammaprod(a+regular_num,b+regular_den)) * ctx.inf
+        else:
+            return ctx.inf
+    # All poles cancel
+    # lim G(i)/G(j) = (-1)**(i+j) * gamma(1-j) / gamma(1-i)
+    p = ctx.one
+    orig = ctx.prec
+    try:
+        ctx.prec = orig + 15
+        while poles_num:
+            i = poles_num.pop()
+            j = poles_den.pop()
+            p *= (-1)**(i+j) * ctx.gamma(1-j) / ctx.gamma(1-i)
+        for x in regular_num: p *= ctx.gamma(x)
+        for x in regular_den: p /= ctx.gamma(x)
+    finally:
+        ctx.prec = orig
+    return +p
+
+@defun
+def beta(ctx, x, y):
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    if ctx.isinf(y):
+        x, y = y, x
+    if ctx.isinf(x):
+        if x == ctx.inf and not ctx._im(y):
+            if y == ctx.ninf:
+                return ctx.nan
+            if y > 0:
+                return ctx.zero
+            if ctx.isint(y):
+                return ctx.nan
+            if y < 0:
+                return ctx.sign(ctx.gamma(y)) * ctx.inf
+        return ctx.nan
+    xy = ctx.fadd(x, y, prec=2*ctx.prec)
+    return ctx.gammaprod([x, y], [xy])
+
+@defun
+def binomial(ctx, n, k):
+    n1 = ctx.fadd(n, 1, prec=2*ctx.prec)
+    k1 = ctx.fadd(k, 1, prec=2*ctx.prec)
+    nk1 = ctx.fsub(n1, k, prec=2*ctx.prec)
+    return ctx.gammaprod([n1], [k1, nk1])
+
+@defun
+def rf(ctx, x, n):
+    xn = ctx.fadd(x, n, prec=2*ctx.prec)
+    return ctx.gammaprod([xn], [x])
+
+@defun
+def ff(ctx, x, n):
+    x1 = ctx.fadd(x, 1, prec=2*ctx.prec)
+    xn1 = ctx.fadd(ctx.fsub(x, n, prec=2*ctx.prec), 1, prec=2*ctx.prec)
+    return ctx.gammaprod([x1], [xn1])
+
+@defun_wrapped
+def fac2(ctx, x):
+    if ctx.isinf(x):
+        if x == ctx.inf:
+            return x
+        return ctx.nan
+    return 2**(x/2)*(ctx.pi/2)**((ctx.cospi(x)-1)/4)*ctx.gamma(x/2+1)
+
+@defun_wrapped
+def barnesg(ctx, z):
+    if ctx.isinf(z):
+        if z == ctx.inf:
+            return z
+        return ctx.nan
+    if ctx.isnan(z):
+        return z
+    if (not ctx._im(z)) and ctx._re(z) <= 0 and ctx.isint(ctx._re(z)):
+        return z*0
+    # Account for size (would not be needed if computing log(G))
+    if abs(z) > 5:
+        ctx.dps += 2*ctx.log(abs(z),2)
+    # Reflection formula
+    if ctx.re(z) < -ctx.dps:
+        w = 1-z
+        pi2 = 2*ctx.pi
+        u = ctx.expjpi(2*w)
+        v = ctx.j*ctx.pi/12 - ctx.j*ctx.pi*w**2/2 + w*ctx.ln(1-u) - \
+            ctx.j*ctx.polylog(2, u)/pi2
+        v = ctx.barnesg(2-z)*ctx.exp(v)/pi2**w
+        if ctx._is_real_type(z):
+            v = ctx._re(v)
+        return v
+    # Estimate terms for asymptotic expansion
+    # TODO: fixme, obviously
+    N = ctx.dps // 2 + 5
+    G = 1
+    while abs(z) < N or ctx.re(z) < 1:
+        G /= ctx.gamma(z)
+        z += 1
+    z -= 1
+    s = ctx.mpf(1)/12
+    s -= ctx.log(ctx.glaisher)
+    s += z*ctx.log(2*ctx.pi)/2
+    s += (z**2/2-ctx.mpf(1)/12)*ctx.log(z)
+    s -= 3*z**2/4
+    z2k = z2 = z**2
+    for k in xrange(1, N+1):
+        t = ctx.bernoulli(2*k+2) / (4*k*(k+1)*z2k)
+        if abs(t) < ctx.eps:
+            #print k, N      # check how many terms were needed
+            break
+        z2k *= z2
+        s += t
+    #if k == N:
+    #    print "warning: series for barnesg failed to converge", ctx.dps
+    return G*ctx.exp(s)
+
+@defun
+def superfac(ctx, z):
+    return ctx.barnesg(z+2)
+
+@defun_wrapped
+def hyperfac(ctx, z):
+    # XXX: estimate needed extra bits accurately
+    if z == ctx.inf:
+        return z
+    if abs(z) > 5:
+        extra = 4*int(ctx.log(abs(z),2))
+    else:
+        extra = 0
+    ctx.prec += extra
+    if not ctx._im(z) and ctx._re(z) < 0 and ctx.isint(ctx._re(z)):
+        n = int(ctx.re(z))
+        h = ctx.hyperfac(-n-1)
+        if ((n+1)//2) & 1:
+            h = -h
+        if ctx._is_complex_type(z):
+            return h + 0j
+        return h
+    zp1 = z+1
+    # Wrong branch cut
+    #v = ctx.gamma(zp1)**z
+    #ctx.prec -= extra
+    #return v / ctx.barnesg(zp1)
+    v = ctx.exp(z*ctx.loggamma(zp1))
+    ctx.prec -= extra
+    return v / ctx.barnesg(zp1)
+
+'''
+@defun
+def psi0(ctx, z):
+    """Shortcut for psi(0,z) (the digamma function)"""
+    return ctx.psi(0, z)
+
+@defun
+def psi1(ctx, z):
+    """Shortcut for psi(1,z) (the trigamma function)"""
+    return ctx.psi(1, z)
+
+@defun
+def psi2(ctx, z):
+    """Shortcut for psi(2,z) (the tetragamma function)"""
+    return ctx.psi(2, z)
+
+@defun
+def psi3(ctx, z):
+    """Shortcut for psi(3,z) (the pentagamma function)"""
+    return ctx.psi(3, z)
+'''
diff --git a/lib/python3.11/site-packages/mpmath/functions/functions.py b/lib/python3.11/site-packages/mpmath/functions/functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cdf5dd921418db10847ea75b32f8e6dfacdba64
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/functions.py
@@ -0,0 +1,645 @@
+from ..libmp.backend import xrange
+
+class SpecialFunctions(object):
+    """
+    This class implements special functions using high-level code.
+
+    Elementary and some other functions (e.g. gamma function, basecase
+    hypergeometric series) are assumed to be predefined by the context as
+    "builtins" or "low-level" functions.
+    """
+    defined_functions = {}
+
+    # The series for the Jacobi theta functions converge for |q| < 1;
+    # in the current implementation they throw a ValueError for
+    # abs(q) > THETA_Q_LIM
+    THETA_Q_LIM = 1 - 10**-7
+
+    def __init__(self):
+        cls = self.__class__
+        for name in cls.defined_functions:
+            f, wrap = cls.defined_functions[name]
+            cls._wrap_specfun(name, f, wrap)
+
+        self.mpq_1 = self._mpq((1,1))
+        self.mpq_0 = self._mpq((0,1))
+        self.mpq_1_2 = self._mpq((1,2))
+        self.mpq_3_2 = self._mpq((3,2))
+        self.mpq_1_4 = self._mpq((1,4))
+        self.mpq_1_16 = self._mpq((1,16))
+        self.mpq_3_16 = self._mpq((3,16))
+        self.mpq_5_2 = self._mpq((5,2))
+        self.mpq_3_4 = self._mpq((3,4))
+        self.mpq_7_4 = self._mpq((7,4))
+        self.mpq_5_4 = self._mpq((5,4))
+        self.mpq_1_3 = self._mpq((1,3))
+        self.mpq_2_3 = self._mpq((2,3))
+        self.mpq_4_3 = self._mpq((4,3))
+        self.mpq_1_6 = self._mpq((1,6))
+        self.mpq_5_6 = self._mpq((5,6))
+        self.mpq_5_3 = self._mpq((5,3))
+
+        self._misc_const_cache = {}
+
+        self._aliases.update({
+            'phase' : 'arg',
+            'conjugate' : 'conj',
+            'nthroot' : 'root',
+            'polygamma' : 'psi',
+            'hurwitz' : 'zeta',
+            #'digamma' : 'psi0',
+            #'trigamma' : 'psi1',
+            #'tetragamma' : 'psi2',
+            #'pentagamma' : 'psi3',
+            'fibonacci' : 'fib',
+            'factorial' : 'fac',
+        })
+
+        self.zetazero_memoized = self.memoize(self.zetazero)
+
+    # Default -- do nothing
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        setattr(cls, name, f)
+
+    # Optional fast versions of common functions in common cases.
+    # If not overridden, default (generic hypergeometric series)
+    # implementations will be used
+    def _besselj(ctx, n, z): raise NotImplementedError
+    def _erf(ctx, z): raise NotImplementedError
+    def _erfc(ctx, z): raise NotImplementedError
+    def _gamma_upper_int(ctx, z, a): raise NotImplementedError
+    def _expint_int(ctx, n, z): raise NotImplementedError
+    def _zeta(ctx, s): raise NotImplementedError
+    def _zetasum_fast(ctx, s, a, n, derivatives, reflect): raise NotImplementedError
+    def _ei(ctx, z): raise NotImplementedError
+    def _e1(ctx, z): raise NotImplementedError
+    def _ci(ctx, z): raise NotImplementedError
+    def _si(ctx, z): raise NotImplementedError
+    def _altzeta(ctx, s): raise NotImplementedError
+
+def defun_wrapped(f):
+    SpecialFunctions.defined_functions[f.__name__] = f, True
+    return f
+
+def defun(f):
+    SpecialFunctions.defined_functions[f.__name__] = f, False
+    return f
+
+def defun_static(f):
+    setattr(SpecialFunctions, f.__name__, f)
+    return f
+
+@defun_wrapped
+def cot(ctx, z): return ctx.one / ctx.tan(z)
+
+@defun_wrapped
+def sec(ctx, z): return ctx.one / ctx.cos(z)
+
+@defun_wrapped
+def csc(ctx, z): return ctx.one / ctx.sin(z)
+
+@defun_wrapped
+def coth(ctx, z): return ctx.one / ctx.tanh(z)
+
+@defun_wrapped
+def sech(ctx, z): return ctx.one / ctx.cosh(z)
+
+@defun_wrapped
+def csch(ctx, z): return ctx.one / ctx.sinh(z)
+
+@defun_wrapped
+def acot(ctx, z):
+    if not z:
+        return ctx.pi * 0.5
+    else:
+        return ctx.atan(ctx.one / z)
+
+@defun_wrapped
+def asec(ctx, z): return ctx.acos(ctx.one / z)
+
+@defun_wrapped
+def acsc(ctx, z): return ctx.asin(ctx.one / z)
+
+@defun_wrapped
+def acoth(ctx, z):
+    if not z:
+        return ctx.pi * 0.5j
+    else:
+        return ctx.atanh(ctx.one / z)
+
+
+@defun_wrapped
+def asech(ctx, z): return ctx.acosh(ctx.one / z)
+
+@defun_wrapped
+def acsch(ctx, z): return ctx.asinh(ctx.one / z)
+
+@defun
+def sign(ctx, x):
+    x = ctx.convert(x)
+    if not x or ctx.isnan(x):
+        return x
+    if ctx._is_real_type(x):
+        if x > 0:
+            return ctx.one
+        else:
+            return -ctx.one
+    return x / abs(x)
+
+@defun
+def agm(ctx, a, b=1):
+    if b == 1:
+        return ctx.agm1(a)
+    a = ctx.convert(a)
+    b = ctx.convert(b)
+    return ctx._agm(a, b)
+
+@defun_wrapped
+def sinc(ctx, x):
+    if ctx.isinf(x):
+        return 1/x
+    if not x:
+        return x+1
+    return ctx.sin(x)/x
+
+@defun_wrapped
+def sincpi(ctx, x):
+    if ctx.isinf(x):
+        return 1/x
+    if not x:
+        return x+1
+    return ctx.sinpi(x)/(ctx.pi*x)
+
+# TODO: tests; improve implementation
+@defun_wrapped
+def expm1(ctx, x):
+    if not x:
+        return ctx.zero
+    # exp(x) - 1 ~ x
+    if ctx.mag(x) < -ctx.prec:
+        return x + 0.5*x**2
+    # TODO: accurately eval the smaller of the real/imag parts
+    return ctx.sum_accurately(lambda: iter([ctx.exp(x),-1]),1)
+
+@defun_wrapped
+def log1p(ctx, x):
+    if not x:
+        return ctx.zero
+    if ctx.mag(x) < -ctx.prec:
+        return x - 0.5*x**2
+    return ctx.log(ctx.fadd(1, x, prec=2*ctx.prec))
+
+@defun_wrapped
+def powm1(ctx, x, y):
+    mag = ctx.mag
+    one = ctx.one
+    w = x**y - one
+    M = mag(w)
+    # Only moderate cancellation
+    if M > -8:
+        return w
+    # Check for the only possible exact cases
+    if not w:
+        if (not y) or (x in (1, -1, 1j, -1j) and ctx.isint(y)):
+            return w
+    x1 = x - one
+    magy = mag(y)
+    lnx = ctx.ln(x)
+    # Small y: x^y - 1 ~ log(x)*y + O(log(x)^2 * y^2)
+    if magy + mag(lnx) < -ctx.prec:
+        return lnx*y + (lnx*y)**2/2
+    # TODO: accurately eval the smaller of the real/imag part
+    return ctx.sum_accurately(lambda: iter([x**y, -1]), 1)
+
+@defun
+def _rootof1(ctx, k, n):
+    k = int(k)
+    n = int(n)
+    k %= n
+    if not k:
+        return ctx.one
+    elif 2*k == n:
+        return -ctx.one
+    elif 4*k == n:
+        return ctx.j
+    elif 4*k == 3*n:
+        return -ctx.j
+    return ctx.expjpi(2*ctx.mpf(k)/n)
+
+@defun
+def root(ctx, x, n, k=0):
+    n = int(n)
+    x = ctx.convert(x)
+    if k:
+        # Special case: there is an exact real root
+        if (n & 1 and 2*k == n-1) and (not ctx.im(x)) and (ctx.re(x) < 0):
+            return -ctx.root(-x, n)
+        # Multiply by root of unity
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            v = ctx.root(x, n, 0) * ctx._rootof1(k, n)
+        finally:
+            ctx.prec = prec
+        return +v
+    return ctx._nthroot(x, n)
+
+@defun
+def unitroots(ctx, n, primitive=False):
+    gcd = ctx._gcd
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        if primitive:
+            v = [ctx._rootof1(k,n) for k in range(n) if gcd(k,n) == 1]
+        else:
+            # TODO: this can be done *much* faster
+            v = [ctx._rootof1(k,n) for k in range(n)]
+    finally:
+        ctx.prec = prec
+    return [+x for x in v]
+
+@defun
+def arg(ctx, x):
+    x = ctx.convert(x)
+    re = ctx._re(x)
+    im = ctx._im(x)
+    return ctx.atan2(im, re)
+
+@defun
+def fabs(ctx, x):
+    return abs(ctx.convert(x))
+
+@defun
+def re(ctx, x):
+    x = ctx.convert(x)
+    if hasattr(x, "real"):    # py2.5 doesn't have .real/.imag for all numbers
+        return x.real
+    return x
+
+@defun
+def im(ctx, x):
+    x = ctx.convert(x)
+    if hasattr(x, "imag"):    # py2.5 doesn't have .real/.imag for all numbers
+        return x.imag
+    return ctx.zero
+
+@defun
+def conj(ctx, x):
+    x = ctx.convert(x)
+    try:
+        return x.conjugate()
+    except AttributeError:
+        return x
+
+@defun
+def polar(ctx, z):
+    return (ctx.fabs(z), ctx.arg(z))
+
+@defun_wrapped
+def rect(ctx, r, phi):
+    return r * ctx.mpc(*ctx.cos_sin(phi))
+
+@defun
+def log(ctx, x, b=None):
+    if b is None:
+        return ctx.ln(x)
+    wp = ctx.prec + 20
+    return ctx.ln(x, prec=wp) / ctx.ln(b, prec=wp)
+
+@defun
+def log10(ctx, x):
+    return ctx.log(x, 10)
+
+@defun
+def fmod(ctx, x, y):
+    return ctx.convert(x) % ctx.convert(y)
+
+@defun
+def degrees(ctx, x):
+    return x / ctx.degree
+
+@defun
+def radians(ctx, x):
+    return x * ctx.degree
+
+def _lambertw_special(ctx, z, k):
+    # W(0,0) = 0; all other branches are singular
+    if not z:
+        if not k:
+            return z
+        return ctx.ninf + z
+    if z == ctx.inf:
+        if k == 0:
+            return z
+        else:
+            return z + 2*k*ctx.pi*ctx.j
+    if z == ctx.ninf:
+        return (-z) + (2*k+1)*ctx.pi*ctx.j
+    # Some kind of nan or complex inf/nan?
+    return ctx.ln(z)
+
+import math
+import cmath
+
+def _lambertw_approx_hybrid(z, k):
+    imag_sign = 0
+    if hasattr(z, "imag"):
+        x = float(z.real)
+        y = z.imag
+        if y:
+            imag_sign = (-1) ** (y < 0)
+        y = float(y)
+    else:
+        x = float(z)
+        y = 0.0
+        imag_sign = 0
+    # hack to work regardless of whether Python supports -0.0
+    if not y:
+        y = 0.0
+    z = complex(x,y)
+    if k == 0:
+        if -4.0 < y < 4.0 and -1.0 < x < 2.5:
+            if imag_sign:
+                # Taylor series in upper/lower half-plane
+                if y > 1.00: return (0.876+0.645j) + (0.118-0.174j)*(z-(0.75+2.5j))
+                if y > 0.25: return (0.505+0.204j) + (0.375-0.132j)*(z-(0.75+0.5j))
+                if y < -1.00: return (0.876-0.645j) + (0.118+0.174j)*(z-(0.75-2.5j))
+                if y < -0.25: return (0.505-0.204j) + (0.375+0.132j)*(z-(0.75-0.5j))
+            # Taylor series near -1
+            if x < -0.5:
+                if imag_sign >= 0:
+                    return (-0.318+1.34j) + (-0.697-0.593j)*(z+1)
+                else:
+                    return (-0.318-1.34j) + (-0.697+0.593j)*(z+1)
+            # return real type
+            r = -0.367879441171442
+            if (not imag_sign) and x > r:
+                z = x
+            # Singularity near -1/e
+            if x < -0.2:
+                return -1 + 2.33164398159712*(z-r)**0.5 - 1.81218788563936*(z-r)
+            # Taylor series near 0
+            if x < 0.5: return z
+            # Simple linear approximation
+            return 0.2 + 0.3*z
+        if (not imag_sign) and x > 0.0:
+            L1 = math.log(x); L2 = math.log(L1)
+        else:
+            L1 = cmath.log(z); L2 = cmath.log(L1)
+    elif k == -1:
+        # return real type
+        r = -0.367879441171442
+        if (not imag_sign) and r < x < 0.0:
+            z = x
+        if (imag_sign >= 0) and y < 0.1 and -0.6 < x < -0.2:
+            return -1 - 2.33164398159712*(z-r)**0.5 - 1.81218788563936*(z-r)
+        if (not imag_sign) and -0.2 <= x < 0.0:
+            L1 = math.log(-x)
+            return L1 - math.log(-L1)
+        else:
+            if imag_sign == -1 and (not y) and x < 0.0:
+                L1 = cmath.log(z) - 3.1415926535897932j
+            else:
+                L1 = cmath.log(z) - 6.2831853071795865j
+            L2 = cmath.log(L1)
+    return L1 - L2 + L2/L1 + L2*(L2-2)/(2*L1**2)
+
+def _lambertw_series(ctx, z, k, tol):
+    """
+    Return rough approximation for W_k(z) from an asymptotic series,
+    sufficiently accurate for the Halley iteration to converge to
+    the correct value.
+    """
+    magz = ctx.mag(z)
+    if (-10 < magz < 900) and (-1000 < k < 1000):
+        # Near the branch point at -1/e
+        if magz < 1 and abs(z+0.36787944117144) < 0.05:
+            if k == 0 or (k == -1 and ctx._im(z) >= 0) or \
+                         (k == 1  and ctx._im(z) < 0):
+                delta = ctx.sum_accurately(lambda: [z, ctx.exp(-1)])
+                cancellation = -ctx.mag(delta)
+                ctx.prec += cancellation
+                # Use series given in Corless et al.
+                p = ctx.sqrt(2*(ctx.e*z+1))
+                ctx.prec -= cancellation
+                u = {0:ctx.mpf(-1), 1:ctx.mpf(1)}
+                a = {0:ctx.mpf(2), 1:ctx.mpf(-1)}
+                if k != 0:
+                    p = -p
+                s = ctx.zero
+                # The series converges, so we could use it directly, but unless
+                # *extremely* close, it is better to just use the first few
+                # terms to get a good approximation for the iteration
+                for l in xrange(max(2,cancellation)):
+                    if l not in u:
+                        a[l] = ctx.fsum(u[j]*u[l+1-j] for j in xrange(2,l))
+                        u[l] = (l-1)*(u[l-2]/2+a[l-2]/4)/(l+1)-a[l]/2-u[l-1]/(l+1)
+                    term = u[l] * p**l
+                    s += term
+                    if ctx.mag(term) < -tol:
+                        return s, True
+                    l += 1
+                ctx.prec += cancellation//2
+                return s, False
+        if k == 0 or k == -1:
+            return _lambertw_approx_hybrid(z, k), False
+    if k == 0:
+        if magz < -1:
+            return z*(1-z), False
+        L1 = ctx.ln(z)
+        L2 = ctx.ln(L1)
+    elif k == -1 and (not ctx._im(z)) and (-0.36787944117144 < ctx._re(z) < 0):
+        L1 = ctx.ln(-z)
+        return L1 - ctx.ln(-L1), False
+    else:
+        # This holds both as z -> 0 and z -> inf.
+        # Relative error is O(1/log(z)).
+        L1 = ctx.ln(z) + 2j*ctx.pi*k
+        L2 = ctx.ln(L1)
+    return L1 - L2 + L2/L1 + L2*(L2-2)/(2*L1**2), False
+
+@defun
+def lambertw(ctx, z, k=0):
+    z = ctx.convert(z)
+    k = int(k)
+    if not ctx.isnormal(z):
+        return _lambertw_special(ctx, z, k)
+    prec = ctx.prec
+    ctx.prec += 20 + ctx.mag(k or 1)
+    wp = ctx.prec
+    tol = wp - 5
+    w, done = _lambertw_series(ctx, z, k, tol)
+    if not done:
+        # Use Halley iteration to solve w*exp(w) = z
+        two = ctx.mpf(2)
+        for i in xrange(100):
+            ew = ctx.exp(w)
+            wew = w*ew
+            wewz = wew-z
+            wn = w - wewz/(wew+ew-(w+two)*wewz/(two*w+two))
+            if ctx.mag(wn-w) <= ctx.mag(wn) - tol:
+                w = wn
+                break
+            else:
+                w = wn
+        if i == 100:
+            ctx.warn("Lambert W iteration failed to converge for z = %s" % z)
+    ctx.prec = prec
+    return +w
+
+@defun_wrapped
+def bell(ctx, n, x=1):
+    x = ctx.convert(x)
+    if not n:
+        if ctx.isnan(x):
+            return x
+        return type(x)(1)
+    if ctx.isinf(x) or ctx.isinf(n) or ctx.isnan(x) or ctx.isnan(n):
+        return x**n
+    if n == 1: return x
+    if n == 2: return x*(x+1)
+    if x == 0: return ctx.sincpi(n)
+    return _polyexp(ctx, n, x, True) / ctx.exp(x)
+
+def _polyexp(ctx, n, x, extra=False):
+    def _terms():
+        if extra:
+            yield ctx.sincpi(n)
+        t = x
+        k = 1
+        while 1:
+            yield k**n * t
+            k += 1
+            t = t*x/k
+    return ctx.sum_accurately(_terms, check_step=4)
+
+@defun_wrapped
+def polyexp(ctx, s, z):
+    if ctx.isinf(z) or ctx.isinf(s) or ctx.isnan(z) or ctx.isnan(s):
+        return z**s
+    if z == 0: return z*s
+    if s == 0: return ctx.expm1(z)
+    if s == 1: return ctx.exp(z)*z
+    if s == 2: return ctx.exp(z)*z*(z+1)
+    return _polyexp(ctx, s, z)
+
+@defun_wrapped
+def cyclotomic(ctx, n, z):
+    n = int(n)
+    if n < 0:
+        raise ValueError("n cannot be negative")
+    p = ctx.one
+    if n == 0:
+        return p
+    if n == 1:
+        return z - p
+    if n == 2:
+        return z + p
+    # Use divisor product representation. Unfortunately, this sometimes
+    # includes singularities for roots of unity, which we have to cancel out.
+    # Matching zeros/poles pairwise, we have (1-z^a)/(1-z^b) ~ a/b + O(z-1).
+    a_prod = 1
+    b_prod = 1
+    num_zeros = 0
+    num_poles = 0
+    for d in range(1,n+1):
+        if not n % d:
+            w = ctx.moebius(n//d)
+            # Use powm1 because it is important that we get 0 only
+            # if it really is exactly 0
+            b = -ctx.powm1(z, d)
+            if b:
+                p *= b**w
+            else:
+                if w == 1:
+                    a_prod *= d
+                    num_zeros += 1
+                elif w == -1:
+                    b_prod *= d
+                    num_poles += 1
+    #print n, num_zeros, num_poles
+    if num_zeros:
+        if num_zeros > num_poles:
+            p *= 0
+        else:
+            p *= a_prod
+            p /= b_prod
+    return p
+
+@defun
+def mangoldt(ctx, n):
+    r"""
+    Evaluates the von Mangoldt function `\Lambda(n) = \log p`
+    if `n = p^k` a power of a prime, and `\Lambda(n) = 0` otherwise.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> [mangoldt(n) for n in range(-2,3)]
+        [0.0, 0.0, 0.0, 0.0, 0.6931471805599453094172321]
+        >>> mangoldt(6)
+        0.0
+        >>> mangoldt(7)
+        1.945910149055313305105353
+        >>> mangoldt(8)
+        0.6931471805599453094172321
+        >>> fsum(mangoldt(n) for n in range(101))
+        94.04531122935739224600493
+        >>> fsum(mangoldt(n) for n in range(10001))
+        10013.39669326311478372032
+
+    """
+    n = int(n)
+    if n < 2:
+        return ctx.zero
+    if n % 2 == 0:
+        # Must be a power of two
+        if n & (n-1) == 0:
+            return +ctx.ln2
+        else:
+            return ctx.zero
+    # TODO: the following could be generalized into a perfect
+    # power testing function
+    # ---
+    # Look for a small factor
+    for p in (3,5,7,11,13,17,19,23,29,31):
+        if not n % p:
+            q, r = n // p, 0
+            while q > 1:
+                q, r = divmod(q, p)
+                if r:
+                    return ctx.zero
+            return ctx.ln(p)
+    if ctx.isprime(n):
+        return ctx.ln(n)
+    # Obviously, we could use arbitrary-precision arithmetic for this...
+    if n > 10**30:
+        raise NotImplementedError
+    k = 2
+    while 1:
+        p = int(n**(1./k) + 0.5)
+        if p < 2:
+            return ctx.zero
+        if p ** k == n:
+            if ctx.isprime(p):
+                return ctx.ln(p)
+        k += 1
+
+@defun
+def stirling1(ctx, n, k, exact=False):
+    v = ctx._stirling1(int(n), int(k))
+    if exact:
+        return int(v)
+    else:
+        return ctx.mpf(v)
+
+@defun
+def stirling2(ctx, n, k, exact=False):
+    v = ctx._stirling2(int(n), int(k))
+    if exact:
+        return int(v)
+    else:
+        return ctx.mpf(v)
diff --git a/lib/python3.11/site-packages/mpmath/functions/hypergeometric.py b/lib/python3.11/site-packages/mpmath/functions/hypergeometric.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddb50cbf3ea6daa5982678d3c26157a67a7d7945
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/hypergeometric.py
@@ -0,0 +1,1413 @@
+from ..libmp.backend import xrange
+from .functions import defun, defun_wrapped
+
+def _check_need_perturb(ctx, terms, prec, discard_known_zeros):
+    perturb = recompute = False
+    extraprec = 0
+    discard = []
+    for term_index, term in enumerate(terms):
+        w_s, c_s, alpha_s, beta_s, a_s, b_s, z = term
+        have_singular_nongamma_weight = False
+        # Avoid division by zero in leading factors (TODO:
+        # also check for near division by zero?)
+        for k, w in enumerate(w_s):
+            if not w:
+                if ctx.re(c_s[k]) <= 0 and c_s[k]:
+                    perturb = recompute = True
+                    have_singular_nongamma_weight = True
+        pole_count = [0, 0, 0]
+        # Check for gamma and series poles and near-poles
+        for data_index, data in enumerate([alpha_s, beta_s, b_s]):
+            for i, x in enumerate(data):
+                n, d = ctx.nint_distance(x)
+                # Poles
+                if n > 0:
+                    continue
+                if d == ctx.ninf:
+                    # OK if we have a polynomial
+                    # ------------------------------
+                    ok = False
+                    if data_index == 2:
+                        for u in a_s:
+                            if ctx.isnpint(u) and u >= int(n):
+                                ok = True
+                                break
+                    if ok:
+                        continue
+                    pole_count[data_index] += 1
+                    # ------------------------------
+                    #perturb = recompute = True
+                    #return perturb, recompute, extraprec
+                elif d < -4:
+                    extraprec += -d
+                    recompute = True
+        if discard_known_zeros and pole_count[1] > pole_count[0] + pole_count[2] \
+            and not have_singular_nongamma_weight:
+            discard.append(term_index)
+        elif sum(pole_count):
+            perturb = recompute = True
+    return perturb, recompute, extraprec, discard
+
+_hypercomb_msg = """
+hypercomb() failed to converge to the requested %i bits of accuracy
+using a working precision of %i bits. The function value may be zero or
+infinite; try passing zeroprec=N or infprec=M to bound finite values between
+2^(-N) and 2^M. Otherwise try a higher maxprec or maxterms.
+"""
+
+@defun
+def hypercomb(ctx, function, params=[], discard_known_zeros=True, **kwargs):
+    orig = ctx.prec
+    sumvalue = ctx.zero
+    dist = ctx.nint_distance
+    ninf = ctx.ninf
+    orig_params = params[:]
+    verbose = kwargs.get('verbose', False)
+    maxprec = kwargs.get('maxprec', ctx._default_hyper_maxprec(orig))
+    kwargs['maxprec'] = maxprec   # For calls to hypsum
+    zeroprec = kwargs.get('zeroprec')
+    infprec = kwargs.get('infprec')
+    perturbed_reference_value = None
+    hextra = 0
+    try:
+        while 1:
+            ctx.prec += 10
+            if ctx.prec > maxprec:
+                raise ValueError(_hypercomb_msg % (orig, ctx.prec))
+            orig2 = ctx.prec
+            params = orig_params[:]
+            terms = function(*params)
+            if verbose:
+                print()
+                print("ENTERING hypercomb main loop")
+                print("prec =", ctx.prec)
+                print("hextra", hextra)
+            perturb, recompute, extraprec, discard = \
+                _check_need_perturb(ctx, terms, orig, discard_known_zeros)
+            ctx.prec += extraprec
+            if perturb:
+                if "hmag" in kwargs:
+                    hmag = kwargs["hmag"]
+                elif ctx._fixed_precision:
+                    hmag = int(ctx.prec*0.3)
+                else:
+                    hmag = orig + 10 + hextra
+                h = ctx.ldexp(ctx.one, -hmag)
+                ctx.prec = orig2 + 10 + hmag + 10
+                for k in range(len(params)):
+                    params[k] += h
+                    # Heuristically ensure that the perturbations
+                    # are "independent" so that two perturbations
+                    # don't accidentally cancel each other out
+                    # in a subtraction.
+                    h += h/(k+1)
+            if recompute:
+                terms = function(*params)
+            if discard_known_zeros:
+                terms = [term for (i, term) in enumerate(terms) if i not in discard]
+            if not terms:
+                return ctx.zero
+            evaluated_terms = []
+            for term_index, term_data in enumerate(terms):
+                w_s, c_s, alpha_s, beta_s, a_s, b_s, z = term_data
+                if verbose:
+                    print()
+                    print("  Evaluating term %i/%i : %iF%i" % \
+                        (term_index+1, len(terms), len(a_s), len(b_s)))
+                    print("    powers", ctx.nstr(w_s), ctx.nstr(c_s))
+                    print("    gamma", ctx.nstr(alpha_s), ctx.nstr(beta_s))
+                    print("    hyper", ctx.nstr(a_s), ctx.nstr(b_s))
+                    print("    z", ctx.nstr(z))
+                #v = ctx.hyper(a_s, b_s, z, **kwargs)
+                #for a in alpha_s: v *= ctx.gamma(a)
+                #for b in beta_s: v *= ctx.rgamma(b)
+                #for w, c in zip(w_s, c_s): v *= ctx.power(w, c)
+                v = ctx.fprod([ctx.hyper(a_s, b_s, z, **kwargs)] + \
+                    [ctx.gamma(a) for a in alpha_s] + \
+                    [ctx.rgamma(b) for b in beta_s] + \
+                    [ctx.power(w,c) for (w,c) in zip(w_s,c_s)])
+                if verbose:
+                    print("    Value:", v)
+                evaluated_terms.append(v)
+
+            if len(terms) == 1 and (not perturb):
+                sumvalue = evaluated_terms[0]
+                break
+
+            if ctx._fixed_precision:
+                sumvalue = ctx.fsum(evaluated_terms)
+                break
+
+            sumvalue = ctx.fsum(evaluated_terms)
+            term_magnitudes = [ctx.mag(x) for x in evaluated_terms]
+            max_magnitude = max(term_magnitudes)
+            sum_magnitude = ctx.mag(sumvalue)
+            cancellation = max_magnitude - sum_magnitude
+            if verbose:
+                print()
+                print("  Cancellation:", cancellation, "bits")
+                print("  Increased precision:", ctx.prec - orig, "bits")
+
+            precision_ok = cancellation < ctx.prec - orig
+
+            if zeroprec is None:
+                zero_ok = False
+            else:
+                zero_ok = max_magnitude - ctx.prec < -zeroprec
+            if infprec is None:
+                inf_ok = False
+            else:
+                inf_ok = max_magnitude > infprec
+
+            if precision_ok and (not perturb) or ctx.isnan(cancellation):
+                break
+            elif precision_ok:
+                if perturbed_reference_value is None:
+                    hextra += 20
+                    perturbed_reference_value = sumvalue
+                    continue
+                elif ctx.mag(sumvalue - perturbed_reference_value) <= \
+                        ctx.mag(sumvalue) - orig:
+                    break
+                elif zero_ok:
+                    sumvalue = ctx.zero
+                    break
+                elif inf_ok:
+                    sumvalue = ctx.inf
+                    break
+                elif 'hmag' in kwargs:
+                    break
+                else:
+                    hextra *= 2
+                    perturbed_reference_value = sumvalue
+            # Increase precision
+            else:
+                increment = min(max(cancellation, orig//2), max(extraprec,orig))
+                ctx.prec += increment
+                if verbose:
+                    print("  Must start over with increased precision")
+                continue
+    finally:
+        ctx.prec = orig
+    return +sumvalue
+
+@defun
+def hyper(ctx, a_s, b_s, z, **kwargs):
+    """
+    Hypergeometric function, general case.
+    """
+    z = ctx.convert(z)
+    p = len(a_s)
+    q = len(b_s)
+    a_s = [ctx._convert_param(a) for a in a_s]
+    b_s = [ctx._convert_param(b) for b in b_s]
+    # Reduce degree by eliminating common parameters
+    if kwargs.get('eliminate', True):
+        elim_nonpositive = kwargs.get('eliminate_all', False)
+        i = 0
+        while i < q and a_s:
+            b = b_s[i]
+            if b in a_s and (elim_nonpositive or not ctx.isnpint(b[0])):
+                a_s.remove(b)
+                b_s.remove(b)
+                p -= 1
+                q -= 1
+            else:
+                i += 1
+    # Handle special cases
+    if p == 0:
+        if   q == 1: return ctx._hyp0f1(b_s, z, **kwargs)
+        elif q == 0: return ctx.exp(z)
+    elif p == 1:
+        if   q == 1: return ctx._hyp1f1(a_s, b_s, z, **kwargs)
+        elif q == 2: return ctx._hyp1f2(a_s, b_s, z, **kwargs)
+        elif q == 0: return ctx._hyp1f0(a_s[0][0], z)
+    elif p == 2:
+        if   q == 1: return ctx._hyp2f1(a_s, b_s, z, **kwargs)
+        elif q == 2: return ctx._hyp2f2(a_s, b_s, z, **kwargs)
+        elif q == 3: return ctx._hyp2f3(a_s, b_s, z, **kwargs)
+        elif q == 0: return ctx._hyp2f0(a_s, b_s, z, **kwargs)
+    elif p == q+1:
+        return ctx._hypq1fq(p, q, a_s, b_s, z, **kwargs)
+    elif p > q+1 and not kwargs.get('force_series'):
+        return ctx._hyp_borel(p, q, a_s, b_s, z, **kwargs)
+    coeffs, types = zip(*(a_s+b_s))
+    return ctx.hypsum(p, q, types, coeffs, z, **kwargs)
+
+@defun
+def hyp0f1(ctx,b,z,**kwargs):
+    return ctx.hyper([],[b],z,**kwargs)
+
+@defun
+def hyp1f1(ctx,a,b,z,**kwargs):
+    return ctx.hyper([a],[b],z,**kwargs)
+
+@defun
+def hyp1f2(ctx,a1,b1,b2,z,**kwargs):
+    return ctx.hyper([a1],[b1,b2],z,**kwargs)
+
+@defun
+def hyp2f1(ctx,a,b,c,z,**kwargs):
+    return ctx.hyper([a,b],[c],z,**kwargs)
+
+@defun
+def hyp2f2(ctx,a1,a2,b1,b2,z,**kwargs):
+    return ctx.hyper([a1,a2],[b1,b2],z,**kwargs)
+
+@defun
+def hyp2f3(ctx,a1,a2,b1,b2,b3,z,**kwargs):
+    return ctx.hyper([a1,a2],[b1,b2,b3],z,**kwargs)
+
+@defun
+def hyp2f0(ctx,a,b,z,**kwargs):
+    return ctx.hyper([a,b],[],z,**kwargs)
+
+@defun
+def hyp3f2(ctx,a1,a2,a3,b1,b2,z,**kwargs):
+    return ctx.hyper([a1,a2,a3],[b1,b2],z,**kwargs)
+
+@defun_wrapped
+def _hyp1f0(ctx, a, z):
+    return (1-z) ** (-a)
+
+@defun
+def _hyp0f1(ctx, b_s, z, **kwargs):
+    (b, btype), = b_s
+    if z:
+        magz = ctx.mag(z)
+    else:
+        magz = 0
+    if magz >= 8 and not kwargs.get('force_series'):
+        try:
+            # http://functions.wolfram.com/HypergeometricFunctions/
+            # Hypergeometric0F1/06/02/03/0004/
+            # TODO: handle the all-real case more efficiently!
+            # TODO: figure out how much precision is needed (exponential growth)
+            orig = ctx.prec
+            try:
+                ctx.prec += 12 + magz//2
+                def h():
+                    w = ctx.sqrt(-z)
+                    jw = ctx.j*w
+                    u = 1/(4*jw)
+                    c = ctx.mpq_1_2 - b
+                    E = ctx.exp(2*jw)
+                    T1 = ([-jw,E], [c,-1], [], [], [b-ctx.mpq_1_2, ctx.mpq_3_2-b], [], -u)
+                    T2 = ([jw,E], [c,1], [], [], [b-ctx.mpq_1_2, ctx.mpq_3_2-b], [], u)
+                    return T1, T2
+                v = ctx.hypercomb(h, [], force_series=True)
+                v = ctx.gamma(b)/(2*ctx.sqrt(ctx.pi))*v
+            finally:
+                ctx.prec = orig
+            if ctx._is_real_type(b) and ctx._is_real_type(z):
+                v = ctx._re(v)
+            return +v
+        except ctx.NoConvergence:
+            pass
+    return ctx.hypsum(0, 1, (btype,), [b], z, **kwargs)
+
+@defun
+def _hyp1f1(ctx, a_s, b_s, z, **kwargs):
+    (a, atype), = a_s
+    (b, btype), = b_s
+    if not z:
+        return ctx.one+z
+    magz = ctx.mag(z)
+    if magz >= 7 and not (ctx.isint(a) and ctx.re(a) <= 0):
+        if ctx.isinf(z):
+            if ctx.sign(a) == ctx.sign(b) == ctx.sign(z) == 1:
+                return ctx.inf
+            return ctx.nan * z
+        try:
+            try:
+                ctx.prec += magz
+                sector = ctx._im(z) < 0
+                def h(a,b):
+                    if sector:
+                        E = ctx.expjpi(ctx.fneg(a, exact=True))
+                    else:
+                        E = ctx.expjpi(a)
+                    rz = 1/z
+                    T1 = ([E,z], [1,-a], [b], [b-a], [a, 1+a-b], [], -rz)
+                    T2 = ([ctx.exp(z),z], [1,a-b], [b], [a], [b-a, 1-a], [], rz)
+                    return T1, T2
+                v = ctx.hypercomb(h, [a,b], force_series=True)
+                if ctx._is_real_type(a) and ctx._is_real_type(b) and ctx._is_real_type(z):
+                    v = ctx._re(v)
+                return +v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec -= magz
+    v = ctx.hypsum(1, 1, (atype, btype), [a, b], z, **kwargs)
+    return v
+
+def _hyp2f1_gosper(ctx,a,b,c,z,**kwargs):
+    # Use Gosper's recurrence
+    # See http://www.math.utexas.edu/pipermail/maxima/2006/000126.html
+    _a,_b,_c,_z = a, b, c, z
+    orig = ctx.prec
+    maxprec = kwargs.get('maxprec', 100*orig)
+    extra = 10
+    while 1:
+        ctx.prec = orig + extra
+        #a = ctx.convert(_a)
+        #b = ctx.convert(_b)
+        #c = ctx.convert(_c)
+        z = ctx.convert(_z)
+        d = ctx.mpf(0)
+        e = ctx.mpf(1)
+        f = ctx.mpf(0)
+        k = 0
+        # Common subexpression elimination, unfortunately making
+        # things a bit unreadable. The formula is quite messy to begin
+        # with, though...
+        abz = a*b*z
+        ch = c * ctx.mpq_1_2
+        c1h = (c+1) * ctx.mpq_1_2
+        nz = 1-z
+        g = z/nz
+        abg = a*b*g
+        cba = c-b-a
+        z2 = z-2
+        tol = -ctx.prec - 10
+        nstr = ctx.nstr
+        nprint = ctx.nprint
+        mag = ctx.mag
+        maxmag = ctx.ninf
+        while 1:
+            kch = k+ch
+            kakbz = (k+a)*(k+b)*z / (4*(k+1)*kch*(k+c1h))
+            d1 = kakbz*(e-(k+cba)*d*g)
+            e1 = kakbz*(d*abg+(k+c)*e)
+            ft = d*(k*(cba*z+k*z2-c)-abz)/(2*kch*nz)
+            f1 = f + e - ft
+            maxmag = max(maxmag, mag(f1))
+            if mag(f1-f) < tol:
+                break
+            d, e, f = d1, e1, f1
+            k += 1
+        cancellation = maxmag - mag(f1)
+        if cancellation < extra:
+            break
+        else:
+            extra += cancellation
+            if extra > maxprec:
+                raise ctx.NoConvergence
+    return f1
+
+@defun
+def _hyp2f1(ctx, a_s, b_s, z, **kwargs):
+    (a, atype), (b, btype) = a_s
+    (c, ctype), = b_s
+    if z == 1:
+        # TODO: the following logic can be simplified
+        convergent = ctx.re(c-a-b) > 0
+        finite = (ctx.isint(a) and a <= 0) or (ctx.isint(b) and b <= 0)
+        zerodiv = ctx.isint(c) and c <= 0 and not \
+            ((ctx.isint(a) and c <= a <= 0) or (ctx.isint(b) and c <= b <= 0))
+        #print "bz", a, b, c, z, convergent, finite, zerodiv
+        # Gauss's theorem gives the value if convergent
+        if (convergent or finite) and not zerodiv:
+            return ctx.gammaprod([c, c-a-b], [c-a, c-b], _infsign=True)
+        # Otherwise, there is a pole and we take the
+        # sign to be that when approaching from below
+        # XXX: this evaluation is not necessarily correct in all cases
+        return ctx.hyp2f1(a,b,c,1-ctx.eps*2) * ctx.inf
+
+    # Equal to 1 (first term), unless there is a subsequent
+    # division by zero
+    if not z:
+        # Division by zero but power of z is higher than
+        # first order so cancels
+        if c or a == 0 or b == 0:
+            return 1+z
+        # Indeterminate
+        return ctx.nan
+
+    # Hit zero denominator unless numerator goes to 0 first
+    if ctx.isint(c) and c <= 0:
+        if (ctx.isint(a) and c <= a <= 0) or \
+           (ctx.isint(b) and c <= b <= 0):
+            pass
+        else:
+            # Pole in series
+            return ctx.inf
+
+    absz = abs(z)
+
+    # Fast case: standard series converges rapidly,
+    # possibly in finitely many terms
+    if absz <= 0.8 or (ctx.isint(a) and a <= 0 and a >= -1000) or \
+                      (ctx.isint(b) and b <= 0 and b >= -1000):
+        return ctx.hypsum(2, 1, (atype, btype, ctype), [a, b, c], z, **kwargs)
+
+    orig = ctx.prec
+    try:
+        ctx.prec += 10
+
+        # Use 1/z transformation
+        if absz >= 1.3:
+            def h(a,b):
+                t = ctx.mpq_1-c; ab = a-b; rz = 1/z
+                T1 = ([-z],[-a], [c,-ab],[b,c-a], [a,t+a],[ctx.mpq_1+ab],  rz)
+                T2 = ([-z],[-b], [c,ab],[a,c-b], [b,t+b],[ctx.mpq_1-ab],  rz)
+                return T1, T2
+            v = ctx.hypercomb(h, [a,b], **kwargs)
+
+        # Use 1-z transformation
+        elif abs(1-z) <= 0.75:
+            def h(a,b):
+                t = c-a-b; ca = c-a; cb = c-b; rz = 1-z
+                T1 = [], [], [c,t], [ca,cb], [a,b], [1-t], rz
+                T2 = [rz], [t], [c,a+b-c], [a,b], [ca,cb], [1+t], rz
+                return T1, T2
+            v = ctx.hypercomb(h, [a,b], **kwargs)
+
+        # Use z/(z-1) transformation
+        elif abs(z/(z-1)) <= 0.75:
+            v = ctx.hyp2f1(a, c-b, c, z/(z-1)) / (1-z)**a
+
+        # Remaining part of unit circle
+        else:
+            v = _hyp2f1_gosper(ctx,a,b,c,z,**kwargs)
+
+    finally:
+        ctx.prec = orig
+    return +v
+
+@defun
+def _hypq1fq(ctx, p, q, a_s, b_s, z, **kwargs):
+    r"""
+    Evaluates 3F2, 4F3, 5F4, ...
+    """
+    a_s, a_types = zip(*a_s)
+    b_s, b_types = zip(*b_s)
+    a_s = list(a_s)
+    b_s = list(b_s)
+    absz = abs(z)
+    ispoly = False
+    for a in a_s:
+        if ctx.isint(a) and a <= 0:
+            ispoly = True
+            break
+    # Direct summation
+    if absz < 1 or ispoly:
+        try:
+            return ctx.hypsum(p, q, a_types+b_types, a_s+b_s, z, **kwargs)
+        except ctx.NoConvergence:
+            if absz > 1.1 or ispoly:
+                raise
+    # Use expansion at |z-1| -> 0.
+    # Reference: Wolfgang Buhring, "Generalized Hypergeometric Functions at
+    #   Unit Argument", Proc. Amer. Math. Soc., Vol. 114, No. 1 (Jan. 1992),
+    #   pp.145-153
+    # The current implementation has several problems:
+    # 1. We only implement it for 3F2. The expansion coefficients are
+    #    given by extremely messy nested sums in the higher degree cases
+    #    (see reference). Is efficient sequential generation of the coefficients
+    #    possible in the > 3F2 case?
+    # 2. Although the series converges, it may do so slowly, so we need
+    #    convergence acceleration. The acceleration implemented by
+    #    nsum does not always help, so results returned are sometimes
+    #    inaccurate! Can we do better?
+    # 3. We should check conditions for convergence, and possibly
+    #    do a better job of cancelling out gamma poles if possible.
+    if z == 1:
+        # XXX: should also check for division by zero in the
+        # denominator of the series (cf. hyp2f1)
+        S = ctx.re(sum(b_s)-sum(a_s))
+        if S <= 0:
+            #return ctx.hyper(a_s, b_s, 1-ctx.eps*2, **kwargs) * ctx.inf
+            return ctx.hyper(a_s, b_s, 0.9, **kwargs) * ctx.inf
+    if (p,q) == (3,2) and abs(z-1) < 0.05:   # and kwargs.get('sum1')
+        #print "Using alternate summation (experimental)"
+        a1,a2,a3 = a_s
+        b1,b2 = b_s
+        u = b1+b2-a3
+        initial = ctx.gammaprod([b2-a3,b1-a3,a1,a2],[b2-a3,b1-a3,1,u])
+        def term(k, _cache={0:initial}):
+            u = b1+b2-a3+k
+            if k in _cache:
+                t = _cache[k]
+            else:
+                t = _cache[k-1]
+                t *= (b1+k-a3-1)*(b2+k-a3-1)
+                t /= k*(u-1)
+                _cache[k] = t
+            return t * ctx.hyp2f1(a1,a2,u,z)
+        try:
+            S = ctx.nsum(term, [0,ctx.inf], verbose=kwargs.get('verbose'),
+                strict=kwargs.get('strict', True))
+            return S * ctx.gammaprod([b1,b2],[a1,a2,a3])
+        except ctx.NoConvergence:
+            pass
+    # Try to use convergence acceleration on and close to the unit circle.
+    # Problem: the convergence acceleration degenerates as |z-1| -> 0,
+    # except for special cases. Everywhere else, the Shanks transformation
+    # is very efficient.
+    if absz < 1.1 and ctx._re(z) <= 1:
+
+        def term(kk, _cache={0:ctx.one}):
+            k = int(kk)
+            if k != kk:
+                t = z ** ctx.mpf(kk) / ctx.fac(kk)
+                for a in a_s: t *= ctx.rf(a,kk)
+                for b in b_s: t /= ctx.rf(b,kk)
+                return t
+            if k in _cache:
+                return _cache[k]
+            t = term(k-1)
+            m = k-1
+            for j in xrange(p): t *= (a_s[j]+m)
+            for j in xrange(q): t /= (b_s[j]+m)
+            t *= z
+            t /= k
+            _cache[k] = t
+            return t
+
+        sum_method = kwargs.get('sum_method', 'r+s+e')
+
+        try:
+            return ctx.nsum(term, [0,ctx.inf], verbose=kwargs.get('verbose'),
+                strict=kwargs.get('strict', True),
+                method=sum_method.replace('e',''))
+        except ctx.NoConvergence:
+            if 'e' not in sum_method:
+                raise
+            pass
+
+        if kwargs.get('verbose'):
+            print("Attempting Euler-Maclaurin summation")
+
+
+        """
+        Somewhat slower version (one diffs_exp for each factor).
+        However, this would be faster with fast direct derivatives
+        of the gamma function.
+
+        def power_diffs(k0):
+            r = 0
+            l = ctx.log(z)
+            while 1:
+                yield z**ctx.mpf(k0) * l**r
+                r += 1
+
+        def loggamma_diffs(x, reciprocal=False):
+            sign = (-1) ** reciprocal
+            yield sign * ctx.loggamma(x)
+            i = 0
+            while 1:
+                yield sign * ctx.psi(i,x)
+                i += 1
+
+        def hyper_diffs(k0):
+            b2 = b_s + [1]
+            A = [ctx.diffs_exp(loggamma_diffs(a+k0)) for a in a_s]
+            B = [ctx.diffs_exp(loggamma_diffs(b+k0,True)) for b in b2]
+            Z = [power_diffs(k0)]
+            C = ctx.gammaprod([b for b in b2], [a for a in a_s])
+            for d in ctx.diffs_prod(A + B + Z):
+                v = C * d
+                yield v
+        """
+
+        def log_diffs(k0):
+            b2 = b_s + [1]
+            yield sum(ctx.loggamma(a+k0) for a in a_s) - \
+                sum(ctx.loggamma(b+k0) for b in b2) + k0*ctx.log(z)
+            i = 0
+            while 1:
+                v = sum(ctx.psi(i,a+k0) for a in a_s) - \
+                    sum(ctx.psi(i,b+k0) for b in b2)
+                if i == 0:
+                    v += ctx.log(z)
+                yield v
+                i += 1
+
+        def hyper_diffs(k0):
+            C = ctx.gammaprod([b for b in b_s], [a for a in a_s])
+            for d in ctx.diffs_exp(log_diffs(k0)):
+                v = C * d
+                yield v
+
+        tol = ctx.eps / 1024
+        prec = ctx.prec
+        try:
+            trunc = 50 * ctx.dps
+            ctx.prec += 20
+            for i in xrange(5):
+                head = ctx.fsum(term(k) for k in xrange(trunc))
+                tail, err = ctx.sumem(term, [trunc, ctx.inf], tol=tol,
+                    adiffs=hyper_diffs(trunc),
+                    verbose=kwargs.get('verbose'),
+                    error=True,
+                    _fast_abort=True)
+                if err < tol:
+                    v = head + tail
+                    break
+                trunc *= 2
+                # Need to increase precision because calculation of
+                # derivatives may be inaccurate
+                ctx.prec += ctx.prec//2
+                if i == 4:
+                    raise ctx.NoConvergence(\
+                        "Euler-Maclaurin summation did not converge")
+        finally:
+            ctx.prec = prec
+        return +v
+
+    # Use 1/z transformation
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #   HypergeometricPFQ/06/01/05/02/0004/
+    def h(*args):
+        a_s = list(args[:p])
+        b_s = list(args[p:])
+        Ts = []
+        recz = ctx.one/z
+        negz = ctx.fneg(z, exact=True)
+        for k in range(q+1):
+            ak = a_s[k]
+            C = [negz]
+            Cp = [-ak]
+            Gn = b_s + [ak] + [a_s[j]-ak for j in range(q+1) if j != k]
+            Gd = a_s + [b_s[j]-ak for j in range(q)]
+            Fn = [ak] + [ak-b_s[j]+1 for j in range(q)]
+            Fd = [1-a_s[j]+ak for j in range(q+1) if j != k]
+            Ts.append((C, Cp, Gn, Gd, Fn, Fd, recz))
+        return Ts
+    return ctx.hypercomb(h, a_s+b_s, **kwargs)
+
+@defun
+def _hyp_borel(ctx, p, q, a_s, b_s, z, **kwargs):
+    if a_s:
+        a_s, a_types = zip(*a_s)
+        a_s = list(a_s)
+    else:
+        a_s, a_types = [], ()
+    if b_s:
+        b_s, b_types = zip(*b_s)
+        b_s = list(b_s)
+    else:
+        b_s, b_types = [], ()
+    kwargs['maxterms'] = kwargs.get('maxterms', ctx.prec)
+    try:
+        return ctx.hypsum(p, q, a_types+b_types, a_s+b_s, z, **kwargs)
+    except ctx.NoConvergence:
+        pass
+    prec = ctx.prec
+    try:
+        tol = kwargs.get('asymp_tol', ctx.eps/4)
+        ctx.prec += 10
+        # hypsum is has a conservative tolerance. So we try again:
+        def term(k, cache={0:ctx.one}):
+            if k in cache:
+                return cache[k]
+            t = term(k-1)
+            for a in a_s: t *= (a+(k-1))
+            for b in b_s: t /= (b+(k-1))
+            t *= z
+            t /= k
+            cache[k] = t
+            return t
+        s = ctx.one
+        for k in xrange(1, ctx.prec):
+            t = term(k)
+            s += t
+            if abs(t) <= tol:
+                return s
+    finally:
+        ctx.prec = prec
+    if p <= q+3:
+        contour = kwargs.get('contour')
+        if not contour:
+            if ctx.arg(z) < 0.25:
+                u = z / max(1, abs(z))
+                if ctx.arg(z) >= 0:
+                    contour = [0, 2j, (2j+2)/u, 2/u, ctx.inf]
+                else:
+                    contour = [0, -2j, (-2j+2)/u, 2/u, ctx.inf]
+                #contour = [0, 2j/z, 2/z, ctx.inf]
+                #contour = [0, 2j, 2/z, ctx.inf]
+                #contour = [0, 2j, ctx.inf]
+            else:
+                contour = [0, ctx.inf]
+        quad_kwargs = kwargs.get('quad_kwargs', {})
+        def g(t):
+            return ctx.exp(-t)*ctx.hyper(a_s, b_s+[1], t*z)
+        I, err = ctx.quad(g, contour, error=True, **quad_kwargs)
+        if err <= abs(I)*ctx.eps*8:
+            return I
+    raise ctx.NoConvergence
+
+
+@defun
+def _hyp2f2(ctx, a_s, b_s, z, **kwargs):
+    (a1, a1type), (a2, a2type) = a_s
+    (b1, b1type), (b2, b2type) = b_s
+
+    absz = abs(z)
+    magz = ctx.mag(z)
+    orig = ctx.prec
+
+    # Asymptotic expansion is ~ exp(z)
+    asymp_extraprec = magz
+
+    # Asymptotic series is in terms of 3F1
+    can_use_asymptotic = (not kwargs.get('force_series')) and \
+        (ctx.mag(absz) > 3)
+
+    # TODO: much of the following could be shared with 2F3 instead of
+    # copypasted
+    if can_use_asymptotic:
+        #print "using asymp"
+        try:
+            try:
+                ctx.prec += asymp_extraprec
+                # http://functions.wolfram.com/HypergeometricFunctions/
+                # Hypergeometric2F2/06/02/02/0002/
+                def h(a1,a2,b1,b2):
+                    X = a1+a2-b1-b2
+                    A2 = a1+a2
+                    B2 = b1+b2
+                    c = {}
+                    c[0] = ctx.one
+                    c[1] = (A2-1)*X+b1*b2-a1*a2
+                    s1 = 0
+                    k = 0
+                    tprev = 0
+                    while 1:
+                        if k not in c:
+                            uu1 = 1-B2+2*a1+a1**2+2*a2+a2**2-A2*B2+a1*a2+b1*b2+(2*B2-3*(A2+1))*k+2*k**2
+                            uu2 = (k-A2+b1-1)*(k-A2+b2-1)*(k-X-2)
+                            c[k] = ctx.one/k * (uu1*c[k-1]-uu2*c[k-2])
+                        t1 = c[k] * z**(-k)
+                        if abs(t1) < 0.1*ctx.eps:
+                            #print "Convergence :)"
+                            break
+                        # Quit if the series doesn't converge quickly enough
+                        if k > 5 and abs(tprev) / abs(t1) < 1.5:
+                            #print "No convergence :("
+                            raise ctx.NoConvergence
+                        s1 += t1
+                        tprev = t1
+                        k += 1
+                    S = ctx.exp(z)*s1
+                    T1 = [z,S], [X,1], [b1,b2],[a1,a2],[],[],0
+                    T2 = [-z],[-a1],[b1,b2,a2-a1],[a2,b1-a1,b2-a1],[a1,a1-b1+1,a1-b2+1],[a1-a2+1],-1/z
+                    T3 = [-z],[-a2],[b1,b2,a1-a2],[a1,b1-a2,b2-a2],[a2,a2-b1+1,a2-b2+1],[-a1+a2+1],-1/z
+                    return T1, T2, T3
+                v = ctx.hypercomb(h, [a1,a2,b1,b2], force_series=True, maxterms=4*ctx.prec)
+                if sum(ctx._is_real_type(u) for u in [a1,a2,b1,b2,z]) == 5:
+                    v = ctx.re(v)
+                return v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec = orig
+
+    return ctx.hypsum(2, 2, (a1type, a2type, b1type, b2type), [a1, a2, b1, b2], z, **kwargs)
+
+
+
+@defun
+def _hyp1f2(ctx, a_s, b_s, z, **kwargs):
+    (a1, a1type), = a_s
+    (b1, b1type), (b2, b2type) = b_s
+
+    absz = abs(z)
+    magz = ctx.mag(z)
+    orig = ctx.prec
+
+    # Asymptotic expansion is ~ exp(sqrt(z))
+    asymp_extraprec = z and magz//2
+
+    # Asymptotic series is in terms of 3F0
+    can_use_asymptotic = (not kwargs.get('force_series')) and \
+        (ctx.mag(absz) > 19) and \
+        (ctx.sqrt(absz) > 1.5*orig)  # and \
+    #   ctx._hyp_check_convergence([a1, a1-b1+1, a1-b2+1], [],
+    #                              1/absz, orig+40+asymp_extraprec)
+
+    # TODO: much of the following could be shared with 2F3 instead of
+    # copypasted
+    if can_use_asymptotic:
+        #print "using asymp"
+        try:
+            try:
+                ctx.prec += asymp_extraprec
+                # http://functions.wolfram.com/HypergeometricFunctions/
+                # Hypergeometric1F2/06/02/03/
+                def h(a1,b1,b2):
+                    X = ctx.mpq_1_2*(a1-b1-b2+ctx.mpq_1_2)
+                    c = {}
+                    c[0] = ctx.one
+                    c[1] = 2*(ctx.mpq_1_4*(3*a1+b1+b2-2)*(a1-b1-b2)+b1*b2-ctx.mpq_3_16)
+                    c[2] = 2*(b1*b2+ctx.mpq_1_4*(a1-b1-b2)*(3*a1+b1+b2-2)-ctx.mpq_3_16)**2+\
+                        ctx.mpq_1_16*(-16*(2*a1-3)*b1*b2 + \
+                        4*(a1-b1-b2)*(-8*a1**2+11*a1+b1+b2-2)-3)
+                    s1 = 0
+                    s2 = 0
+                    k = 0
+                    tprev = 0
+                    while 1:
+                        if k not in c:
+                            uu1 = (3*k**2+(-6*a1+2*b1+2*b2-4)*k + 3*a1**2 - \
+                                (b1-b2)**2 - 2*a1*(b1+b2-2) + ctx.mpq_1_4)
+                            uu2 = (k-a1+b1-b2-ctx.mpq_1_2)*(k-a1-b1+b2-ctx.mpq_1_2)*\
+                                (k-a1+b1+b2-ctx.mpq_5_2)
+                            c[k] = ctx.one/(2*k)*(uu1*c[k-1]-uu2*c[k-2])
+                        w = c[k] * (-z)**(-0.5*k)
+                        t1 = (-ctx.j)**k * ctx.mpf(2)**(-k) * w
+                        t2 = ctx.j**k * ctx.mpf(2)**(-k) * w
+                        if abs(t1) < 0.1*ctx.eps:
+                            #print "Convergence :)"
+                            break
+                        # Quit if the series doesn't converge quickly enough
+                        if k > 5 and abs(tprev) / abs(t1) < 1.5:
+                            #print "No convergence :("
+                            raise ctx.NoConvergence
+                        s1 += t1
+                        s2 += t2
+                        tprev = t1
+                        k += 1
+                    S = ctx.expj(ctx.pi*X+2*ctx.sqrt(-z))*s1 + \
+                        ctx.expj(-(ctx.pi*X+2*ctx.sqrt(-z)))*s2
+                    T1 = [0.5*S, ctx.pi, -z], [1, -0.5, X], [b1, b2], [a1],\
+                        [], [], 0
+                    T2 = [-z], [-a1], [b1,b2],[b1-a1,b2-a1], \
+                        [a1,a1-b1+1,a1-b2+1], [], 1/z
+                    return T1, T2
+                v = ctx.hypercomb(h, [a1,b1,b2], force_series=True, maxterms=4*ctx.prec)
+                if sum(ctx._is_real_type(u) for u in [a1,b1,b2,z]) == 4:
+                    v = ctx.re(v)
+                return v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec = orig
+
+    #print "not using asymp"
+    return ctx.hypsum(1, 2, (a1type, b1type, b2type), [a1, b1, b2], z, **kwargs)
+
+
+
+@defun
+def _hyp2f3(ctx, a_s, b_s, z, **kwargs):
+    (a1, a1type), (a2, a2type) = a_s
+    (b1, b1type), (b2, b2type), (b3, b3type) = b_s
+
+    absz = abs(z)
+    magz = ctx.mag(z)
+
+    # Asymptotic expansion is ~ exp(sqrt(z))
+    asymp_extraprec = z and magz//2
+    orig = ctx.prec
+
+    # Asymptotic series is in terms of 4F1
+    # The square root below empirically provides a plausible criterion
+    # for the leading series to converge
+    can_use_asymptotic = (not kwargs.get('force_series')) and \
+        (ctx.mag(absz) > 19) and (ctx.sqrt(absz) > 1.5*orig)
+
+    if can_use_asymptotic:
+        #print "using asymp"
+        try:
+            try:
+                ctx.prec += asymp_extraprec
+                # http://functions.wolfram.com/HypergeometricFunctions/
+                # Hypergeometric2F3/06/02/03/01/0002/
+                def h(a1,a2,b1,b2,b3):
+                    X = ctx.mpq_1_2*(a1+a2-b1-b2-b3+ctx.mpq_1_2)
+                    A2 = a1+a2
+                    B3 = b1+b2+b3
+                    A = a1*a2
+                    B = b1*b2+b3*b2+b1*b3
+                    R = b1*b2*b3
+                    c = {}
+                    c[0] = ctx.one
+                    c[1] = 2*(B - A + ctx.mpq_1_4*(3*A2+B3-2)*(A2-B3) - ctx.mpq_3_16)
+                    c[2] = ctx.mpq_1_2*c[1]**2 + ctx.mpq_1_16*(-16*(2*A2-3)*(B-A) + 32*R +\
+                        4*(-8*A2**2 + 11*A2 + 8*A + B3 - 2)*(A2-B3)-3)
+                    s1 = 0
+                    s2 = 0
+                    k = 0
+                    tprev = 0
+                    while 1:
+                        if k not in c:
+                            uu1 = (k-2*X-3)*(k-2*X-2*b1-1)*(k-2*X-2*b2-1)*\
+                                (k-2*X-2*b3-1)
+                            uu2 = (4*(k-1)**3 - 6*(4*X+B3)*(k-1)**2 + \
+                                2*(24*X**2+12*B3*X+4*B+B3-1)*(k-1) - 32*X**3 - \
+                                24*B3*X**2 - 4*B - 8*R - 4*(4*B+B3-1)*X + 2*B3-1)
+                            uu3 = (5*(k-1)**2+2*(-10*X+A2-3*B3+3)*(k-1)+2*c[1])
+                            c[k] = ctx.one/(2*k)*(uu1*c[k-3]-uu2*c[k-2]+uu3*c[k-1])
+                        w = c[k] * ctx.power(-z, -0.5*k)
+                        t1 = (-ctx.j)**k * ctx.mpf(2)**(-k) * w
+                        t2 = ctx.j**k * ctx.mpf(2)**(-k) * w
+                        if abs(t1) < 0.1*ctx.eps:
+                            break
+                        # Quit if the series doesn't converge quickly enough
+                        if k > 5 and abs(tprev) / abs(t1) < 1.5:
+                            raise ctx.NoConvergence
+                        s1 += t1
+                        s2 += t2
+                        tprev = t1
+                        k += 1
+                    S = ctx.expj(ctx.pi*X+2*ctx.sqrt(-z))*s1 + \
+                        ctx.expj(-(ctx.pi*X+2*ctx.sqrt(-z)))*s2
+                    T1 = [0.5*S, ctx.pi, -z], [1, -0.5, X], [b1, b2, b3], [a1, a2],\
+                        [], [], 0
+                    T2 = [-z], [-a1], [b1,b2,b3,a2-a1],[a2,b1-a1,b2-a1,b3-a1], \
+                        [a1,a1-b1+1,a1-b2+1,a1-b3+1], [a1-a2+1], 1/z
+                    T3 = [-z], [-a2], [b1,b2,b3,a1-a2],[a1,b1-a2,b2-a2,b3-a2], \
+                        [a2,a2-b1+1,a2-b2+1,a2-b3+1],[-a1+a2+1], 1/z
+                    return T1, T2, T3
+                v = ctx.hypercomb(h, [a1,a2,b1,b2,b3], force_series=True, maxterms=4*ctx.prec)
+                if sum(ctx._is_real_type(u) for u in [a1,a2,b1,b2,b3,z]) == 6:
+                    v = ctx.re(v)
+                return v
+            except ctx.NoConvergence:
+                pass
+        finally:
+            ctx.prec = orig
+
+    return ctx.hypsum(2, 3, (a1type, a2type, b1type, b2type, b3type), [a1, a2, b1, b2, b3], z, **kwargs)
+
+@defun
+def _hyp2f0(ctx, a_s, b_s, z, **kwargs):
+    (a, atype), (b, btype) = a_s
+    # We want to try aggressively to use the asymptotic expansion,
+    # and fall back only when absolutely necessary
+    try:
+        kwargsb = kwargs.copy()
+        kwargsb['maxterms'] = kwargsb.get('maxterms', ctx.prec)
+        return ctx.hypsum(2, 0, (atype,btype), [a,b], z, **kwargsb)
+    except ctx.NoConvergence:
+        if kwargs.get('force_series'):
+            raise
+        pass
+    def h(a, b):
+        w = ctx.sinpi(b)
+        rz = -1/z
+        T1 = ([ctx.pi,w,rz],[1,-1,a],[],[a-b+1,b],[a],[b],rz)
+        T2 = ([-ctx.pi,w,rz],[1,-1,1+a-b],[],[a,2-b],[a-b+1],[2-b],rz)
+        return T1, T2
+    return ctx.hypercomb(h, [a, 1+a-b], **kwargs)
+
+@defun
+def meijerg(ctx, a_s, b_s, z, r=1, series=None, **kwargs):
+    an, ap = a_s
+    bm, bq = b_s
+    n = len(an)
+    p = n + len(ap)
+    m = len(bm)
+    q = m + len(bq)
+    a = an+ap
+    b = bm+bq
+    a = [ctx.convert(_) for _ in a]
+    b = [ctx.convert(_) for _ in b]
+    z = ctx.convert(z)
+    if series is None:
+        if p < q: series = 1
+        if p > q: series = 2
+        if p == q:
+            if m+n == p and abs(z) > 1:
+                series = 2
+            else:
+                series = 1
+    if kwargs.get('verbose'):
+        print("Meijer G m,n,p,q,series =", m,n,p,q,series)
+    if series == 1:
+        def h(*args):
+            a = args[:p]
+            b = args[p:]
+            terms = []
+            for k in range(m):
+                bases = [z]
+                expts = [b[k]/r]
+                gn = [b[j]-b[k] for j in range(m) if j != k]
+                gn += [1-a[j]+b[k] for j in range(n)]
+                gd = [a[j]-b[k] for j in range(n,p)]
+                gd += [1-b[j]+b[k] for j in range(m,q)]
+                hn = [1-a[j]+b[k] for j in range(p)]
+                hd = [1-b[j]+b[k] for j in range(q) if j != k]
+                hz = (-ctx.one)**(p-m-n) * z**(ctx.one/r)
+                terms.append((bases, expts, gn, gd, hn, hd, hz))
+            return terms
+    else:
+        def h(*args):
+            a = args[:p]
+            b = args[p:]
+            terms = []
+            for k in range(n):
+                bases = [z]
+                if r == 1:
+                    expts = [a[k]-1]
+                else:
+                    expts = [(a[k]-1)/ctx.convert(r)]
+                gn = [a[k]-a[j] for j in range(n) if j != k]
+                gn += [1-a[k]+b[j] for j in range(m)]
+                gd = [a[k]-b[j] for j in range(m,q)]
+                gd += [1-a[k]+a[j] for j in range(n,p)]
+                hn = [1-a[k]+b[j] for j in range(q)]
+                hd = [1+a[j]-a[k] for j in range(p) if j != k]
+                hz = (-ctx.one)**(q-m-n) / z**(ctx.one/r)
+                terms.append((bases, expts, gn, gd, hn, hd, hz))
+            return terms
+    return ctx.hypercomb(h, a+b, **kwargs)
+
+@defun_wrapped
+def appellf1(ctx,a,b1,b2,c,x,y,**kwargs):
+    # Assume x smaller
+    # We will use x for the outer loop
+    if abs(x) > abs(y):
+        x, y = y, x
+        b1, b2 = b2, b1
+    def ok(x):
+        return abs(x) < 0.99
+    # Finite cases
+    if ctx.isnpint(a):
+        pass
+    elif ctx.isnpint(b1):
+        pass
+    elif ctx.isnpint(b2):
+        x, y, b1, b2 = y, x, b2, b1
+    else:
+        #print x, y
+        # Note: ok if |y| > 1, because
+        # 2F1 implements analytic continuation
+        if not ok(x):
+            u1 = (x-y)/(x-1)
+            if not ok(u1):
+                raise ValueError("Analytic continuation not implemented")
+            #print "Using analytic continuation"
+            return (1-x)**(-b1)*(1-y)**(c-a-b2)*\
+                ctx.appellf1(c-a,b1,c-b1-b2,c,u1,y,**kwargs)
+    return ctx.hyper2d({'m+n':[a],'m':[b1],'n':[b2]}, {'m+n':[c]}, x,y, **kwargs)
+
+@defun
+def appellf2(ctx,a,b1,b2,c1,c2,x,y,**kwargs):
+    # TODO: continuation
+    return ctx.hyper2d({'m+n':[a],'m':[b1],'n':[b2]},
+        {'m':[c1],'n':[c2]}, x,y, **kwargs)
+
+@defun
+def appellf3(ctx,a1,a2,b1,b2,c,x,y,**kwargs):
+    outer_polynomial = ctx.isnpint(a1) or ctx.isnpint(b1)
+    inner_polynomial = ctx.isnpint(a2) or ctx.isnpint(b2)
+    if not outer_polynomial:
+        if inner_polynomial or abs(x) > abs(y):
+            x, y = y, x
+            a1,a2,b1,b2 = a2,a1,b2,b1
+    return ctx.hyper2d({'m':[a1,b1],'n':[a2,b2]}, {'m+n':[c]},x,y,**kwargs)
+
+@defun
+def appellf4(ctx,a,b,c1,c2,x,y,**kwargs):
+    # TODO: continuation
+    return ctx.hyper2d({'m+n':[a,b]}, {'m':[c1],'n':[c2]},x,y,**kwargs)
+
+@defun
+def hyper2d(ctx, a, b, x, y, **kwargs):
+    r"""
+    Sums the generalized 2D hypergeometric series
+
+    .. math ::
+
+        \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+            \frac{P((a),m,n)}{Q((b),m,n)}
+            \frac{x^m y^n} {m! n!}
+
+    where `(a) = (a_1,\ldots,a_r)`, `(b) = (b_1,\ldots,b_s)` and where
+    `P` and `Q` are products of rising factorials such as `(a_j)_n` or
+    `(a_j)_{m+n}`. `P` and `Q` are specified in the form of dicts, with
+    the `m` and `n` dependence as keys and parameter lists as values.
+    The supported rising factorials are given in the following table
+    (note that only a few are supported in `Q`):
+
+    +------------+-------------------+--------+
+    | Key        |  Rising factorial | `Q`    |
+    +============+===================+========+
+    | ``'m'``    |   `(a_j)_m`       | Yes    |
+    +------------+-------------------+--------+
+    | ``'n'``    |   `(a_j)_n`       | Yes    |
+    +------------+-------------------+--------+
+    | ``'m+n'``  |   `(a_j)_{m+n}`   | Yes    |
+    +------------+-------------------+--------+
+    | ``'m-n'``  |   `(a_j)_{m-n}`   | No     |
+    +------------+-------------------+--------+
+    | ``'n-m'``  |   `(a_j)_{n-m}`   | No     |
+    +------------+-------------------+--------+
+    | ``'2m+n'`` |   `(a_j)_{2m+n}`  | No     |
+    +------------+-------------------+--------+
+    | ``'2m-n'`` |   `(a_j)_{2m-n}`  | No     |
+    +------------+-------------------+--------+
+    | ``'2n-m'`` |   `(a_j)_{2n-m}`  | No     |
+    +------------+-------------------+--------+
+
+    For example, the Appell F1 and F4 functions
+
+    .. math ::
+
+        F_1 = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+              \frac{(a)_{m+n} (b)_m (c)_n}{(d)_{m+n}}
+              \frac{x^m y^n}{m! n!}
+
+        F_4 = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+              \frac{(a)_{m+n} (b)_{m+n}}{(c)_m (d)_{n}}
+              \frac{x^m y^n}{m! n!}
+
+    can be represented respectively as
+
+        ``hyper2d({'m+n':[a], 'm':[b], 'n':[c]}, {'m+n':[d]}, x, y)``
+
+        ``hyper2d({'m+n':[a,b]}, {'m':[c], 'n':[d]}, x, y)``
+
+    More generally, :func:`~mpmath.hyper2d` can evaluate any of the 34 distinct
+    convergent second-order (generalized Gaussian) hypergeometric
+    series enumerated by Horn, as well as the Kampe de Feriet
+    function.
+
+    The series is computed by rewriting it so that the inner
+    series (i.e. the series containing `n` and `y`) has the form of an
+    ordinary generalized hypergeometric series and thereby can be
+    evaluated efficiently using :func:`~mpmath.hyper`. If possible,
+    manually swapping `x` and `y` and the corresponding parameters
+    can sometimes give better results.
+
+    **Examples**
+
+    Two separable cases: a product of two geometric series, and a
+    product of two Gaussian hypergeometric functions::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> x, y = mpf(0.25), mpf(0.5)
+        >>> hyper2d({'m':1,'n':1}, {}, x,y)
+        2.666666666666666666666667
+        >>> 1/(1-x)/(1-y)
+        2.666666666666666666666667
+        >>> hyper2d({'m':[1,2],'n':[3,4]}, {'m':[5],'n':[6]}, x,y)
+        4.164358531238938319669856
+        >>> hyp2f1(1,2,5,x)*hyp2f1(3,4,6,y)
+        4.164358531238938319669856
+
+    Some more series that can be done in closed form::
+
+        >>> hyper2d({'m':1,'n':1},{'m+n':1},x,y)
+        2.013417124712514809623881
+        >>> (exp(x)*x-exp(y)*y)/(x-y)
+        2.013417124712514809623881
+
+    Six of the 34 Horn functions, G1-G3 and H1-H3::
+
+        >>> from mpmath import *
+        >>> mp.dps = 10; mp.pretty = True
+        >>> x, y = 0.0625, 0.125
+        >>> a1,a2,b1,b2,c1,c2,d = 1.1,-1.2,-1.3,-1.4,1.5,-1.6,1.7
+        >>> hyper2d({'m+n':a1,'n-m':b1,'m-n':b2},{},x,y)  # G1
+        1.139090746
+        >>> nsum(lambda m,n: rf(a1,m+n)*rf(b1,n-m)*rf(b2,m-n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        1.139090746
+        >>> hyper2d({'m':a1,'n':a2,'n-m':b1,'m-n':b2},{},x,y)  # G2
+        0.9503682696
+        >>> nsum(lambda m,n: rf(a1,m)*rf(a2,n)*rf(b1,n-m)*rf(b2,m-n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        0.9503682696
+        >>> hyper2d({'2n-m':a1,'2m-n':a2},{},x,y)  # G3
+        1.029372029
+        >>> nsum(lambda m,n: rf(a1,2*n-m)*rf(a2,2*m-n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        1.029372029
+        >>> hyper2d({'m-n':a1,'m+n':b1,'n':c1},{'m':d},x,y)  # H1
+        -1.605331256
+        >>> nsum(lambda m,n: rf(a1,m-n)*rf(b1,m+n)*rf(c1,n)/rf(d,m)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        -1.605331256
+        >>> hyper2d({'m-n':a1,'m':b1,'n':[c1,c2]},{'m':d},x,y)  # H2
+        -2.35405404
+        >>> nsum(lambda m,n: rf(a1,m-n)*rf(b1,m)*rf(c1,n)*rf(c2,n)/rf(d,m)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        -2.35405404
+        >>> hyper2d({'2m+n':a1,'n':b1},{'m+n':c1},x,y)  # H3
+        0.974479074
+        >>> nsum(lambda m,n: rf(a1,2*m+n)*rf(b1,n)/rf(c1,m+n)*\
+        ...     x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
+        0.974479074
+
+    **References**
+
+    1. [SrivastavaKarlsson]_
+    2. [Weisstein]_ http://mathworld.wolfram.com/HornFunction.html
+    3. [Weisstein]_ http://mathworld.wolfram.com/AppellHypergeometricFunction.html
+
+    """
+    x = ctx.convert(x)
+    y = ctx.convert(y)
+    def parse(dct, key):
+        args = dct.pop(key, [])
+        try:
+            args = list(args)
+        except TypeError:
+            args = [args]
+        return [ctx.convert(arg) for arg in args]
+    a_s = dict(a)
+    b_s = dict(b)
+    a_m = parse(a, 'm')
+    a_n = parse(a, 'n')
+    a_m_add_n = parse(a, 'm+n')
+    a_m_sub_n = parse(a, 'm-n')
+    a_n_sub_m = parse(a, 'n-m')
+    a_2m_add_n = parse(a, '2m+n')
+    a_2m_sub_n = parse(a, '2m-n')
+    a_2n_sub_m = parse(a, '2n-m')
+    b_m = parse(b, 'm')
+    b_n = parse(b, 'n')
+    b_m_add_n = parse(b, 'm+n')
+    if a: raise ValueError("unsupported key: %r" % a.keys()[0])
+    if b: raise ValueError("unsupported key: %r" % b.keys()[0])
+    s = 0
+    outer = ctx.one
+    m = ctx.mpf(0)
+    ok_count = 0
+    prec = ctx.prec
+    maxterms = kwargs.get('maxterms', 20*prec)
+    try:
+        ctx.prec += 10
+        tol = +ctx.eps
+        while 1:
+            inner_sign = 1
+            outer_sign = 1
+            inner_a = list(a_n)
+            inner_b = list(b_n)
+            outer_a = [a+m for a in a_m]
+            outer_b = [b+m for b in b_m]
+            # (a)_{m+n} = (a)_m (a+m)_n
+            for a in a_m_add_n:
+                a = a+m
+                inner_a.append(a)
+                outer_a.append(a)
+            # (b)_{m+n} = (b)_m (b+m)_n
+            for b in b_m_add_n:
+                b = b+m
+                inner_b.append(b)
+                outer_b.append(b)
+            # (a)_{n-m} = (a-m)_n / (a-m)_m
+            for a in a_n_sub_m:
+                inner_a.append(a-m)
+                outer_b.append(a-m-1)
+            # (a)_{m-n} = (-1)^(m+n) (1-a-m)_m / (1-a-m)_n
+            for a in a_m_sub_n:
+                inner_sign *= (-1)
+                outer_sign *= (-1)**(m)
+                inner_b.append(1-a-m)
+                outer_a.append(-a-m)
+            # (a)_{2m+n} = (a)_{2m} (a+2m)_n
+            for a in a_2m_add_n:
+                inner_a.append(a+2*m)
+                outer_a.append((a+2*m)*(1+a+2*m))
+            # (a)_{2m-n} = (-1)^(2m+n) (1-a-2m)_{2m} / (1-a-2m)_n
+            for a in a_2m_sub_n:
+                inner_sign *= (-1)
+                inner_b.append(1-a-2*m)
+                outer_a.append((a+2*m)*(1+a+2*m))
+            # (a)_{2n-m} = 4^n ((a-m)/2)_n ((a-m+1)/2)_n / (a-m)_m
+            for a in a_2n_sub_m:
+                inner_sign *= 4
+                inner_a.append(0.5*(a-m))
+                inner_a.append(0.5*(a-m+1))
+                outer_b.append(a-m-1)
+            inner = ctx.hyper(inner_a, inner_b, inner_sign*y,
+                zeroprec=ctx.prec, **kwargs)
+            term = outer * inner * outer_sign
+            if abs(term) < tol:
+                ok_count += 1
+            else:
+                ok_count = 0
+            if ok_count >= 3 or not outer:
+                break
+            s += term
+            for a in outer_a: outer *= a
+            for b in outer_b: outer /= b
+            m += 1
+            outer = outer * x / m
+            if m > maxterms:
+                raise ctx.NoConvergence("maxterms exceeded in hyper2d")
+    finally:
+        ctx.prec = prec
+    return +s
+
+"""
+@defun
+def kampe_de_feriet(ctx,a,b,c,d,e,f,x,y,**kwargs):
+    return ctx.hyper2d({'m+n':a,'m':b,'n':c},
+        {'m+n':d,'m':e,'n':f}, x,y, **kwargs)
+"""
+
+@defun
+def bihyper(ctx, a_s, b_s, z, **kwargs):
+    r"""
+    Evaluates the bilateral hypergeometric series
+
+    .. math ::
+
+        \,_AH_B(a_1, \ldots, a_k; b_1, \ldots, b_B; z) =
+            \sum_{n=-\infty}^{\infty}
+            \frac{(a_1)_n \ldots (a_A)_n}
+                 {(b_1)_n \ldots (b_B)_n} \, z^n
+
+    where, for direct convergence, `A = B` and `|z| = 1`, although a
+    regularized sum exists more generally by considering the
+    bilateral series as a sum of two ordinary hypergeometric
+    functions. In order for the series to make sense, none of the
+    parameters may be integers.
+
+    **Examples**
+
+    The value of `\,_2H_2` at `z = 1` is given by Dougall's formula::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a,b,c,d = 0.5, 1.5, 2.25, 3.25
+        >>> bihyper([a,b],[c,d],1)
+        -14.49118026212345786148847
+        >>> gammaprod([c,d,1-a,1-b,c+d-a-b-1],[c-a,d-a,c-b,d-b])
+        -14.49118026212345786148847
+
+    The regularized function `\,_1H_0` can be expressed as the
+    sum of one `\,_2F_0` function and one `\,_1F_1` function::
+
+        >>> a = mpf(0.25)
+        >>> z = mpf(0.75)
+        >>> bihyper([a], [], z)
+        (0.2454393389657273841385582 + 0.2454393389657273841385582j)
+        >>> hyper([a,1],[],z) + (hyper([1],[1-a],-1/z)-1)
+        (0.2454393389657273841385582 + 0.2454393389657273841385582j)
+        >>> hyper([a,1],[],z) + hyper([1],[2-a],-1/z)/z/(a-1)
+        (0.2454393389657273841385582 + 0.2454393389657273841385582j)
+
+    **References**
+
+    1. [Slater]_ (chapter 6: "Bilateral Series", pp. 180-189)
+    2. [Wikipedia]_ http://en.wikipedia.org/wiki/Bilateral_hypergeometric_series
+
+    """
+    z = ctx.convert(z)
+    c_s = a_s + b_s
+    p = len(a_s)
+    q = len(b_s)
+    if (p, q) == (0,0) or (p, q) == (1,1):
+        return ctx.zero * z
+    neg = (p-q) % 2
+    def h(*c_s):
+        a_s = list(c_s[:p])
+        b_s = list(c_s[p:])
+        aa_s = [2-b for b in b_s]
+        bb_s = [2-a for a in a_s]
+        rp = [(-1)**neg * z] + [1-b for b in b_s] + [1-a for a in a_s]
+        rc = [-1] + [1]*len(b_s) + [-1]*len(a_s)
+        T1 = [], [], [], [], a_s + [1], b_s, z
+        T2 = rp, rc, [], [], aa_s + [1], bb_s, (-1)**neg / z
+        return T1, T2
+    return ctx.hypercomb(h, c_s, **kwargs)
diff --git a/lib/python3.11/site-packages/mpmath/functions/orthogonal.py b/lib/python3.11/site-packages/mpmath/functions/orthogonal.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa33d8bd78290f55a970e78dab7a317d5f652dee
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/orthogonal.py
@@ -0,0 +1,493 @@
+from .functions import defun, defun_wrapped
+
+def _hermite_param(ctx, n, z, parabolic_cylinder):
+    """
+    Combined calculation of the Hermite polynomial H_n(z) (and its
+    generalization to complex n) and the parabolic cylinder
+    function D.
+    """
+    n, ntyp = ctx._convert_param(n)
+    z = ctx.convert(z)
+    q = -ctx.mpq_1_2
+    # For re(z) > 0, 2F0 -- http://functions.wolfram.com/
+    #     HypergeometricFunctions/HermiteHGeneral/06/02/0009/
+    # Otherwise, there is a reflection formula
+    # 2F0 + http://functions.wolfram.com/HypergeometricFunctions/
+    #           HermiteHGeneral/16/01/01/0006/
+    #
+    # TODO:
+    # An alternative would be to use
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #     HermiteHGeneral/06/02/0006/
+    #
+    # Also, the 1F1 expansion
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #     HermiteHGeneral/26/01/02/0001/
+    # should probably be used for tiny z
+    if not z:
+        T1 = [2, ctx.pi], [n, 0.5], [], [q*(n-1)], [], [], 0
+        if parabolic_cylinder:
+            T1[1][0] += q*n
+        return T1,
+    can_use_2f0 = ctx.isnpint(-n) or ctx.re(z) > 0 or \
+        (ctx.re(z) == 0 and ctx.im(z) > 0)
+    expprec = ctx.prec*4 + 20
+    if parabolic_cylinder:
+        u = ctx.fmul(ctx.fmul(z,z,prec=expprec), -0.25, exact=True)
+        w = ctx.fmul(z, ctx.sqrt(0.5,prec=expprec), prec=expprec)
+    else:
+        w = z
+    w2 = ctx.fmul(w, w, prec=expprec)
+    rw2 = ctx.fdiv(1, w2, prec=expprec)
+    nrw2 = ctx.fneg(rw2, exact=True)
+    nw = ctx.fneg(w, exact=True)
+    if can_use_2f0:
+        T1 = [2, w], [n, n], [], [], [q*n, q*(n-1)], [], nrw2
+        terms = [T1]
+    else:
+        T1 = [2, nw], [n, n], [], [], [q*n, q*(n-1)], [], nrw2
+        T2 = [2, ctx.pi, nw], [n+2, 0.5, 1], [], [q*n], [q*(n-1)], [1-q], w2
+        terms = [T1,T2]
+    # Multiply by prefactor for D_n
+    if parabolic_cylinder:
+        expu = ctx.exp(u)
+        for i in range(len(terms)):
+            terms[i][1][0] += q*n
+            terms[i][0].append(expu)
+            terms[i][1].append(1)
+    return tuple(terms)
+
+@defun
+def hermite(ctx, n, z, **kwargs):
+    return ctx.hypercomb(lambda: _hermite_param(ctx, n, z, 0), [], **kwargs)
+
+@defun
+def pcfd(ctx, n, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function in Whittaker's notation
+    `D_n(z) = U(-n-1/2, z)` (see :func:`~mpmath.pcfu`).
+    It solves the differential equation
+
+    .. math ::
+
+        y'' + \left(n + \frac{1}{2} - \frac{1}{4} z^2\right) y = 0.
+
+    and can be represented in terms of Hermite polynomials
+    (see :func:`~mpmath.hermite`) as
+
+    .. math ::
+
+        D_n(z) = 2^{-n/2} e^{-z^2/4} H_n\left(\frac{z}{\sqrt{2}}\right).
+
+    **Plots**
+
+    .. literalinclude :: /plots/pcfd.py
+    .. image :: /plots/pcfd.png
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> pcfd(0,0); pcfd(1,0); pcfd(2,0); pcfd(3,0)
+        1.0
+        0.0
+        -1.0
+        0.0
+        >>> pcfd(4,0); pcfd(-3,0)
+        3.0
+        0.6266570686577501256039413
+        >>> pcfd('1/2', 2+3j)
+        (-5.363331161232920734849056 - 3.858877821790010714163487j)
+        >>> pcfd(2, -10)
+        1.374906442631438038871515e-9
+
+    Verifying the differential equation::
+
+        >>> n = mpf(2.5)
+        >>> y = lambda z: pcfd(n,z)
+        >>> z = 1.75
+        >>> chop(diff(y,z,2) + (n+0.5-0.25*z**2)*y(z))
+        0.0
+
+    Rational Taylor series expansion when `n` is an integer::
+
+        >>> taylor(lambda z: pcfd(5,z), 0, 7)
+        [0.0, 15.0, 0.0, -13.75, 0.0, 3.96875, 0.0, -0.6015625]
+
+    """
+    return ctx.hypercomb(lambda: _hermite_param(ctx, n, z, 1), [], **kwargs)
+
+@defun
+def pcfu(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `U(a,z)`, which may be
+    defined for `\Re(z) > 0` in terms of the confluent
+    U-function (see :func:`~mpmath.hyperu`) by
+
+    .. math ::
+
+        U(a,z) = 2^{-\frac{1}{4}-\frac{a}{2}} e^{-\frac{1}{4} z^2}
+            U\left(\frac{a}{2}+\frac{1}{4},
+            \frac{1}{2}, \frac{1}{2}z^2\right)
+
+    or, for arbitrary `z`,
+
+    .. math ::
+
+        e^{-\frac{1}{4}z^2} U(a,z) =
+            U(a,0) \,_1F_1\left(-\tfrac{a}{2}+\tfrac{1}{4};
+            \tfrac{1}{2}; -\tfrac{1}{2}z^2\right) +
+            U'(a,0) z \,_1F_1\left(-\tfrac{a}{2}+\tfrac{3}{4};
+            \tfrac{3}{2}; -\tfrac{1}{2}z^2\right).
+
+    **Examples**
+
+    Connection to other functions::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> z = mpf(3)
+        >>> pcfu(0.5,z)
+        0.03210358129311151450551963
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(z/sqrt(2))
+        0.03210358129311151450551963
+        >>> pcfu(0.5,-z)
+        23.75012332835297233711255
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(-z/sqrt(2))
+        23.75012332835297233711255
+        >>> pcfu(0.5,-z)
+        23.75012332835297233711255
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(-z/sqrt(2))
+        23.75012332835297233711255
+
+    """
+    n, _ = ctx._convert_param(a)
+    return ctx.pcfd(-n-ctx.mpq_1_2, z)
+
+@defun
+def pcfv(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `V(a,z)`, which can be
+    represented in terms of :func:`~mpmath.pcfu` as
+
+    .. math ::
+
+        V(a,z) = \frac{\Gamma(a+\tfrac{1}{2}) (U(a,-z)-\sin(\pi a) U(a,z)}{\pi}.
+
+    **Examples**
+
+    Wronskian relation between `U` and `V`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a, z = 2, 3
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> sqrt(2/pi)
+        0.7978845608028653558798921
+        >>> a, z = 2.5, 3
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> a, z = 0.25, -1
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> a, z = 2+1j, 2+3j
+        >>> chop(pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z))
+        0.7978845608028653558798921
+
+    """
+    n, ntype = ctx._convert_param(a)
+    z = ctx.convert(z)
+    q = ctx.mpq_1_2
+    r = ctx.mpq_1_4
+    if ntype == 'Q' and ctx.isint(n*2):
+        # Faster for half-integers
+        def h():
+            jz = ctx.fmul(z, -1j, exact=True)
+            T1terms = _hermite_param(ctx, -n-q, z, 1)
+            T2terms = _hermite_param(ctx, n-q, jz, 1)
+            for T in T1terms:
+                T[0].append(1j)
+                T[1].append(1)
+                T[3].append(q-n)
+            u = ctx.expjpi((q*n-r)) * ctx.sqrt(2/ctx.pi)
+            for T in T2terms:
+                T[0].append(u)
+                T[1].append(1)
+            return T1terms + T2terms
+        v = ctx.hypercomb(h, [], **kwargs)
+        if ctx._is_real_type(n) and ctx._is_real_type(z):
+            v = ctx._re(v)
+        return v
+    else:
+        def h(n):
+            w = ctx.square_exp_arg(z, -0.25)
+            u = ctx.square_exp_arg(z, 0.5)
+            e = ctx.exp(w)
+            l = [ctx.pi, q, ctx.exp(w)]
+            Y1 = l, [-q, n*q+r, 1], [r-q*n], [], [q*n+r], [q], u
+            Y2 = l + [z], [-q, n*q-r, 1, 1], [1-r-q*n], [], [q*n+1-r], [1+q], u
+            c, s = ctx.cospi_sinpi(r+q*n)
+            Y1[0].append(s)
+            Y2[0].append(c)
+            for Y in (Y1, Y2):
+                Y[1].append(1)
+                Y[3].append(q-n)
+            return Y1, Y2
+        return ctx.hypercomb(h, [n], **kwargs)
+
+
+@defun
+def pcfw(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `W(a,z)` defined in (DLMF 12.14).
+
+    **Examples**
+
+    Value at the origin::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a = mpf(0.25)
+        >>> pcfw(a,0)
+        0.9722833245718180765617104
+        >>> power(2,-0.75)*sqrt(abs(gamma(0.25+0.5j*a)/gamma(0.75+0.5j*a)))
+        0.9722833245718180765617104
+        >>> diff(pcfw,(a,0),(0,1))
+        -0.5142533944210078966003624
+        >>> -power(2,-0.25)*sqrt(abs(gamma(0.75+0.5j*a)/gamma(0.25+0.5j*a)))
+        -0.5142533944210078966003624
+
+    """
+    n, _ = ctx._convert_param(a)
+    z = ctx.convert(z)
+    def terms():
+        phi2 = ctx.arg(ctx.gamma(0.5 + ctx.j*n))
+        phi2 = (ctx.loggamma(0.5+ctx.j*n) - ctx.loggamma(0.5-ctx.j*n))/2j
+        rho = ctx.pi/8 + 0.5*phi2
+        # XXX: cancellation computing k
+        k = ctx.sqrt(1 + ctx.exp(2*ctx.pi*n)) - ctx.exp(ctx.pi*n)
+        C = ctx.sqrt(k/2) * ctx.exp(0.25*ctx.pi*n)
+        yield C * ctx.expj(rho) * ctx.pcfu(ctx.j*n, z*ctx.expjpi(-0.25))
+        yield C * ctx.expj(-rho) * ctx.pcfu(-ctx.j*n, z*ctx.expjpi(0.25))
+    v = ctx.sum_accurately(terms)
+    if ctx._is_real_type(n) and ctx._is_real_type(z):
+        v = ctx._re(v)
+    return v
+
+"""
+Even/odd PCFs. Useful?
+
+@defun
+def pcfy1(ctx, a, z, **kwargs):
+    a, _ = ctx._convert_param(n)
+    z = ctx.convert(z)
+    def h():
+        w = ctx.square_exp_arg(z)
+        w1 = ctx.fmul(w, -0.25, exact=True)
+        w2 = ctx.fmul(w, 0.5, exact=True)
+        e = ctx.exp(w1)
+        return [e], [1], [], [], [ctx.mpq_1_2*a+ctx.mpq_1_4], [ctx.mpq_1_2], w2
+    return ctx.hypercomb(h, [], **kwargs)
+
+@defun
+def pcfy2(ctx, a, z, **kwargs):
+    a, _ = ctx._convert_param(n)
+    z = ctx.convert(z)
+    def h():
+        w = ctx.square_exp_arg(z)
+        w1 = ctx.fmul(w, -0.25, exact=True)
+        w2 = ctx.fmul(w, 0.5, exact=True)
+        e = ctx.exp(w1)
+        return [e, z], [1, 1], [], [], [ctx.mpq_1_2*a+ctx.mpq_3_4], \
+            [ctx.mpq_3_2], w2
+    return ctx.hypercomb(h, [], **kwargs)
+"""
+
+@defun_wrapped
+def gegenbauer(ctx, n, a, z, **kwargs):
+    # Special cases: a+0.5, a*2 poles
+    if ctx.isnpint(a):
+        return 0*(z+n)
+    if ctx.isnpint(a+0.5):
+        # TODO: something else is required here
+        # E.g.: gegenbauer(-2, -0.5, 3) == -12
+        if ctx.isnpint(n+1):
+            raise NotImplementedError("Gegenbauer function with two limits")
+        def h(a):
+            a2 = 2*a
+            T = [], [], [n+a2], [n+1, a2], [-n, n+a2], [a+0.5], 0.5*(1-z)
+            return [T]
+        return ctx.hypercomb(h, [a], **kwargs)
+    def h(n):
+        a2 = 2*a
+        T = [], [], [n+a2], [n+1, a2], [-n, n+a2], [a+0.5], 0.5*(1-z)
+        return [T]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun_wrapped
+def jacobi(ctx, n, a, b, x, **kwargs):
+    if not ctx.isnpint(a):
+        def h(n):
+            return (([], [], [a+n+1], [n+1, a+1], [-n, a+b+n+1], [a+1], (1-x)*0.5),)
+        return ctx.hypercomb(h, [n], **kwargs)
+    if not ctx.isint(b):
+        def h(n, a):
+            return (([], [], [-b], [n+1, -b-n], [-n, a+b+n+1], [b+1], (x+1)*0.5),)
+        return ctx.hypercomb(h, [n, a], **kwargs)
+    # XXX: determine appropriate limit
+    return ctx.binomial(n+a,n) * ctx.hyp2f1(-n,1+n+a+b,a+1,(1-x)/2, **kwargs)
+
+@defun_wrapped
+def laguerre(ctx, n, a, z, **kwargs):
+    # XXX: limits, poles
+    #if ctx.isnpint(n):
+    #    return 0*(a+z)
+    def h(a):
+        return (([], [], [a+n+1], [a+1, n+1], [-n], [a+1], z),)
+    return ctx.hypercomb(h, [a], **kwargs)
+
+@defun_wrapped
+def legendre(ctx, n, x, **kwargs):
+    if ctx.isint(n):
+        n = int(n)
+        # Accuracy near zeros
+        if (n + (n < 0)) & 1:
+            if not x:
+                return x
+            mag = ctx.mag(x)
+            if mag < -2*ctx.prec-10:
+                return x
+            if mag < -5:
+                ctx.prec += -mag
+    return ctx.hyp2f1(-n,n+1,1,(1-x)/2, **kwargs)
+
+@defun
+def legenp(ctx, n, m, z, type=2, **kwargs):
+    # Legendre function, 1st kind
+    n = ctx.convert(n)
+    m = ctx.convert(m)
+    # Faster
+    if not m:
+        return ctx.legendre(n, z, **kwargs)
+    # TODO: correct evaluation at singularities
+    if type == 2:
+        def h(n,m):
+            g = m*0.5
+            T = [1+z, 1-z], [g, -g], [], [1-m], [-n, n+1], [1-m], 0.5*(1-z)
+            return (T,)
+        return ctx.hypercomb(h, [n,m], **kwargs)
+    if type == 3:
+        def h(n,m):
+            g = m*0.5
+            T = [z+1, z-1], [g, -g], [], [1-m], [-n, n+1], [1-m], 0.5*(1-z)
+            return (T,)
+        return ctx.hypercomb(h, [n,m], **kwargs)
+    raise ValueError("requires type=2 or type=3")
+
+@defun
+def legenq(ctx, n, m, z, type=2, **kwargs):
+    # Legendre function, 2nd kind
+    n = ctx.convert(n)
+    m = ctx.convert(m)
+    z = ctx.convert(z)
+    if z in (1, -1):
+        #if ctx.isint(m):
+        #    return ctx.nan
+        #return ctx.inf  # unsigned
+        return ctx.nan
+    if type == 2:
+        def h(n, m):
+            cos, sin = ctx.cospi_sinpi(m)
+            s = 2 * sin / ctx.pi
+            c = cos
+            a = 1+z
+            b = 1-z
+            u = m/2
+            w = (1-z)/2
+            T1 = [s, c, a, b], [-1, 1, u, -u], [], [1-m], \
+                [-n, n+1], [1-m], w
+            T2 = [-s, a, b], [-1, -u, u], [n+m+1], [n-m+1, m+1], \
+                [-n, n+1], [m+1], w
+            return T1, T2
+        return ctx.hypercomb(h, [n, m], **kwargs)
+    if type == 3:
+        # The following is faster when there only is a single series
+        # Note: not valid for -1 < z < 0 (?)
+        if abs(z) > 1:
+            def h(n, m):
+                T1 = [ctx.expjpi(m), 2, ctx.pi, z, z-1, z+1], \
+                     [1, -n-1, 0.5, -n-m-1, 0.5*m, 0.5*m], \
+                     [n+m+1], [n+1.5], \
+                     [0.5*(2+n+m), 0.5*(1+n+m)], [n+1.5], z**(-2)
+                return [T1]
+            return ctx.hypercomb(h, [n, m], **kwargs)
+        else:
+            # not valid for 1 < z < inf ?
+            def h(n, m):
+                s = 2 * ctx.sinpi(m) / ctx.pi
+                c = ctx.expjpi(m)
+                a = 1+z
+                b = z-1
+                u = m/2
+                w = (1-z)/2
+                T1 = [s, c, a, b], [-1, 1, u, -u], [], [1-m], \
+                    [-n, n+1], [1-m], w
+                T2 = [-s, c, a, b], [-1, 1, -u, u], [n+m+1], [n-m+1, m+1], \
+                    [-n, n+1], [m+1], w
+                return T1, T2
+            return ctx.hypercomb(h, [n, m], **kwargs)
+    raise ValueError("requires type=2 or type=3")
+
+@defun_wrapped
+def chebyt(ctx, n, x, **kwargs):
+    if (not x) and ctx.isint(n) and int(ctx._re(n)) % 2 == 1:
+        return x * 0
+    return ctx.hyp2f1(-n,n,(1,2),(1-x)/2, **kwargs)
+
+@defun_wrapped
+def chebyu(ctx, n, x, **kwargs):
+    if (not x) and ctx.isint(n) and int(ctx._re(n)) % 2 == 1:
+        return x * 0
+    return (n+1) * ctx.hyp2f1(-n, n+2, (3,2), (1-x)/2, **kwargs)
+
+@defun
+def spherharm(ctx, l, m, theta, phi, **kwargs):
+    l = ctx.convert(l)
+    m = ctx.convert(m)
+    theta = ctx.convert(theta)
+    phi = ctx.convert(phi)
+    l_isint = ctx.isint(l)
+    l_natural = l_isint and l >= 0
+    m_isint = ctx.isint(m)
+    if l_isint and l < 0 and m_isint:
+        return ctx.spherharm(-(l+1), m, theta, phi, **kwargs)
+    if theta == 0 and m_isint and m < 0:
+        return ctx.zero * 1j
+    if l_natural and m_isint:
+        if abs(m) > l:
+            return ctx.zero * 1j
+        # http://functions.wolfram.com/Polynomials/
+        #     SphericalHarmonicY/26/01/02/0004/
+        def h(l,m):
+            absm = abs(m)
+            C = [-1, ctx.expj(m*phi),
+                 (2*l+1)*ctx.fac(l+absm)/ctx.pi/ctx.fac(l-absm),
+                 ctx.sin(theta)**2,
+                 ctx.fac(absm), 2]
+            P = [0.5*m*(ctx.sign(m)+1), 1, 0.5, 0.5*absm, -1, -absm-1]
+            return ((C, P, [], [], [absm-l, l+absm+1], [absm+1],
+                ctx.sin(0.5*theta)**2),)
+    else:
+        # http://functions.wolfram.com/HypergeometricFunctions/
+        #     SphericalHarmonicYGeneral/26/01/02/0001/
+        def h(l,m):
+            if ctx.isnpint(l-m+1) or ctx.isnpint(l+m+1) or ctx.isnpint(1-m):
+                return (([0], [-1], [], [], [], [], 0),)
+            cos, sin = ctx.cos_sin(0.5*theta)
+            C = [0.5*ctx.expj(m*phi), (2*l+1)/ctx.pi,
+                 ctx.gamma(l-m+1), ctx.gamma(l+m+1),
+                 cos**2, sin**2]
+            P = [1, 0.5, 0.5, -0.5, 0.5*m, -0.5*m]
+            return ((C, P, [], [1-m], [-l,l+1], [1-m], sin**2),)
+    return ctx.hypercomb(h, [l,m], **kwargs)
diff --git a/lib/python3.11/site-packages/mpmath/functions/qfunctions.py b/lib/python3.11/site-packages/mpmath/functions/qfunctions.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a20e53a8b6fa0d8fbc9ad098614d2694998f49a
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/qfunctions.py
@@ -0,0 +1,280 @@
+from .functions import defun, defun_wrapped
+
+@defun
+def qp(ctx, a, q=None, n=None, **kwargs):
+    r"""
+    Evaluates the q-Pochhammer symbol (or q-rising factorial)
+
+    .. math ::
+
+        (a; q)_n = \prod_{k=0}^{n-1} (1-a q^k)
+
+    where `n = \infty` is permitted if `|q| < 1`. Called with two arguments,
+    ``qp(a,q)`` computes `(a;q)_{\infty}`; with a single argument, ``qp(q)``
+    computes `(q;q)_{\infty}`. The special case
+
+    .. math ::
+
+        \phi(q) = (q; q)_{\infty} = \prod_{k=1}^{\infty} (1-q^k) =
+            \sum_{k=-\infty}^{\infty} (-1)^k q^{(3k^2-k)/2}
+
+    is also known as the Euler function, or (up to a factor `q^{-1/24}`)
+    the Dedekind eta function.
+
+    **Examples**
+
+    If `n` is a positive integer, the function amounts to a finite product::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qp(2,3,5)
+        -725305.0
+        >>> fprod(1-2*3**k for k in range(5))
+        -725305.0
+        >>> qp(2,3,0)
+        1.0
+
+    Complex arguments are allowed::
+
+        >>> qp(2-1j, 0.75j)
+        (0.4628842231660149089976379 + 4.481821753552703090628793j)
+
+    The regular Pochhammer symbol `(a)_n` is obtained in the
+    following limit as `q \to 1`::
+
+        >>> a, n = 4, 7
+        >>> limit(lambda q: qp(q**a,q,n) / (1-q)**n, 1)
+        604800.0
+        >>> rf(a,n)
+        604800.0
+
+    The Taylor series of the reciprocal Euler function gives
+    the partition function `P(n)`, i.e. the number of ways of writing
+    `n` as a sum of positive integers::
+
+        >>> taylor(lambda q: 1/qp(q), 0, 10)
+        [1.0, 1.0, 2.0, 3.0, 5.0, 7.0, 11.0, 15.0, 22.0, 30.0, 42.0]
+
+    Special values include::
+
+        >>> qp(0)
+        1.0
+        >>> findroot(diffun(qp), -0.4)   # location of maximum
+        -0.4112484791779547734440257
+        >>> qp(_)
+        1.228348867038575112586878
+
+    The q-Pochhammer symbol is related to the Jacobi theta functions.
+    For example, the following identity holds::
+
+        >>> q = mpf(0.5)    # arbitrary
+        >>> qp(q)
+        0.2887880950866024212788997
+        >>> root(3,-2)*root(q,-24)*jtheta(2,pi/6,root(q,6))
+        0.2887880950866024212788997
+
+    """
+    a = ctx.convert(a)
+    if n is None:
+        n = ctx.inf
+    else:
+        n = ctx.convert(n)
+    if n < 0:
+        raise ValueError("n cannot be negative")
+    if q is None:
+        q = a
+    else:
+        q = ctx.convert(q)
+    if n == 0:
+        return ctx.one + 0*(a+q)
+    infinite = (n == ctx.inf)
+    same = (a == q)
+    if infinite:
+        if abs(q) >= 1:
+            if same and (q == -1 or q == 1):
+                return ctx.zero * q
+            raise ValueError("q-function only defined for |q| < 1")
+        elif q == 0:
+            return ctx.one - a
+    maxterms = kwargs.get('maxterms', 50*ctx.prec)
+    if infinite and same:
+        # Euler's pentagonal theorem
+        def terms():
+            t = 1
+            yield t
+            k = 1
+            x1 = q
+            x2 = q**2
+            while 1:
+                yield (-1)**k * x1
+                yield (-1)**k * x2
+                x1 *= q**(3*k+1)
+                x2 *= q**(3*k+2)
+                k += 1
+                if k > maxterms:
+                    raise ctx.NoConvergence
+        return ctx.sum_accurately(terms)
+    # return ctx.nprod(lambda k: 1-a*q**k, [0,n-1])
+    def factors():
+        k = 0
+        r = ctx.one
+        while 1:
+            yield 1 - a*r
+            r *= q
+            k += 1
+            if k >= n:
+                return
+            if k > maxterms:
+                raise ctx.NoConvergence
+    return ctx.mul_accurately(factors)
+
+@defun_wrapped
+def qgamma(ctx, z, q, **kwargs):
+    r"""
+    Evaluates the q-gamma function
+
+    .. math ::
+
+        \Gamma_q(z) = \frac{(q; q)_{\infty}}{(q^z; q)_{\infty}} (1-q)^{1-z}.
+
+
+    **Examples**
+
+    Evaluation for real and complex arguments::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qgamma(4,0.75)
+        4.046875
+        >>> qgamma(6,6)
+        121226245.0
+        >>> qgamma(3+4j, 0.5j)
+        (0.1663082382255199834630088 + 0.01952474576025952984418217j)
+
+    The q-gamma function satisfies a functional equation similar
+    to that of the ordinary gamma function::
+
+        >>> q = mpf(0.25)
+        >>> z = mpf(2.5)
+        >>> qgamma(z+1,q)
+        1.428277424823760954685912
+        >>> (1-q**z)/(1-q)*qgamma(z,q)
+        1.428277424823760954685912
+
+    """
+    if abs(q) > 1:
+        return ctx.qgamma(z,1/q)*q**((z-2)*(z-1)*0.5)
+    return ctx.qp(q, q, None, **kwargs) / \
+        ctx.qp(q**z, q, None, **kwargs) * (1-q)**(1-z)
+
+@defun_wrapped
+def qfac(ctx, z, q, **kwargs):
+    r"""
+    Evaluates the q-factorial,
+
+    .. math ::
+
+        [n]_q! = (1+q)(1+q+q^2)\cdots(1+q+\cdots+q^{n-1})
+
+    or more generally
+
+    .. math ::
+
+        [z]_q! = \frac{(q;q)_z}{(1-q)^z}.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qfac(0,0)
+        1.0
+        >>> qfac(4,3)
+        2080.0
+        >>> qfac(5,6)
+        121226245.0
+        >>> qfac(1+1j, 2+1j)
+        (0.4370556551322672478613695 + 0.2609739839216039203708921j)
+
+    """
+    if ctx.isint(z) and ctx._re(z) > 0:
+        n = int(ctx._re(z))
+        return ctx.qp(q, q, n, **kwargs) / (1-q)**n
+    return ctx.qgamma(z+1, q, **kwargs)
+
+@defun
+def qhyper(ctx, a_s, b_s, q, z, **kwargs):
+    r"""
+    Evaluates the basic hypergeometric series or hypergeometric q-series
+
+    .. math ::
+
+        \,_r\phi_s \left[\begin{matrix}
+            a_1 & a_2 & \ldots & a_r \\
+            b_1 & b_2 & \ldots & b_s
+        \end{matrix} ; q,z \right] =
+        \sum_{n=0}^\infty
+        \frac{(a_1;q)_n, \ldots, (a_r;q)_n}
+             {(b_1;q)_n, \ldots, (b_s;q)_n}
+        \left((-1)^n q^{n\choose 2}\right)^{1+s-r}
+        \frac{z^n}{(q;q)_n}
+
+    where `(a;q)_n` denotes the q-Pochhammer symbol (see :func:`~mpmath.qp`).
+
+    **Examples**
+
+    Evaluation works for real and complex arguments::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> qhyper([0.5], [2.25], 0.25, 4)
+        -0.1975849091263356009534385
+        >>> qhyper([0.5], [2.25], 0.25-0.25j, 4)
+        (2.806330244925716649839237 + 3.568997623337943121769938j)
+        >>> qhyper([1+j], [2,3+0.5j], 0.25, 3+4j)
+        (9.112885171773400017270226 - 1.272756997166375050700388j)
+
+    Comparing with a summation of the defining series, using
+    :func:`~mpmath.nsum`::
+
+        >>> b, q, z = 3, 0.25, 0.5
+        >>> qhyper([], [b], q, z)
+        0.6221136748254495583228324
+        >>> nsum(lambda n: z**n / qp(q,q,n)/qp(b,q,n) * q**(n*(n-1)), [0,inf])
+        0.6221136748254495583228324
+
+    """
+    #a_s = [ctx._convert_param(a)[0] for a in a_s]
+    #b_s = [ctx._convert_param(b)[0] for b in b_s]
+    #q = ctx._convert_param(q)[0]
+    a_s = [ctx.convert(a) for a in a_s]
+    b_s = [ctx.convert(b) for b in b_s]
+    q = ctx.convert(q)
+    z = ctx.convert(z)
+    r = len(a_s)
+    s = len(b_s)
+    d = 1+s-r
+    maxterms = kwargs.get('maxterms', 50*ctx.prec)
+    def terms():
+        t = ctx.one
+        yield t
+        qk = 1
+        k = 0
+        x = 1
+        while 1:
+            for a in a_s:
+                p = 1 - a*qk
+                t *= p
+            for b in b_s:
+                p = 1 - b*qk
+                if not p:
+                    raise ValueError
+                t /= p
+            t *= z
+            x *= (-1)**d * qk ** d
+            qk *= q
+            t /= (1 - qk)
+            k += 1
+            yield t * x
+            if k > maxterms:
+                raise ctx.NoConvergence
+    return ctx.sum_accurately(terms)
diff --git a/lib/python3.11/site-packages/mpmath/functions/rszeta.py b/lib/python3.11/site-packages/mpmath/functions/rszeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..19e2c9a251b81bafe8cf77a2b0180636b1078ee4
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/rszeta.py
@@ -0,0 +1,1403 @@
+"""
+---------------------------------------------------------------------
+.. sectionauthor:: Juan Arias de Reyna <arias@us.es>
+
+This module implements zeta-related functions using the Riemann-Siegel
+expansion: zeta_offline(s,k=0)
+
+* coef(J, eps): Need in the computation of Rzeta(s,k)
+
+* Rzeta_simul(s, der=0) computes Rzeta^(k)(s) and Rzeta^(k)(1-s) simultaneously
+  for  0 <= k <= der. Used by zeta_offline and z_offline
+
+* Rzeta_set(s, derivatives) computes Rzeta^(k)(s) for given derivatives, used by
+  z_half(t,k) and zeta_half
+
+* z_offline(w,k): Z(w) and its derivatives of order k <= 4
+* z_half(t,k): Z(t) (Riemann Siegel function) and its derivatives of order k <= 4
+* zeta_offline(s): zeta(s) and its derivatives of order k<= 4
+* zeta_half(1/2+it,k):  zeta(s)  and its derivatives of order k<= 4
+
+* rs_zeta(s,k=0) Computes zeta^(k)(s)   Unifies zeta_half and zeta_offline
+* rs_z(w,k=0)    Computes Z^(k)(w)      Unifies z_offline and z_half
+----------------------------------------------------------------------
+
+This program uses Riemann-Siegel expansion even to compute
+zeta(s) on points s = sigma + i t  with sigma arbitrary not
+necessarily equal to 1/2.
+
+It is founded on a new deduction of the formula, with rigorous
+and sharp bounds for the  terms and rest of this expansion.
+
+More information on the papers:
+
+ J. Arias de Reyna, High Precision Computation of Riemann's
+ Zeta Function by the Riemann-Siegel Formula I, II
+
+ We refer to them as I, II.
+
+ In them we shall find detailed explanation of all the
+ procedure.
+
+The program uses Riemann-Siegel expansion.
+This  is useful when t is big, ( say  t > 10000 ).
+The precision is limited, roughly it can compute zeta(sigma+it)
+with an error less than exp(-c t) for some constant c depending
+on sigma.  The program gives an error when the Riemann-Siegel
+formula can not compute to the wanted precision.
+
+"""
+
+import math
+
+class RSCache(object):
+    def __init__(ctx):
+        ctx._rs_cache = [0, 10, {}, {}]
+
+from .functions import defun
+
+#-------------------------------------------------------------------------------#
+#                                                                               #
+#                       coef(ctx, J, eps, _cache=[0, 10, {} ] )                 #
+#                                                                               #
+#-------------------------------------------------------------------------------#
+
+#  This function computes the coefficients c[n] defined on (I, equation (47))
+#  but see also  (II, section 3.14).
+#
+#  Since these coefficients are very difficult to compute we save the values
+#  in a cache. So if we compute several values of the functions Rzeta(s) for
+#  near values of s, we do not recompute these coefficients.
+#
+#  c[n] are the Taylor coefficients of the function:
+#
+#  F(z):= (exp(pi*j*(z*z/2+3/8))-j* sqrt(2) cos(pi*z/2))/(2*cos(pi *z))
+#
+#
+
+def _coef(ctx, J, eps):
+    r"""
+    Computes the coefficients  `c_n`  for `0\le n\le 2J` with error less than eps
+
+    **Definition**
+
+    The coefficients c_n are defined by
+
+    .. math ::
+
+        \begin{equation}
+        F(z)=\frac{e^{\pi i
+        \bigl(\frac{z^2}{2}+\frac38\bigr)}-i\sqrt{2}\cos\frac{\pi}{2}z}{2\cos\pi
+        z}=\sum_{n=0}^\infty c_{2n} z^{2n}
+        \end{equation}
+
+    they are computed applying the relation
+
+    .. math ::
+
+        \begin{multline}
+        c_{2n}=-\frac{i}{\sqrt{2}}\Bigl(\frac{\pi}{2}\Bigr)^{2n}
+        \sum_{k=0}^n\frac{(-1)^k}{(2k)!}
+        2^{2n-2k}\frac{(-1)^{n-k}E_{2n-2k}}{(2n-2k)!}+\\
+        +e^{3\pi i/8}\sum_{j=0}^n(-1)^j\frac{
+        E_{2j}}{(2j)!}\frac{i^{n-j}\pi^{n+j}}{(n-j)!2^{n-j+1}}.
+        \end{multline}
+    """
+
+    newJ = J+2        # compute more coefficients that are needed
+    neweps6 = eps/2.  # compute with a slight more precision that are needed
+
+    #  PREPARATION FOR THE COMPUTATION OF V(N) AND W(N)
+    #    See II Section 3.16
+    #
+    #  Computing the exponent wpvw of the error II equation (81)
+    wpvw = max(ctx.mag(10*(newJ+3)), 4*newJ+5-ctx.mag(neweps6))
+
+    #  Preparation of Euler numbers (we need until the 2*RS_NEWJ)
+    E = ctx._eulernum(2*newJ)
+
+    #  Now we have in the cache all the needed Euler numbers.
+    #
+    #  Computing the powers of pi
+    #
+    # We need to compute the powers pi**n for 1<= n <= 2*J
+    # with relative error less than 2**(-wpvw)
+    # it is easy to show that this is obtained
+    # taking wppi as the least d with
+    # 2**d>40*J and 2**d> 4.24 *newJ + 2**wpvw
+    # In II Section 3.9 we need also that
+    #  wppi > wptcoef[0], and that the powers
+    # here computed  0<= k <= 2*newJ are more
+    # than those needed there that are 2*L-2.
+    # so we need  J >= L this will be checked
+    # before computing tcoef[]
+    wppi = max(ctx.mag(40*newJ), ctx.mag(newJ)+3 +wpvw)
+    ctx.prec = wppi
+    pipower = {}
+    pipower[0] = ctx.one
+    pipower[1] = ctx.pi
+    for n in range(2,2*newJ+1):
+        pipower[n] = pipower[n-1]*ctx.pi
+
+    # COMPUTING THE COEFFICIENTS v(n) AND w(n)
+    #  see II equation (61) and equations (81) and (82)
+    ctx.prec = wpvw+2
+    v={}
+    w={}
+    for n in range(0,newJ+1):
+        va = (-1)**n * ctx._eulernum(2*n)
+        va = ctx.mpf(va)/ctx.fac(2*n)
+        v[n]=va*pipower[2*n]
+    for n in range(0,2*newJ+1):
+        wa = ctx.one/ctx.fac(n)
+        wa=wa/(2**n)
+        w[n]=wa*pipower[n]
+
+    # COMPUTATION OF THE CONVOLUTIONS RS_P1 AND RS_P2
+    #  See II Section 3.16
+    ctx.prec = 15
+    wpp1a = 9 - ctx.mag(neweps6)
+    P1 = {}
+    for n in range(0,newJ+1):
+        ctx.prec = 15
+        wpp1 = max(ctx.mag(10*(n+4)),4*n+wpp1a)
+        ctx.prec = wpp1
+        sump = 0
+        for k in range(0,n+1):
+            sump += ((-1)**k) * v[k]*w[2*n-2*k]
+        P1[n]=((-1)**(n+1))*ctx.j*sump
+    P2={}
+    for n in range(0,newJ+1):
+        ctx.prec = 15
+        wpp2 = max(ctx.mag(10*(n+4)),4*n+wpp1a)
+        ctx.prec = wpp2
+        sump = 0
+        for k in range(0,n+1):
+            sump += (ctx.j**(n-k)) * v[k]*w[n-k]
+        P2[n]=sump
+    # COMPUTING THE COEFFICIENTS c[2n]
+    # See II Section 3.14
+    ctx.prec = 15
+    wpc0 = 5 - ctx.mag(neweps6)
+    wpc = max(6,4*newJ+wpc0)
+    ctx.prec = wpc
+    mu = ctx.sqrt(ctx.mpf('2'))/2
+    nu = ctx.expjpi(3./8)/2
+    c={}
+    for n in range(0,newJ):
+        ctx.prec = 15
+        wpc = max(6,4*n+wpc0)
+        ctx.prec = wpc
+        c[2*n] = mu*P1[n]+nu*P2[n]
+    for n in range(1,2*newJ,2):
+        c[n] = 0
+    return [newJ, neweps6, c, pipower]
+
+def coef(ctx, J, eps):
+    _cache = ctx._rs_cache
+    if J <= _cache[0] and eps >= _cache[1]:
+        return _cache[2], _cache[3]
+    orig = ctx._mp.prec
+    try:
+        data = _coef(ctx._mp, J, eps)
+    finally:
+        ctx._mp.prec = orig
+    if ctx is not ctx._mp:
+        data[2] = dict((k,ctx.convert(v)) for (k,v) in data[2].items())
+        data[3] = dict((k,ctx.convert(v)) for (k,v) in data[3].items())
+    ctx._rs_cache[:] = data
+    return ctx._rs_cache[2], ctx._rs_cache[3]
+
+#-------------------------------------------------------------------------------#
+#                                                                               #
+#                          Rzeta_simul(s,k=0)                                   #
+#                                                                               #
+#-------------------------------------------------------------------------------#
+#  This function return a list with the values:
+#  Rzeta(sigma+it), conj(Rzeta(1-sigma+it)),Rzeta'(sigma+it), conj(Rzeta'(1-sigma+it)),
+#  .... , Rzeta^{(k)}(sigma+it), conj(Rzeta^{(k)}(1-sigma+it))
+#
+#  Useful to compute  the function zeta(s) and Z(w)  or its derivatives.
+#
+
+def aux_M_Fp(ctx, xA, xeps4, a, xB1, xL):
+    # COMPUTING M  NUMBER OF DERIVATIVES Fp[m] TO COMPUTE
+    #  See II Section 3.11  equations (47) and (48)
+    aux1 = 126.0657606*xA/xeps4   # 126.06.. = 316/sqrt(2*pi)
+    aux1 = ctx.ln(aux1)
+    aux2 = (2*ctx.ln(ctx.pi)+ctx.ln(xB1)+ctx.ln(a))/3 -ctx.ln(2*ctx.pi)/2
+    m = 3*xL-3
+    aux3= (ctx.loggamma(m+1)-ctx.loggamma(m/3.0+2))/2 -ctx.loggamma((m+1)/2.)
+    while((aux1 < m*aux2+ aux3)and (m>1)):
+        m = m - 1
+        aux3 = (ctx.loggamma(m+1)-ctx.loggamma(m/3.0+2))/2 -ctx.loggamma((m+1)/2.)
+    xM = m
+    return xM
+
+def aux_J_needed(ctx, xA, xeps4, a, xB1, xM):
+    #  DETERMINATION OF  J  THE NUMBER OF TERMS NEEDED
+    #            IN THE TAYLOR SERIES OF F.
+    #  See II Section 3.11 equation (49))
+    #  Only determine one
+    h1 = xeps4/(632*xA)
+    h2 = xB1*a * 126.31337419529260248  # = pi^2*e^2*sqrt(3)
+    h2 = h1 * ctx.power((h2/xM**2),(xM-1)/3) / xM
+    h3 = min(h1,h2)
+    return h3
+
+def Rzeta_simul(ctx, s, der=0):
+    # First we take the value of ctx.prec
+    wpinitial = ctx.prec
+
+    # INITIALIZATION
+    # Take the real and imaginary part of s
+    t = ctx._im(s)
+    xsigma = ctx._re(s)
+    ysigma = 1 - xsigma
+
+    # Now compute several parameter that appear on the program
+    ctx.prec = 15
+    a = ctx.sqrt(t/(2*ctx.pi))
+    xasigma = a ** xsigma
+    yasigma = a ** ysigma
+
+    # We need a simple bound A1 < asigma  (see II Section 3.1 and 3.3)
+    xA1=ctx.power(2, ctx.mag(xasigma)-1)
+    yA1=ctx.power(2, ctx.mag(yasigma)-1)
+
+    # We compute various epsilon's  (see II end of Section 3.1)
+    eps = ctx.power(2, -wpinitial)
+    eps1 = eps/6.
+    xeps2 = eps * xA1/3.
+    yeps2 = eps * yA1/3.
+
+    #  COMPUTING SOME COEFFICIENTS THAT DEPENDS
+    #                ON  sigma
+    #  constant b and c  (see I  Theorem 2 formula (26) )
+    #  coefficients A and B1  (see I Section 6.1 equation (50))
+    #
+    # here we not need high precision
+    ctx.prec = 15
+    if xsigma > 0:
+        xb = 2.
+        xc = math.pow(9,xsigma)/4.44288
+        # 4.44288 =(math.sqrt(2)*math.pi)
+        xA = math.pow(9,xsigma)
+        xB1 = 1
+    else:
+        xb = 2.25158  #  math.sqrt( (3-2* math.log(2))*math.pi )
+        xc = math.pow(2,-xsigma)/4.44288
+        xA = math.pow(2,-xsigma)
+        xB1 = 1.10789   #  = 2*sqrt(1-log(2))
+
+    if(ysigma > 0):
+        yb = 2.
+        yc = math.pow(9,ysigma)/4.44288
+        # 4.44288 =(math.sqrt(2)*math.pi)
+        yA = math.pow(9,ysigma)
+        yB1 = 1
+    else:
+        yb = 2.25158  #  math.sqrt( (3-2* math.log(2))*math.pi )
+        yc = math.pow(2,-ysigma)/4.44288
+        yA = math.pow(2,-ysigma)
+        yB1 = 1.10789   #  = 2*sqrt(1-log(2))
+
+    #  COMPUTING L THE NUMBER OF TERMS NEEDED IN THE RIEMANN-SIEGEL
+    #                         CORRECTION
+    #  See II Section 3.2
+    ctx.prec = 15
+    xL = 1
+    while 3*xc*ctx.gamma(xL*0.5) * ctx.power(xb*a,-xL) >= xeps2:
+        xL = xL+1
+    xL = max(2,xL)
+    yL = 1
+    while 3*yc*ctx.gamma(yL*0.5) * ctx.power(yb*a,-yL) >= yeps2:
+        yL = yL+1
+    yL = max(2,yL)
+
+    #  The number L has to satify some conditions.
+    #  If not RS can not compute Rzeta(s) with the prescribed precision
+    #  (see II, Section 3.2 condition (20)  ) and
+    #  (II, Section 3.3 condition (22) ). Also we have added
+    #  an additional technical  condition in Section 3.17 Proposition 17
+    if ((3*xL >= 2*a*a/25.) or (3*xL+2+xsigma<0) or (abs(xsigma) > a/2.) or \
+        (3*yL >= 2*a*a/25.) or (3*yL+2+ysigma<0) or (abs(ysigma) > a/2.)):
+        ctx.prec = wpinitial
+        raise NotImplementedError("Riemann-Siegel can not compute with such precision")
+
+    #  We take the maximum of the two values
+    L = max(xL, yL)
+
+    #  INITIALIZATION (CONTINUATION)
+    #
+    # eps3 is the constant defined on (II, Section 3.5 equation (27) )
+    # each term of the RS correction must be computed with error <= eps3
+    xeps3 =  xeps2/(4*xL)
+    yeps3 =  yeps2/(4*yL)
+
+    # eps4 is defined on (II Section 3.6  equation (30) )
+    # each component of the formula (II Section 3.6 equation (29) )
+    # must be computed with error <= eps4
+    xeps4 = xeps3/(3*xL)
+    yeps4 = yeps3/(3*yL)
+
+    # COMPUTING M NUMBER OF DERIVATIVES Fp[m] TO COMPUTE
+    xM = aux_M_Fp(ctx, xA, xeps4, a, xB1, xL)
+    yM = aux_M_Fp(ctx, yA, yeps4, a, yB1, yL)
+    M = max(xM, yM)
+
+    # COMPUTING NUMBER OF TERMS J NEEDED
+    h3 = aux_J_needed(ctx, xA, xeps4, a, xB1, xM)
+    h4 = aux_J_needed(ctx, yA, yeps4, a, yB1, yM)
+    h3 = min(h3,h4)
+    J = 12
+    jvalue = (2*ctx.pi)**J / ctx.gamma(J+1)
+    while jvalue > h3:
+        J = J+1
+        jvalue = (2*ctx.pi)*jvalue/J
+
+    # COMPUTING eps5[m] for 1 <= m <= 21
+    #  See II Section 10 equation (43)
+    #  We choose the minimum of the two possibilities
+    eps5={}
+    xforeps5 = math.pi*math.pi*xB1*a
+    yforeps5 = math.pi*math.pi*yB1*a
+    for m in range(0,22):
+        xaux1 = math.pow(xforeps5, m/3)/(316.*xA)
+        yaux1 = math.pow(yforeps5, m/3)/(316.*yA)
+        aux1 = min(xaux1, yaux1)
+        aux2 = ctx.gamma(m+1)/ctx.gamma(m/3.0+0.5)
+        aux2 = math.sqrt(aux2)
+        eps5[m] = (aux1*aux2*min(xeps4,yeps4))
+
+    # COMPUTING wpfp
+    #  See II Section 3.13 equation (59)
+    twenty = min(3*L-3, 21)+1
+    aux = 6812*J
+    wpfp = ctx.mag(44*J)
+    for m in range(0,twenty):
+        wpfp = max(wpfp, ctx.mag(aux*ctx.gamma(m+1)/eps5[m]))
+
+    # COMPUTING N AND p
+    #  See II Section
+    ctx.prec = wpfp + ctx.mag(t)+20
+    a = ctx.sqrt(t/(2*ctx.pi))
+    N = ctx.floor(a)
+    p = 1-2*(a-N)
+
+    # now we get a rounded version of p
+    # to the precision wpfp
+    # this possibly is not necessary
+    num=ctx.floor(p*(ctx.mpf('2')**wpfp))
+    difference = p * (ctx.mpf('2')**wpfp)-num
+    if (difference < 0.5):
+        num = num
+    else:
+        num = num+1
+    p = ctx.convert(num * (ctx.mpf('2')**(-wpfp)))
+
+    # COMPUTING THE COEFFICIENTS c[n] = cc[n]
+    # We shall use the notation cc[n], since there is
+    # a constant that is called c
+    # See II Section 3.14
+    # We compute the coefficients and also save then in a
+    # cache.  The bulk of the computation is passed to
+    # the function  coef()
+    #
+    #  eps6 is defined in II Section 3.13  equation (58)
+    eps6 = ctx.power(ctx.convert(2*ctx.pi), J)/(ctx.gamma(J+1)*3*J)
+
+    #  Now we compute the coefficients
+    cc = {}
+    cont = {}
+    cont, pipowers = coef(ctx, J, eps6)
+    cc=cont.copy()   # we need a copy since we have to change his values.
+    Fp={}            # this is the adequate locus of this
+    for n in range(M, 3*L-2):
+        Fp[n] = 0
+    Fp={}
+    ctx.prec = wpfp
+    for m in range(0,M+1):
+        sumP = 0
+        for k in range(2*J-m-1,-1,-1):
+            sumP = (sumP * p)+ cc[k]
+        Fp[m] = sumP
+        # preparation of the new coefficients
+        for k in range(0,2*J-m-1):
+            cc[k] = (k+1)* cc[k+1]
+
+    # COMPUTING THE NUMBERS  xd[u,n,k], yd[u,n,k]
+    #  See II Section 3.17
+    #
+    #  First we compute the working precisions xwpd[k]
+    #   Se II equation (92)
+    xwpd={}
+    d1 = max(6,ctx.mag(40*L*L))
+    xd2 = 13+ctx.mag((1+abs(xsigma))*xA)-ctx.mag(xeps4)-1
+    xconst = ctx.ln(8/(ctx.pi*ctx.pi*a*a*xB1*xB1)) /2
+    for n in range(0,L):
+        xd3 = ctx.mag(ctx.sqrt(ctx.gamma(n-0.5)))-ctx.floor(n*xconst)+xd2
+        xwpd[n]=max(xd3,d1)
+
+    # procedure of II Section 3.17
+    ctx.prec = xwpd[1]+10
+    xpsigma = 1-(2*xsigma)
+    xd = {}
+    xd[0,0,-2]=0; xd[0,0,-1]=0; xd[0,0,0]=1; xd[0,0,1]=0
+    xd[0,-1,-2]=0; xd[0,-1,-1]=0; xd[0,-1,0]=1; xd[0,-1,1]=0
+    for n in range(1,L):
+        ctx.prec = xwpd[n]+10
+        for k in range(0,3*n//2+1):
+            m = 3*n-2*k
+            if(m!=0):
+                m1 = ctx.one/m
+                c1= m1/4
+                c2=(xpsigma*m1)/2
+                c3=-(m+1)
+                xd[0,n,k]=c3*xd[0,n-1,k-2]+c1*xd[0,n-1,k]+c2*xd[0,n-1,k-1]
+            else:
+                xd[0,n,k]=0
+                for r in range(0,k):
+                    add=xd[0,n,r]*(ctx.mpf('1.0')*ctx.fac(2*k-2*r)/ctx.fac(k-r))
+                    xd[0,n,k] -= ((-1)**(k-r))*add
+        xd[0,n,-2]=0; xd[0,n,-1]=0; xd[0,n,3*n//2+1]=0
+    for mu in range(-2,der+1):
+        for n in range(-2,L):
+            for k in range(-3,max(1,3*n//2+2)):
+                if( (mu<0)or (n<0) or(k<0)or (k>3*n//2)):
+                    xd[mu,n,k] = 0
+    for mu in range(1,der+1):
+        for n in range(0,L):
+            ctx.prec = xwpd[n]+10
+            for k in range(0,3*n//2+1):
+                aux=(2*mu-2)*xd[mu-2,n-2,k-3]+2*(xsigma+n-2)*xd[mu-1,n-2,k-3]
+                xd[mu,n,k] = aux - xd[mu-1,n-1,k-1]
+
+    #  Now we compute the working precisions ywpd[k]
+    #   Se II equation (92)
+    ywpd={}
+    d1 = max(6,ctx.mag(40*L*L))
+    yd2 = 13+ctx.mag((1+abs(ysigma))*yA)-ctx.mag(yeps4)-1
+    yconst = ctx.ln(8/(ctx.pi*ctx.pi*a*a*yB1*yB1)) /2
+    for n in range(0,L):
+        yd3 = ctx.mag(ctx.sqrt(ctx.gamma(n-0.5)))-ctx.floor(n*yconst)+yd2
+        ywpd[n]=max(yd3,d1)
+
+    # procedure of II Section 3.17
+    ctx.prec = ywpd[1]+10
+    ypsigma = 1-(2*ysigma)
+    yd = {}
+    yd[0,0,-2]=0; yd[0,0,-1]=0; yd[0,0,0]=1; yd[0,0,1]=0
+    yd[0,-1,-2]=0; yd[0,-1,-1]=0; yd[0,-1,0]=1; yd[0,-1,1]=0
+    for n in range(1,L):
+        ctx.prec = ywpd[n]+10
+        for k in range(0,3*n//2+1):
+            m = 3*n-2*k
+            if(m!=0):
+                m1 = ctx.one/m
+                c1= m1/4
+                c2=(ypsigma*m1)/2
+                c3=-(m+1)
+                yd[0,n,k]=c3*yd[0,n-1,k-2]+c1*yd[0,n-1,k]+c2*yd[0,n-1,k-1]
+            else:
+                yd[0,n,k]=0
+                for r in range(0,k):
+                    add=yd[0,n,r]*(ctx.mpf('1.0')*ctx.fac(2*k-2*r)/ctx.fac(k-r))
+                    yd[0,n,k] -= ((-1)**(k-r))*add
+        yd[0,n,-2]=0; yd[0,n,-1]=0; yd[0,n,3*n//2+1]=0
+
+    for mu in range(-2,der+1):
+        for n in range(-2,L):
+            for k in range(-3,max(1,3*n//2+2)):
+                if( (mu<0)or (n<0) or(k<0)or (k>3*n//2)):
+                    yd[mu,n,k] = 0
+    for mu in range(1,der+1):
+        for n in range(0,L):
+            ctx.prec = ywpd[n]+10
+            for k in range(0,3*n//2+1):
+                aux=(2*mu-2)*yd[mu-2,n-2,k-3]+2*(ysigma+n-2)*yd[mu-1,n-2,k-3]
+                yd[mu,n,k] = aux - yd[mu-1,n-1,k-1]
+
+    # COMPUTING THE COEFFICIENTS xtcoef[k,l]
+    #  See II Section 3.9
+    #
+    # computing the needed wp
+    xwptcoef={}
+    xwpterm={}
+    ctx.prec = 15
+    c1 = ctx.mag(40*(L+2))
+    xc2 = ctx.mag(68*(L+2)*xA)
+    xc4 = ctx.mag(xB1*a*math.sqrt(ctx.pi))-1
+    for k in range(0,L):
+        xc3 = xc2 - k*xc4+ctx.mag(ctx.fac(k+0.5))/2.
+        xwptcoef[k] = (max(c1,xc3-ctx.mag(xeps4)+1)+1 +20)*1.5
+        xwpterm[k] = (max(c1,ctx.mag(L+2)+xc3-ctx.mag(xeps3)+1)+1 +20)
+    ywptcoef={}
+    ywpterm={}
+    ctx.prec = 15
+    c1 = ctx.mag(40*(L+2))
+    yc2 = ctx.mag(68*(L+2)*yA)
+    yc4 = ctx.mag(yB1*a*math.sqrt(ctx.pi))-1
+    for k in range(0,L):
+        yc3 = yc2 - k*yc4+ctx.mag(ctx.fac(k+0.5))/2.
+        ywptcoef[k] = ((max(c1,yc3-ctx.mag(yeps4)+1))+10)*1.5
+        ywpterm[k] = (max(c1,ctx.mag(L+2)+yc3-ctx.mag(yeps3)+1)+1)+10
+
+    # check of power of pi
+    # computing the fortcoef[mu,k,ell]
+    xfortcoef={}
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                xfortcoef[mu,k,ell]=0
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = xwptcoef[k]
+            for ell in range(0,3*k//2+1):
+                xfortcoef[mu,k,ell]=xd[mu,k,ell]*Fp[3*k-2*ell]/pipowers[2*k-ell]
+                xfortcoef[mu,k,ell]=xfortcoef[mu,k,ell]/((2*ctx.j)**ell)
+
+    def trunc_a(t):
+        wp = ctx.prec
+        ctx.prec = wp + 2
+        aa = ctx.sqrt(t/(2*ctx.pi))
+        ctx.prec = wp
+        return aa
+
+    # computing the tcoef[k,ell]
+    xtcoef={}
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                xtcoef[mu,k,ell]=0
+    ctx.prec = max(xwptcoef[0],ywptcoef[0])+3
+    aa= trunc_a(t)
+    la = -ctx.ln(aa)
+
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = xwptcoef[k]
+            for ell in range(0,3*k//2+1):
+                xtcoef[chi,k,ell] =0
+                for mu in range(0, chi+1):
+                    tcoefter=ctx.binomial(chi,mu)*ctx.power(la,mu)*xfortcoef[chi-mu,k,ell]
+                    xtcoef[chi,k,ell] += tcoefter
+
+    # COMPUTING THE COEFFICIENTS ytcoef[k,l]
+    #  See II Section 3.9
+    #
+    # computing the needed wp
+    # check of power of pi
+    # computing the fortcoef[mu,k,ell]
+    yfortcoef={}
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                yfortcoef[mu,k,ell]=0
+    for mu in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = ywptcoef[k]
+            for ell in range(0,3*k//2+1):
+                yfortcoef[mu,k,ell]=yd[mu,k,ell]*Fp[3*k-2*ell]/pipowers[2*k-ell]
+                yfortcoef[mu,k,ell]=yfortcoef[mu,k,ell]/((2*ctx.j)**ell)
+    # computing the tcoef[k,ell]
+    ytcoef={}
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                ytcoef[chi,k,ell]=0
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = ywptcoef[k]
+            for ell in range(0,3*k//2+1):
+                ytcoef[chi,k,ell] =0
+                for mu in range(0, chi+1):
+                    tcoefter=ctx.binomial(chi,mu)*ctx.power(la,mu)*yfortcoef[chi-mu,k,ell]
+                    ytcoef[chi,k,ell] += tcoefter
+
+    # COMPUTING tv[k,ell]
+    # See II Section 3.8
+    #
+    #  a has a good value
+    ctx.prec = max(xwptcoef[0], ywptcoef[0])+2
+    av = {}
+    av[0] = 1
+    av[1] = av[0]/a
+
+    ctx.prec = max(xwptcoef[0],ywptcoef[0])
+    for k in range(2,L):
+        av[k] = av[k-1] * av[1]
+
+    # Computing the quotients
+    xtv = {}
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = xwptcoef[k]
+            for ell in range(0,3*k//2+1):
+                xtv[chi,k,ell] = xtcoef[chi,k,ell]* av[k]
+    # Computing the quotients
+    ytv = {}
+    for chi in range(0,der+1):
+        for k in range(0,L):
+            ctx.prec = ywptcoef[k]
+            for ell in range(0,3*k//2+1):
+                ytv[chi,k,ell] = ytcoef[chi,k,ell]* av[k]
+
+    # COMPUTING THE TERMS xterm[k]
+    # See II Section 3.6
+    xterm = {}
+    for chi in range(0,der+1):
+        for n in range(0,L):
+            ctx.prec = xwpterm[n]
+            te = 0
+            for k in range(0, 3*n//2+1):
+                te += xtv[chi,n,k]
+            xterm[chi,n] = te
+
+    # COMPUTING THE TERMS yterm[k]
+    # See II Section 3.6
+    yterm = {}
+    for chi in range(0,der+1):
+        for n in range(0,L):
+            ctx.prec = ywpterm[n]
+            te = 0
+            for k in range(0, 3*n//2+1):
+                te += ytv[chi,n,k]
+            yterm[chi,n] = te
+
+    # COMPUTING  rssum
+    # See II Section 3.5
+    xrssum={}
+    ctx.prec=15
+    xrsbound = math.sqrt(ctx.pi) * xc /(xb*a)
+    ctx.prec=15
+    xwprssum = ctx.mag(4.4*((L+3)**2)*xrsbound / xeps2)
+    xwprssum = max(xwprssum, ctx.mag(10*(L+1)))
+    ctx.prec = xwprssum
+    for chi in range(0,der+1):
+        xrssum[chi] = 0
+        for k in range(1,L+1):
+            xrssum[chi] += xterm[chi,L-k]
+    yrssum={}
+    ctx.prec=15
+    yrsbound = math.sqrt(ctx.pi) * yc /(yb*a)
+    ctx.prec=15
+    ywprssum = ctx.mag(4.4*((L+3)**2)*yrsbound / yeps2)
+    ywprssum = max(ywprssum, ctx.mag(10*(L+1)))
+    ctx.prec = ywprssum
+    for chi in range(0,der+1):
+        yrssum[chi] = 0
+        for k in range(1,L+1):
+            yrssum[chi] += yterm[chi,L-k]
+
+    # COMPUTING S3
+    # See II Section 3.19
+    ctx.prec = 15
+    A2 = 2**(max(ctx.mag(abs(xrssum[0])), ctx.mag(abs(yrssum[0]))))
+    eps8 = eps/(3*A2)
+    T = t *ctx.ln(t/(2*ctx.pi))
+    xwps3 = 5 +  ctx.mag((1+(2/eps8)*ctx.power(a,-xsigma))*T)
+    ywps3 = 5 +  ctx.mag((1+(2/eps8)*ctx.power(a,-ysigma))*T)
+
+    ctx.prec = max(xwps3, ywps3)
+
+    tpi = t/(2*ctx.pi)
+    arg = (t/2)*ctx.ln(tpi)-(t/2)-ctx.pi/8
+    U = ctx.expj(-arg)
+    a = trunc_a(t)
+    xasigma = ctx.power(a, -xsigma)
+    yasigma = ctx.power(a, -ysigma)
+    xS3 = ((-1)**(N-1)) * xasigma * U
+    yS3 = ((-1)**(N-1)) * yasigma * U
+
+    # COMPUTING S1 the zetasum
+    # See II Section 3.18
+    ctx.prec = 15
+    xwpsum =  4+ ctx.mag((N+ctx.power(N,1-xsigma))*ctx.ln(N) /eps1)
+    ywpsum =  4+ ctx.mag((N+ctx.power(N,1-ysigma))*ctx.ln(N) /eps1)
+    wpsum = max(xwpsum, ywpsum)
+
+    ctx.prec = wpsum +10
+    '''
+    # This can be improved
+    xS1={}
+    yS1={}
+    for chi in range(0,der+1):
+        xS1[chi] = 0
+        yS1[chi] = 0
+    for n in range(1,int(N)+1):
+        ln = ctx.ln(n)
+        xexpn = ctx.exp(-ln*(xsigma+ctx.j*t))
+        yexpn = ctx.conj(1/(n*xexpn))
+        for chi in range(0,der+1):
+            pown = ctx.power(-ln, chi)
+            xterm = pown*xexpn
+            yterm = pown*yexpn
+            xS1[chi] += xterm
+            yS1[chi] += yterm
+    '''
+    xS1, yS1 = ctx._zetasum(s, 1, int(N)-1, range(0,der+1), True)
+
+    # END OF COMPUTATION of xrz, yrz
+    #  See II Section 3.1
+    ctx.prec = 15
+    xabsS1 = abs(xS1[der])
+    xabsS2 = abs(xrssum[der] * xS3)
+    xwpend = max(6, wpinitial+ctx.mag(6*(3*xabsS1+7*xabsS2) ) )
+
+    ctx.prec = xwpend
+    xrz={}
+    for chi in range(0,der+1):
+        xrz[chi] = xS1[chi]+xrssum[chi]*xS3
+
+    ctx.prec = 15
+    yabsS1 = abs(yS1[der])
+    yabsS2 = abs(yrssum[der] * yS3)
+    ywpend = max(6, wpinitial+ctx.mag(6*(3*yabsS1+7*yabsS2) ) )
+
+    ctx.prec = ywpend
+    yrz={}
+    for chi in range(0,der+1):
+        yrz[chi] = yS1[chi]+yrssum[chi]*yS3
+        yrz[chi] = ctx.conj(yrz[chi])
+    ctx.prec = wpinitial
+    return xrz, yrz
+
+def Rzeta_set(ctx, s, derivatives=[0]):
+    r"""
+    Computes several derivatives of the auxiliary function of Riemann `R(s)`.
+
+    **Definition**
+
+    The function is defined by
+
+    .. math ::
+
+        \begin{equation}
+        {\mathop{\mathcal R }\nolimits}(s)=
+        \int_{0\swarrow1}\frac{x^{-s} e^{\pi i x^2}}{e^{\pi i x}-
+        e^{-\pi i x}}\,dx
+        \end{equation}
+
+    To this function we apply the Riemann-Siegel expansion.
+    """
+    der = max(derivatives)
+    # First we take the value of ctx.prec
+    # During the computation we will change ctx.prec, and finally we will
+    # restaurate the initial value
+    wpinitial = ctx.prec
+    # Take the real and imaginary part of s
+    t = ctx._im(s)
+    sigma = ctx._re(s)
+    # Now compute several parameter that appear on the program
+    ctx.prec = 15
+    a = ctx.sqrt(t/(2*ctx.pi))     #  Careful
+    asigma = ctx.power(a, sigma)  #  Careful
+    # We need a simple bound A1 < asigma  (see II Section 3.1 and 3.3)
+    A1 = ctx.power(2, ctx.mag(asigma)-1)
+    # We compute various epsilon's  (see II end of Section 3.1)
+    eps = ctx.power(2, -wpinitial)
+    eps1 = eps/6.
+    eps2 = eps * A1/3.
+    # COMPUTING SOME COEFFICIENTS THAT DEPENDS
+    #               ON  sigma
+    # constant b and c  (see I  Theorem 2 formula (26) )
+    # coefficients A and B1  (see I Section 6.1 equation (50))
+    # here we not need high precision
+    ctx.prec = 15
+    if sigma > 0:
+        b = 2.
+        c = math.pow(9,sigma)/4.44288
+        # 4.44288 =(math.sqrt(2)*math.pi)
+        A = math.pow(9,sigma)
+        B1 = 1
+    else:
+        b = 2.25158  #  math.sqrt( (3-2* math.log(2))*math.pi )
+        c = math.pow(2,-sigma)/4.44288
+        A = math.pow(2,-sigma)
+        B1 = 1.10789   #  = 2*sqrt(1-log(2))
+    #  COMPUTING L THE NUMBER OF TERMS NEEDED IN THE RIEMANN-SIEGEL
+    #                         CORRECTION
+    #  See II Section 3.2
+    ctx.prec = 15
+    L = 1
+    while 3*c*ctx.gamma(L*0.5) * ctx.power(b*a,-L) >= eps2:
+        L = L+1
+    L = max(2,L)
+    #  The number L has to satify some conditions.
+    #  If not RS can not compute Rzeta(s) with the prescribed precision
+    #  (see II, Section 3.2 condition (20)  ) and
+    #  (II, Section 3.3 condition (22) ). Also we have added
+    #  an additional technical  condition in Section 3.17 Proposition 17
+    if ((3*L >= 2*a*a/25.) or (3*L+2+sigma<0) or (abs(sigma)> a/2.)):
+        #print 'Error Riemann-Siegel can not compute with such precision'
+        ctx.prec = wpinitial
+        raise NotImplementedError("Riemann-Siegel can not compute with such precision")
+
+    #  INITIALIZATION (CONTINUATION)
+    #
+    # eps3 is the constant defined on (II, Section 3.5 equation (27) )
+    # each term of the RS correction must be computed with error <= eps3
+    eps3 =  eps2/(4*L)
+
+    # eps4 is defined on (II Section 3.6  equation (30) )
+    # each component of the formula (II Section 3.6 equation (29) )
+    # must be computed with error <= eps4
+    eps4 = eps3/(3*L)
+
+    # COMPUTING M.  NUMBER OF DERIVATIVES Fp[m] TO COMPUTE
+    M = aux_M_Fp(ctx, A, eps4, a, B1, L)
+    Fp = {}
+    for n in range(M, 3*L-2):
+        Fp[n] = 0
+
+    #  But I have not seen an instance of  M != 3*L-3
+    #
+    #  DETERMINATION OF  J  THE NUMBER OF TERMS NEEDED
+    #            IN THE TAYLOR SERIES OF F.
+    #  See II Section 3.11 equation (49))
+    h1 = eps4/(632*A)
+    h2 = ctx.pi*ctx.pi*B1*a *ctx.sqrt(3)*math.e*math.e
+    h2 = h1 * ctx.power((h2/M**2),(M-1)/3) / M
+    h3 = min(h1,h2)
+    J=12
+    jvalue = (2*ctx.pi)**J / ctx.gamma(J+1)
+    while jvalue > h3:
+        J = J+1
+        jvalue = (2*ctx.pi)*jvalue/J
+
+    # COMPUTING eps5[m] for 1 <= m <= 21
+    #  See II Section 10 equation (43)
+    eps5={}
+    foreps5 = math.pi*math.pi*B1*a
+    for m in range(0,22):
+        aux1 = math.pow(foreps5, m/3)/(316.*A)
+        aux2 = ctx.gamma(m+1)/ctx.gamma(m/3.0+0.5)
+        aux2 = math.sqrt(aux2)
+        eps5[m] = aux1*aux2*eps4
+
+    # COMPUTING wpfp
+    #  See II Section 3.13 equation (59)
+    twenty = min(3*L-3, 21)+1
+    aux = 6812*J
+    wpfp = ctx.mag(44*J)
+    for m in range(0, twenty):
+        wpfp = max(wpfp, ctx.mag(aux*ctx.gamma(m+1)/eps5[m]))
+    # COMPUTING N AND p
+    #  See II Section
+    ctx.prec = wpfp + ctx.mag(t) + 20
+    a = ctx.sqrt(t/(2*ctx.pi))
+    N = ctx.floor(a)
+    p = 1-2*(a-N)
+
+    # now we get a rounded version of p to the precision wpfp
+    # this possibly is not necessary
+    num = ctx.floor(p*(ctx.mpf(2)**wpfp))
+    difference = p * (ctx.mpf(2)**wpfp)-num
+    if difference < 0.5:
+        num = num
+    else:
+        num = num+1
+    p = ctx.convert(num * (ctx.mpf(2)**(-wpfp)))
+
+    # COMPUTING THE COEFFICIENTS c[n] = cc[n]
+    # We shall use the notation cc[n], since there is
+    # a constant that is called c
+    # See II Section 3.14
+    # We compute the coefficients and also save then in a
+    # cache.  The bulk of the computation is passed to
+    # the function  coef()
+    #
+    #  eps6 is defined in II Section 3.13  equation (58)
+    eps6 = ctx.power(2*ctx.pi, J)/(ctx.gamma(J+1)*3*J)
+
+    #  Now we compute the coefficients
+    cc={}
+    cont={}
+    cont, pipowers = coef(ctx, J, eps6)
+    cc = cont.copy()   # we need a copy since we have
+    Fp={}
+    for n in range(M, 3*L-2):
+        Fp[n] = 0
+    ctx.prec = wpfp
+    for m in range(0,M+1):
+        sumP = 0
+        for k in range(2*J-m-1,-1,-1):
+            sumP = (sumP * p) + cc[k]
+        Fp[m] = sumP
+        # preparation of the new coefficients
+        for k in range(0, 2*J-m-1):
+            cc[k] = (k+1) * cc[k+1]
+
+    # COMPUTING THE NUMBERS  d[n,k]
+    #  See II Section 3.17
+
+    #  First we compute the working precisions wpd[k]
+    #   Se II equation (92)
+    wpd = {}
+    d1 = max(6, ctx.mag(40*L*L))
+    d2 = 13+ctx.mag((1+abs(sigma))*A)-ctx.mag(eps4)-1
+    const = ctx.ln(8/(ctx.pi*ctx.pi*a*a*B1*B1)) /2
+    for n in range(0,L):
+        d3 = ctx.mag(ctx.sqrt(ctx.gamma(n-0.5)))-ctx.floor(n*const)+d2
+        wpd[n] = max(d3,d1)
+
+    # procedure of II Section 3.17
+    ctx.prec = wpd[1]+10
+    psigma = 1-(2*sigma)
+    d = {}
+    d[0,0,-2]=0; d[0,0,-1]=0; d[0,0,0]=1; d[0,0,1]=0
+    d[0,-1,-2]=0; d[0,-1,-1]=0; d[0,-1,0]=1; d[0,-1,1]=0
+    for n in range(1,L):
+        ctx.prec = wpd[n]+10
+        for k in range(0,3*n//2+1):
+            m = 3*n-2*k
+            if (m!=0):
+                m1 = ctx.one/m
+                c1 = m1/4
+                c2 = (psigma*m1)/2
+                c3 = -(m+1)
+                d[0,n,k] = c3*d[0,n-1,k-2]+c1*d[0,n-1,k]+c2*d[0,n-1,k-1]
+            else:
+                d[0,n,k]=0
+                for r in range(0,k):
+                    add = d[0,n,r]*(ctx.one*ctx.fac(2*k-2*r)/ctx.fac(k-r))
+                    d[0,n,k] -= ((-1)**(k-r))*add
+        d[0,n,-2]=0; d[0,n,-1]=0; d[0,n,3*n//2+1]=0
+
+    for mu in range(-2,der+1):
+        for n in range(-2,L):
+            for k in range(-3,max(1,3*n//2+2)):
+                if ((mu<0)or (n<0) or(k<0)or (k>3*n//2)):
+                    d[mu,n,k] = 0
+
+    for mu in range(1,der+1):
+        for n in range(0,L):
+            ctx.prec = wpd[n]+10
+            for k in range(0,3*n//2+1):
+                aux=(2*mu-2)*d[mu-2,n-2,k-3]+2*(sigma+n-2)*d[mu-1,n-2,k-3]
+                d[mu,n,k] = aux - d[mu-1,n-1,k-1]
+
+    # COMPUTING THE COEFFICIENTS t[k,l]
+    #  See II Section 3.9
+    #
+    # computing the needed wp
+    wptcoef = {}
+    wpterm = {}
+    ctx.prec = 15
+    c1 = ctx.mag(40*(L+2))
+    c2 = ctx.mag(68*(L+2)*A)
+    c4 = ctx.mag(B1*a*math.sqrt(ctx.pi))-1
+    for k in range(0,L):
+        c3 = c2 - k*c4+ctx.mag(ctx.fac(k+0.5))/2.
+        wptcoef[k] = max(c1,c3-ctx.mag(eps4)+1)+1 +10
+        wpterm[k] = max(c1,ctx.mag(L+2)+c3-ctx.mag(eps3)+1)+1 +10
+
+    # check of power of pi
+
+    # computing the fortcoef[mu,k,ell]
+    fortcoef={}
+    for mu in derivatives:
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                fortcoef[mu,k,ell]=0
+
+    for mu in derivatives:
+        for k in range(0,L):
+            ctx.prec = wptcoef[k]
+            for ell in range(0,3*k//2+1):
+                fortcoef[mu,k,ell]=d[mu,k,ell]*Fp[3*k-2*ell]/pipowers[2*k-ell]
+                fortcoef[mu,k,ell]=fortcoef[mu,k,ell]/((2*ctx.j)**ell)
+
+    def trunc_a(t):
+        wp = ctx.prec
+        ctx.prec = wp + 2
+        aa = ctx.sqrt(t/(2*ctx.pi))
+        ctx.prec = wp
+        return aa
+
+    # computing the tcoef[chi,k,ell]
+    tcoef={}
+    for chi in derivatives:
+        for k in range(0,L):
+            for ell in range(-2,3*k//2+1):
+                tcoef[chi,k,ell]=0
+    ctx.prec = wptcoef[0]+3
+    aa = trunc_a(t)
+    la = -ctx.ln(aa)
+
+    for chi in derivatives:
+        for k in range(0,L):
+            ctx.prec = wptcoef[k]
+            for ell in range(0,3*k//2+1):
+                tcoef[chi,k,ell] = 0
+                for mu in range(0, chi+1):
+                    tcoefter = ctx.binomial(chi,mu) * la**mu * \
+                        fortcoef[chi-mu,k,ell]
+                    tcoef[chi,k,ell] += tcoefter
+
+    # COMPUTING tv[k,ell]
+    # See II Section 3.8
+
+    # Computing the powers av[k] = a**(-k)
+    ctx.prec = wptcoef[0] + 2
+
+    # a has a good value of a.
+    # See II Section 3.6
+    av = {}
+    av[0] = 1
+    av[1] = av[0]/a
+
+    ctx.prec = wptcoef[0]
+    for k in range(2,L):
+        av[k] = av[k-1] * av[1]
+
+    # Computing the quotients
+    tv = {}
+    for chi in derivatives:
+        for k in range(0,L):
+            ctx.prec = wptcoef[k]
+            for ell in range(0,3*k//2+1):
+                tv[chi,k,ell] = tcoef[chi,k,ell]* av[k]
+
+    # COMPUTING THE TERMS term[k]
+    # See II Section 3.6
+    term = {}
+    for chi in derivatives:
+        for n in range(0,L):
+            ctx.prec = wpterm[n]
+            te = 0
+            for k in range(0, 3*n//2+1):
+                te += tv[chi,n,k]
+            term[chi,n] = te
+
+    # COMPUTING  rssum
+    # See II Section 3.5
+    rssum={}
+    ctx.prec=15
+    rsbound = math.sqrt(ctx.pi) * c /(b*a)
+    ctx.prec=15
+    wprssum = ctx.mag(4.4*((L+3)**2)*rsbound / eps2)
+    wprssum = max(wprssum, ctx.mag(10*(L+1)))
+    ctx.prec = wprssum
+    for chi in derivatives:
+        rssum[chi] = 0
+        for k in range(1,L+1):
+            rssum[chi] += term[chi,L-k]
+
+    # COMPUTING S3
+    # See II Section 3.19
+    ctx.prec = 15
+    A2 = 2**(ctx.mag(rssum[0]))
+    eps8 = eps/(3* A2)
+    T = t * ctx.ln(t/(2*ctx.pi))
+    wps3 = 5 + ctx.mag((1+(2/eps8)*ctx.power(a,-sigma))*T)
+
+    ctx.prec = wps3
+    tpi = t/(2*ctx.pi)
+    arg = (t/2)*ctx.ln(tpi)-(t/2)-ctx.pi/8
+    U = ctx.expj(-arg)
+    a = trunc_a(t)
+    asigma = ctx.power(a, -sigma)
+    S3 = ((-1)**(N-1)) * asigma * U
+
+    # COMPUTING S1 the zetasum
+    # See II Section 3.18
+    ctx.prec = 15
+    wpsum = 4 + ctx.mag((N+ctx.power(N,1-sigma))*ctx.ln(N)/eps1)
+
+    ctx.prec = wpsum + 10
+    '''
+    # This can be improved
+    S1 = {}
+    for chi in derivatives:
+        S1[chi] = 0
+    for n in range(1,int(N)+1):
+        ln = ctx.ln(n)
+        expn = ctx.exp(-ln*(sigma+ctx.j*t))
+        for chi in derivatives:
+            term = ctx.power(-ln, chi)*expn
+            S1[chi] += term
+    '''
+    S1 = ctx._zetasum(s, 1, int(N)-1, derivatives)[0]
+
+    # END OF COMPUTATION
+    #  See II Section 3.1
+    ctx.prec = 15
+    absS1 = abs(S1[der])
+    absS2 = abs(rssum[der] * S3)
+    wpend = max(6, wpinitial + ctx.mag(6*(3*absS1+7*absS2)))
+    ctx.prec = wpend
+    rz = {}
+    for chi in derivatives:
+        rz[chi] = S1[chi]+rssum[chi]*S3
+    ctx.prec = wpinitial
+    return rz
+
+
+def z_half(ctx,t,der=0):
+    r"""
+    z_half(t,der=0) Computes Z^(der)(t)
+    """
+    s=ctx.mpf('0.5')+ctx.j*t
+    wpinitial = ctx.prec
+    ctx.prec = 15
+    tt = t/(2*ctx.pi)
+    wptheta = wpinitial +1 + ctx.mag(3*(tt**1.5)*ctx.ln(tt))
+    wpz = wpinitial + 1 + ctx.mag(12*tt*ctx.ln(tt))
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(t)
+    ctx.prec = wpz
+    rz = Rzeta_set(ctx,s, range(der+1))
+    if der > 0: ps1 = ctx._re(ctx.psi(0,s/2)/2 - ctx.ln(ctx.pi)/2)
+    if der > 1: ps2 = ctx._re(ctx.j*ctx.psi(1,s/2)/4)
+    if der > 2: ps3 = ctx._re(-ctx.psi(2,s/2)/8)
+    if der > 3: ps4 = ctx._re(-ctx.j*ctx.psi(3,s/2)/16)
+    exptheta = ctx.expj(theta)
+    if der == 0:
+        z = 2*exptheta*rz[0]
+    if der == 1:
+        zf = 2j*exptheta
+        z = zf*(ps1*rz[0]+rz[1])
+    if der == 2:
+        zf = 2 * exptheta
+        z = -zf*(2*rz[1]*ps1+rz[0]*ps1**2+rz[2]-ctx.j*rz[0]*ps2)
+    if der == 3:
+        zf = -2j*exptheta
+        z = 3*rz[1]*ps1**2+rz[0]*ps1**3+3*ps1*rz[2]
+        z = zf*(z-3j*rz[1]*ps2-3j*rz[0]*ps1*ps2+rz[3]-rz[0]*ps3)
+    if der == 4:
+        zf = 2*exptheta
+        z = 4*rz[1]*ps1**3+rz[0]*ps1**4+6*ps1**2*rz[2]
+        z = z-12j*rz[1]*ps1*ps2-6j*rz[0]*ps1**2*ps2-6j*rz[2]*ps2-3*rz[0]*ps2*ps2
+        z = z + 4*ps1*rz[3]-4*rz[1]*ps3-4*rz[0]*ps1*ps3+rz[4]+ctx.j*rz[0]*ps4
+        z = zf*z
+    ctx.prec = wpinitial
+    return ctx._re(z)
+
+def zeta_half(ctx, s, k=0):
+    """
+    zeta_half(s,k=0) Computes zeta^(k)(s) when Re s = 0.5
+    """
+    wpinitial = ctx.prec
+    sigma = ctx._re(s)
+    t = ctx._im(s)
+    #--- compute wptheta, wpR, wpbasic ---
+    ctx.prec = 53
+    #  X see II Section 3.21 (109) and (110)
+    if sigma > 0:
+        X = ctx.sqrt(abs(s))
+    else:
+        X = (2*ctx.pi)**(sigma-1) * abs(1-s)**(0.5-sigma)
+    # M1  see II Section 3.21 (111) and (112)
+    if sigma > 0:
+        M1 = 2*ctx.sqrt(t/(2*ctx.pi))
+    else:
+        M1 = 4 * t * X
+    # T  see II Section 3.21 (113)
+    abst = abs(0.5-s)
+    T = 2* abst*math.log(abst)
+    # computing wpbasic, wptheta, wpR  see II Section 3.21
+    wpbasic = max(6,3+ctx.mag(t))
+    wpbasic2 = 2+ctx.mag(2.12*M1+21.2*M1*X+1.3*M1*X*T)+wpinitial+1
+    wpbasic = max(wpbasic, wpbasic2)
+    wptheta = max(4, 3+ctx.mag(2.7*M1*X)+wpinitial+1)
+    wpR = 3+ctx.mag(1.1+2*X)+wpinitial+1
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(t-ctx.j*(sigma-ctx.mpf('0.5')))
+    if k > 0: ps1 = (ctx._re(ctx.psi(0,s/2)))/2 - ctx.ln(ctx.pi)/2
+    if k > 1: ps2 = -(ctx._im(ctx.psi(1,s/2)))/4
+    if k > 2: ps3 = -(ctx._re(ctx.psi(2,s/2)))/8
+    if k > 3: ps4 = (ctx._im(ctx.psi(3,s/2)))/16
+    ctx.prec = wpR
+    xrz = Rzeta_set(ctx,s,range(k+1))
+    yrz={}
+    for chi in range(0,k+1):
+        yrz[chi] = ctx.conj(xrz[chi])
+    ctx.prec = wpbasic
+    exptheta = ctx.expj(-2*theta)
+    if k==0:
+        zv = xrz[0]+exptheta*yrz[0]
+    if k==1:
+        zv1 = -yrz[1] - 2*yrz[0]*ps1
+        zv = xrz[1] + exptheta*zv1
+    if k==2:
+        zv1 = 4*yrz[1]*ps1+4*yrz[0]*(ps1**2)+yrz[2]+2j*yrz[0]*ps2
+        zv = xrz[2]+exptheta*zv1
+    if k==3:
+        zv1 = -12*yrz[1]*ps1**2-8*yrz[0]*ps1**3-6*yrz[2]*ps1-6j*yrz[1]*ps2
+        zv1 = zv1 - 12j*yrz[0]*ps1*ps2-yrz[3]+2*yrz[0]*ps3
+        zv = xrz[3]+exptheta*zv1
+    if k == 4:
+        zv1 = 32*yrz[1]*ps1**3 +16*yrz[0]*ps1**4+24*yrz[2]*ps1**2
+        zv1 = zv1 +48j*yrz[1]*ps1*ps2+48j*yrz[0]*(ps1**2)*ps2
+        zv1 = zv1+12j*yrz[2]*ps2-12*yrz[0]*ps2**2+8*yrz[3]*ps1-8*yrz[1]*ps3
+        zv1 = zv1-16*yrz[0]*ps1*ps3+yrz[4]-2j*yrz[0]*ps4
+        zv = xrz[4]+exptheta*zv1
+    ctx.prec = wpinitial
+    return zv
+
+def zeta_offline(ctx, s, k=0):
+    """
+    Computes zeta^(k)(s) off the line
+    """
+    wpinitial = ctx.prec
+    sigma = ctx._re(s)
+    t = ctx._im(s)
+    #--- compute wptheta, wpR, wpbasic ---
+    ctx.prec = 53
+    #  X see II Section 3.21 (109) and (110)
+    if sigma > 0:
+        X = ctx.power(abs(s), 0.5)
+    else:
+        X = ctx.power(2*ctx.pi, sigma-1)*ctx.power(abs(1-s),0.5-sigma)
+    # M1  see II Section 3.21 (111) and (112)
+    if (sigma > 0):
+        M1 = 2*ctx.sqrt(t/(2*ctx.pi))
+    else:
+        M1 = 4 * t * X
+    # M2  see II Section 3.21 (111) and (112)
+    if (1-sigma > 0):
+        M2 = 2*ctx.sqrt(t/(2*ctx.pi))
+    else:
+        M2 = 4*t*ctx.power(2*ctx.pi, -sigma)*ctx.power(abs(s),sigma-0.5)
+    # T  see II Section 3.21 (113)
+    abst = abs(0.5-s)
+    T = 2* abst*math.log(abst)
+    # computing wpbasic, wptheta, wpR  see II Section 3.21
+    wpbasic = max(6,3+ctx.mag(t))
+    wpbasic2 = 2+ctx.mag(2.12*M1+21.2*M2*X+1.3*M2*X*T)+wpinitial+1
+    wpbasic = max(wpbasic, wpbasic2)
+    wptheta = max(4, 3+ctx.mag(2.7*M2*X)+wpinitial+1)
+    wpR = 3+ctx.mag(1.1+2*X)+wpinitial+1
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(t-ctx.j*(sigma-ctx.mpf('0.5')))
+    s1 = s
+    s2 = ctx.conj(1-s1)
+    ctx.prec = wpR
+    xrz, yrz = Rzeta_simul(ctx, s, k)
+    if k > 0: ps1 = (ctx.psi(0,s1/2)+ctx.psi(0,(1-s1)/2))/4 - ctx.ln(ctx.pi)/2
+    if k > 1: ps2 = ctx.j*(ctx.psi(1,s1/2)-ctx.psi(1,(1-s1)/2))/8
+    if k > 2: ps3 = -(ctx.psi(2,s1/2)+ctx.psi(2,(1-s1)/2))/16
+    if k > 3: ps4 = -ctx.j*(ctx.psi(3,s1/2)-ctx.psi(3,(1-s1)/2))/32
+    ctx.prec = wpbasic
+    exptheta = ctx.expj(-2*theta)
+    if k == 0:
+        zv = xrz[0]+exptheta*yrz[0]
+    if k == 1:
+        zv1 = -yrz[1]-2*yrz[0]*ps1
+        zv = xrz[1]+exptheta*zv1
+    if k == 2:
+        zv1 = 4*yrz[1]*ps1+4*yrz[0]*(ps1**2) +yrz[2]+2j*yrz[0]*ps2
+        zv = xrz[2]+exptheta*zv1
+    if k == 3:
+        zv1 = -12*yrz[1]*ps1**2 -8*yrz[0]*ps1**3-6*yrz[2]*ps1-6j*yrz[1]*ps2
+        zv1 = zv1 - 12j*yrz[0]*ps1*ps2-yrz[3]+2*yrz[0]*ps3
+        zv = xrz[3]+exptheta*zv1
+    if k == 4:
+        zv1 = 32*yrz[1]*ps1**3 +16*yrz[0]*ps1**4+24*yrz[2]*ps1**2
+        zv1 = zv1 +48j*yrz[1]*ps1*ps2+48j*yrz[0]*(ps1**2)*ps2
+        zv1 = zv1+12j*yrz[2]*ps2-12*yrz[0]*ps2**2+8*yrz[3]*ps1-8*yrz[1]*ps3
+        zv1 = zv1-16*yrz[0]*ps1*ps3+yrz[4]-2j*yrz[0]*ps4
+        zv = xrz[4]+exptheta*zv1
+    ctx.prec = wpinitial
+    return zv
+
+def z_offline(ctx, w, k=0):
+    r"""
+    Computes Z(w) and its derivatives off the line
+    """
+    s = ctx.mpf('0.5')+ctx.j*w
+    s1 = s
+    s2 = ctx.conj(1-s1)
+    wpinitial = ctx.prec
+    ctx.prec = 35
+    #  X see II Section 3.21 (109) and (110)
+    # M1  see II Section 3.21 (111) and (112)
+    if (ctx._re(s1) >= 0):
+        M1 = 2*ctx.sqrt(ctx._im(s1)/(2 * ctx.pi))
+        X = ctx.sqrt(abs(s1))
+    else:
+        X = (2*ctx.pi)**(ctx._re(s1)-1) * abs(1-s1)**(0.5-ctx._re(s1))
+        M1 = 4 * ctx._im(s1)*X
+    # M2  see II Section 3.21 (111) and (112)
+    if (ctx._re(s2) >= 0):
+        M2 = 2*ctx.sqrt(ctx._im(s2)/(2 * ctx.pi))
+    else:
+        M2 = 4 * ctx._im(s2)*(2*ctx.pi)**(ctx._re(s2)-1)*abs(1-s2)**(0.5-ctx._re(s2))
+    # T  see II Section 3.21  Prop. 27
+    T = 2*abs(ctx.siegeltheta(w))
+    # defining some precisions
+    # see II Section 3.22 (115), (116), (117)
+    aux1 = ctx.sqrt(X)
+    aux2 = aux1*(M1+M2)
+    aux3 = 3 +wpinitial
+    wpbasic = max(6, 3+ctx.mag(T), ctx.mag(aux2*(26+2*T))+aux3)
+    wptheta = max(4,ctx.mag(2.04*aux2)+aux3)
+    wpR = ctx.mag(4*aux1)+aux3
+    # now the computations
+    ctx.prec = wptheta
+    theta = ctx.siegeltheta(w)
+    ctx.prec = wpR
+    xrz, yrz = Rzeta_simul(ctx,s,k)
+    pta = 0.25 + 0.5j*w
+    ptb = 0.25 - 0.5j*w
+    if k > 0: ps1 = 0.25*(ctx.psi(0,pta)+ctx.psi(0,ptb)) - ctx.ln(ctx.pi)/2
+    if k > 1: ps2 = (1j/8)*(ctx.psi(1,pta)-ctx.psi(1,ptb))
+    if k > 2: ps3 = (-1./16)*(ctx.psi(2,pta)+ctx.psi(2,ptb))
+    if k > 3: ps4 = (-1j/32)*(ctx.psi(3,pta)-ctx.psi(3,ptb))
+    ctx.prec = wpbasic
+    exptheta = ctx.expj(theta)
+    if k == 0:
+        zv = exptheta*xrz[0]+yrz[0]/exptheta
+    j = ctx.j
+    if k == 1:
+        zv = j*exptheta*(xrz[1]+xrz[0]*ps1)-j*(yrz[1]+yrz[0]*ps1)/exptheta
+    if k == 2:
+        zv = exptheta*(-2*xrz[1]*ps1-xrz[0]*ps1**2-xrz[2]+j*xrz[0]*ps2)
+        zv =zv + (-2*yrz[1]*ps1-yrz[0]*ps1**2-yrz[2]-j*yrz[0]*ps2)/exptheta
+    if k == 3:
+        zv1 = -3*xrz[1]*ps1**2-xrz[0]*ps1**3-3*xrz[2]*ps1+j*3*xrz[1]*ps2
+        zv1 = (zv1+ 3j*xrz[0]*ps1*ps2-xrz[3]+xrz[0]*ps3)*j*exptheta
+        zv2 = 3*yrz[1]*ps1**2+yrz[0]*ps1**3+3*yrz[2]*ps1+j*3*yrz[1]*ps2
+        zv2 = j*(zv2 + 3j*yrz[0]*ps1*ps2+ yrz[3]-yrz[0]*ps3)/exptheta
+        zv = zv1+zv2
+    if k == 4:
+        zv1 = 4*xrz[1]*ps1**3+xrz[0]*ps1**4 + 6*xrz[2]*ps1**2
+        zv1 = zv1-12j*xrz[1]*ps1*ps2-6j*xrz[0]*ps1**2*ps2-6j*xrz[2]*ps2
+        zv1 = zv1-3*xrz[0]*ps2*ps2+4*xrz[3]*ps1-4*xrz[1]*ps3-4*xrz[0]*ps1*ps3
+        zv1 = zv1+xrz[4]+j*xrz[0]*ps4
+        zv2 = 4*yrz[1]*ps1**3+yrz[0]*ps1**4 + 6*yrz[2]*ps1**2
+        zv2 = zv2+12j*yrz[1]*ps1*ps2+6j*yrz[0]*ps1**2*ps2+6j*yrz[2]*ps2
+        zv2 = zv2-3*yrz[0]*ps2*ps2+4*yrz[3]*ps1-4*yrz[1]*ps3-4*yrz[0]*ps1*ps3
+        zv2 = zv2+yrz[4]-j*yrz[0]*ps4
+        zv = exptheta*zv1+zv2/exptheta
+    ctx.prec = wpinitial
+    return zv
+
+@defun
+def rs_zeta(ctx, s, derivative=0, **kwargs):
+    if derivative > 4:
+        raise NotImplementedError
+    s = ctx.convert(s)
+    re = ctx._re(s); im = ctx._im(s)
+    if im < 0:
+        z = ctx.conj(ctx.rs_zeta(ctx.conj(s), derivative))
+        return z
+    critical_line = (re == 0.5)
+    if critical_line:
+        return zeta_half(ctx, s, derivative)
+    else:
+        return zeta_offline(ctx, s, derivative)
+
+@defun
+def rs_z(ctx, w, derivative=0):
+    w = ctx.convert(w)
+    re = ctx._re(w); im = ctx._im(w)
+    if re < 0:
+        return rs_z(ctx, -w, derivative)
+    critical_line = (im == 0)
+    if critical_line :
+        return z_half(ctx, w, derivative)
+    else:
+        return z_offline(ctx, w, derivative)
diff --git a/lib/python3.11/site-packages/mpmath/functions/signals.py b/lib/python3.11/site-packages/mpmath/functions/signals.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fadafb2dbb44fe19a2defa8d807d81d7c8e2789
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/signals.py
@@ -0,0 +1,32 @@
+from .functions import defun_wrapped
+
+@defun_wrapped
+def squarew(ctx, t, amplitude=1, period=1):
+    P = period
+    A = amplitude
+    return A*((-1)**ctx.floor(2*t/P))
+
+@defun_wrapped
+def trianglew(ctx, t, amplitude=1, period=1):
+    A = amplitude
+    P = period
+
+    return 2*A*(0.5 - ctx.fabs(1 - 2*ctx.frac(t/P + 0.25)))
+
+@defun_wrapped
+def sawtoothw(ctx, t, amplitude=1, period=1):
+    A = amplitude
+    P = period
+    return A*ctx.frac(t/P)
+
+@defun_wrapped
+def unit_triangle(ctx, t, amplitude=1):
+    A = amplitude
+    if t <= -1 or t >= 1:
+        return ctx.zero
+    return A*(-ctx.fabs(t) + 1)
+
+@defun_wrapped
+def sigmoid(ctx, t, amplitude=1):
+    A = amplitude
+    return A / (1 + ctx.exp(-t))
diff --git a/lib/python3.11/site-packages/mpmath/functions/theta.py b/lib/python3.11/site-packages/mpmath/functions/theta.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b3d8323a163a43186b85417a1b40f3b656c30d0
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/theta.py
@@ -0,0 +1,1049 @@
+from .functions import defun, defun_wrapped
+
+@defun
+def _jacobi_theta2(ctx, z, q):
+    extra1 = 10
+    extra2 = 20
+    # the loops below break when the fixed precision quantities
+    # a and b go to zero;
+    # right shifting small negative numbers by wp one obtains -1, not zero,
+    # so the condition a**2 + b**2 > MIN is used to break the loops.
+    MIN = 2
+    if z == ctx.zero:
+        if (not ctx._im(q)):
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            x2 = (x*x) >> wp
+            a = b = x2
+            s = x2
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                s += a
+            s = (1 << (wp+1)) + (s << 1)
+            s = ctx.ldexp(s, -wp)
+        else:
+            wp = ctx.prec + extra1
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp-1)
+            are = bre = x2re
+            aim = bim = x2im
+            sre = (1<<wp) + are
+            sim = aim
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                sre += are
+                sim += aim
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+    else:
+        if (not ctx._im(q)) and (not ctx._im(z)):
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            x2 = (x*x) >> wp
+            a = b = x2
+            c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+            cn = c1 = ctx.to_fixed(c1, wp)
+            sn = s1 = ctx.to_fixed(s1, wp)
+            c2 = (c1*c1 - s1*s1) >> wp
+            s2 = (c1 * s1) >> (wp - 1)
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            s = c1 + ((a * cn) >> wp)
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+                s += (a * cn) >> wp
+            s = (s << 1)
+            s = ctx.ldexp(s, -wp)
+            s *= ctx.nthroot(q, 4)
+            return s
+        # case z real, q complex
+        elif not ctx._im(z):
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = x2re
+            aim = bim = x2im
+            c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+            cn = c1 = ctx.to_fixed(c1, wp)
+            sn = s1 = ctx.to_fixed(s1, wp)
+            c2 = (c1*c1 - s1*s1) >> wp
+            s2 = (c1 * s1) >> (wp - 1)
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            sre = c1 + ((are * cn) >> wp)
+            sim = ((aim * cn) >> wp)
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+                sre += ((are * cn) >> wp)
+                sim += ((aim * cn) >> wp)
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+        #case z complex, q real
+        elif not ctx._im(q):
+            wp = ctx.prec + extra2
+            x = ctx.to_fixed(ctx._re(q), wp)
+            x2 = (x*x) >> wp
+            a = b = x2
+            prec0 = ctx.prec
+            ctx.prec = wp
+            c1, s1 = ctx.cos_sin(z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            #c2 = (c1*c1 - s1*s1) >> wp
+            c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+            c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+            #s2 = (c1 * s1) >> (wp - 1)
+            s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+            s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+            #cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            sre = c1re + ((a * cnre) >> wp)
+            sim = c1im + ((a * cnim) >> wp)
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+                t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+                t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+                t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                sre += ((a * cnre) >> wp)
+                sim += ((a * cnim) >> wp)
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+        # case z and q complex
+        else:
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = x2re
+            aim = bim = x2im
+            prec0 = ctx.prec
+            ctx.prec = wp
+            # cos(z), sin(z) with z complex
+            c1, s1 = ctx.cos_sin(z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+            c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+            s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+            s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            n = 1
+            termre = c1re
+            termim = c1im
+            sre = c1re + ((are * cnre - aim * cnim) >> wp)
+            sim = c1im + ((are * cnim + aim * cnre) >> wp)
+            n = 3
+            termre = ((are * cnre - aim * cnim) >> wp)
+            termim = ((are * cnim + aim * cnre) >> wp)
+            sre = c1re + ((are * cnre - aim * cnim) >> wp)
+            sim = c1im + ((are * cnim + aim * cnre) >> wp)
+            n = 5
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                #cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+                t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+                t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+                t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+                t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                termre = ((are * cnre - aim * cnim) >> wp)
+                termim = ((aim * cnre + are * cnim) >> wp)
+                sre += ((are * cnre - aim * cnim) >> wp)
+                sim += ((aim * cnre + are * cnim) >> wp)
+                n += 2
+            sre = (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+    s *= ctx.nthroot(q, 4)
+    return s
+
+@defun
+def _djacobi_theta2(ctx, z, q, nd):
+    MIN = 2
+    extra1 = 10
+    extra2 = 20
+    if (not ctx._im(q)) and (not ctx._im(z)):
+        wp = ctx.prec + extra1
+        x = ctx.to_fixed(ctx._re(q), wp)
+        x2 = (x*x) >> wp
+        a = b = x2
+        c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+        cn = c1 = ctx.to_fixed(c1, wp)
+        sn = s1 = ctx.to_fixed(s1, wp)
+        c2 = (c1*c1 - s1*s1) >> wp
+        s2 = (c1 * s1) >> (wp - 1)
+        cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+        if (nd&1):
+            s = s1 + ((a * sn * 3**nd) >> wp)
+        else:
+            s = c1 + ((a * cn * 3**nd) >> wp)
+        n = 2
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+            if nd&1:
+                s += (a * sn * (2*n+1)**nd) >> wp
+            else:
+                s += (a * cn * (2*n+1)**nd) >> wp
+            n += 1
+        s = -(s << 1)
+        s = ctx.ldexp(s, -wp)
+        # case z real, q complex
+    elif not ctx._im(z):
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = x2re
+        aim = bim = x2im
+        c1, s1 = ctx.cos_sin(ctx._re(z), prec=wp)
+        cn = c1 = ctx.to_fixed(c1, wp)
+        sn = s1 = ctx.to_fixed(s1, wp)
+        c2 = (c1*c1 - s1*s1) >> wp
+        s2 = (c1 * s1) >> (wp - 1)
+        cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+        if (nd&1):
+            sre = s1 + ((are * sn * 3**nd) >> wp)
+            sim = ((aim * sn * 3**nd) >> wp)
+        else:
+            sre = c1 + ((are * cn * 3**nd) >> wp)
+            sim = ((aim * cn * 3**nd) >> wp)
+        n = 5
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+
+            if (nd&1):
+                sre += ((are * sn * n**nd) >> wp)
+                sim += ((aim * sn * n**nd) >> wp)
+            else:
+                sre += ((are * cn * n**nd) >> wp)
+                sim += ((aim * cn * n**nd) >> wp)
+            n += 2
+        sre = -(sre << 1)
+        sim = -(sim << 1)
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    #case z complex, q real
+    elif not ctx._im(q):
+        wp = ctx.prec + extra2
+        x = ctx.to_fixed(ctx._re(q), wp)
+        x2 = (x*x) >> wp
+        a = b = x2
+        prec0 = ctx.prec
+        ctx.prec = wp
+        c1, s1 = ctx.cos_sin(z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        #c2 = (c1*c1 - s1*s1) >> wp
+        c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+        c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+        #s2 = (c1 * s1) >> (wp - 1)
+        s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+        s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+        #cn, sn = (cn*c2 - sn*s2) >> wp, (sn*c2 + cn*s2) >> wp
+        t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+        t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+        t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+        t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+        cnre = t1
+        cnim = t2
+        snre = t3
+        snim = t4
+        if (nd&1):
+            sre = s1re + ((a * snre * 3**nd) >> wp)
+            sim = s1im + ((a * snim * 3**nd) >> wp)
+        else:
+            sre = c1re + ((a * cnre * 3**nd) >> wp)
+            sim = c1im + ((a * cnim * 3**nd) >> wp)
+        n = 5
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if (nd&1):
+                sre += ((a * snre * n**nd) >> wp)
+                sim += ((a * snim * n**nd) >> wp)
+            else:
+                sre += ((a * cnre * n**nd) >> wp)
+                sim += ((a * cnim * n**nd) >> wp)
+            n += 2
+        sre = -(sre << 1)
+        sim = -(sim << 1)
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    # case z and q complex
+    else:
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = x2re
+        aim = bim = x2im
+        prec0 = ctx.prec
+        ctx.prec = wp
+        # cos(2*z), sin(2*z) with z complex
+        c1, s1 = ctx.cos_sin(z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        c2re = (c1re*c1re - c1im*c1im - s1re*s1re + s1im*s1im) >> wp
+        c2im = (c1re*c1im - s1re*s1im) >> (wp - 1)
+        s2re = (c1re*s1re - c1im*s1im) >> (wp - 1)
+        s2im = (c1re*s1im + c1im*s1re) >> (wp - 1)
+        t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+        t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+        t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+        t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+        cnre = t1
+        cnim = t2
+        snre = t3
+        snim = t4
+        if (nd&1):
+            sre = s1re + (((are * snre - aim * snim) * 3**nd) >> wp)
+            sim = s1im + (((are * snim + aim * snre)* 3**nd) >> wp)
+        else:
+            sre = c1re + (((are * cnre - aim * cnim) * 3**nd) >> wp)
+            sim = c1im + (((are * cnim + aim * cnre)* 3**nd) >> wp)
+        n = 5
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            #cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+            t1 = (cnre*c2re - cnim*c2im - snre*s2re + snim*s2im) >> wp
+            t2 = (cnre*c2im + cnim*c2re - snre*s2im - snim*s2re) >> wp
+            t3 = (snre*c2re - snim*c2im + cnre*s2re - cnim*s2im) >> wp
+            t4 = (snre*c2im + snim*c2re + cnre*s2im + cnim*s2re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if (nd&1):
+                sre += (((are * snre - aim * snim) * n**nd) >> wp)
+                sim += (((aim * snre + are * snim) * n**nd) >> wp)
+            else:
+                sre += (((are * cnre - aim * cnim) * n**nd) >> wp)
+                sim += (((aim * cnre + are * cnim) * n**nd) >> wp)
+            n += 2
+        sre = -(sre << 1)
+        sim = -(sim << 1)
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    s *= ctx.nthroot(q, 4)
+    if (nd&1):
+        return (-1)**(nd//2) * s
+    else:
+        return (-1)**(1 + nd//2) * s
+
+@defun
+def _jacobi_theta3(ctx, z, q):
+    extra1 = 10
+    extra2 = 20
+    MIN = 2
+    if z == ctx.zero:
+        if not ctx._im(q):
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            s = x
+            a = b = x
+            x2 = (x*x) >> wp
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                s += a
+            s = (1 << wp) + (s << 1)
+            s = ctx.ldexp(s, -wp)
+            return s
+        else:
+            wp = ctx.prec + extra1
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            sre = are = bre = xre
+            sim = aim = bim = xim
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                sre += are
+                sim += aim
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+    else:
+        if (not ctx._im(q)) and (not ctx._im(z)):
+            s = 0
+            wp = ctx.prec + extra1
+            x = ctx.to_fixed(ctx._re(q), wp)
+            a = b = x
+            x2 = (x*x) >> wp
+            c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+            c1 = ctx.to_fixed(c1, wp)
+            s1 = ctx.to_fixed(s1, wp)
+            cn = c1
+            sn = s1
+            s += (a * cn) >> wp
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+                s += (a * cn) >> wp
+            s = (1 << wp) + (s << 1)
+            s = ctx.ldexp(s, -wp)
+            return s
+        # case z real, q complex
+        elif not ctx._im(z):
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = xre
+            aim = bim = xim
+            c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+            c1 = ctx.to_fixed(c1, wp)
+            s1 = ctx.to_fixed(s1, wp)
+            cn = c1
+            sn = s1
+            sre = (are * cn) >> wp
+            sim = (aim * cn) >> wp
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+                sre += (are * cn) >> wp
+                sim += (aim * cn) >> wp
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+        #case z complex, q real
+        elif not ctx._im(q):
+            wp = ctx.prec + extra2
+            x = ctx.to_fixed(ctx._re(q), wp)
+            a = b = x
+            x2 = (x*x) >> wp
+            prec0 = ctx.prec
+            ctx.prec = wp
+            c1, s1 = ctx.cos_sin(2*z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            sre = (a * cnre) >> wp
+            sim = (a * cnim) >> wp
+            while abs(a) > MIN:
+                b = (b*x2) >> wp
+                a = (a*b) >> wp
+                t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+                t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+                t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+                t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                sre += (a * cnre) >> wp
+                sim += (a * cnim) >> wp
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+        # case z and q complex
+        else:
+            wp = ctx.prec + extra2
+            xre = ctx.to_fixed(ctx._re(q), wp)
+            xim = ctx.to_fixed(ctx._im(q), wp)
+            x2re = (xre*xre - xim*xim) >> wp
+            x2im = (xre*xim) >> (wp - 1)
+            are = bre = xre
+            aim = bim = xim
+            prec0 = ctx.prec
+            ctx.prec = wp
+            # cos(2*z), sin(2*z) with z complex
+            c1, s1 = ctx.cos_sin(2*z)
+            ctx.prec = prec0
+            cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+            cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+            snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+            snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+            sre = (are * cnre - aim * cnim) >> wp
+            sim = (aim * cnre + are * cnim) >> wp
+            while are**2 + aim**2 > MIN:
+                bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                           (bre * x2im + bim * x2re) >> wp
+                are, aim = (are * bre - aim * bim) >> wp,   \
+                           (are * bim + aim * bre) >> wp
+                t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+                t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+                t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+                t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+                cnre = t1
+                cnim = t2
+                snre = t3
+                snim = t4
+                sre += (are * cnre - aim * cnim) >> wp
+                sim += (aim * cnre + are * cnim) >> wp
+            sre = (1 << wp) + (sre << 1)
+            sim = (sim << 1)
+            sre = ctx.ldexp(sre, -wp)
+            sim = ctx.ldexp(sim, -wp)
+            s = ctx.mpc(sre, sim)
+            return s
+
+@defun
+def _djacobi_theta3(ctx, z, q, nd):
+    """nd=1,2,3 order of the derivative with respect to z"""
+    MIN = 2
+    extra1 = 10
+    extra2 = 20
+    if (not ctx._im(q)) and (not ctx._im(z)):
+        s = 0
+        wp = ctx.prec + extra1
+        x = ctx.to_fixed(ctx._re(q), wp)
+        a = b = x
+        x2 = (x*x) >> wp
+        c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+        c1 = ctx.to_fixed(c1, wp)
+        s1 = ctx.to_fixed(s1, wp)
+        cn = c1
+        sn = s1
+        if (nd&1):
+            s += (a * sn) >> wp
+        else:
+            s += (a * cn) >> wp
+        n = 2
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+            if nd&1:
+                s += (a * sn * n**nd) >> wp
+            else:
+                s += (a * cn * n**nd) >> wp
+            n += 1
+        s = -(s << (nd+1))
+        s = ctx.ldexp(s, -wp)
+    # case z real, q complex
+    elif not ctx._im(z):
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = xre
+        aim = bim = xim
+        c1, s1 = ctx.cos_sin(ctx._re(z)*2, prec=wp)
+        c1 = ctx.to_fixed(c1, wp)
+        s1 = ctx.to_fixed(s1, wp)
+        cn = c1
+        sn = s1
+        if (nd&1):
+            sre = (are * sn) >> wp
+            sim = (aim * sn) >> wp
+        else:
+            sre = (are * cn) >> wp
+            sim = (aim * cn) >> wp
+        n = 2
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            cn, sn = (cn*c1 - sn*s1) >> wp, (sn*c1 + cn*s1) >> wp
+            if nd&1:
+                sre += (are * sn * n**nd) >> wp
+                sim += (aim * sn * n**nd) >> wp
+            else:
+                sre += (are * cn * n**nd) >> wp
+                sim += (aim * cn * n**nd) >> wp
+            n += 1
+        sre = -(sre << (nd+1))
+        sim = -(sim << (nd+1))
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    #case z complex, q real
+    elif not ctx._im(q):
+        wp = ctx.prec + extra2
+        x = ctx.to_fixed(ctx._re(q), wp)
+        a = b = x
+        x2 = (x*x) >> wp
+        prec0 = ctx.prec
+        ctx.prec = wp
+        c1, s1 = ctx.cos_sin(2*z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        if (nd&1):
+            sre = (a * snre) >> wp
+            sim = (a * snim) >> wp
+        else:
+            sre = (a * cnre) >> wp
+            sim = (a * cnim) >> wp
+        n = 2
+        while abs(a) > MIN:
+            b = (b*x2) >> wp
+            a = (a*b) >> wp
+            t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+            t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+            t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+            t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if (nd&1):
+                sre += (a * snre * n**nd) >> wp
+                sim += (a * snim * n**nd) >> wp
+            else:
+                sre += (a * cnre * n**nd) >> wp
+                sim += (a * cnim * n**nd) >> wp
+            n += 1
+        sre = -(sre << (nd+1))
+        sim = -(sim << (nd+1))
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    # case z and q complex
+    else:
+        wp = ctx.prec + extra2
+        xre = ctx.to_fixed(ctx._re(q), wp)
+        xim = ctx.to_fixed(ctx._im(q), wp)
+        x2re = (xre*xre - xim*xim) >> wp
+        x2im = (xre*xim) >> (wp - 1)
+        are = bre = xre
+        aim = bim = xim
+        prec0 = ctx.prec
+        ctx.prec = wp
+        # cos(2*z), sin(2*z) with z complex
+        c1, s1 = ctx.cos_sin(2*z)
+        ctx.prec = prec0
+        cnre = c1re = ctx.to_fixed(ctx._re(c1), wp)
+        cnim = c1im = ctx.to_fixed(ctx._im(c1), wp)
+        snre = s1re = ctx.to_fixed(ctx._re(s1), wp)
+        snim = s1im = ctx.to_fixed(ctx._im(s1), wp)
+        if (nd&1):
+            sre = (are * snre - aim * snim) >> wp
+            sim = (aim * snre + are * snim) >> wp
+        else:
+            sre = (are * cnre - aim * cnim) >> wp
+            sim = (aim * cnre + are * cnim) >> wp
+        n = 2
+        while are**2 + aim**2 > MIN:
+            bre, bim = (bre * x2re - bim * x2im) >> wp, \
+                       (bre * x2im + bim * x2re) >> wp
+            are, aim = (are * bre - aim * bim) >> wp,   \
+                       (are * bim + aim * bre) >> wp
+            t1 = (cnre*c1re - cnim*c1im - snre*s1re + snim*s1im) >> wp
+            t2 = (cnre*c1im + cnim*c1re - snre*s1im - snim*s1re) >> wp
+            t3 = (snre*c1re - snim*c1im + cnre*s1re - cnim*s1im) >> wp
+            t4 = (snre*c1im + snim*c1re + cnre*s1im + cnim*s1re) >> wp
+            cnre = t1
+            cnim = t2
+            snre = t3
+            snim = t4
+            if(nd&1):
+                sre += ((are * snre - aim * snim) * n**nd) >> wp
+                sim += ((aim * snre + are * snim) * n**nd) >> wp
+            else:
+                sre += ((are * cnre - aim * cnim) * n**nd) >> wp
+                sim += ((aim * cnre + are * cnim) * n**nd) >> wp
+            n += 1
+        sre = -(sre << (nd+1))
+        sim = -(sim << (nd+1))
+        sre = ctx.ldexp(sre, -wp)
+        sim = ctx.ldexp(sim, -wp)
+        s = ctx.mpc(sre, sim)
+    if (nd&1):
+        return (-1)**(nd//2) * s
+    else:
+        return (-1)**(1 + nd//2) * s
+
+@defun
+def _jacobi_theta2a(ctx, z, q):
+    """
+    case ctx._im(z) != 0
+    theta(2, z, q) =
+    q**1/4 * Sum(q**(n*n + n) * exp(j*(2*n + 1)*z), n=-inf, inf)
+    max term for minimum (2*n+1)*log(q).real - 2* ctx._im(z)
+    n0 = int(ctx._im(z)/log(q).real - 1/2)
+    theta(2, z, q) =
+    q**1/4 * Sum(q**(n*n + n) * exp(j*(2*n + 1)*z), n=n0, inf) +
+    q**1/4 * Sum(q**(n*n + n) * exp(j*(2*n + 1)*z), n, n0-1, -inf)
+    """
+    n = n0 = int(ctx._im(z)/ctx._re(ctx.log(q)) - 1/2)
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj((2*n+1)*z)
+    a = q**(n*n + n)
+    # leading term
+    term = a * e
+    s = term
+    eps1 = ctx.eps*abs(term)
+    while 1:
+        n += 1
+        e = e * e2
+        term = q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        term = q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    s = s * ctx.nthroot(q, 4)
+    return s
+
+@defun
+def _jacobi_theta3a(ctx, z, q):
+    """
+    case ctx._im(z) != 0
+    theta3(z, q) = Sum(q**(n*n) * exp(j*2*n*z), n, -inf, inf)
+    max term for n*abs(log(q).real) + ctx._im(z) ~= 0
+    n0 = int(- ctx._im(z)/abs(log(q).real))
+    """
+    n = n0 = int(-ctx._im(z)/abs(ctx._re(ctx.log(q))))
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj(2*n*z)
+    s = term = q**(n*n) * e
+    eps1 = ctx.eps*abs(term)
+    while 1:
+        n += 1
+        e = e * e2
+        term = q**(n*n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        term = q**(n*n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    return s
+
+@defun
+def _djacobi_theta2a(ctx, z, q, nd):
+    """
+    case ctx._im(z) != 0
+    dtheta(2, z, q, nd) =
+    j* q**1/4 * Sum(q**(n*n + n) * (2*n+1)*exp(j*(2*n + 1)*z), n=-inf, inf)
+    max term for (2*n0+1)*log(q).real - 2* ctx._im(z) ~= 0
+    n0 = int(ctx._im(z)/log(q).real - 1/2)
+    """
+    n = n0 = int(ctx._im(z)/ctx._re(ctx.log(q)) - 1/2)
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj((2*n + 1)*z)
+    a = q**(n*n + n)
+    # leading term
+    term = (2*n+1)**nd * a * e
+    s = term
+    eps1 = ctx.eps*abs(term)
+    while 1:
+        n += 1
+        e = e * e2
+        term = (2*n+1)**nd * q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        term = (2*n+1)**nd * q**(n*n + n) * e
+        if abs(term) < eps1:
+            break
+        s += term
+    return ctx.j**nd * s * ctx.nthroot(q, 4)
+
+@defun
+def _djacobi_theta3a(ctx, z, q, nd):
+    """
+    case ctx._im(z) != 0
+    djtheta3(z, q, nd) = (2*j)**nd *
+      Sum(q**(n*n) * n**nd * exp(j*2*n*z), n, -inf, inf)
+    max term for minimum n*abs(log(q).real) + ctx._im(z)
+    """
+    n = n0 = int(-ctx._im(z)/abs(ctx._re(ctx.log(q))))
+    e2 = ctx.expj(2*z)
+    e = e0 = ctx.expj(2*n*z)
+    a = q**(n*n) * e
+    s = term = n**nd * a
+    if n != 0:
+        eps1 = ctx.eps*abs(term)
+    else:
+        eps1 = ctx.eps*abs(a)
+    while 1:
+        n += 1
+        e = e * e2
+        a = q**(n*n) * e
+        term = n**nd * a
+        if n != 0:
+            aterm = abs(term)
+        else:
+            aterm = abs(a)
+        if aterm < eps1:
+            break
+        s += term
+    e = e0
+    e2 = ctx.expj(-2*z)
+    n = n0
+    while 1:
+        n -= 1
+        e = e * e2
+        a = q**(n*n) * e
+        term = n**nd * a
+        if n != 0:
+            aterm = abs(term)
+        else:
+            aterm = abs(a)
+        if aterm < eps1:
+            break
+        s += term
+    return (2*ctx.j)**nd * s
+
+@defun
+def jtheta(ctx, n, z, q, derivative=0):
+    if derivative:
+        return ctx._djtheta(n, z, q, derivative)
+
+    z = ctx.convert(z)
+    q = ctx.convert(q)
+
+    # Implementation note
+    # If ctx._im(z) is close to zero, _jacobi_theta2 and _jacobi_theta3
+    # are used,
+    # which compute the series starting from n=0 using fixed precision
+    # numbers;
+    # otherwise  _jacobi_theta2a and _jacobi_theta3a are used, which compute
+    # the series starting from n=n0, which is the largest term.
+
+    # TODO: write _jacobi_theta2a and _jacobi_theta3a using fixed-point
+
+    if abs(q) > ctx.THETA_Q_LIM:
+        raise ValueError('abs(q) > THETA_Q_LIM = %f' % ctx.THETA_Q_LIM)
+
+    extra = 10
+    if z:
+        M = ctx.mag(z)
+        if M > 5 or (n == 1 and M < -5):
+            extra += 2*abs(M)
+    cz = 0.5
+    extra2 = 50
+    prec0 = ctx.prec
+    try:
+        ctx.prec += extra
+        if n == 1:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta2(z - ctx.pi/2, q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta2a(z - ctx.pi/2, q)
+            else:
+                res = ctx._jacobi_theta2(z - ctx.pi/2, q)
+        elif n == 2:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta2(z, q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta2a(z, q)
+            else:
+                res = ctx._jacobi_theta2(z, q)
+        elif n == 3:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta3(z, q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta3a(z, q)
+            else:
+                res = ctx._jacobi_theta3(z, q)
+        elif n == 4:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._jacobi_theta3(z, -q)
+                else:
+                    ctx.dps += 10
+                    res = ctx._jacobi_theta3a(z, -q)
+            else:
+                res = ctx._jacobi_theta3(z, -q)
+        else:
+            raise ValueError
+    finally:
+        ctx.prec = prec0
+    return res
+
+@defun
+def _djtheta(ctx, n, z, q, derivative=1):
+    z = ctx.convert(z)
+    q = ctx.convert(q)
+    nd = int(derivative)
+
+    if abs(q) > ctx.THETA_Q_LIM:
+        raise ValueError('abs(q) > THETA_Q_LIM = %f' % ctx.THETA_Q_LIM)
+    extra = 10 + ctx.prec * nd // 10
+    if z:
+        M = ctx.mag(z)
+        if M > 5 or (n != 1 and M < -5):
+            extra += 2*abs(M)
+    cz = 0.5
+    extra2 = 50
+    prec0 = ctx.prec
+    try:
+        ctx.prec += extra
+        if n == 1:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta2(z - ctx.pi/2, q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta2a(z - ctx.pi/2, q, nd)
+            else:
+                res = ctx._djacobi_theta2(z - ctx.pi/2, q, nd)
+        elif n == 2:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta2(z, q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta2a(z, q, nd)
+            else:
+                res = ctx._djacobi_theta2(z, q, nd)
+        elif n == 3:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta3(z, q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta3a(z, q, nd)
+            else:
+                res = ctx._djacobi_theta3(z, q, nd)
+        elif n == 4:
+            if ctx._im(z):
+                if abs(ctx._im(z)) < cz * abs(ctx._re(ctx.log(q))):
+                    ctx.dps += extra2
+                    res = ctx._djacobi_theta3(z, -q, nd)
+                else:
+                    ctx.dps += 10
+                    res = ctx._djacobi_theta3a(z, -q, nd)
+            else:
+                res = ctx._djacobi_theta3(z, -q, nd)
+        else:
+            raise ValueError
+    finally:
+        ctx.prec = prec0
+    return +res
diff --git a/lib/python3.11/site-packages/mpmath/functions/zeta.py b/lib/python3.11/site-packages/mpmath/functions/zeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7ede50d95e5b6eff511619620c934529942cbdd
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/zeta.py
@@ -0,0 +1,1154 @@
+from __future__ import print_function
+
+from ..libmp.backend import xrange
+from .functions import defun, defun_wrapped, defun_static
+
+@defun
+def stieltjes(ctx, n, a=1):
+    n = ctx.convert(n)
+    a = ctx.convert(a)
+    if n < 0:
+        return ctx.bad_domain("Stieltjes constants defined for n >= 0")
+    if hasattr(ctx, "stieltjes_cache"):
+        stieltjes_cache = ctx.stieltjes_cache
+    else:
+        stieltjes_cache = ctx.stieltjes_cache = {}
+    if a == 1:
+        if n == 0:
+            return +ctx.euler
+        if n in stieltjes_cache:
+            prec, s = stieltjes_cache[n]
+            if prec >= ctx.prec:
+                return +s
+    mag = 1
+    def f(x):
+        xa = x/a
+        v = (xa-ctx.j)*ctx.ln(a-ctx.j*x)**n/(1+xa**2)/(ctx.exp(2*ctx.pi*x)-1)
+        return ctx._re(v) / mag
+    orig = ctx.prec
+    try:
+        # Normalize integrand by approx. magnitude to
+        # speed up quadrature (which uses absolute error)
+        if n > 50:
+            ctx.prec = 20
+            mag = ctx.quad(f, [0,ctx.inf], maxdegree=3)
+        ctx.prec = orig + 10 + int(n**0.5)
+        s = ctx.quad(f, [0,ctx.inf], maxdegree=20)
+        v = ctx.ln(a)**n/(2*a) - ctx.ln(a)**(n+1)/(n+1) + 2*s/a*mag
+    finally:
+        ctx.prec = orig
+    if a == 1 and ctx.isint(n):
+        stieltjes_cache[n] = (ctx.prec, v)
+    return +v
+
+@defun_wrapped
+def siegeltheta(ctx, t, derivative=0):
+    d = int(derivative)
+    if  (t == ctx.inf or t == ctx.ninf):
+        if d < 2:
+            if t == ctx.ninf and d == 0:
+                return ctx.ninf
+            return ctx.inf
+        else:
+            return ctx.zero
+    if d == 0:
+        if ctx._im(t):
+            # XXX: cancellation occurs
+            a = ctx.loggamma(0.25+0.5j*t)
+            b = ctx.loggamma(0.25-0.5j*t)
+            return -ctx.ln(ctx.pi)/2*t - 0.5j*(a-b)
+        else:
+            if ctx.isinf(t):
+                return t
+            return ctx._im(ctx.loggamma(0.25+0.5j*t)) - ctx.ln(ctx.pi)/2*t
+    if d > 0:
+        a = (-0.5j)**(d-1)*ctx.polygamma(d-1, 0.25-0.5j*t)
+        b = (0.5j)**(d-1)*ctx.polygamma(d-1, 0.25+0.5j*t)
+        if ctx._im(t):
+            if d == 1:
+                return -0.5*ctx.log(ctx.pi)+0.25*(a+b)
+            else:
+                return 0.25*(a+b)
+        else:
+            if d == 1:
+                return ctx._re(-0.5*ctx.log(ctx.pi)+0.25*(a+b))
+            else:
+                return ctx._re(0.25*(a+b))
+
+@defun_wrapped
+def grampoint(ctx, n):
+    # asymptotic expansion, from
+    # http://mathworld.wolfram.com/GramPoint.html
+    g = 2*ctx.pi*ctx.exp(1+ctx.lambertw((8*n+1)/(8*ctx.e)))
+    return ctx.findroot(lambda t: ctx.siegeltheta(t)-ctx.pi*n, g)
+
+
+@defun_wrapped
+def siegelz(ctx, t, **kwargs):
+    d = int(kwargs.get("derivative", 0))
+    t = ctx.convert(t)
+    t1 = ctx._re(t)
+    t2 = ctx._im(t)
+    prec = ctx.prec
+    try:
+        if abs(t1) > 500*prec and t2**2 < t1:
+            v = ctx.rs_z(t, d)
+            if ctx._is_real_type(t):
+                return ctx._re(v)
+            return v
+    except NotImplementedError:
+        pass
+    ctx.prec += 21
+    e1 = ctx.expj(ctx.siegeltheta(t))
+    z = ctx.zeta(0.5+ctx.j*t)
+    if d == 0:
+        v = e1*z
+        ctx.prec=prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    z1 = ctx.zeta(0.5+ctx.j*t, derivative=1)
+    theta1 = ctx.siegeltheta(t, derivative=1)
+    if d == 1:
+        v =  ctx.j*e1*(z1+z*theta1)
+        ctx.prec=prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    z2 = ctx.zeta(0.5+ctx.j*t, derivative=2)
+    theta2 = ctx.siegeltheta(t, derivative=2)
+    comb1 = theta1**2-ctx.j*theta2
+    if d == 2:
+        def terms():
+            return [2*z1*theta1, z2, z*comb1]
+        v = ctx.sum_accurately(terms, 1)
+        v =  -e1*v
+        ctx.prec = prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    ctx.prec += 10
+    z3 = ctx.zeta(0.5+ctx.j*t, derivative=3)
+    theta3 = ctx.siegeltheta(t, derivative=3)
+    comb2 = theta1**3-3*ctx.j*theta1*theta2-theta3
+    if d == 3:
+        def terms():
+            return  [3*theta1*z2, 3*z1*comb1, z3+z*comb2]
+        v = ctx.sum_accurately(terms, 1)
+        v =  -ctx.j*e1*v
+        ctx.prec = prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    z4 = ctx.zeta(0.5+ctx.j*t, derivative=4)
+    theta4 = ctx.siegeltheta(t, derivative=4)
+    def terms():
+        return [theta1**4, -6*ctx.j*theta1**2*theta2, -3*theta2**2,
+            -4*theta1*theta3, ctx.j*theta4]
+    comb3 = ctx.sum_accurately(terms, 1)
+    if d == 4:
+        def terms():
+            return  [6*theta1**2*z2, -6*ctx.j*z2*theta2, 4*theta1*z3,
+                 4*z1*comb2, z4, z*comb3]
+        v = ctx.sum_accurately(terms, 1)
+        v =  e1*v
+        ctx.prec = prec
+        if ctx._is_real_type(t):
+            return ctx._re(v)
+        return +v
+    if d > 4:
+        h = lambda x: ctx.siegelz(x, derivative=4)
+        return ctx.diff(h, t, n=d-4)
+
+
+_zeta_zeros = [
+14.134725142,21.022039639,25.010857580,30.424876126,32.935061588,
+37.586178159,40.918719012,43.327073281,48.005150881,49.773832478,
+52.970321478,56.446247697,59.347044003,60.831778525,65.112544048,
+67.079810529,69.546401711,72.067157674,75.704690699,77.144840069,
+79.337375020,82.910380854,84.735492981,87.425274613,88.809111208,
+92.491899271,94.651344041,95.870634228,98.831194218,101.317851006,
+103.725538040,105.446623052,107.168611184,111.029535543,111.874659177,
+114.320220915,116.226680321,118.790782866,121.370125002,122.946829294,
+124.256818554,127.516683880,129.578704200,131.087688531,133.497737203,
+134.756509753,138.116042055,139.736208952,141.123707404,143.111845808,
+146.000982487,147.422765343,150.053520421,150.925257612,153.024693811,
+156.112909294,157.597591818,158.849988171,161.188964138,163.030709687,
+165.537069188,167.184439978,169.094515416,169.911976479,173.411536520,
+174.754191523,176.441434298,178.377407776,179.916484020,182.207078484,
+184.874467848,185.598783678,187.228922584,189.416158656,192.026656361,
+193.079726604,195.265396680,196.876481841,198.015309676,201.264751944,
+202.493594514,204.189671803,205.394697202,207.906258888,209.576509717,
+211.690862595,213.347919360,214.547044783,216.169538508,219.067596349,
+220.714918839,221.430705555,224.007000255,224.983324670,227.421444280,
+229.337413306,231.250188700,231.987235253,233.693404179,236.524229666,
+]
+
+def _load_zeta_zeros(url):
+    import urllib
+    d = urllib.urlopen(url)
+    L = [float(x) for x in d.readlines()]
+    # Sanity check
+    assert round(L[0]) == 14
+    _zeta_zeros[:] = L
+
+@defun
+def oldzetazero(ctx, n, url='http://www.dtc.umn.edu/~odlyzko/zeta_tables/zeros1'):
+    n = int(n)
+    if n < 0:
+        return ctx.zetazero(-n).conjugate()
+    if n == 0:
+        raise ValueError("n must be nonzero")
+    if n > len(_zeta_zeros) and n <= 100000:
+        _load_zeta_zeros(url)
+    if n > len(_zeta_zeros):
+        raise NotImplementedError("n too large for zetazeros")
+    return ctx.mpc(0.5, ctx.findroot(ctx.siegelz, _zeta_zeros[n-1]))
+
+@defun_wrapped
+def riemannr(ctx, x):
+    if x == 0:
+        return ctx.zero
+    # Check if a simple asymptotic estimate is accurate enough
+    if abs(x) > 1000:
+        a = ctx.li(x)
+        b = 0.5*ctx.li(ctx.sqrt(x))
+        if abs(b) < abs(a)*ctx.eps:
+            return a
+    if abs(x) < 0.01:
+        # XXX
+        ctx.prec += int(-ctx.log(abs(x),2))
+    # Sum Gram's series
+    s = t = ctx.one
+    u = ctx.ln(x)
+    k = 1
+    while abs(t) > abs(s)*ctx.eps:
+        t = t * u / k
+        s += t / (k * ctx._zeta_int(k+1))
+        k += 1
+    return s
+
+@defun_static
+def primepi(ctx, x):
+    x = int(x)
+    if x < 2:
+        return 0
+    return len(ctx.list_primes(x))
+
+# TODO: fix the interface wrt contexts
+@defun_wrapped
+def primepi2(ctx, x):
+    x = int(x)
+    if x < 2:
+        return ctx._iv.zero
+    if x < 2657:
+        return ctx._iv.mpf(ctx.primepi(x))
+    mid = ctx.li(x)
+    # Schoenfeld's estimate for x >= 2657, assuming RH
+    err = ctx.sqrt(x,rounding='u')*ctx.ln(x,rounding='u')/8/ctx.pi(rounding='d')
+    a = ctx.floor((ctx._iv.mpf(mid)-err).a, rounding='d')
+    b = ctx.ceil((ctx._iv.mpf(mid)+err).b, rounding='u')
+    return ctx._iv.mpf([a,b])
+
+@defun_wrapped
+def primezeta(ctx, s):
+    if ctx.isnan(s):
+        return s
+    if ctx.re(s) <= 0:
+        raise ValueError("prime zeta function defined only for re(s) > 0")
+    if s == 1:
+        return ctx.inf
+    if s == 0.5:
+        return ctx.mpc(ctx.ninf, ctx.pi)
+    r = ctx.re(s)
+    if r > ctx.prec:
+        return 0.5**s
+    else:
+        wp = ctx.prec + int(r)
+        def terms():
+            orig = ctx.prec
+            # zeta ~ 1+eps; need to set precision
+            # to get logarithm accurately
+            k = 0
+            while 1:
+                k += 1
+                u = ctx.moebius(k)
+                if not u:
+                    continue
+                ctx.prec = wp
+                t = u*ctx.ln(ctx.zeta(k*s))/k
+                if not t:
+                    return
+                #print ctx.prec, ctx.nstr(t)
+                ctx.prec = orig
+                yield t
+    return ctx.sum_accurately(terms)
+
+# TODO: for bernpoly and eulerpoly, ensure that all exact zeros are covered
+
+@defun_wrapped
+def bernpoly(ctx, n, z):
+    # Slow implementation:
+    #return sum(ctx.binomial(n,k)*ctx.bernoulli(k)*z**(n-k) for k in xrange(0,n+1))
+    n = int(n)
+    if n < 0:
+        raise ValueError("Bernoulli polynomials only defined for n >= 0")
+    if z == 0 or (z == 1 and n > 1):
+        return ctx.bernoulli(n)
+    if z == 0.5:
+        return (ctx.ldexp(1,1-n)-1)*ctx.bernoulli(n)
+    if n <= 3:
+        if n == 0: return z ** 0
+        if n == 1: return z - 0.5
+        if n == 2: return (6*z*(z-1)+1)/6
+        if n == 3: return z*(z*(z-1.5)+0.5)
+    if ctx.isinf(z):
+        return z ** n
+    if ctx.isnan(z):
+        return z
+    if abs(z) > 2:
+        def terms():
+            t = ctx.one
+            yield t
+            r = ctx.one/z
+            k = 1
+            while k <= n:
+                t = t*(n+1-k)/k*r
+                if not (k > 2 and k & 1):
+                    yield t*ctx.bernoulli(k)
+                k += 1
+        return ctx.sum_accurately(terms) * z**n
+    else:
+        def terms():
+            yield ctx.bernoulli(n)
+            t = ctx.one
+            k = 1
+            while k <= n:
+                t = t*(n+1-k)/k * z
+                m = n-k
+                if not (m > 2 and m & 1):
+                    yield t*ctx.bernoulli(m)
+                k += 1
+        return ctx.sum_accurately(terms)
+
+@defun_wrapped
+def eulerpoly(ctx, n, z):
+    n = int(n)
+    if n < 0:
+        raise ValueError("Euler polynomials only defined for n >= 0")
+    if n <= 2:
+        if n == 0: return z ** 0
+        if n == 1: return z - 0.5
+        if n == 2: return z*(z-1)
+    if ctx.isinf(z):
+        return z**n
+    if ctx.isnan(z):
+        return z
+    m = n+1
+    if z == 0:
+        return -2*(ctx.ldexp(1,m)-1)*ctx.bernoulli(m)/m * z**0
+    if z == 1:
+        return 2*(ctx.ldexp(1,m)-1)*ctx.bernoulli(m)/m * z**0
+    if z == 0.5:
+        if n % 2:
+            return ctx.zero
+        # Use exact code for Euler numbers
+        if n < 100 or n*ctx.mag(0.46839865*n) < ctx.prec*0.25:
+            return ctx.ldexp(ctx._eulernum(n), -n)
+    # http://functions.wolfram.com/Polynomials/EulerE2/06/01/02/01/0002/
+    def terms():
+        t = ctx.one
+        k = 0
+        w = ctx.ldexp(1,n+2)
+        while 1:
+            v = n-k+1
+            if not (v > 2 and v & 1):
+                yield (2-w)*ctx.bernoulli(v)*t
+            k += 1
+            if k > n:
+                break
+            t = t*z*(n-k+2)/k
+            w *= 0.5
+    return ctx.sum_accurately(terms) / m
+
+@defun
+def eulernum(ctx, n, exact=False):
+    n = int(n)
+    if exact:
+        return int(ctx._eulernum(n))
+    if n < 100:
+        return ctx.mpf(ctx._eulernum(n))
+    if n % 2:
+        return ctx.zero
+    return ctx.ldexp(ctx.eulerpoly(n,0.5), n)
+
+# TODO: this should be implemented low-level
+def polylog_series(ctx, s, z):
+    tol = +ctx.eps
+    l = ctx.zero
+    k = 1
+    zk = z
+    while 1:
+        term = zk / k**s
+        l += term
+        if abs(term) < tol:
+            break
+        zk *= z
+        k += 1
+    return l
+
+def polylog_continuation(ctx, n, z):
+    if n < 0:
+        return z*0
+    twopij = 2j * ctx.pi
+    a = -twopij**n/ctx.fac(n) * ctx.bernpoly(n, ctx.ln(z)/twopij)
+    if ctx._is_real_type(z) and z < 0:
+        a = ctx._re(a)
+    if ctx._im(z) < 0 or (ctx._im(z) == 0 and ctx._re(z) >= 1):
+        a -= twopij*ctx.ln(z)**(n-1)/ctx.fac(n-1)
+    return a
+
+def polylog_unitcircle(ctx, n, z):
+    tol = +ctx.eps
+    if n > 1:
+        l = ctx.zero
+        logz = ctx.ln(z)
+        logmz = ctx.one
+        m = 0
+        while 1:
+            if (n-m) != 1:
+                term = ctx.zeta(n-m) * logmz / ctx.fac(m)
+                if term and abs(term) < tol:
+                    break
+                l += term
+            logmz *= logz
+            m += 1
+        l += ctx.ln(z)**(n-1)/ctx.fac(n-1)*(ctx.harmonic(n-1)-ctx.ln(-ctx.ln(z)))
+    elif n < 1:  # else
+        l = ctx.fac(-n)*(-ctx.ln(z))**(n-1)
+        logz = ctx.ln(z)
+        logkz = ctx.one
+        k = 0
+        while 1:
+            b = ctx.bernoulli(k-n+1)
+            if b:
+                term = b*logkz/(ctx.fac(k)*(k-n+1))
+                if abs(term) < tol:
+                    break
+                l -= term
+            logkz *= logz
+            k += 1
+    else:
+        raise ValueError
+    if ctx._is_real_type(z) and z < 0:
+        l = ctx._re(l)
+    return l
+
+def polylog_general(ctx, s, z):
+    v = ctx.zero
+    u = ctx.ln(z)
+    if not abs(u) < 5: # theoretically |u| < 2*pi
+        j = ctx.j
+        v = 1-s
+        y = ctx.ln(-z)/(2*ctx.pi*j)
+        return ctx.gamma(v)*(j**v*ctx.zeta(v,0.5+y) + j**-v*ctx.zeta(v,0.5-y))/(2*ctx.pi)**v
+    t = 1
+    k = 0
+    while 1:
+        term = ctx.zeta(s-k) * t
+        if abs(term) < ctx.eps:
+            break
+        v += term
+        k += 1
+        t *= u
+        t /= k
+    return ctx.gamma(1-s)*(-u)**(s-1) + v
+
+@defun_wrapped
+def polylog(ctx, s, z):
+    s = ctx.convert(s)
+    z = ctx.convert(z)
+    if z == 1:
+        return ctx.zeta(s)
+    if z == -1:
+        return -ctx.altzeta(s)
+    if s == 0:
+        return z/(1-z)
+    if s == 1:
+        return -ctx.ln(1-z)
+    if s == -1:
+        return z/(1-z)**2
+    if abs(z) <= 0.75 or (not ctx.isint(s) and abs(z) < 0.9):
+        return polylog_series(ctx, s, z)
+    if abs(z) >= 1.4 and ctx.isint(s):
+        return (-1)**(s+1)*polylog_series(ctx, s, 1/z) + polylog_continuation(ctx, int(ctx.re(s)), z)
+    if ctx.isint(s):
+        return polylog_unitcircle(ctx, int(ctx.re(s)), z)
+    return polylog_general(ctx, s, z)
+
+@defun_wrapped
+def clsin(ctx, s, z, pi=False):
+    if ctx.isint(s) and s < 0 and int(s) % 2 == 1:
+        return z*0
+    if pi:
+        a = ctx.expjpi(z)
+    else:
+        a = ctx.expj(z)
+    if ctx._is_real_type(z) and ctx._is_real_type(s):
+        return ctx.im(ctx.polylog(s,a))
+    b = 1/a
+    return (-0.5j)*(ctx.polylog(s,a) - ctx.polylog(s,b))
+
+@defun_wrapped
+def clcos(ctx, s, z, pi=False):
+    if ctx.isint(s) and s < 0 and int(s) % 2 == 0:
+        return z*0
+    if pi:
+        a = ctx.expjpi(z)
+    else:
+        a = ctx.expj(z)
+    if ctx._is_real_type(z) and ctx._is_real_type(s):
+        return ctx.re(ctx.polylog(s,a))
+    b = 1/a
+    return 0.5*(ctx.polylog(s,a) + ctx.polylog(s,b))
+
+@defun
+def altzeta(ctx, s, **kwargs):
+    try:
+        return ctx._altzeta(s, **kwargs)
+    except NotImplementedError:
+        return ctx._altzeta_generic(s)
+
+@defun_wrapped
+def _altzeta_generic(ctx, s):
+    if s == 1:
+        return ctx.ln2 + 0*s
+    return -ctx.powm1(2, 1-s) * ctx.zeta(s)
+
+@defun
+def zeta(ctx, s, a=1, derivative=0, method=None, **kwargs):
+    d = int(derivative)
+    if a == 1 and not (d or method):
+        try:
+            return ctx._zeta(s, **kwargs)
+        except NotImplementedError:
+            pass
+    s = ctx.convert(s)
+    prec = ctx.prec
+    method = kwargs.get('method')
+    verbose = kwargs.get('verbose')
+    if (not s) and (not derivative):
+        return ctx.mpf(0.5) - ctx._convert_param(a)[0]
+    if a == 1 and method != 'euler-maclaurin':
+        im = abs(ctx._im(s))
+        re = abs(ctx._re(s))
+        #if (im < prec or method == 'borwein') and not derivative:
+        #    try:
+        #        if verbose:
+        #            print "zeta: Attempting to use the Borwein algorithm"
+        #        return ctx._zeta(s, **kwargs)
+        #    except NotImplementedError:
+        #        if verbose:
+        #            print "zeta: Could not use the Borwein algorithm"
+        #        pass
+        if abs(im) > 500*prec and 10*re < prec and derivative <= 4 or \
+            method == 'riemann-siegel':
+            try:   #  py2.4 compatible try block
+                try:
+                    if verbose:
+                        print("zeta: Attempting to use the Riemann-Siegel algorithm")
+                    return ctx.rs_zeta(s, derivative, **kwargs)
+                except NotImplementedError:
+                    if verbose:
+                        print("zeta: Could not use the Riemann-Siegel algorithm")
+                    pass
+            finally:
+                ctx.prec = prec
+    if s == 1:
+        return ctx.inf
+    abss = abs(s)
+    if abss == ctx.inf:
+        if ctx.re(s) == ctx.inf:
+            if d == 0:
+                return ctx.one
+            return ctx.zero
+        return s*0
+    elif ctx.isnan(abss):
+        return 1/s
+    if ctx.re(s) > 2*ctx.prec and a == 1 and not derivative:
+        return ctx.one + ctx.power(2, -s)
+    return +ctx._hurwitz(s, a, d, **kwargs)
+
+@defun
+def _hurwitz(ctx, s, a=1, d=0, **kwargs):
+    prec = ctx.prec
+    verbose = kwargs.get('verbose')
+    try:
+        extraprec = 10
+        ctx.prec += extraprec
+        # We strongly want to special-case rational a
+        a, atype = ctx._convert_param(a)
+        if ctx.re(s) < 0:
+            if verbose:
+                print("zeta: Attempting reflection formula")
+            try:
+                return _hurwitz_reflection(ctx, s, a, d, atype)
+            except NotImplementedError:
+                pass
+            if verbose:
+                print("zeta: Reflection formula failed")
+        if verbose:
+            print("zeta: Using the Euler-Maclaurin algorithm")
+        while 1:
+            ctx.prec = prec + extraprec
+            T1, T2 = _hurwitz_em(ctx, s, a, d, prec+10, verbose)
+            cancellation = ctx.mag(T1) - ctx.mag(T1+T2)
+            if verbose:
+                print("Term 1:", T1)
+                print("Term 2:", T2)
+                print("Cancellation:", cancellation, "bits")
+            if cancellation < extraprec:
+                return T1 + T2
+            else:
+                extraprec = max(2*extraprec, min(cancellation + 5, 100*prec))
+                if extraprec > kwargs.get('maxprec', 100*prec):
+                    raise ctx.NoConvergence("zeta: too much cancellation")
+    finally:
+        ctx.prec = prec
+
+def _hurwitz_reflection(ctx, s, a, d, atype):
+    # TODO: implement for derivatives
+    if d != 0:
+        raise NotImplementedError
+    res = ctx.re(s)
+    negs = -s
+    # Integer reflection formula
+    if ctx.isnpint(s):
+        n = int(res)
+        if n <= 0:
+            return ctx.bernpoly(1-n, a) / (n-1)
+    if not (atype == 'Q' or atype == 'Z'):
+        raise NotImplementedError
+    t = 1-s
+    # We now require a to be standardized
+    v = 0
+    shift = 0
+    b = a
+    while ctx.re(b) > 1:
+        b -= 1
+        v -= b**negs
+        shift -= 1
+    while ctx.re(b) <= 0:
+        v += b**negs
+        b += 1
+        shift += 1
+    # Rational reflection formula
+    try:
+        p, q = a._mpq_
+    except:
+        assert a == int(a)
+        p = int(a)
+        q = 1
+    p += shift*q
+    assert 1 <= p <= q
+    g = ctx.fsum(ctx.cospi(t/2-2*k*b)*ctx._hurwitz(t,(k,q)) \
+        for k in range(1,q+1))
+    g *= 2*ctx.gamma(t)/(2*ctx.pi*q)**t
+    v += g
+    return v
+
+def _hurwitz_em(ctx, s, a, d, prec, verbose):
+    # May not be converted at this point
+    a = ctx.convert(a)
+    tol = -prec
+    # Estimate number of terms for Euler-Maclaurin summation; could be improved
+    M1 = 0
+    M2 = prec // 3
+    N = M2
+    lsum = 0
+    # This speeds up the recurrence for derivatives
+    if ctx.isint(s):
+        s = int(ctx._re(s))
+    s1 = s-1
+    while 1:
+        # Truncated L-series
+        l = ctx._zetasum(s, M1+a, M2-M1-1, [d])[0][0]
+        #if d:
+        #    l = ctx.fsum((-ctx.ln(n+a))**d * (n+a)**negs for n in range(M1,M2))
+        #else:
+        #    l = ctx.fsum((n+a)**negs for n in range(M1,M2))
+        lsum += l
+        M2a = M2+a
+        logM2a = ctx.ln(M2a)
+        logM2ad = logM2a**d
+        logs = [logM2ad]
+        logr = 1/logM2a
+        rM2a = 1/M2a
+        M2as = M2a**(-s)
+        if d:
+            tailsum = ctx.gammainc(d+1, s1*logM2a) / s1**(d+1)
+        else:
+            tailsum = 1/((s1)*(M2a)**s1)
+        tailsum += 0.5 * logM2ad * M2as
+        U = [1]
+        r = M2as
+        fact = 2
+        for j in range(1, N+1):
+            # TODO: the following could perhaps be tidied a bit
+            j2 = 2*j
+            if j == 1:
+                upds = [1]
+            else:
+                upds = [j2-2, j2-1]
+            for m in upds:
+                D = min(m,d+1)
+                if m <= d:
+                    logs.append(logs[-1] * logr)
+                Un = [0]*(D+1)
+                for i in xrange(D): Un[i] = (1-m-s)*U[i]
+                for i in xrange(1,D+1): Un[i] += (d-(i-1))*U[i-1]
+                U = Un
+                r *= rM2a
+            t = ctx.fdot(U, logs) * r * ctx.bernoulli(j2)/(-fact)
+            tailsum += t
+            if ctx.mag(t) < tol:
+                return lsum, (-1)**d * tailsum
+            fact *= (j2+1)*(j2+2)
+        if verbose:
+            print("Sum range:", M1, M2, "term magnitude", ctx.mag(t), "tolerance", tol)
+        M1, M2 = M2, M2*2
+        if ctx.re(s) < 0:
+            N += N//2
+
+
+
+@defun
+def _zetasum(ctx, s, a, n, derivatives=[0], reflect=False):
+    """
+    Returns [xd0,xd1,...,xdr], [yd0,yd1,...ydr] where
+
+    xdk = D^k     ( 1/a^s     +  1/(a+1)^s      +  ...  +  1/(a+n)^s     )
+    ydk = D^k conj( 1/a^(1-s) +  1/(a+1)^(1-s)  +  ...  +  1/(a+n)^(1-s) )
+
+    D^k = kth derivative with respect to s, k ranges over the given list of
+    derivatives (which should consist of either a single element
+    or a range 0,1,...r). If reflect=False, the ydks are not computed.
+    """
+    #print "zetasum", s, a, n
+    # don't use the fixed-point code if there are large exponentials
+    if abs(ctx.re(s)) < 0.5 * ctx.prec:
+        try:
+            return ctx._zetasum_fast(s, a, n, derivatives, reflect)
+        except NotImplementedError:
+            pass
+    negs = ctx.fneg(s, exact=True)
+    have_derivatives = derivatives != [0]
+    have_one_derivative = len(derivatives) == 1
+    if not reflect:
+        if not have_derivatives:
+            return [ctx.fsum((a+k)**negs for k in xrange(n+1))], []
+        if have_one_derivative:
+            d = derivatives[0]
+            x = ctx.fsum(ctx.ln(a+k)**d * (a+k)**negs for k in xrange(n+1))
+            return [(-1)**d * x], []
+    maxd = max(derivatives)
+    if not have_one_derivative:
+        derivatives = range(maxd+1)
+    xs = [ctx.zero for d in derivatives]
+    if reflect:
+        ys = [ctx.zero for d in derivatives]
+    else:
+        ys = []
+    for k in xrange(n+1):
+        w = a + k
+        xterm = w ** negs
+        if reflect:
+            yterm = ctx.conj(ctx.one / (w * xterm))
+        if have_derivatives:
+            logw = -ctx.ln(w)
+            if have_one_derivative:
+                logw = logw ** maxd
+                xs[0] += xterm * logw
+                if reflect:
+                    ys[0] += yterm * logw
+            else:
+                t = ctx.one
+                for d in derivatives:
+                    xs[d] += xterm * t
+                    if reflect:
+                        ys[d] += yterm * t
+                    t *= logw
+        else:
+            xs[0] += xterm
+            if reflect:
+                ys[0] += yterm
+    return xs, ys
+
+@defun
+def dirichlet(ctx, s, chi=[1], derivative=0):
+    s = ctx.convert(s)
+    q = len(chi)
+    d = int(derivative)
+    if d > 2:
+        raise NotImplementedError("arbitrary order derivatives")
+    prec = ctx.prec
+    try:
+        ctx.prec += 10
+        if s == 1:
+            have_pole = True
+            for x in chi:
+                if x and x != 1:
+                    have_pole = False
+                    h = +ctx.eps
+                    ctx.prec *= 2*(d+1)
+                    s += h
+            if have_pole:
+                return +ctx.inf
+        z = ctx.zero
+        for p in range(1,q+1):
+            if chi[p%q]:
+                if d == 1:
+                    z += chi[p%q] * (ctx.zeta(s, (p,q), 1) - \
+                        ctx.zeta(s, (p,q))*ctx.log(q))
+                else:
+                    z += chi[p%q] * ctx.zeta(s, (p,q))
+        z /= q**s
+    finally:
+        ctx.prec = prec
+    return +z
+
+
+def secondzeta_main_term(ctx, s, a, **kwargs):
+    tol = ctx.eps
+    f = lambda n: ctx.gammainc(0.5*s, a*gamm**2, regularized=True)*gamm**(-s)
+    totsum = term = ctx.zero
+    mg = ctx.inf
+    n = 0
+    while mg > tol:
+        totsum += term
+        n += 1
+        gamm = ctx.im(ctx.zetazero_memoized(n))
+        term = f(n)
+        mg = abs(term)
+    err = 0
+    if kwargs.get("error"):
+        sg = ctx.re(s)
+        err = 0.5*ctx.pi**(-1)*max(1,sg)*a**(sg-0.5)*ctx.log(gamm/(2*ctx.pi))*\
+             ctx.gammainc(-0.5, a*gamm**2)/abs(ctx.gamma(s/2))
+        err = abs(err)
+    return +totsum, err, n
+
+def secondzeta_prime_term(ctx, s, a, **kwargs):
+    tol = ctx.eps
+    f = lambda n: ctx.gammainc(0.5*(1-s),0.25*ctx.log(n)**2 * a**(-1))*\
+        ((0.5*ctx.log(n))**(s-1))*ctx.mangoldt(n)/ctx.sqrt(n)/\
+        (2*ctx.gamma(0.5*s)*ctx.sqrt(ctx.pi))
+    totsum = term = ctx.zero
+    mg = ctx.inf
+    n = 1
+    while mg > tol or n < 9:
+        totsum += term
+        n += 1
+        term = f(n)
+        if term == 0:
+            mg = ctx.inf
+        else:
+            mg = abs(term)
+    if kwargs.get("error"):
+        err = mg
+    return +totsum, err, n
+
+def secondzeta_exp_term(ctx, s, a):
+    if ctx.isint(s) and ctx.re(s) <= 0:
+        m = int(round(ctx.re(s)))
+        if not m & 1:
+            return ctx.mpf('-0.25')**(-m//2)
+    tol = ctx.eps
+    f = lambda n: (0.25*a)**n/((n+0.5*s)*ctx.fac(n))
+    totsum = ctx.zero
+    term = f(0)
+    mg = ctx.inf
+    n = 0
+    while mg > tol:
+        totsum += term
+        n += 1
+        term = f(n)
+        mg = abs(term)
+    v = a**(0.5*s)*totsum/ctx.gamma(0.5*s)
+    return v
+
+def secondzeta_singular_term(ctx, s, a, **kwargs):
+    factor = a**(0.5*(s-1))/(4*ctx.sqrt(ctx.pi)*ctx.gamma(0.5*s))
+    extraprec = ctx.mag(factor)
+    ctx.prec += extraprec
+    factor = a**(0.5*(s-1))/(4*ctx.sqrt(ctx.pi)*ctx.gamma(0.5*s))
+    tol = ctx.eps
+    f = lambda n: ctx.bernpoly(n,0.75)*(4*ctx.sqrt(a))**n*\
+       ctx.gamma(0.5*n)/((s+n-1)*ctx.fac(n))
+    totsum = ctx.zero
+    mg1 = ctx.inf
+    n = 1
+    term = f(n)
+    mg2 = abs(term)
+    while mg2 > tol and mg2 <= mg1:
+        totsum += term
+        n += 1
+        term = f(n)
+        totsum += term
+        n +=1
+        term = f(n)
+        mg1 = mg2
+        mg2 = abs(term)
+    totsum += term
+    pole = -2*(s-1)**(-2)+(ctx.euler+ctx.log(16*ctx.pi**2*a))*(s-1)**(-1)
+    st = factor*(pole+totsum)
+    err = 0
+    if kwargs.get("error"):
+        if not ((mg2 > tol) and (mg2 <= mg1)):
+            if mg2 <= tol:
+                err = ctx.mpf(10)**int(ctx.log(abs(factor*tol),10))
+            if mg2 > mg1:
+                err = ctx.mpf(10)**int(ctx.log(abs(factor*mg1),10))
+        err = max(err, ctx.eps*1.)
+    ctx.prec -= extraprec
+    return +st, err
+
+@defun
+def secondzeta(ctx, s, a = 0.015, **kwargs):
+    r"""
+    Evaluates the secondary zeta function `Z(s)`, defined for
+    `\mathrm{Re}(s)>1` by
+
+    .. math ::
+
+        Z(s) = \sum_{n=1}^{\infty} \frac{1}{\tau_n^s}
+
+    where `\frac12+i\tau_n` runs through the zeros of `\zeta(s)` with
+    imaginary part positive.
+
+    `Z(s)` extends to a meromorphic function on `\mathbb{C}`  with a
+    double pole at `s=1` and  simple poles at the points `-2n` for
+    `n=0`,  1, 2, ...
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.pretty = True; mp.dps = 15
+        >>> secondzeta(2)
+        0.023104993115419
+        >>> xi = lambda s: 0.5*s*(s-1)*pi**(-0.5*s)*gamma(0.5*s)*zeta(s)
+        >>> Xi = lambda t: xi(0.5+t*j)
+        >>> chop(-0.5*diff(Xi,0,n=2)/Xi(0))
+        0.023104993115419
+
+    We may ask for an approximate error value::
+
+        >>> secondzeta(0.5+100j, error=True)
+        ((-0.216272011276718 - 0.844952708937228j), 2.22044604925031e-16)
+
+    The function has poles at the negative odd integers,
+    and dyadic rational values at the negative even integers::
+
+        >>> mp.dps = 30
+        >>> secondzeta(-8)
+        -0.67236328125
+        >>> secondzeta(-7)
+        +inf
+
+    **Implementation notes**
+
+    The function is computed as sum of four terms `Z(s)=A(s)-P(s)+E(s)-S(s)`
+    respectively main, prime, exponential and singular terms.
+    The main term `A(s)` is computed from the zeros of zeta.
+    The prime term depends on the von Mangoldt function.
+    The singular term is responsible for the poles of the function.
+
+    The four terms depends on a small parameter `a`. We may change the
+    value of `a`. Theoretically this has no effect on the sum of the four
+    terms, but in practice may be important.
+
+    A smaller value of the parameter `a` makes `A(s)` depend on
+    a smaller number of zeros of zeta, but `P(s)`  uses more values of
+    von Mangoldt function.
+
+    We may also add a verbose option to obtain data about the
+    values of the four terms.
+
+        >>> mp.dps = 10
+        >>> secondzeta(0.5 + 40j, error=True, verbose=True)
+        main term = (-30190318549.138656312556 - 13964804384.624622876523j)
+            computed using 19 zeros of zeta
+        prime term = (132717176.89212754625045 + 188980555.17563978290601j)
+            computed using 9 values of the von Mangoldt function
+        exponential term = (542447428666.07179812536 + 362434922978.80192435203j)
+        singular term = (512124392939.98154322355 + 348281138038.65531023921j)
+        ((0.059471043 + 0.3463514534j), 1.455191523e-11)
+
+        >>> secondzeta(0.5 + 40j, a=0.04, error=True, verbose=True)
+        main term = (-151962888.19606243907725 - 217930683.90210294051982j)
+            computed using 9 zeros of zeta
+        prime term = (2476659342.3038722372461 + 28711581821.921627163136j)
+            computed using 37 values of the von Mangoldt function
+        exponential term = (178506047114.7838188264 + 819674143244.45677330576j)
+        singular term = (175877424884.22441310708 + 790744630738.28669174871j)
+        ((0.059471043 + 0.3463514534j), 1.455191523e-11)
+
+    Notice the great cancellation between the four terms. Changing `a`, the
+    four terms are very different numbers but the cancellation gives
+    the good value of Z(s).
+
+    **References**
+
+    A. Voros, Zeta functions for the Riemann zeros, Ann. Institute Fourier,
+    53, (2003) 665--699.
+
+    A. Voros, Zeta functions over Zeros of Zeta Functions, Lecture Notes
+    of the Unione Matematica Italiana, Springer, 2009.
+    """
+    s = ctx.convert(s)
+    a = ctx.convert(a)
+    tol = ctx.eps
+    if ctx.isint(s) and ctx.re(s) <= 1:
+        if abs(s-1) < tol*1000:
+            return ctx.inf
+        m = int(round(ctx.re(s)))
+        if m & 1:
+            return ctx.inf
+        else:
+            return ((-1)**(-m//2)*\
+                   ctx.fraction(8-ctx.eulernum(-m,exact=True),2**(-m+3)))
+    prec = ctx.prec
+    try:
+        t3 = secondzeta_exp_term(ctx, s, a)
+        extraprec = max(ctx.mag(t3),0)
+        ctx.prec += extraprec + 3
+        t1, r1, gt = secondzeta_main_term(ctx,s,a,error='True', verbose='True')
+        t2, r2, pt = secondzeta_prime_term(ctx,s,a,error='True', verbose='True')
+        t4, r4 = secondzeta_singular_term(ctx,s,a,error='True')
+        t3 = secondzeta_exp_term(ctx, s, a)
+        err = r1+r2+r4
+        t = t1-t2+t3-t4
+        if kwargs.get("verbose"):
+            print('main term =', t1)
+            print('    computed using', gt, 'zeros of zeta')
+            print('prime term =', t2)
+            print('    computed using', pt, 'values of the von Mangoldt function')
+            print('exponential term =', t3)
+            print('singular term =', t4)
+    finally:
+        ctx.prec = prec
+    if kwargs.get("error"):
+        w = max(ctx.mag(abs(t)),0)
+        err = max(err*2**w, ctx.eps*1.*2**w)
+        return +t, err
+    return +t
+
+
+@defun_wrapped
+def lerchphi(ctx, z, s, a):
+    r"""
+    Gives the Lerch transcendent, defined for `|z| < 1` and
+    `\Re{a} > 0` by
+
+    .. math ::
+
+        \Phi(z,s,a) = \sum_{k=0}^{\infty} \frac{z^k}{(a+k)^s}
+
+    and generally by the recurrence `\Phi(z,s,a) = z \Phi(z,s,a+1) + a^{-s}`
+    along with the integral representation valid for `\Re{a} > 0`
+
+    .. math ::
+
+        \Phi(z,s,a) = \frac{1}{2 a^s} +
+                \int_0^{\infty} \frac{z^t}{(a+t)^s} dt -
+                2 \int_0^{\infty} \frac{\sin(t \log z - s
+                    \operatorname{arctan}(t/a)}{(a^2 + t^2)^{s/2}
+                    (e^{2 \pi t}-1)} dt.
+
+    The Lerch transcendent generalizes the Hurwitz zeta function :func:`zeta`
+    (`z = 1`) and the polylogarithm :func:`polylog` (`a = 1`).
+
+    **Examples**
+
+    Several evaluations in terms of simpler functions::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> lerchphi(-1,2,0.5); 4*catalan
+        3.663862376708876060218414
+        3.663862376708876060218414
+        >>> diff(lerchphi, (-1,-2,1), (0,1,0)); 7*zeta(3)/(4*pi**2)
+        0.2131391994087528954617607
+        0.2131391994087528954617607
+        >>> lerchphi(-4,1,1); log(5)/4
+        0.4023594781085250936501898
+        0.4023594781085250936501898
+        >>> lerchphi(-3+2j,1,0.5); 2*atanh(sqrt(-3+2j))/sqrt(-3+2j)
+        (1.142423447120257137774002 + 0.2118232380980201350495795j)
+        (1.142423447120257137774002 + 0.2118232380980201350495795j)
+
+    Evaluation works for complex arguments and `|z| \ge 1`::
+
+        >>> lerchphi(1+2j, 3-j, 4+2j)
+        (0.002025009957009908600539469 + 0.003327897536813558807438089j)
+        >>> lerchphi(-2,2,-2.5)
+        -12.28676272353094275265944
+        >>> lerchphi(10,10,10)
+        (-4.462130727102185701817349e-11 - 1.575172198981096218823481e-12j)
+        >>> lerchphi(10,10,-10.5)
+        (112658784011940.5605789002 - 498113185.5756221777743631j)
+
+    Some degenerate cases::
+
+        >>> lerchphi(0,1,2)
+        0.5
+        >>> lerchphi(0,1,-2)
+        -0.5
+
+    Reduction to simpler functions::
+
+        >>> lerchphi(1, 4.25+1j, 1)
+        (1.044674457556746668033975 - 0.04674508654012658932271226j)
+        >>> zeta(4.25+1j)
+        (1.044674457556746668033975 - 0.04674508654012658932271226j)
+        >>> lerchphi(1 - 0.5**10, 4.25+1j, 1)
+        (1.044629338021507546737197 - 0.04667768813963388181708101j)
+        >>> lerchphi(3, 4, 1)
+        (1.249503297023366545192592 - 0.2314252413375664776474462j)
+        >>> polylog(4, 3) / 3
+        (1.249503297023366545192592 - 0.2314252413375664776474462j)
+        >>> lerchphi(3, 4, 1 - 0.5**10)
+        (1.253978063946663945672674 - 0.2316736622836535468765376j)
+
+    **References**
+
+    1. [DLMF]_ section 25.14
+
+    """
+    if z == 0:
+        return a ** (-s)
+    # Faster, but these cases are useful for testing right now
+    if z == 1:
+        return ctx.zeta(s, a)
+    if a == 1:
+        return ctx.polylog(s, z) / z
+    if ctx.re(a) < 1:
+        if ctx.isnpint(a):
+            raise ValueError("Lerch transcendent complex infinity")
+        m = int(ctx.ceil(1-ctx.re(a)))
+        v = ctx.zero
+        zpow = ctx.one
+        for n in xrange(m):
+            v += zpow / (a+n)**s
+            zpow *= z
+        return zpow * ctx.lerchphi(z,s, a+m) + v
+    g = ctx.ln(z)
+    v = 1/(2*a**s) + ctx.gammainc(1-s, -a*g) * (-g)**(s-1) / z**a
+    h = s / 2
+    r = 2*ctx.pi
+    f = lambda t: ctx.sin(s*ctx.atan(t/a)-t*g) / \
+        ((a**2+t**2)**h * ctx.expm1(r*t))
+    v += 2*ctx.quad(f, [0, ctx.inf])
+    if not ctx.im(z) and not ctx.im(s) and not ctx.im(a) and ctx.re(z) < 1:
+        v = ctx.chop(v)
+    return v
diff --git a/lib/python3.11/site-packages/mpmath/functions/zetazeros.py b/lib/python3.11/site-packages/mpmath/functions/zetazeros.py
new file mode 100644
index 0000000000000000000000000000000000000000..37c11a29426b0114053ae61664541f7ae7de95d8
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/functions/zetazeros.py
@@ -0,0 +1,1018 @@
+"""
+The function zetazero(n) computes the n-th nontrivial zero of zeta(s).
+
+The general strategy is to locate a block of Gram intervals B where we
+know exactly the number of zeros contained and which of those zeros
+is that which we search.
+
+If n <= 400 000 000  we know exactly the Rosser exceptions, contained
+in a list in this file. Hence for n<=400 000 000 we simply
+look at these list of exceptions. If our zero is implicated in one of
+these exceptions we have our block B.  In other case we simply locate
+the good Rosser block containing our zero.
+
+For n > 400 000 000 we apply the method of Turing, as complemented by
+Lehman, Brent and Trudgian  to find a suitable B.
+"""
+
+from .functions import defun, defun_wrapped
+
+def find_rosser_block_zero(ctx, n):
+    """for n<400 000 000 determines a block were one find our zero"""
+    for k in range(len(_ROSSER_EXCEPTIONS)//2):
+        a=_ROSSER_EXCEPTIONS[2*k][0]
+        b=_ROSSER_EXCEPTIONS[2*k][1]
+        if ((a<= n-2) and (n-1 <= b)):
+            t0 = ctx.grampoint(a)
+            t1 = ctx.grampoint(b)
+            v0 = ctx._fp.siegelz(t0)
+            v1 = ctx._fp.siegelz(t1)
+            my_zero_number = n-a-1
+            zero_number_block = b-a
+            pattern = _ROSSER_EXCEPTIONS[2*k+1]
+            return (my_zero_number, [a,b], [t0,t1], [v0,v1])
+    k = n-2
+    t,v,b = compute_triple_tvb(ctx, k)
+    T = [t]
+    V = [v]
+    while b < 0:
+        k -= 1
+        t,v,b = compute_triple_tvb(ctx, k)
+        T.insert(0,t)
+        V.insert(0,v)
+    my_zero_number = n-k-1
+    m = n-1
+    t,v,b = compute_triple_tvb(ctx, m)
+    T.append(t)
+    V.append(v)
+    while b < 0:
+        m += 1
+        t,v,b = compute_triple_tvb(ctx, m)
+        T.append(t)
+        V.append(v)
+    return (my_zero_number, [k,m], T, V)
+
+def wpzeros(t):
+    """Precision needed to compute higher zeros"""
+    wp = 53
+    if t > 3*10**8:
+        wp = 63
+    if t > 10**11:
+        wp = 70
+    if t > 10**14:
+        wp = 83
+    return wp
+
+def separate_zeros_in_block(ctx, zero_number_block, T, V, limitloop=None,
+    fp_tolerance=None):
+    """Separate the zeros contained in the block T, limitloop
+    determines how long one must search"""
+    if limitloop is None:
+        limitloop = ctx.inf
+    loopnumber = 0
+    variations = count_variations(V)
+    while ((variations < zero_number_block) and (loopnumber <limitloop)):
+        a = T[0]
+        v = V[0]
+        newT = [a]
+        newV = [v]
+        variations = 0
+        for n in range(1,len(T)):
+            b2 = T[n]
+            u = V[n]
+            if (u*v>0):
+                alpha = ctx.sqrt(u/v)
+                b= (alpha*a+b2)/(alpha+1)
+            else:
+                b = (a+b2)/2
+            if fp_tolerance < 10:
+                w = ctx._fp.siegelz(b)
+                if abs(w)<fp_tolerance:
+                    w = ctx.siegelz(b)
+            else:
+                w=ctx.siegelz(b)
+            if v*w<0:
+                variations += 1
+            newT.append(b)
+            newV.append(w)
+            u = V[n]
+            if u*w <0:
+                variations += 1
+            newT.append(b2)
+            newV.append(u)
+            a = b2
+            v = u
+        T = newT
+        V = newV
+        loopnumber +=1
+        if (limitloop>ITERATION_LIMIT)and(loopnumber>2)and(variations+2==zero_number_block):
+            dtMax=0
+            dtSec=0
+            kMax = 0
+            for k1 in range(1,len(T)):
+                dt = T[k1]-T[k1-1]
+                if dt > dtMax:
+                    kMax=k1
+                    dtSec = dtMax
+                    dtMax = dt
+                elif  (dt<dtMax) and(dt >dtSec):
+                    dtSec = dt
+            if dtMax>3*dtSec:
+                f = lambda x: ctx.rs_z(x,derivative=1)
+                t0=T[kMax-1]
+                t1 = T[kMax]
+                t=ctx.findroot(f,  (t0,t1), solver ='illinois',verify=False, verbose=False)
+                v = ctx.siegelz(t)
+                if (t0<t) and (t<t1) and (v*V[kMax]<0):
+                    T.insert(kMax,t)
+                    V.insert(kMax,v)
+        variations = count_variations(V)
+    if variations == zero_number_block:
+        separated = True
+    else:
+        separated = False
+    return (T,V, separated)
+
+def separate_my_zero(ctx, my_zero_number, zero_number_block, T, V, prec):
+    """If we know which zero of this block is mine,
+    the function separates the zero"""
+    variations = 0
+    v0 = V[0]
+    for k in range(1,len(V)):
+        v1 = V[k]
+        if v0*v1 < 0:
+            variations +=1
+            if variations == my_zero_number:
+                k0 = k
+                leftv = v0
+                rightv = v1
+        v0 = v1
+    t1 = T[k0]
+    t0 = T[k0-1]
+    ctx.prec = prec
+    wpz = wpzeros(my_zero_number*ctx.log(my_zero_number))
+
+    guard = 4*ctx.mag(my_zero_number)
+    precs = [ctx.prec+4]
+    index=0
+    while precs[0] > 2*wpz:
+        index +=1
+        precs = [precs[0] // 2 +3+2*index] + precs
+    ctx.prec = precs[0] + guard
+    r = ctx.findroot(lambda x:ctx.siegelz(x), (t0,t1), solver ='illinois', verbose=False)
+    #print "first step at", ctx.dps, "digits"
+    z=ctx.mpc(0.5,r)
+    for prec in precs[1:]:
+        ctx.prec = prec + guard
+        #print "refining to", ctx.dps, "digits"
+        znew = z - ctx.zeta(z) / ctx.zeta(z, derivative=1)
+        #print "difference", ctx.nstr(abs(z-znew))
+        z=ctx.mpc(0.5,ctx.im(znew))
+    return ctx.im(z)
+
+def sure_number_block(ctx, n):
+    """The number of good Rosser blocks needed to apply
+    Turing method
+    References:
+    R. P. Brent, On the Zeros of the Riemann Zeta Function
+    in the Critical Strip, Math. Comp. 33 (1979) 1361--1372
+    T. Trudgian, Improvements to Turing Method, Math. Comp."""
+    if n < 9*10**5:
+        return(2)
+    g = ctx.grampoint(n-100)
+    lg = ctx._fp.ln(g)
+    brent = 0.0061 * lg**2 +0.08*lg
+    trudgian = 0.0031 * lg**2 +0.11*lg
+    N = ctx.ceil(min(brent,trudgian))
+    N = int(N)
+    return N
+
+def compute_triple_tvb(ctx, n):
+    t = ctx.grampoint(n)
+    v = ctx._fp.siegelz(t)
+    if ctx.mag(abs(v))<ctx.mag(t)-45:
+        v = ctx.siegelz(t)
+    b = v*(-1)**n
+    return t,v,b
+
+
+
+ITERATION_LIMIT = 4
+
+def search_supergood_block(ctx, n, fp_tolerance):
+    """To use for n>400 000 000"""
+    sb = sure_number_block(ctx, n)
+    number_goodblocks = 0
+    m2 = n-1
+    t, v, b = compute_triple_tvb(ctx, m2)
+    Tf = [t]
+    Vf = [v]
+    while b < 0:
+        m2 += 1
+        t,v,b = compute_triple_tvb(ctx, m2)
+        Tf.append(t)
+        Vf.append(v)
+    goodpoints = [m2]
+    T = [t]
+    V = [v]
+    while number_goodblocks < 2*sb:
+        m2 += 1
+        t, v, b = compute_triple_tvb(ctx, m2)
+        T.append(t)
+        V.append(v)
+        while b < 0:
+            m2 += 1
+            t,v,b = compute_triple_tvb(ctx, m2)
+            T.append(t)
+            V.append(v)
+        goodpoints.append(m2)
+        zn = len(T)-1
+        A, B, separated =\
+           separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT,
+                fp_tolerance=fp_tolerance)
+        Tf.pop()
+        Tf.extend(A)
+        Vf.pop()
+        Vf.extend(B)
+        if separated:
+            number_goodblocks += 1
+        else:
+            number_goodblocks = 0
+        T = [t]
+        V = [v]
+    # Now the same procedure to the left
+    number_goodblocks = 0
+    m2 = n-2
+    t, v, b = compute_triple_tvb(ctx, m2)
+    Tf.insert(0,t)
+    Vf.insert(0,v)
+    while b < 0:
+        m2 -= 1
+        t,v,b = compute_triple_tvb(ctx, m2)
+        Tf.insert(0,t)
+        Vf.insert(0,v)
+    goodpoints.insert(0,m2)
+    T = [t]
+    V = [v]
+    while number_goodblocks < 2*sb:
+        m2 -= 1
+        t, v, b = compute_triple_tvb(ctx, m2)
+        T.insert(0,t)
+        V.insert(0,v)
+        while b < 0:
+            m2 -= 1
+            t,v,b = compute_triple_tvb(ctx, m2)
+            T.insert(0,t)
+            V.insert(0,v)
+        goodpoints.insert(0,m2)
+        zn = len(T)-1
+        A, B, separated =\
+           separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance)
+        A.pop()
+        Tf = A+Tf
+        B.pop()
+        Vf = B+Vf
+        if separated:
+            number_goodblocks += 1
+        else:
+            number_goodblocks = 0
+        T = [t]
+        V = [v]
+    r = goodpoints[2*sb]
+    lg = len(goodpoints)
+    s = goodpoints[lg-2*sb-1]
+    tr, vr, br = compute_triple_tvb(ctx, r)
+    ar = Tf.index(tr)
+    ts, vs, bs = compute_triple_tvb(ctx, s)
+    as1 = Tf.index(ts)
+    T = Tf[ar:as1+1]
+    V = Vf[ar:as1+1]
+    zn = s-r
+    A, B, separated =\
+       separate_zeros_in_block(ctx, zn,T,V,limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance)
+    if separated:
+        return (n-r-1,[r,s],A,B)
+    q = goodpoints[sb]
+    lg = len(goodpoints)
+    t = goodpoints[lg-sb-1]
+    tq, vq, bq = compute_triple_tvb(ctx, q)
+    aq = Tf.index(tq)
+    tt, vt, bt = compute_triple_tvb(ctx, t)
+    at = Tf.index(tt)
+    T = Tf[aq:at+1]
+    V = Vf[aq:at+1]
+    return (n-q-1,[q,t],T,V)
+
+def count_variations(V):
+    count = 0
+    vold = V[0]
+    for n in range(1, len(V)):
+        vnew = V[n]
+        if vold*vnew < 0:
+            count +=1
+        vold = vnew
+    return count
+
+def pattern_construct(ctx, block, T, V):
+    pattern = '('
+    a = block[0]
+    b = block[1]
+    t0,v0,b0 = compute_triple_tvb(ctx, a)
+    k = 0
+    k0 = 0
+    for n in range(a+1,b+1):
+        t1,v1,b1 = compute_triple_tvb(ctx, n)
+        lgT =len(T)
+        while (k < lgT) and (T[k] <= t1):
+            k += 1
+        L = V[k0:k]
+        L.append(v1)
+        L.insert(0,v0)
+        count = count_variations(L)
+        pattern = pattern + ("%s" % count)
+        if b1 > 0:
+            pattern = pattern + ')('
+        k0 = k
+        t0,v0,b0 = t1,v1,b1
+    pattern = pattern[:-1]
+    return pattern
+
+@defun
+def zetazero(ctx, n, info=False, round=True):
+    r"""
+    Computes the `n`-th nontrivial zero of `\zeta(s)` on the critical line,
+    i.e. returns an approximation of the `n`-th largest complex number
+    `s = \frac{1}{2} + ti` for which `\zeta(s) = 0`. Equivalently, the
+    imaginary part `t` is a zero of the Z-function (:func:`~mpmath.siegelz`).
+
+    **Examples**
+
+    The first few zeros::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> zetazero(1)
+        (0.5 + 14.13472514173469379045725j)
+        >>> zetazero(2)
+        (0.5 + 21.02203963877155499262848j)
+        >>> zetazero(20)
+        (0.5 + 77.14484006887480537268266j)
+
+    Verifying that the values are zeros::
+
+        >>> for n in range(1,5):
+        ...     s = zetazero(n)
+        ...     chop(zeta(s)), chop(siegelz(s.imag))
+        ...
+        (0.0, 0.0)
+        (0.0, 0.0)
+        (0.0, 0.0)
+        (0.0, 0.0)
+
+    Negative indices give the conjugate zeros (`n = 0` is undefined)::
+
+        >>> zetazero(-1)
+        (0.5 - 14.13472514173469379045725j)
+
+    :func:`~mpmath.zetazero` supports arbitrarily large `n` and arbitrary precision::
+
+        >>> mp.dps = 15
+        >>> zetazero(1234567)
+        (0.5 + 727690.906948208j)
+        >>> mp.dps = 50
+        >>> zetazero(1234567)
+        (0.5 + 727690.9069482075392389420041147142092708393819935j)
+        >>> chop(zeta(_)/_)
+        0.0
+
+    with *info=True*, :func:`~mpmath.zetazero` gives additional information::
+
+        >>> mp.dps = 15
+        >>> zetazero(542964976,info=True)
+        ((0.5 + 209039046.578535j), [542964969, 542964978], 6, '(013111110)')
+
+    This means that the zero is between Gram points 542964969 and 542964978;
+    it is the 6-th zero between them. Finally (01311110) is the pattern
+    of zeros in this interval. The numbers indicate the number of zeros
+    in each Gram interval (Rosser blocks between parenthesis). In this case
+    there is only one Rosser block of length nine.
+    """
+    n = int(n)
+    if n < 0:
+        return ctx.zetazero(-n).conjugate()
+    if n == 0:
+        raise ValueError("n must be nonzero")
+    wpinitial = ctx.prec
+    try:
+        wpz, fp_tolerance = comp_fp_tolerance(ctx, n)
+        ctx.prec = wpz
+        if n < 400000000:
+            my_zero_number, block, T, V =\
+             find_rosser_block_zero(ctx, n)
+        else:
+            my_zero_number, block, T, V =\
+             search_supergood_block(ctx, n, fp_tolerance)
+        zero_number_block = block[1]-block[0]
+        T, V, separated = separate_zeros_in_block(ctx, zero_number_block, T, V,
+            limitloop=ctx.inf, fp_tolerance=fp_tolerance)
+        if info:
+            pattern = pattern_construct(ctx,block,T,V)
+        prec = max(wpinitial, wpz)
+        t = separate_my_zero(ctx, my_zero_number, zero_number_block,T,V,prec)
+        v = ctx.mpc(0.5,t)
+    finally:
+        ctx.prec = wpinitial
+    if round:
+        v =+v
+    if info:
+        return (v,block,my_zero_number,pattern)
+    else:
+        return v
+
+def gram_index(ctx, t):
+    if t > 10**13:
+        wp = 3*ctx.log(t, 10)
+    else:
+        wp = 0
+    prec = ctx.prec
+    try:
+        ctx.prec += wp
+        h = int(ctx.siegeltheta(t)/ctx.pi)
+    finally:
+        ctx.prec = prec
+    return(h)
+
+def count_to(ctx, t, T, V):
+    count = 0
+    vold = V[0]
+    told = T[0]
+    tnew = T[1]
+    k = 1
+    while tnew < t:
+        vnew = V[k]
+        if vold*vnew < 0:
+            count += 1
+        vold = vnew
+        k += 1
+        tnew = T[k]
+    a = ctx.siegelz(t)
+    if a*vold < 0:
+        count += 1
+    return count
+
+def comp_fp_tolerance(ctx, n):
+    wpz = wpzeros(n*ctx.log(n))
+    if n < 15*10**8:
+        fp_tolerance = 0.0005
+    elif n <= 10**14:
+        fp_tolerance = 0.1
+    else:
+        fp_tolerance = 100
+    return wpz, fp_tolerance
+
+@defun
+def nzeros(ctx, t):
+    r"""
+    Computes the number of zeros of the Riemann zeta function in
+    `(0,1) \times (0,t]`, usually denoted by `N(t)`.
+
+    **Examples**
+
+    The first zero has imaginary part between 14 and 15::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> nzeros(14)
+        0
+        >>> nzeros(15)
+        1
+        >>> zetazero(1)
+        (0.5 + 14.1347251417347j)
+
+    Some closely spaced zeros::
+
+        >>> nzeros(10**7)
+        21136125
+        >>> zetazero(21136125)
+        (0.5 + 9999999.32718175j)
+        >>> zetazero(21136126)
+        (0.5 + 10000000.2400236j)
+        >>> nzeros(545439823.215)
+        1500000001
+        >>> zetazero(1500000001)
+        (0.5 + 545439823.201985j)
+        >>> zetazero(1500000002)
+        (0.5 + 545439823.325697j)
+
+    This confirms the data given by J. van de Lune,
+    H. J. J. te Riele and D. T. Winter in 1986.
+    """
+    if t < 14.1347251417347:
+        return 0
+    x = gram_index(ctx, t)
+    k = int(ctx.floor(x))
+    wpinitial = ctx.prec
+    wpz, fp_tolerance = comp_fp_tolerance(ctx, k)
+    ctx.prec = wpz
+    a = ctx.siegelz(t)
+    if k == -1 and a < 0:
+        return 0
+    elif k == -1 and a > 0:
+        return 1
+    if k+2 < 400000000:
+        Rblock = find_rosser_block_zero(ctx, k+2)
+    else:
+        Rblock = search_supergood_block(ctx, k+2, fp_tolerance)
+    n1, n2 = Rblock[1]
+    if n2-n1 == 1:
+        b = Rblock[3][0]
+        if a*b > 0:
+            ctx.prec = wpinitial
+            return k+1
+        else:
+            ctx.prec = wpinitial
+            return k+2
+    my_zero_number,block, T, V = Rblock
+    zero_number_block = n2-n1
+    T, V, separated = separate_zeros_in_block(ctx,\
+                                              zero_number_block, T, V,\
+                                              limitloop=ctx.inf,\
+                                            fp_tolerance=fp_tolerance)
+    n = count_to(ctx, t, T, V)
+    ctx.prec = wpinitial
+    return n+n1+1
+
+@defun_wrapped
+def backlunds(ctx, t):
+    r"""
+    Computes the function
+    `S(t) = \operatorname{arg} \zeta(\frac{1}{2} + it) / \pi`.
+
+    See Titchmarsh Section 9.3 for details of the definition.
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> backlunds(217.3)
+        0.16302205431184
+
+    Generally, the value is a small number. At Gram points it is an integer,
+    frequently equal to 0::
+
+        >>> chop(backlunds(grampoint(200)))
+        0.0
+        >>> backlunds(extraprec(10)(grampoint)(211))
+        1.0
+        >>> backlunds(extraprec(10)(grampoint)(232))
+        -1.0
+
+    The number of zeros of the Riemann zeta function up to height `t`
+    satisfies `N(t) = \theta(t)/\pi + 1 + S(t)` (see :func:nzeros` and
+    :func:`siegeltheta`)::
+
+        >>> t = 1234.55
+        >>> nzeros(t)
+        842
+        >>> siegeltheta(t)/pi+1+backlunds(t)
+        842.0
+
+    """
+    return ctx.nzeros(t)-1-ctx.siegeltheta(t)/ctx.pi
+
+
+"""
+_ROSSER_EXCEPTIONS is a list of all  exceptions to
+Rosser's rule for n <= 400 000 000.
+
+Alternately the  entry is of type   [n,m], or a string.
+The string is the zero pattern of the Block and the relevant
+adjacent.  For example (010)3 corresponds to a block
+composed of three Gram intervals, the first ant third without
+a zero and the intermediate with a zero. The next Gram interval
+contain three zeros. So that in total we have 4 zeros in 4 Gram
+blocks. n and m are the indices of the Gram points  of this
+interval of four Gram intervals. The Rosser exception is therefore
+formed by the three Gram intervals that are signaled between
+parenthesis.
+
+We have included also some Rosser's exceptions beyond n=400 000 000
+that are noted in the literature by some reason.
+
+The list is composed from the data published in the references:
+
+R. P. Brent, J. van de Lune, H. J. J. te Riele, D. T. Winter,
+'On the Zeros of the Riemann Zeta Function in the Critical Strip. II',
+Math. Comp. 39 (1982) 681--688.
+See also Corrigenda in Math. Comp. 46 (1986) 771.
+
+J. van de Lune, H. J. J. te Riele,
+'On the Zeros of the Riemann Zeta Function in the Critical Strip. III',
+Math. Comp. 41 (1983) 759--767.
+See also  Corrigenda in Math. Comp. 46 (1986) 771.
+
+J. van de Lune,
+'Sums of Equal Powers of Positive Integers',
+Dissertation,
+Vrije Universiteit te Amsterdam, Centrum voor Wiskunde en Informatica,
+Amsterdam, 1984.
+
+Thanks to the authors all this papers and those others that have
+contributed to make this possible.
+"""
+
+
+
+
+
+
+
+_ROSSER_EXCEPTIONS = \
+[[13999525, 13999528], '(00)3',
+[30783329, 30783332], '(00)3',
+[30930926, 30930929], '3(00)',
+[37592215, 37592218], '(00)3',
+[40870156, 40870159], '(00)3',
+[43628107, 43628110], '(00)3',
+[46082042, 46082045], '(00)3',
+[46875667, 46875670], '(00)3',
+[49624540, 49624543], '3(00)',
+[50799238, 50799241], '(00)3',
+[55221453, 55221456], '3(00)',
+[56948779, 56948782], '3(00)',
+[60515663, 60515666], '(00)3',
+[61331766, 61331770], '(00)40',
+[69784843, 69784846], '3(00)',
+[75052114, 75052117], '(00)3',
+[79545240, 79545243], '3(00)',
+[79652247, 79652250], '3(00)',
+[83088043, 83088046], '(00)3',
+[83689522, 83689525], '3(00)',
+[85348958, 85348961], '(00)3',
+[86513820, 86513823], '(00)3',
+[87947596, 87947599], '3(00)',
+[88600095, 88600098], '(00)3',
+[93681183, 93681186], '(00)3',
+[100316551, 100316554], '3(00)',
+[100788444, 100788447], '(00)3',
+[106236172, 106236175], '(00)3',
+[106941327, 106941330], '3(00)',
+[107287955, 107287958], '(00)3',
+[107532016, 107532019], '3(00)',
+[110571044, 110571047], '(00)3',
+[111885253, 111885256], '3(00)',
+[113239783, 113239786], '(00)3',
+[120159903, 120159906], '(00)3',
+[121424391, 121424394], '3(00)',
+[121692931, 121692934], '3(00)',
+[121934170, 121934173], '3(00)',
+[122612848, 122612851], '3(00)',
+[126116567, 126116570], '(00)3',
+[127936513, 127936516], '(00)3',
+[128710277, 128710280], '3(00)',
+[129398902, 129398905], '3(00)',
+[130461096, 130461099], '3(00)',
+[131331947, 131331950], '3(00)',
+[137334071, 137334074], '3(00)',
+[137832603, 137832606], '(00)3',
+[138799471, 138799474], '3(00)',
+[139027791, 139027794], '(00)3',
+[141617806, 141617809], '(00)3',
+[144454931, 144454934], '(00)3',
+[145402379, 145402382], '3(00)',
+[146130245, 146130248], '3(00)',
+[147059770, 147059773], '(00)3',
+[147896099, 147896102], '3(00)',
+[151097113, 151097116], '(00)3',
+[152539438, 152539441], '(00)3',
+[152863168, 152863171], '3(00)',
+[153522726, 153522729], '3(00)',
+[155171524, 155171527], '3(00)',
+[155366607, 155366610], '(00)3',
+[157260686, 157260689], '3(00)',
+[157269224, 157269227], '(00)3',
+[157755123, 157755126], '(00)3',
+[158298484, 158298487], '3(00)',
+[160369050, 160369053], '3(00)',
+[162962787, 162962790], '(00)3',
+[163724709, 163724712], '(00)3',
+[164198113, 164198116], '3(00)',
+[164689301, 164689305], '(00)40',
+[164880228, 164880231], '3(00)',
+[166201932, 166201935], '(00)3',
+[168573836, 168573839], '(00)3',
+[169750763, 169750766], '(00)3',
+[170375507, 170375510], '(00)3',
+[170704879, 170704882], '3(00)',
+[172000992, 172000995], '3(00)',
+[173289941, 173289944], '(00)3',
+[173737613, 173737616], '3(00)',
+[174102513, 174102516], '(00)3',
+[174284990, 174284993], '(00)3',
+[174500513, 174500516], '(00)3',
+[175710609, 175710612], '(00)3',
+[176870843, 176870846], '3(00)',
+[177332732, 177332735], '3(00)',
+[177902861, 177902864], '3(00)',
+[179979095, 179979098], '(00)3',
+[181233726, 181233729], '3(00)',
+[181625435, 181625438], '(00)3',
+[182105255, 182105259], '22(00)',
+[182223559, 182223562], '3(00)',
+[191116404, 191116407], '3(00)',
+[191165599, 191165602], '3(00)',
+[191297535, 191297539], '(00)22',
+[192485616, 192485619], '(00)3',
+[193264634, 193264638], '22(00)',
+[194696968, 194696971], '(00)3',
+[195876805, 195876808], '(00)3',
+[195916548, 195916551], '3(00)',
+[196395160, 196395163], '3(00)',
+[196676303, 196676306], '(00)3',
+[197889882, 197889885], '3(00)',
+[198014122, 198014125], '(00)3',
+[199235289, 199235292], '(00)3',
+[201007375, 201007378], '(00)3',
+[201030605, 201030608], '3(00)',
+[201184290, 201184293], '3(00)',
+[201685414, 201685418], '(00)22',
+[202762875, 202762878], '3(00)',
+[202860957, 202860960], '3(00)',
+[203832577, 203832580], '3(00)',
+[205880544, 205880547], '(00)3',
+[206357111, 206357114], '(00)3',
+[207159767, 207159770], '3(00)',
+[207167343, 207167346], '3(00)',
+[207482539, 207482543], '3(010)',
+[207669540, 207669543], '3(00)',
+[208053426, 208053429], '(00)3',
+[208110027, 208110030], '3(00)',
+[209513826, 209513829], '3(00)',
+[212623522, 212623525], '(00)3',
+[213841715, 213841718], '(00)3',
+[214012333, 214012336], '(00)3',
+[214073567, 214073570], '(00)3',
+[215170600, 215170603], '3(00)',
+[215881039, 215881042], '3(00)',
+[216274604, 216274607], '3(00)',
+[216957120, 216957123], '3(00)',
+[217323208, 217323211], '(00)3',
+[218799264, 218799267], '(00)3',
+[218803557, 218803560], '3(00)',
+[219735146, 219735149], '(00)3',
+[219830062, 219830065], '3(00)',
+[219897904, 219897907], '(00)3',
+[221205545, 221205548], '(00)3',
+[223601929, 223601932], '(00)3',
+[223907076, 223907079], '3(00)',
+[223970397, 223970400], '(00)3',
+[224874044, 224874048], '22(00)',
+[225291157, 225291160], '(00)3',
+[227481734, 227481737], '(00)3',
+[228006442, 228006445], '3(00)',
+[228357900, 228357903], '(00)3',
+[228386399, 228386402], '(00)3',
+[228907446, 228907449], '(00)3',
+[228984552, 228984555], '3(00)',
+[229140285, 229140288], '3(00)',
+[231810024, 231810027], '(00)3',
+[232838062, 232838065], '3(00)',
+[234389088, 234389091], '3(00)',
+[235588194, 235588197], '(00)3',
+[236645695, 236645698], '(00)3',
+[236962876, 236962879], '3(00)',
+[237516723, 237516727], '04(00)',
+[240004911, 240004914], '(00)3',
+[240221306, 240221309], '3(00)',
+[241389213, 241389217], '(010)3',
+[241549003, 241549006], '(00)3',
+[241729717, 241729720], '(00)3',
+[241743684, 241743687], '3(00)',
+[243780200, 243780203], '3(00)',
+[243801317, 243801320], '(00)3',
+[244122072, 244122075], '(00)3',
+[244691224, 244691227], '3(00)',
+[244841577, 244841580], '(00)3',
+[245813461, 245813464], '(00)3',
+[246299475, 246299478], '(00)3',
+[246450176, 246450179], '3(00)',
+[249069349, 249069352], '(00)3',
+[250076378, 250076381], '(00)3',
+[252442157, 252442160], '3(00)',
+[252904231, 252904234], '3(00)',
+[255145220, 255145223], '(00)3',
+[255285971, 255285974], '3(00)',
+[256713230, 256713233], '(00)3',
+[257992082, 257992085], '(00)3',
+[258447955, 258447959], '22(00)',
+[259298045, 259298048], '3(00)',
+[262141503, 262141506], '(00)3',
+[263681743, 263681746], '3(00)',
+[266527881, 266527885], '(010)3',
+[266617122, 266617125], '(00)3',
+[266628044, 266628047], '3(00)',
+[267305763, 267305766], '(00)3',
+[267388404, 267388407], '3(00)',
+[267441672, 267441675], '3(00)',
+[267464886, 267464889], '(00)3',
+[267554907, 267554910], '3(00)',
+[269787480, 269787483], '(00)3',
+[270881434, 270881437], '(00)3',
+[270997583, 270997586], '3(00)',
+[272096378, 272096381], '3(00)',
+[272583009, 272583012], '(00)3',
+[274190881, 274190884], '3(00)',
+[274268747, 274268750], '(00)3',
+[275297429, 275297432], '3(00)',
+[275545476, 275545479], '3(00)',
+[275898479, 275898482], '3(00)',
+[275953000, 275953003], '(00)3',
+[277117197, 277117201], '(00)22',
+[277447310, 277447313], '3(00)',
+[279059657, 279059660], '3(00)',
+[279259144, 279259147], '3(00)',
+[279513636, 279513639], '3(00)',
+[279849069, 279849072], '3(00)',
+[280291419, 280291422], '(00)3',
+[281449425, 281449428], '3(00)',
+[281507953, 281507956], '3(00)',
+[281825600, 281825603], '(00)3',
+[282547093, 282547096], '3(00)',
+[283120963, 283120966], '3(00)',
+[283323493, 283323496], '(00)3',
+[284764535, 284764538], '3(00)',
+[286172639, 286172642], '3(00)',
+[286688824, 286688827], '(00)3',
+[287222172, 287222175], '3(00)',
+[287235534, 287235537], '3(00)',
+[287304861, 287304864], '3(00)',
+[287433571, 287433574], '(00)3',
+[287823551, 287823554], '(00)3',
+[287872422, 287872425], '3(00)',
+[288766615, 288766618], '3(00)',
+[290122963, 290122966], '3(00)',
+[290450849, 290450853], '(00)22',
+[291426141, 291426144], '3(00)',
+[292810353, 292810356], '3(00)',
+[293109861, 293109864], '3(00)',
+[293398054, 293398057], '3(00)',
+[294134426, 294134429], '3(00)',
+[294216438, 294216441], '(00)3',
+[295367141, 295367144], '3(00)',
+[297834111, 297834114], '3(00)',
+[299099969, 299099972], '3(00)',
+[300746958, 300746961], '3(00)',
+[301097423, 301097426], '(00)3',
+[301834209, 301834212], '(00)3',
+[302554791, 302554794], '(00)3',
+[303497445, 303497448], '3(00)',
+[304165344, 304165347], '3(00)',
+[304790218, 304790222], '3(010)',
+[305302352, 305302355], '(00)3',
+[306785996, 306785999], '3(00)',
+[307051443, 307051446], '3(00)',
+[307481539, 307481542], '3(00)',
+[308605569, 308605572], '3(00)',
+[309237610, 309237613], '3(00)',
+[310509287, 310509290], '(00)3',
+[310554057, 310554060], '3(00)',
+[310646345, 310646348], '3(00)',
+[311274896, 311274899], '(00)3',
+[311894272, 311894275], '3(00)',
+[312269470, 312269473], '(00)3',
+[312306601, 312306605], '(00)40',
+[312683193, 312683196], '3(00)',
+[314499804, 314499807], '3(00)',
+[314636802, 314636805], '(00)3',
+[314689897, 314689900], '3(00)',
+[314721319, 314721322], '3(00)',
+[316132890, 316132893], '3(00)',
+[316217470, 316217474], '(010)3',
+[316465705, 316465708], '3(00)',
+[316542790, 316542793], '(00)3',
+[320822347, 320822350], '3(00)',
+[321733242, 321733245], '3(00)',
+[324413970, 324413973], '(00)3',
+[325950140, 325950143], '(00)3',
+[326675884, 326675887], '(00)3',
+[326704208, 326704211], '3(00)',
+[327596247, 327596250], '3(00)',
+[328123172, 328123175], '3(00)',
+[328182212, 328182215], '(00)3',
+[328257498, 328257501], '3(00)',
+[328315836, 328315839], '(00)3',
+[328800974, 328800977], '(00)3',
+[328998509, 328998512], '3(00)',
+[329725370, 329725373], '(00)3',
+[332080601, 332080604], '(00)3',
+[332221246, 332221249], '(00)3',
+[332299899, 332299902], '(00)3',
+[332532822, 332532825], '(00)3',
+[333334544, 333334548], '(00)22',
+[333881266, 333881269], '3(00)',
+[334703267, 334703270], '3(00)',
+[334875138, 334875141], '3(00)',
+[336531451, 336531454], '3(00)',
+[336825907, 336825910], '(00)3',
+[336993167, 336993170], '(00)3',
+[337493998, 337494001], '3(00)',
+[337861034, 337861037], '3(00)',
+[337899191, 337899194], '(00)3',
+[337958123, 337958126], '(00)3',
+[342331982, 342331985], '3(00)',
+[342676068, 342676071], '3(00)',
+[347063781, 347063784], '3(00)',
+[347697348, 347697351], '3(00)',
+[347954319, 347954322], '3(00)',
+[348162775, 348162778], '3(00)',
+[349210702, 349210705], '(00)3',
+[349212913, 349212916], '3(00)',
+[349248650, 349248653], '(00)3',
+[349913500, 349913503], '3(00)',
+[350891529, 350891532], '3(00)',
+[351089323, 351089326], '3(00)',
+[351826158, 351826161], '3(00)',
+[352228580, 352228583], '(00)3',
+[352376244, 352376247], '3(00)',
+[352853758, 352853761], '(00)3',
+[355110439, 355110442], '(00)3',
+[355808090, 355808094], '(00)40',
+[355941556, 355941559], '3(00)',
+[356360231, 356360234], '(00)3',
+[356586657, 356586660], '3(00)',
+[356892926, 356892929], '(00)3',
+[356908232, 356908235], '3(00)',
+[357912730, 357912733], '3(00)',
+[358120344, 358120347], '3(00)',
+[359044096, 359044099], '(00)3',
+[360819357, 360819360], '3(00)',
+[361399662, 361399666], '(010)3',
+[362361315, 362361318], '(00)3',
+[363610112, 363610115], '(00)3',
+[363964804, 363964807], '3(00)',
+[364527375, 364527378], '(00)3',
+[365090327, 365090330], '(00)3',
+[365414539, 365414542], '3(00)',
+[366738474, 366738477], '3(00)',
+[368714778, 368714783], '04(010)',
+[368831545, 368831548], '(00)3',
+[368902387, 368902390], '(00)3',
+[370109769, 370109772], '3(00)',
+[370963333, 370963336], '3(00)',
+[372541136, 372541140], '3(010)',
+[372681562, 372681565], '(00)3',
+[373009410, 373009413], '(00)3',
+[373458970, 373458973], '3(00)',
+[375648658, 375648661], '3(00)',
+[376834728, 376834731], '3(00)',
+[377119945, 377119948], '(00)3',
+[377335703, 377335706], '(00)3',
+[378091745, 378091748], '3(00)',
+[379139522, 379139525], '3(00)',
+[380279160, 380279163], '(00)3',
+[380619442, 380619445], '3(00)',
+[381244231, 381244234], '3(00)',
+[382327446, 382327450], '(010)3',
+[382357073, 382357076], '3(00)',
+[383545479, 383545482], '3(00)',
+[384363766, 384363769], '(00)3',
+[384401786, 384401790], '22(00)',
+[385198212, 385198215], '3(00)',
+[385824476, 385824479], '(00)3',
+[385908194, 385908197], '3(00)',
+[386946806, 386946809], '3(00)',
+[387592175, 387592179], '22(00)',
+[388329293, 388329296], '(00)3',
+[388679566, 388679569], '3(00)',
+[388832142, 388832145], '3(00)',
+[390087103, 390087106], '(00)3',
+[390190926, 390190930], '(00)22',
+[390331207, 390331210], '3(00)',
+[391674495, 391674498], '3(00)',
+[391937831, 391937834], '3(00)',
+[391951632, 391951636], '(00)22',
+[392963986, 392963989], '(00)3',
+[393007921, 393007924], '3(00)',
+[393373210, 393373213], '3(00)',
+[393759572, 393759575], '(00)3',
+[394036662, 394036665], '(00)3',
+[395813866, 395813869], '(00)3',
+[395956690, 395956693], '3(00)',
+[396031670, 396031673], '3(00)',
+[397076433, 397076436], '3(00)',
+[397470601, 397470604], '3(00)',
+[398289458, 398289461], '3(00)',
+#
+[368714778, 368714783], '04(010)',
+[437953499, 437953504], '04(010)',
+[526196233, 526196238], '032(00)',
+[744719566, 744719571], '(010)40',
+[750375857, 750375862], '032(00)',
+[958241932, 958241937], '04(010)',
+[983377342, 983377347], '(00)410',
+[1003780080, 1003780085], '04(010)',
+[1070232754, 1070232759], '(00)230',
+[1209834865, 1209834870], '032(00)',
+[1257209100, 1257209105], '(00)410',
+[1368002233, 1368002238], '(00)230'
+]
diff --git a/lib/python3.11/site-packages/mpmath/identification.py b/lib/python3.11/site-packages/mpmath/identification.py
new file mode 100644
index 0000000000000000000000000000000000000000..226f62d3fe9cacedbd9ba2b1e66ff0ad017fa604
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/identification.py
@@ -0,0 +1,844 @@
+"""
+Implements the PSLQ algorithm for integer relation detection,
+and derivative algorithms for constant recognition.
+"""
+
+from .libmp.backend import xrange
+from .libmp import int_types, sqrt_fixed
+
+# round to nearest integer (can be done more elegantly...)
+def round_fixed(x, prec):
+    return ((x + (1<<(prec-1))) >> prec) << prec
+
+class IdentificationMethods(object):
+    pass
+
+
+def pslq(ctx, x, tol=None, maxcoeff=1000, maxsteps=100, verbose=False):
+    r"""
+    Given a vector of real numbers `x = [x_0, x_1, ..., x_n]`, ``pslq(x)``
+    uses the PSLQ algorithm to find a list of integers
+    `[c_0, c_1, ..., c_n]` such that
+
+    .. math ::
+
+        |c_1 x_1 + c_2 x_2 + ... + c_n x_n| < \mathrm{tol}
+
+    and such that `\max |c_k| < \mathrm{maxcoeff}`. If no such vector
+    exists, :func:`~mpmath.pslq` returns ``None``. The tolerance defaults to
+    3/4 of the working precision.
+
+    **Examples**
+
+    Find rational approximations for `\pi`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> pslq([-1, pi], tol=0.01)
+        [22, 7]
+        >>> pslq([-1, pi], tol=0.001)
+        [355, 113]
+        >>> mpf(22)/7; mpf(355)/113; +pi
+        3.14285714285714
+        3.14159292035398
+        3.14159265358979
+
+    Pi is not a rational number with denominator less than 1000::
+
+        >>> pslq([-1, pi])
+        >>>
+
+    To within the standard precision, it can however be approximated
+    by at least one rational number with denominator less than `10^{12}`::
+
+        >>> p, q = pslq([-1, pi], maxcoeff=10**12)
+        >>> print(p); print(q)
+        238410049439
+        75888275702
+        >>> mpf(p)/q
+        3.14159265358979
+
+    The PSLQ algorithm can be applied to long vectors. For example,
+    we can investigate the rational (in)dependence of integer square
+    roots::
+
+        >>> mp.dps = 30
+        >>> pslq([sqrt(n) for n in range(2, 5+1)])
+        >>>
+        >>> pslq([sqrt(n) for n in range(2, 6+1)])
+        >>>
+        >>> pslq([sqrt(n) for n in range(2, 8+1)])
+        [2, 0, 0, 0, 0, 0, -1]
+
+    **Machin formulas**
+
+    A famous formula for `\pi` is Machin's,
+
+    .. math ::
+
+        \frac{\pi}{4} = 4 \operatorname{acot} 5 - \operatorname{acot} 239
+
+    There are actually infinitely many formulas of this type. Two
+    others are
+
+    .. math ::
+
+        \frac{\pi}{4} = \operatorname{acot} 1
+
+        \frac{\pi}{4} = 12 \operatorname{acot} 49 + 32 \operatorname{acot} 57
+            + 5 \operatorname{acot} 239 + 12 \operatorname{acot} 110443
+
+    We can easily verify the formulas using the PSLQ algorithm::
+
+        >>> mp.dps = 30
+        >>> pslq([pi/4, acot(1)])
+        [1, -1]
+        >>> pslq([pi/4, acot(5), acot(239)])
+        [1, -4, 1]
+        >>> pslq([pi/4, acot(49), acot(57), acot(239), acot(110443)])
+        [1, -12, -32, 5, -12]
+
+    We could try to generate a custom Machin-like formula by running
+    the PSLQ algorithm with a few inverse cotangent values, for example
+    acot(2), acot(3) ... acot(10). Unfortunately, there is a linear
+    dependence among these values, resulting in only that dependence
+    being detected, with a zero coefficient for `\pi`::
+
+        >>> pslq([pi] + [acot(n) for n in range(2,11)])
+        [0, 1, -1, 0, 0, 0, -1, 0, 0, 0]
+
+    We get better luck by removing linearly dependent terms::
+
+        >>> pslq([pi] + [acot(n) for n in range(2,11) if n not in (3, 5)])
+        [1, -8, 0, 0, 4, 0, 0, 0]
+
+    In other words, we found the following formula::
+
+        >>> 8*acot(2) - 4*acot(7)
+        3.14159265358979323846264338328
+        >>> +pi
+        3.14159265358979323846264338328
+
+    **Algorithm**
+
+    This is a fairly direct translation to Python of the pseudocode given by
+    David Bailey, "The PSLQ Integer Relation Algorithm":
+    http://www.cecm.sfu.ca/organics/papers/bailey/paper/html/node3.html
+
+    The present implementation uses fixed-point instead of floating-point
+    arithmetic, since this is significantly (about 7x) faster.
+    """
+
+    n = len(x)
+    if n < 2:
+        raise ValueError("n cannot be less than 2")
+
+    # At too low precision, the algorithm becomes meaningless
+    prec = ctx.prec
+    if prec < 53:
+        raise ValueError("prec cannot be less than 53")
+
+    if verbose and prec // max(2,n) < 5:
+        print("Warning: precision for PSLQ may be too low")
+
+    target = int(prec * 0.75)
+
+    if tol is None:
+        tol = ctx.mpf(2)**(-target)
+    else:
+        tol = ctx.convert(tol)
+
+    extra = 60
+    prec += extra
+
+    if verbose:
+        print("PSLQ using prec %i and tol %s" % (prec, ctx.nstr(tol)))
+
+    tol = ctx.to_fixed(tol, prec)
+    assert tol
+
+    # Convert to fixed-point numbers. The dummy None is added so we can
+    # use 1-based indexing. (This just allows us to be consistent with
+    # Bailey's indexing. The algorithm is 100 lines long, so debugging
+    # a single wrong index can be painful.)
+    x = [None] + [ctx.to_fixed(ctx.mpf(xk), prec) for xk in x]
+
+    # Sanity check on magnitudes
+    minx = min(abs(xx) for xx in x[1:])
+    if not minx:
+        raise ValueError("PSLQ requires a vector of nonzero numbers")
+    if minx < tol//100:
+        if verbose:
+            print("STOPPING: (one number is too small)")
+        return None
+
+    g = sqrt_fixed((4<<prec)//3, prec)
+    A = {}
+    B = {}
+    H = {}
+    # Initialization
+    # step 1
+    for i in xrange(1, n+1):
+        for j in xrange(1, n+1):
+            A[i,j] = B[i,j] = (i==j) << prec
+            H[i,j] = 0
+    # step 2
+    s = [None] + [0] * n
+    for k in xrange(1, n+1):
+        t = 0
+        for j in xrange(k, n+1):
+            t += (x[j]**2 >> prec)
+        s[k] = sqrt_fixed(t, prec)
+    t = s[1]
+    y = x[:]
+    for k in xrange(1, n+1):
+        y[k] = (x[k] << prec) // t
+        s[k] = (s[k] << prec) // t
+    # step 3
+    for i in xrange(1, n+1):
+        for j in xrange(i+1, n):
+            H[i,j] = 0
+        if i <= n-1:
+            if s[i]:
+                H[i,i] = (s[i+1] << prec) // s[i]
+            else:
+                H[i,i] = 0
+        for j in range(1, i):
+            sjj1 = s[j]*s[j+1]
+            if sjj1:
+                H[i,j] = ((-y[i]*y[j])<<prec)//sjj1
+            else:
+                H[i,j] = 0
+    # step 4
+    for i in xrange(2, n+1):
+        for j in xrange(i-1, 0, -1):
+            #t = floor(H[i,j]/H[j,j] + 0.5)
+            if H[j,j]:
+                t = round_fixed((H[i,j] << prec)//H[j,j], prec)
+            else:
+                #t = 0
+                continue
+            y[j] = y[j] + (t*y[i] >> prec)
+            for k in xrange(1, j+1):
+                H[i,k] = H[i,k] - (t*H[j,k] >> prec)
+            for k in xrange(1, n+1):
+                A[i,k] = A[i,k] - (t*A[j,k] >> prec)
+                B[k,j] = B[k,j] + (t*B[k,i] >> prec)
+    # Main algorithm
+    for REP in range(maxsteps):
+        # Step 1
+        m = -1
+        szmax = -1
+        for i in range(1, n):
+            h = H[i,i]
+            sz = (g**i * abs(h)) >> (prec*(i-1))
+            if sz > szmax:
+                m = i
+                szmax = sz
+        # Step 2
+        y[m], y[m+1] = y[m+1], y[m]
+        for i in xrange(1,n+1): H[m,i], H[m+1,i] = H[m+1,i], H[m,i]
+        for i in xrange(1,n+1): A[m,i], A[m+1,i] = A[m+1,i], A[m,i]
+        for i in xrange(1,n+1): B[i,m], B[i,m+1] = B[i,m+1], B[i,m]
+        # Step 3
+        if m <= n - 2:
+            t0 = sqrt_fixed((H[m,m]**2 + H[m,m+1]**2)>>prec, prec)
+            # A zero element probably indicates that the precision has
+            # been exhausted. XXX: this could be spurious, due to
+            # using fixed-point arithmetic
+            if not t0:
+                break
+            t1 = (H[m,m] << prec) // t0
+            t2 = (H[m,m+1] << prec) // t0
+            for i in xrange(m, n+1):
+                t3 = H[i,m]
+                t4 = H[i,m+1]
+                H[i,m] = (t1*t3+t2*t4) >> prec
+                H[i,m+1] = (-t2*t3+t1*t4) >> prec
+        # Step 4
+        for i in xrange(m+1, n+1):
+            for j in xrange(min(i-1, m+1), 0, -1):
+                try:
+                    t = round_fixed((H[i,j] << prec)//H[j,j], prec)
+                # Precision probably exhausted
+                except ZeroDivisionError:
+                    break
+                y[j] = y[j] + ((t*y[i]) >> prec)
+                for k in xrange(1, j+1):
+                    H[i,k] = H[i,k] - (t*H[j,k] >> prec)
+                for k in xrange(1, n+1):
+                    A[i,k] = A[i,k] - (t*A[j,k] >> prec)
+                    B[k,j] = B[k,j] + (t*B[k,i] >> prec)
+        # Until a relation is found, the error typically decreases
+        # slowly (e.g. a factor 1-10) with each step TODO: we could
+        # compare err from two successive iterations. If there is a
+        # large drop (several orders of magnitude), that indicates a
+        # "high quality" relation was detected. Reporting this to
+        # the user somehow might be useful.
+        best_err = maxcoeff<<prec
+        for i in xrange(1, n+1):
+            err = abs(y[i])
+            # Maybe we are done?
+            if err < tol:
+                # We are done if the coefficients are acceptable
+                vec = [int(round_fixed(B[j,i], prec) >> prec) for j in \
+                range(1,n+1)]
+                if max(abs(v) for v in vec) < maxcoeff:
+                    if verbose:
+                        print("FOUND relation at iter %i/%i, error: %s" % \
+                            (REP, maxsteps, ctx.nstr(err / ctx.mpf(2)**prec, 1)))
+                    return vec
+            best_err = min(err, best_err)
+        # Calculate a lower bound for the norm. We could do this
+        # more exactly (using the Euclidean norm) but there is probably
+        # no practical benefit.
+        recnorm = max(abs(h) for h in H.values())
+        if recnorm:
+            norm = ((1 << (2*prec)) // recnorm) >> prec
+            norm //= 100
+        else:
+            norm = ctx.inf
+        if verbose:
+            print("%i/%i:  Error: %8s   Norm: %s" % \
+                (REP, maxsteps, ctx.nstr(best_err / ctx.mpf(2)**prec, 1), norm))
+        if norm >= maxcoeff:
+            break
+    if verbose:
+        print("CANCELLING after step %i/%i." % (REP, maxsteps))
+        print("Could not find an integer relation. Norm bound: %s" % norm)
+    return None
+
+def findpoly(ctx, x, n=1, **kwargs):
+    r"""
+    ``findpoly(x, n)`` returns the coefficients of an integer
+    polynomial `P` of degree at most `n` such that `P(x) \approx 0`.
+    If no polynomial having `x` as a root can be found,
+    :func:`~mpmath.findpoly` returns ``None``.
+
+    :func:`~mpmath.findpoly` works by successively calling :func:`~mpmath.pslq` with
+    the vectors `[1, x]`, `[1, x, x^2]`, `[1, x, x^2, x^3]`, ...,
+    `[1, x, x^2, .., x^n]` as input. Keyword arguments given to
+    :func:`~mpmath.findpoly` are forwarded verbatim to :func:`~mpmath.pslq`. In
+    particular, you can specify a tolerance for `P(x)` with ``tol``
+    and a maximum permitted coefficient size with ``maxcoeff``.
+
+    For large values of `n`, it is recommended to run :func:`~mpmath.findpoly`
+    at high precision; preferably 50 digits or more.
+
+    **Examples**
+
+    By default (degree `n = 1`), :func:`~mpmath.findpoly` simply finds a linear
+    polynomial with a rational root::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> findpoly(0.7)
+        [-10, 7]
+
+    The generated coefficient list is valid input to ``polyval`` and
+    ``polyroots``::
+
+        >>> nprint(polyval(findpoly(phi, 2), phi), 1)
+        -2.0e-16
+        >>> for r in polyroots(findpoly(phi, 2)):
+        ...     print(r)
+        ...
+        -0.618033988749895
+        1.61803398874989
+
+    Numbers of the form `m + n \sqrt p` for integers `(m, n, p)` are
+    solutions to quadratic equations. As we find here, `1+\sqrt 2`
+    is a root of the polynomial `x^2 - 2x - 1`::
+
+        >>> findpoly(1+sqrt(2), 2)
+        [1, -2, -1]
+        >>> findroot(lambda x: x**2 - 2*x - 1, 1)
+        2.4142135623731
+
+    Despite only containing square roots, the following number results
+    in a polynomial of degree 4::
+
+        >>> findpoly(sqrt(2)+sqrt(3), 4)
+        [1, 0, -10, 0, 1]
+
+    In fact, `x^4 - 10x^2 + 1` is the *minimal polynomial* of
+    `r = \sqrt 2 + \sqrt 3`, meaning that a rational polynomial of
+    lower degree having `r` as a root does not exist. Given sufficient
+    precision, :func:`~mpmath.findpoly` will usually find the correct
+    minimal polynomial of a given algebraic number.
+
+    **Non-algebraic numbers**
+
+    If :func:`~mpmath.findpoly` fails to find a polynomial with given
+    coefficient size and tolerance constraints, that means no such
+    polynomial exists.
+
+    We can verify that `\pi` is not an algebraic number of degree 3 with
+    coefficients less than 1000::
+
+        >>> mp.dps = 15
+        >>> findpoly(pi, 3)
+        >>>
+
+    It is always possible to find an algebraic approximation of a number
+    using one (or several) of the following methods:
+
+        1. Increasing the permitted degree
+        2. Allowing larger coefficients
+        3. Reducing the tolerance
+
+    One example of each method is shown below::
+
+        >>> mp.dps = 15
+        >>> findpoly(pi, 4)
+        [95, -545, 863, -183, -298]
+        >>> findpoly(pi, 3, maxcoeff=10000)
+        [836, -1734, -2658, -457]
+        >>> findpoly(pi, 3, tol=1e-7)
+        [-4, 22, -29, -2]
+
+    It is unknown whether Euler's constant is transcendental (or even
+    irrational). We can use :func:`~mpmath.findpoly` to check that if is
+    an algebraic number, its minimal polynomial must have degree
+    at least 7 and a coefficient of magnitude at least 1000000::
+
+        >>> mp.dps = 200
+        >>> findpoly(euler, 6, maxcoeff=10**6, tol=1e-100, maxsteps=1000)
+        >>>
+
+    Note that the high precision and strict tolerance is necessary
+    for such high-degree runs, since otherwise unwanted low-accuracy
+    approximations will be detected. It may also be necessary to set
+    maxsteps high to prevent a premature exit (before the coefficient
+    bound has been reached). Running with ``verbose=True`` to get an
+    idea what is happening can be useful.
+    """
+    x = ctx.mpf(x)
+    if n < 1:
+        raise ValueError("n cannot be less than 1")
+    if x == 0:
+        return [1, 0]
+    xs = [ctx.mpf(1)]
+    for i in range(1,n+1):
+        xs.append(x**i)
+        a = ctx.pslq(xs, **kwargs)
+        if a is not None:
+            return a[::-1]
+
+def fracgcd(p, q):
+    x, y = p, q
+    while y:
+        x, y = y, x % y
+    if x != 1:
+        p //= x
+        q //= x
+    if q == 1:
+        return p
+    return p, q
+
+def pslqstring(r, constants):
+    q = r[0]
+    r = r[1:]
+    s = []
+    for i in range(len(r)):
+        p = r[i]
+        if p:
+            z = fracgcd(-p,q)
+            cs = constants[i][1]
+            if cs == '1':
+                cs = ''
+            else:
+                cs = '*' + cs
+            if isinstance(z, int_types):
+                if z > 0: term = str(z) + cs
+                else:     term = ("(%s)" % z) + cs
+            else:
+                term = ("(%s/%s)" % z) + cs
+            s.append(term)
+    s = ' + '.join(s)
+    if '+' in s or '*' in s:
+        s = '(' + s + ')'
+    return s or '0'
+
+def prodstring(r, constants):
+    q = r[0]
+    r = r[1:]
+    num = []
+    den = []
+    for i in range(len(r)):
+        p = r[i]
+        if p:
+            z = fracgcd(-p,q)
+            cs = constants[i][1]
+            if isinstance(z, int_types):
+                if abs(z) == 1: t = cs
+                else:           t = '%s**%s' % (cs, abs(z))
+                ([num,den][z<0]).append(t)
+            else:
+                t = '%s**(%s/%s)' % (cs, abs(z[0]), z[1])
+                ([num,den][z[0]<0]).append(t)
+    num = '*'.join(num)
+    den = '*'.join(den)
+    if num and den: return "(%s)/(%s)" % (num, den)
+    if num: return num
+    if den: return "1/(%s)" % den
+
+def quadraticstring(ctx,t,a,b,c):
+    if c < 0:
+        a,b,c = -a,-b,-c
+    u1 = (-b+ctx.sqrt(b**2-4*a*c))/(2*c)
+    u2 = (-b-ctx.sqrt(b**2-4*a*c))/(2*c)
+    if abs(u1-t) < abs(u2-t):
+        if b:  s = '((%s+sqrt(%s))/%s)' % (-b,b**2-4*a*c,2*c)
+        else:  s = '(sqrt(%s)/%s)' % (-4*a*c,2*c)
+    else:
+        if b:  s = '((%s-sqrt(%s))/%s)' % (-b,b**2-4*a*c,2*c)
+        else:  s = '(-sqrt(%s)/%s)' % (-4*a*c,2*c)
+    return s
+
+# Transformation y = f(x,c), with inverse function x = f(y,c)
+# The third entry indicates whether the transformation is
+# redundant when c = 1
+transforms = [
+  (lambda ctx,x,c: x*c, '$y/$c', 0),
+  (lambda ctx,x,c: x/c, '$c*$y', 1),
+  (lambda ctx,x,c: c/x, '$c/$y', 0),
+  (lambda ctx,x,c: (x*c)**2, 'sqrt($y)/$c', 0),
+  (lambda ctx,x,c: (x/c)**2, '$c*sqrt($y)', 1),
+  (lambda ctx,x,c: (c/x)**2, '$c/sqrt($y)', 0),
+  (lambda ctx,x,c: c*x**2, 'sqrt($y)/sqrt($c)', 1),
+  (lambda ctx,x,c: x**2/c, 'sqrt($c)*sqrt($y)', 1),
+  (lambda ctx,x,c: c/x**2, 'sqrt($c)/sqrt($y)', 1),
+  (lambda ctx,x,c: ctx.sqrt(x*c), '$y**2/$c', 0),
+  (lambda ctx,x,c: ctx.sqrt(x/c), '$c*$y**2', 1),
+  (lambda ctx,x,c: ctx.sqrt(c/x), '$c/$y**2', 0),
+  (lambda ctx,x,c: c*ctx.sqrt(x), '$y**2/$c**2', 1),
+  (lambda ctx,x,c: ctx.sqrt(x)/c, '$c**2*$y**2', 1),
+  (lambda ctx,x,c: c/ctx.sqrt(x), '$c**2/$y**2', 1),
+  (lambda ctx,x,c: ctx.exp(x*c), 'log($y)/$c', 0),
+  (lambda ctx,x,c: ctx.exp(x/c), '$c*log($y)', 1),
+  (lambda ctx,x,c: ctx.exp(c/x), '$c/log($y)', 0),
+  (lambda ctx,x,c: c*ctx.exp(x), 'log($y/$c)', 1),
+  (lambda ctx,x,c: ctx.exp(x)/c, 'log($c*$y)', 1),
+  (lambda ctx,x,c: c/ctx.exp(x), 'log($c/$y)', 0),
+  (lambda ctx,x,c: ctx.ln(x*c), 'exp($y)/$c', 0),
+  (lambda ctx,x,c: ctx.ln(x/c), '$c*exp($y)', 1),
+  (lambda ctx,x,c: ctx.ln(c/x), '$c/exp($y)', 0),
+  (lambda ctx,x,c: c*ctx.ln(x), 'exp($y/$c)', 1),
+  (lambda ctx,x,c: ctx.ln(x)/c, 'exp($c*$y)', 1),
+  (lambda ctx,x,c: c/ctx.ln(x), 'exp($c/$y)', 0),
+]
+
+def identify(ctx, x, constants=[], tol=None, maxcoeff=1000, full=False,
+    verbose=False):
+    r"""
+    Given a real number `x`, ``identify(x)`` attempts to find an exact
+    formula for `x`. This formula is returned as a string. If no match
+    is found, ``None`` is returned. With ``full=True``, a list of
+    matching formulas is returned.
+
+    As a simple example, :func:`~mpmath.identify` will find an algebraic
+    formula for the golden ratio::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> identify(phi)
+        '((1+sqrt(5))/2)'
+
+    :func:`~mpmath.identify` can identify simple algebraic numbers and simple
+    combinations of given base constants, as well as certain basic
+    transformations thereof. More specifically, :func:`~mpmath.identify`
+    looks for the following:
+
+        1. Fractions
+        2. Quadratic algebraic numbers
+        3. Rational linear combinations of the base constants
+        4. Any of the above after first transforming `x` into `f(x)` where
+           `f(x)` is `1/x`, `\sqrt x`, `x^2`, `\log x` or `\exp x`, either
+           directly or with `x` or `f(x)` multiplied or divided by one of
+           the base constants
+        5. Products of fractional powers of the base constants and
+           small integers
+
+    Base constants can be given as a list of strings representing mpmath
+    expressions (:func:`~mpmath.identify` will ``eval`` the strings to numerical
+    values and use the original strings for the output), or as a dict of
+    formula:value pairs.
+
+    In order not to produce spurious results, :func:`~mpmath.identify` should
+    be used with high precision; preferably 50 digits or more.
+
+    **Examples**
+
+    Simple identifications can be performed safely at standard
+    precision. Here the default recognition of rational, algebraic,
+    and exp/log of algebraic numbers is demonstrated::
+
+        >>> mp.dps = 15
+        >>> identify(0.22222222222222222)
+        '(2/9)'
+        >>> identify(1.9662210973805663)
+        'sqrt(((24+sqrt(48))/8))'
+        >>> identify(4.1132503787829275)
+        'exp((sqrt(8)/2))'
+        >>> identify(0.881373587019543)
+        'log(((2+sqrt(8))/2))'
+
+    By default, :func:`~mpmath.identify` does not recognize `\pi`. At standard
+    precision it finds a not too useful approximation. At slightly
+    increased precision, this approximation is no longer accurate
+    enough and :func:`~mpmath.identify` more correctly returns ``None``::
+
+        >>> identify(pi)
+        '(2**(176/117)*3**(20/117)*5**(35/39))/(7**(92/117))'
+        >>> mp.dps = 30
+        >>> identify(pi)
+        >>>
+
+    Numbers such as `\pi`, and simple combinations of user-defined
+    constants, can be identified if they are provided explicitly::
+
+        >>> identify(3*pi-2*e, ['pi', 'e'])
+        '(3*pi + (-2)*e)'
+
+    Here is an example using a dict of constants. Note that the
+    constants need not be "atomic"; :func:`~mpmath.identify` can just
+    as well express the given number in terms of expressions
+    given by formulas::
+
+        >>> identify(pi+e, {'a':pi+2, 'b':2*e})
+        '((-2) + 1*a + (1/2)*b)'
+
+    Next, we attempt some identifications with a set of base constants.
+    It is necessary to increase the precision a bit.
+
+        >>> mp.dps = 50
+        >>> base = ['sqrt(2)','pi','log(2)']
+        >>> identify(0.25, base)
+        '(1/4)'
+        >>> identify(3*pi + 2*sqrt(2) + 5*log(2)/7, base)
+        '(2*sqrt(2) + 3*pi + (5/7)*log(2))'
+        >>> identify(exp(pi+2), base)
+        'exp((2 + 1*pi))'
+        >>> identify(1/(3+sqrt(2)), base)
+        '((3/7) + (-1/7)*sqrt(2))'
+        >>> identify(sqrt(2)/(3*pi+4), base)
+        'sqrt(2)/(4 + 3*pi)'
+        >>> identify(5**(mpf(1)/3)*pi*log(2)**2, base)
+        '5**(1/3)*pi*log(2)**2'
+
+    An example of an erroneous solution being found when too low
+    precision is used::
+
+        >>> mp.dps = 15
+        >>> identify(1/(3*pi-4*e+sqrt(8)), ['pi', 'e', 'sqrt(2)'])
+        '((11/25) + (-158/75)*pi + (76/75)*e + (44/15)*sqrt(2))'
+        >>> mp.dps = 50
+        >>> identify(1/(3*pi-4*e+sqrt(8)), ['pi', 'e', 'sqrt(2)'])
+        '1/(3*pi + (-4)*e + 2*sqrt(2))'
+
+    **Finding approximate solutions**
+
+    The tolerance ``tol`` defaults to 3/4 of the working precision.
+    Lowering the tolerance is useful for finding approximate matches.
+    We can for example try to generate approximations for pi::
+
+        >>> mp.dps = 15
+        >>> identify(pi, tol=1e-2)
+        '(22/7)'
+        >>> identify(pi, tol=1e-3)
+        '(355/113)'
+        >>> identify(pi, tol=1e-10)
+        '(5**(339/269))/(2**(64/269)*3**(13/269)*7**(92/269))'
+
+    With ``full=True``, and by supplying a few base constants,
+    ``identify`` can generate almost endless lists of approximations
+    for any number (the output below has been truncated to show only
+    the first few)::
+
+        >>> for p in identify(pi, ['e', 'catalan'], tol=1e-5, full=True):
+        ...     print(p)
+        ...  # doctest: +ELLIPSIS
+        e/log((6 + (-4/3)*e))
+        (3**3*5*e*catalan**2)/(2*7**2)
+        sqrt(((-13) + 1*e + 22*catalan))
+        log(((-6) + 24*e + 4*catalan)/e)
+        exp(catalan*((-1/5) + (8/15)*e))
+        catalan*(6 + (-6)*e + 15*catalan)
+        sqrt((5 + 26*e + (-3)*catalan))/e
+        e*sqrt(((-27) + 2*e + 25*catalan))
+        log(((-1) + (-11)*e + 59*catalan))
+        ((3/20) + (21/20)*e + (3/20)*catalan)
+        ...
+
+    The numerical values are roughly as close to `\pi` as permitted by the
+    specified tolerance:
+
+        >>> e/log(6-4*e/3)
+        3.14157719846001
+        >>> 135*e*catalan**2/98
+        3.14166950419369
+        >>> sqrt(e-13+22*catalan)
+        3.14158000062992
+        >>> log(24*e-6+4*catalan)-1
+        3.14158791577159
+
+    **Symbolic processing**
+
+    The output formula can be evaluated as a Python expression.
+    Note however that if fractions (like '2/3') are present in
+    the formula, Python's :func:`~mpmath.eval()` may erroneously perform
+    integer division. Note also that the output is not necessarily
+    in the algebraically simplest form::
+
+        >>> identify(sqrt(2))
+        '(sqrt(8)/2)'
+
+    As a solution to both problems, consider using SymPy's
+    :func:`~mpmath.sympify` to convert the formula into a symbolic expression.
+    SymPy can be used to pretty-print or further simplify the formula
+    symbolically::
+
+        >>> from sympy import sympify # doctest: +SKIP
+        >>> sympify(identify(sqrt(2))) # doctest: +SKIP
+        2**(1/2)
+
+    Sometimes :func:`~mpmath.identify` can simplify an expression further than
+    a symbolic algorithm::
+
+        >>> from sympy import simplify # doctest: +SKIP
+        >>> x = sympify('-1/(-3/2+(1/2)*5**(1/2))*(3/2-1/2*5**(1/2))**(1/2)') # doctest: +SKIP
+        >>> x # doctest: +SKIP
+        (3/2 - 5**(1/2)/2)**(-1/2)
+        >>> x = simplify(x) # doctest: +SKIP
+        >>> x # doctest: +SKIP
+        2/(6 - 2*5**(1/2))**(1/2)
+        >>> mp.dps = 30 # doctest: +SKIP
+        >>> x = sympify(identify(x.evalf(30))) # doctest: +SKIP
+        >>> x # doctest: +SKIP
+        1/2 + 5**(1/2)/2
+
+    (In fact, this functionality is available directly in SymPy as the
+    function :func:`~mpmath.nsimplify`, which is essentially a wrapper for
+    :func:`~mpmath.identify`.)
+
+    **Miscellaneous issues and limitations**
+
+    The input `x` must be a real number. All base constants must be
+    positive real numbers and must not be rationals or rational linear
+    combinations of each other.
+
+    The worst-case computation time grows quickly with the number of
+    base constants. Already with 3 or 4 base constants,
+    :func:`~mpmath.identify` may require several seconds to finish. To search
+    for relations among a large number of constants, you should
+    consider using :func:`~mpmath.pslq` directly.
+
+    The extended transformations are applied to x, not the constants
+    separately. As a result, ``identify`` will for example be able to
+    recognize ``exp(2*pi+3)`` with ``pi`` given as a base constant, but
+    not ``2*exp(pi)+3``. It will be able to recognize the latter if
+    ``exp(pi)`` is given explicitly as a base constant.
+
+    """
+
+    solutions = []
+
+    def addsolution(s):
+        if verbose: print("Found: ", s)
+        solutions.append(s)
+
+    x = ctx.mpf(x)
+
+    # Further along, x will be assumed positive
+    if x == 0:
+        if full: return ['0']
+        else:    return '0'
+    if x < 0:
+        sol = ctx.identify(-x, constants, tol, maxcoeff, full, verbose)
+        if sol is None:
+            return sol
+        if full:
+            return ["-(%s)"%s for s in sol]
+        else:
+            return "-(%s)" % sol
+
+    if tol:
+        tol = ctx.mpf(tol)
+    else:
+        tol = ctx.eps**0.7
+    M = maxcoeff
+
+    if constants:
+        if isinstance(constants, dict):
+            constants = [(ctx.mpf(v), name) for (name, v) in sorted(constants.items())]
+        else:
+            namespace = dict((name, getattr(ctx,name)) for name in dir(ctx))
+            constants = [(eval(p, namespace), p) for p in constants]
+    else:
+        constants = []
+
+    # We always want to find at least rational terms
+    if 1 not in [value for (name, value) in constants]:
+        constants = [(ctx.mpf(1), '1')] + constants
+
+    # PSLQ with simple algebraic and functional transformations
+    for ft, ftn, red in transforms:
+        for c, cn in constants:
+            if red and cn == '1':
+                continue
+            t = ft(ctx,x,c)
+            # Prevent exponential transforms from wreaking havoc
+            if abs(t) > M**2 or abs(t) < tol:
+                continue
+            # Linear combination of base constants
+            r = ctx.pslq([t] + [a[0] for a in constants], tol, M)
+            s = None
+            if r is not None and max(abs(uw) for uw in r) <= M and r[0]:
+                s = pslqstring(r, constants)
+            # Quadratic algebraic numbers
+            else:
+                q = ctx.pslq([ctx.one, t, t**2], tol, M)
+                if q is not None and len(q) == 3 and q[2]:
+                    aa, bb, cc = q
+                    if max(abs(aa),abs(bb),abs(cc)) <= M:
+                        s = quadraticstring(ctx,t,aa,bb,cc)
+            if s:
+                if cn == '1' and ('/$c' in ftn):
+                    s = ftn.replace('$y', s).replace('/$c', '')
+                else:
+                    s = ftn.replace('$y', s).replace('$c', cn)
+                addsolution(s)
+                if not full: return solutions[0]
+
+            if verbose:
+                print(".")
+
+    # Check for a direct multiplicative formula
+    if x != 1:
+        # Allow fractional powers of fractions
+        ilogs = [2,3,5,7]
+        # Watch out for existing fractional powers of fractions
+        logs = []
+        for a, s in constants:
+            if not sum(bool(ctx.findpoly(ctx.ln(a)/ctx.ln(i),1)) for i in ilogs):
+                logs.append((ctx.ln(a), s))
+        logs = [(ctx.ln(i),str(i)) for i in ilogs] + logs
+        r = ctx.pslq([ctx.ln(x)] + [a[0] for a in logs], tol, M)
+        if r is not None and max(abs(uw) for uw in r) <= M and r[0]:
+            addsolution(prodstring(r, logs))
+            if not full: return solutions[0]
+
+    if full:
+        return sorted(solutions, key=len)
+    else:
+        return None
+
+IdentificationMethods.pslq = pslq
+IdentificationMethods.findpoly = findpoly
+IdentificationMethods.identify = identify
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__init__.py b/lib/python3.11/site-packages/mpmath/libmp/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1573114afc4fbce73f2ba9d2ddc99882c00027c0
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/__init__.py
@@ -0,0 +1,77 @@
+from .libmpf import (prec_to_dps, dps_to_prec, repr_dps,
+  round_down, round_up, round_floor, round_ceiling, round_nearest,
+  to_pickable, from_pickable, ComplexResult,
+  fzero, fnzero, fone, fnone, ftwo, ften, fhalf, fnan, finf, fninf,
+  math_float_inf, round_int, normalize, normalize1,
+  from_man_exp, from_int, to_man_exp, to_int, mpf_ceil, mpf_floor,
+  mpf_nint, mpf_frac,
+  from_float, from_npfloat, from_Decimal, to_float, from_rational, to_rational, to_fixed,
+  mpf_rand, mpf_eq, mpf_hash, mpf_cmp, mpf_lt, mpf_le, mpf_gt, mpf_ge,
+  mpf_pos, mpf_neg, mpf_abs, mpf_sign, mpf_add, mpf_sub, mpf_sum,
+  mpf_mul, mpf_mul_int, mpf_shift, mpf_frexp,
+  mpf_div, mpf_rdiv_int, mpf_mod, mpf_pow_int,
+  mpf_perturb,
+  to_digits_exp, to_str, str_to_man_exp, from_str, from_bstr, to_bstr,
+  mpf_sqrt, mpf_hypot)
+
+from .libmpc import (mpc_one, mpc_zero, mpc_two, mpc_half,
+  mpc_is_inf, mpc_is_infnan, mpc_to_str, mpc_to_complex, mpc_hash,
+  mpc_conjugate, mpc_is_nonzero, mpc_add, mpc_add_mpf,
+  mpc_sub, mpc_sub_mpf, mpc_pos, mpc_neg, mpc_shift, mpc_abs,
+  mpc_arg, mpc_floor, mpc_ceil,  mpc_nint, mpc_frac, mpc_mul, mpc_square,
+  mpc_mul_mpf, mpc_mul_imag_mpf, mpc_mul_int,
+  mpc_div, mpc_div_mpf, mpc_reciprocal, mpc_mpf_div,
+  complex_int_pow, mpc_pow, mpc_pow_mpf, mpc_pow_int,
+  mpc_sqrt, mpc_nthroot, mpc_cbrt, mpc_exp, mpc_log, mpc_cos, mpc_sin,
+  mpc_tan, mpc_cos_pi, mpc_sin_pi, mpc_cosh, mpc_sinh, mpc_tanh,
+  mpc_atan, mpc_acos, mpc_asin, mpc_asinh, mpc_acosh, mpc_atanh,
+  mpc_fibonacci, mpf_expj, mpf_expjpi, mpc_expj, mpc_expjpi,
+  mpc_cos_sin, mpc_cos_sin_pi)
+
+from .libelefun import (ln2_fixed, mpf_ln2, ln10_fixed, mpf_ln10,
+  pi_fixed, mpf_pi, e_fixed, mpf_e, phi_fixed, mpf_phi,
+  degree_fixed, mpf_degree,
+  mpf_pow, mpf_nthroot, mpf_cbrt, log_int_fixed, agm_fixed,
+  mpf_log, mpf_log_hypot, mpf_exp, mpf_cos_sin, mpf_cos, mpf_sin, mpf_tan,
+  mpf_cos_sin_pi, mpf_cos_pi, mpf_sin_pi, mpf_cosh_sinh,
+  mpf_cosh, mpf_sinh, mpf_tanh, mpf_atan, mpf_atan2, mpf_asin,
+  mpf_acos, mpf_asinh, mpf_acosh, mpf_atanh, mpf_fibonacci)
+
+from .libhyper import (NoConvergence, make_hyp_summator,
+  mpf_erf, mpf_erfc, mpf_ei, mpc_ei, mpf_e1, mpc_e1, mpf_expint,
+  mpf_ci_si, mpf_ci, mpf_si, mpc_ci, mpc_si, mpf_besseljn,
+  mpc_besseljn, mpf_agm, mpf_agm1, mpc_agm, mpc_agm1,
+  mpf_ellipk, mpc_ellipk, mpf_ellipe, mpc_ellipe)
+
+from .gammazeta import (catalan_fixed, mpf_catalan,
+  khinchin_fixed, mpf_khinchin, glaisher_fixed, mpf_glaisher,
+  apery_fixed, mpf_apery, euler_fixed, mpf_euler, mertens_fixed,
+  mpf_mertens, twinprime_fixed, mpf_twinprime,
+  mpf_bernoulli, bernfrac, mpf_gamma_int,
+  mpf_factorial, mpc_factorial, mpf_gamma, mpc_gamma,
+  mpf_loggamma, mpc_loggamma, mpf_rgamma, mpc_rgamma,
+  mpf_harmonic, mpc_harmonic, mpf_psi0, mpc_psi0,
+  mpf_psi, mpc_psi, mpf_zeta_int, mpf_zeta, mpc_zeta,
+  mpf_altzeta, mpc_altzeta, mpf_zetasum, mpc_zetasum)
+
+from .libmpi import (mpi_str,
+  mpi_from_str, mpi_to_str,
+  mpi_eq, mpi_ne,
+  mpi_lt, mpi_le, mpi_gt, mpi_ge,
+  mpi_add, mpi_sub, mpi_delta, mpi_mid,
+  mpi_pos, mpi_neg, mpi_abs, mpi_mul, mpi_div, mpi_exp,
+  mpi_log, mpi_sqrt, mpi_pow_int, mpi_pow, mpi_cos_sin,
+  mpi_cos, mpi_sin, mpi_tan, mpi_cot,
+  mpi_atan, mpi_atan2,
+  mpci_pos, mpci_neg, mpci_add, mpci_sub, mpci_mul, mpci_div, mpci_pow,
+  mpci_abs, mpci_pow, mpci_exp, mpci_log, mpci_cos, mpci_sin,
+  mpi_gamma, mpci_gamma, mpi_loggamma, mpci_loggamma,
+  mpi_rgamma, mpci_rgamma, mpi_factorial, mpci_factorial)
+
+from .libintmath import (trailing, bitcount, numeral, bin_to_radix,
+  isqrt, isqrt_small, isqrt_fast, sqrt_fixed, sqrtrem, ifib, ifac,
+  list_primes, isprime, moebius, gcd, eulernum, stirling1, stirling2)
+
+from .backend import (gmpy, sage, BACKEND, STRICT, MPZ, MPZ_TYPE,
+  MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_THREE, MPZ_FIVE, int_types,
+  HASH_MODULUS, HASH_BITS)
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..293430dfe826ea4e0ecd3cb2d5f67031d55a84c1
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/backend.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/backend.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e9bccf8bd730f5f607d2eb9bcb9fc207cd661138
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/backend.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/gammazeta.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/gammazeta.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..afc8045b5ca2d6c8591c02d0189f4b56275ace2c
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/gammazeta.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libelefun.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libelefun.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..434891834f039de07186727e5948b26a554de9f5
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libelefun.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libhyper.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libhyper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f573867b0e4fd927582270455ada47e60b309e7
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libhyper.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libintmath.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libintmath.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d82b1f331176b4d6edd6d8aa81445ca5c98952a0
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libintmath.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpc.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpc.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..978e6d8f664ef80444c748454c9403007842c00c
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpc.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpf.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpf.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a62422f7f14a693f31c970e5a66623b84ec91fc3
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpf.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpi.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpi.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05a6e1bb203e795850070a0b27103c4c7baeef3d
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/libmp/__pycache__/libmpi.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/libmp/backend.py b/lib/python3.11/site-packages/mpmath/libmp/backend.py
new file mode 100644
index 0000000000000000000000000000000000000000..5610221290a05078f21f09df3c1a76b0e4ccdc02
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/backend.py
@@ -0,0 +1,115 @@
+import os
+import sys
+
+#----------------------------------------------------------------------------#
+# Support GMPY for high-speed large integer arithmetic.                      #
+#                                                                            #
+# To allow an external module to handle arithmetic, we need to make sure     #
+# that all high-precision variables are declared of the correct type. MPZ    #
+# is the constructor for the high-precision type. It defaults to Python's    #
+# long type but can be assinged another type, typically gmpy.mpz.            #
+#                                                                            #
+# MPZ must be used for the mantissa component of an mpf and must be used     #
+# for internal fixed-point operations.                                       #
+#                                                                            #
+# Side-effects                                                               #
+# 1) "is" cannot be used to test for special values. Must use "==".          #
+# 2) There are bugs in GMPY prior to v1.02 so we must use v1.03 or later.    #
+#----------------------------------------------------------------------------#
+
+# So we can import it from this module
+gmpy = None
+sage = None
+sage_utils = None
+
+if sys.version_info[0] < 3:
+    python3 = False
+else:
+    python3 = True
+
+BACKEND = 'python'
+
+if not python3:
+    MPZ = long
+    xrange = xrange
+    basestring = basestring
+
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+else:
+    MPZ = int
+    xrange = range
+    basestring = str
+
+    import builtins
+    exec_ = getattr(builtins, "exec")
+
+# Define constants for calculating hash on Python 3.2.
+if sys.version_info >= (3, 2):
+    HASH_MODULUS = sys.hash_info.modulus
+    if sys.hash_info.width == 32:
+        HASH_BITS = 31
+    else:
+        HASH_BITS = 61
+else:
+    HASH_MODULUS = None
+    HASH_BITS = None
+
+if 'MPMATH_NOGMPY' not in os.environ:
+    try:
+        try:
+            import gmpy2 as gmpy
+        except ImportError:
+            try:
+                import gmpy
+            except ImportError:
+                raise ImportError
+        if gmpy.version() >= '1.03':
+            BACKEND = 'gmpy'
+            MPZ = gmpy.mpz
+    except:
+        pass
+
+if ('MPMATH_NOSAGE' not in os.environ and 'SAGE_ROOT' in os.environ or
+        'MPMATH_SAGE' in os.environ):
+    try:
+        import sage.all
+        import sage.libs.mpmath.utils as _sage_utils
+        sage = sage.all
+        sage_utils = _sage_utils
+        BACKEND = 'sage'
+        MPZ = sage.Integer
+    except:
+        pass
+
+if 'MPMATH_STRICT' in os.environ:
+    STRICT = True
+else:
+    STRICT = False
+
+MPZ_TYPE = type(MPZ(0))
+MPZ_ZERO = MPZ(0)
+MPZ_ONE = MPZ(1)
+MPZ_TWO = MPZ(2)
+MPZ_THREE = MPZ(3)
+MPZ_FIVE = MPZ(5)
+
+try:
+    if BACKEND == 'python':
+        int_types = (int, long)
+    else:
+        int_types = (int, long, MPZ_TYPE)
+except NameError:
+    if BACKEND == 'python':
+        int_types = (int,)
+    else:
+        int_types = (int, MPZ_TYPE)
diff --git a/lib/python3.11/site-packages/mpmath/libmp/gammazeta.py b/lib/python3.11/site-packages/mpmath/libmp/gammazeta.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b05cc63c5f00e6c76d8383853dba06f15e46030
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/gammazeta.py
@@ -0,0 +1,2167 @@
+"""
+-----------------------------------------------------------------------
+This module implements gamma- and zeta-related functions:
+
+* Bernoulli numbers
+* Factorials
+* The gamma function
+* Polygamma functions
+* Harmonic numbers
+* The Riemann zeta function
+* Constants related to these functions
+
+-----------------------------------------------------------------------
+"""
+
+import math
+import sys
+
+from .backend import xrange
+from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_THREE, gmpy
+
+from .libintmath import list_primes, ifac, ifac2, moebius
+
+from .libmpf import (\
+    round_floor, round_ceiling, round_down, round_up,
+    round_nearest, round_fast,
+    lshift, sqrt_fixed, isqrt_fast,
+    fzero, fone, fnone, fhalf, ftwo, finf, fninf, fnan,
+    from_int, to_int, to_fixed, from_man_exp, from_rational,
+    mpf_pos, mpf_neg, mpf_abs, mpf_add, mpf_sub,
+    mpf_mul, mpf_mul_int, mpf_div, mpf_sqrt, mpf_pow_int,
+    mpf_rdiv_int,
+    mpf_perturb, mpf_le, mpf_lt, mpf_gt, mpf_shift,
+    negative_rnd, reciprocal_rnd,
+    bitcount, to_float, mpf_floor, mpf_sign, ComplexResult
+)
+
+from .libelefun import (\
+    constant_memo,
+    def_mpf_constant,
+    mpf_pi, pi_fixed, ln2_fixed, log_int_fixed, mpf_ln2,
+    mpf_exp, mpf_log, mpf_pow, mpf_cosh,
+    mpf_cos_sin, mpf_cosh_sinh, mpf_cos_sin_pi, mpf_cos_pi, mpf_sin_pi,
+    ln_sqrt2pi_fixed, mpf_ln_sqrt2pi, sqrtpi_fixed, mpf_sqrtpi,
+    cos_sin_fixed, exp_fixed
+)
+
+from .libmpc import (\
+    mpc_zero, mpc_one, mpc_half, mpc_two,
+    mpc_abs, mpc_shift, mpc_pos, mpc_neg,
+    mpc_add, mpc_sub, mpc_mul, mpc_div,
+    mpc_add_mpf, mpc_mul_mpf, mpc_div_mpf, mpc_mpf_div,
+    mpc_mul_int, mpc_pow_int,
+    mpc_log, mpc_exp, mpc_pow,
+    mpc_cos_pi, mpc_sin_pi,
+    mpc_reciprocal, mpc_square,
+    mpc_sub_mpf
+)
+
+
+
+# Catalan's constant is computed using Lupas's rapidly convergent series
+# (listed on http://mathworld.wolfram.com/CatalansConstant.html)
+#            oo
+#            ___       n-1  8n     2                   3    2
+#        1  \      (-1)    2   (40n  - 24n + 3) [(2n)!] (n!)
+#  K =  ---  )     -----------------------------------------
+#       64  /___               3               2
+#                             n  (2n-1) [(4n)!]
+#           n = 1
+
+@constant_memo
+def catalan_fixed(prec):
+    prec = prec + 20
+    a = one = MPZ_ONE << prec
+    s, t, n = 0, 1, 1
+    while t:
+        a *= 32 * n**3 * (2*n-1)
+        a //= (3-16*n+16*n**2)**2
+        t = a * (-1)**(n-1) * (40*n**2-24*n+3) // (n**3 * (2*n-1))
+        s += t
+        n += 1
+    return s >> (20 + 6)
+
+# Khinchin's constant is relatively difficult to compute. Here
+# we use the rational zeta series
+
+#                    oo                2*n-1
+#                   ___                ___
+#                   \   ` zeta(2*n)-1  \   ` (-1)^(k+1)
+#  log(K)*log(2) =   )    ------------  )    ----------
+#                   /___.      n       /___.      k
+#                   n = 1              k = 1
+
+# which adds half a digit per term. The essential trick for achieving
+# reasonable efficiency is to recycle both the values of the zeta
+# function (essentially Bernoulli numbers) and the partial terms of
+# the inner sum.
+
+# An alternative might be to use K = 2*exp[1/log(2) X] where
+
+#      / 1     1       [ pi*x*(1-x^2) ]
+#  X = |    ------ log [ ------------ ].
+#      / 0  x(1+x)     [  sin(pi*x)   ]
+
+# and integrate numerically. In practice, this seems to be slightly
+# slower than the zeta series at high precision.
+
+@constant_memo
+def khinchin_fixed(prec):
+    wp = int(prec + prec**0.5 + 15)
+    s = MPZ_ZERO
+    fac = from_int(4)
+    t = ONE = MPZ_ONE << wp
+    pi = mpf_pi(wp)
+    pipow = twopi2 = mpf_shift(mpf_mul(pi, pi, wp), 2)
+    n = 1
+    while 1:
+        zeta2n = mpf_abs(mpf_bernoulli(2*n, wp))
+        zeta2n = mpf_mul(zeta2n, pipow, wp)
+        zeta2n = mpf_div(zeta2n, fac, wp)
+        zeta2n = to_fixed(zeta2n, wp)
+        term = (((zeta2n - ONE) * t) // n) >> wp
+        if term < 100:
+            break
+        #if not n % 10:
+        #    print n, math.log(int(abs(term)))
+        s += term
+        t += ONE//(2*n+1) - ONE//(2*n)
+        n += 1
+        fac = mpf_mul_int(fac, (2*n)*(2*n-1), wp)
+        pipow = mpf_mul(pipow, twopi2, wp)
+    s = (s << wp) // ln2_fixed(wp)
+    K = mpf_exp(from_man_exp(s, -wp), wp)
+    K = to_fixed(K, prec)
+    return K
+
+
+# Glaisher's constant is defined as A = exp(1/2 - zeta'(-1)).
+# One way to compute it would be to perform direct numerical
+# differentiation, but computing arbitrary Riemann zeta function
+# values at high precision is expensive. We instead use the formula
+
+#     A = exp((6 (-zeta'(2))/pi^2 + log 2 pi + gamma)/12)
+
+# and compute zeta'(2) from the series representation
+
+#              oo
+#              ___
+#             \     log k
+#  -zeta'(2) = )    -----
+#             /___     2
+#                    k
+#            k = 2
+
+# This series converges exceptionally slowly, but can be accelerated
+# using Euler-Maclaurin formula. The important insight is that the
+# E-M integral can be done in closed form and that the high order
+# are given by
+
+#    n  /       \
+#   d   | log x |   a + b log x
+#   --- | ----- | = -----------
+#     n |   2   |      2 + n
+#   dx  \  x    /     x
+
+# where a and b are integers given by a simple recurrence. Note
+# that just one logarithm is needed. However, lots of integer
+# logarithms are required for the initial summation.
+
+# This algorithm could possibly be turned into a faster algorithm
+# for general evaluation of zeta(s) or zeta'(s); this should be
+# looked into.
+
+@constant_memo
+def glaisher_fixed(prec):
+    wp = prec + 30
+    # Number of direct terms to sum before applying the Euler-Maclaurin
+    # formula to the tail. TODO: choose more intelligently
+    N = int(0.33*prec + 5)
+    ONE = MPZ_ONE << wp
+    # Euler-Maclaurin, step 1: sum log(k)/k**2 for k from 2 to N-1
+    s = MPZ_ZERO
+    for k in range(2, N):
+        #print k, N
+        s += log_int_fixed(k, wp) // k**2
+    logN = log_int_fixed(N, wp)
+    #logN = to_fixed(mpf_log(from_int(N), wp+20), wp)
+    # E-M step 2: integral of log(x)/x**2 from N to inf
+    s += (ONE + logN) // N
+    # E-M step 3: endpoint correction term f(N)/2
+    s += logN // (N**2 * 2)
+    # E-M step 4: the series of derivatives
+    pN = N**3
+    a = 1
+    b = -2
+    j = 3
+    fac = from_int(2)
+    k = 1
+    while 1:
+        # D(2*k-1) * B(2*k) / fac(2*k) [D(n) = nth derivative]
+        D = ((a << wp) + b*logN) // pN
+        D = from_man_exp(D, -wp)
+        B = mpf_bernoulli(2*k, wp)
+        term = mpf_mul(B, D, wp)
+        term = mpf_div(term, fac, wp)
+        term = to_fixed(term, wp)
+        if abs(term) < 100:
+            break
+        #if not k % 10:
+        #    print k, math.log(int(abs(term)), 10)
+        s -= term
+        # Advance derivative twice
+        a, b, pN, j = b-a*j, -j*b, pN*N, j+1
+        a, b, pN, j = b-a*j, -j*b, pN*N, j+1
+        k += 1
+        fac = mpf_mul_int(fac, (2*k)*(2*k-1), wp)
+    # A = exp((6*s/pi**2 + log(2*pi) + euler)/12)
+    pi = pi_fixed(wp)
+    s *= 6
+    s = (s << wp) // (pi**2 >> wp)
+    s += euler_fixed(wp)
+    s += to_fixed(mpf_log(from_man_exp(2*pi, -wp), wp), wp)
+    s //= 12
+    A = mpf_exp(from_man_exp(s, -wp), wp)
+    return to_fixed(A, prec)
+
+# Apery's constant can be computed using the very rapidly convergent
+# series
+#              oo
+#              ___              2                      10
+#             \         n  205 n  + 250 n + 77     (n!)
+#  zeta(3) =   )    (-1)   -------------------  ----------
+#             /___               64                      5
+#             n = 0                             ((2n+1)!)
+
+@constant_memo
+def apery_fixed(prec):
+    prec += 20
+    d = MPZ_ONE << prec
+    term = MPZ(77) << prec
+    n = 1
+    s = MPZ_ZERO
+    while term:
+        s += term
+        d *= (n**10)
+        d //= (((2*n+1)**5) * (2*n)**5)
+        term = (-1)**n * (205*(n**2) + 250*n + 77) * d
+        n += 1
+    return s >> (20 + 6)
+
+"""
+Euler's constant (gamma) is computed using the Brent-McMillan formula,
+gamma ~= I(n)/J(n) - log(n), where
+
+   I(n) = sum_{k=0,1,2,...} (n**k / k!)**2 * H(k)
+   J(n) = sum_{k=0,1,2,...} (n**k / k!)**2
+   H(k) = 1 + 1/2 + 1/3 + ... + 1/k
+
+The error is bounded by O(exp(-4n)). Choosing n to be a power
+of two, 2**p, the logarithm becomes particularly easy to calculate.[1]
+
+We use the formulation of Algorithm 3.9 in [2] to make the summation
+more efficient.
+
+Reference:
+[1] Xavier Gourdon & Pascal Sebah, The Euler constant: gamma
+http://numbers.computation.free.fr/Constants/Gamma/gamma.pdf
+
+[2] [BorweinBailey]_
+"""
+
+@constant_memo
+def euler_fixed(prec):
+    extra = 30
+    prec += extra
+    # choose p such that exp(-4*(2**p)) < 2**-n
+    p = int(math.log((prec/4) * math.log(2), 2)) + 1
+    n = 2**p
+    A = U = -p*ln2_fixed(prec)
+    B = V = MPZ_ONE << prec
+    k = 1
+    while 1:
+        B = B*n**2//k**2
+        A = (A*n**2//k + B)//k
+        U += A
+        V += B
+        if max(abs(A), abs(B)) < 100:
+            break
+        k += 1
+    return (U<<(prec-extra))//V
+
+# Use zeta accelerated formulas for the Mertens and twin
+# prime constants; see
+# http://mathworld.wolfram.com/MertensConstant.html
+# http://mathworld.wolfram.com/TwinPrimesConstant.html
+
+@constant_memo
+def mertens_fixed(prec):
+    wp = prec + 20
+    m = 2
+    s = mpf_euler(wp)
+    while 1:
+        t = mpf_zeta_int(m, wp)
+        if t == fone:
+            break
+        t = mpf_log(t, wp)
+        t = mpf_mul_int(t, moebius(m), wp)
+        t = mpf_div(t, from_int(m), wp)
+        s = mpf_add(s, t)
+        m += 1
+    return to_fixed(s, prec)
+
+@constant_memo
+def twinprime_fixed(prec):
+    def I(n):
+        return sum(moebius(d)<<(n//d) for d in xrange(1,n+1) if not n%d)//n
+    wp = 2*prec + 30
+    res = fone
+    primes = [from_rational(1,p,wp) for p in [2,3,5,7]]
+    ppowers = [mpf_mul(p,p,wp) for p in primes]
+    n = 2
+    while 1:
+        a = mpf_zeta_int(n, wp)
+        for i in range(4):
+            a = mpf_mul(a, mpf_sub(fone, ppowers[i]), wp)
+            ppowers[i] = mpf_mul(ppowers[i], primes[i], wp)
+        a = mpf_pow_int(a, -I(n), wp)
+        if mpf_pos(a, prec+10, 'n') == fone:
+            break
+        #from libmpf import to_str
+        #print n, to_str(mpf_sub(fone, a), 6)
+        res = mpf_mul(res, a, wp)
+        n += 1
+    res = mpf_mul(res, from_int(3*15*35), wp)
+    res = mpf_div(res, from_int(4*16*36), wp)
+    return to_fixed(res, prec)
+
+
+mpf_euler = def_mpf_constant(euler_fixed)
+mpf_apery = def_mpf_constant(apery_fixed)
+mpf_khinchin = def_mpf_constant(khinchin_fixed)
+mpf_glaisher = def_mpf_constant(glaisher_fixed)
+mpf_catalan = def_mpf_constant(catalan_fixed)
+mpf_mertens = def_mpf_constant(mertens_fixed)
+mpf_twinprime = def_mpf_constant(twinprime_fixed)
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                          Bernoulli numbers                            #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+MAX_BERNOULLI_CACHE = 3000
+
+
+r"""
+Small Bernoulli numbers and factorials are used in numerous summations,
+so it is critical for speed that sequential computation is fast and that
+values are cached up to a fairly high threshold.
+
+On the other hand, we also want to support fast computation of isolated
+large numbers. Currently, no such acceleration is provided for integer
+factorials (though it is for large floating-point factorials, which are
+computed via gamma if the precision is low enough).
+
+For sequential computation of Bernoulli numbers, we use Ramanujan's formula
+
+                           / n + 3 \
+  B   =  (A(n) - S(n))  /  |       |
+   n                       \   n   /
+
+where A(n) = (n+3)/3 when n = 0 or 2 (mod 6), A(n) = -(n+3)/6
+when n = 4 (mod 6), and
+
+         [n/6]
+          ___
+         \      /  n + 3  \
+  S(n) =  )     |         | * B
+         /___   \ n - 6*k /    n-6*k
+         k = 1
+
+For isolated large Bernoulli numbers, we use the Riemann zeta function
+to calculate a numerical value for B_n. The von Staudt-Clausen theorem
+can then be used to optionally find the exact value of the
+numerator and denominator.
+"""
+
+bernoulli_cache = {}
+f3 = from_int(3)
+f6 = from_int(6)
+
+def bernoulli_size(n):
+    """Accurately estimate the size of B_n (even n > 2 only)"""
+    lgn = math.log(n,2)
+    return int(2.326 + 0.5*lgn + n*(lgn - 4.094))
+
+BERNOULLI_PREC_CUTOFF = bernoulli_size(MAX_BERNOULLI_CACHE)
+
+def mpf_bernoulli(n, prec, rnd=None):
+    """Computation of Bernoulli numbers (numerically)"""
+    if n < 2:
+        if n < 0:
+            raise ValueError("Bernoulli numbers only defined for n >= 0")
+        if n == 0:
+            return fone
+        if n == 1:
+            return mpf_neg(fhalf)
+    # For odd n > 1, the Bernoulli numbers are zero
+    if n & 1:
+        return fzero
+    # If precision is extremely high, we can save time by computing
+    # the Bernoulli number at a lower precision that is sufficient to
+    # obtain the exact fraction, round to the exact fraction, and
+    # convert the fraction back to an mpf value at the original precision
+    if prec > BERNOULLI_PREC_CUTOFF and prec > bernoulli_size(n)*1.1 + 1000:
+        p, q = bernfrac(n)
+        return from_rational(p, q, prec, rnd or round_floor)
+    if n > MAX_BERNOULLI_CACHE:
+        return mpf_bernoulli_huge(n, prec, rnd)
+    wp = prec + 30
+    # Reuse nearby precisions
+    wp += 32 - (prec & 31)
+    cached = bernoulli_cache.get(wp)
+    if cached:
+        numbers, state = cached
+        if n in numbers:
+            if not rnd:
+                return numbers[n]
+            return mpf_pos(numbers[n], prec, rnd)
+        m, bin, bin1 = state
+        if n - m > 10:
+            return mpf_bernoulli_huge(n, prec, rnd)
+    else:
+        if n > 10:
+            return mpf_bernoulli_huge(n, prec, rnd)
+        numbers = {0:fone}
+        m, bin, bin1 = state = [2, MPZ(10), MPZ_ONE]
+        bernoulli_cache[wp] = (numbers, state)
+    while m <= n:
+        #print m
+        case = m % 6
+        # Accurately estimate size of B_m so we can use
+        # fixed point math without using too much precision
+        szbm = bernoulli_size(m)
+        s = 0
+        sexp = max(0, szbm)  - wp
+        if m < 6:
+            a = MPZ_ZERO
+        else:
+            a = bin1
+        for j in xrange(1, m//6+1):
+            usign, uman, uexp, ubc = u = numbers[m-6*j]
+            if usign:
+                uman = -uman
+            s += lshift(a*uman, uexp-sexp)
+            # Update inner binomial coefficient
+            j6 = 6*j
+            a *= ((m-5-j6)*(m-4-j6)*(m-3-j6)*(m-2-j6)*(m-1-j6)*(m-j6))
+            a //= ((4+j6)*(5+j6)*(6+j6)*(7+j6)*(8+j6)*(9+j6))
+        if case == 0: b = mpf_rdiv_int(m+3, f3, wp)
+        if case == 2: b = mpf_rdiv_int(m+3, f3, wp)
+        if case == 4: b = mpf_rdiv_int(-m-3, f6, wp)
+        s = from_man_exp(s, sexp, wp)
+        b = mpf_div(mpf_sub(b, s, wp), from_int(bin), wp)
+        numbers[m] = b
+        m += 2
+        # Update outer binomial coefficient
+        bin = bin * ((m+2)*(m+3)) // (m*(m-1))
+        if m > 6:
+            bin1 = bin1 * ((2+m)*(3+m)) // ((m-7)*(m-6))
+        state[:] = [m, bin, bin1]
+    return numbers[n]
+
+def mpf_bernoulli_huge(n, prec, rnd=None):
+    wp = prec + 10
+    piprec = wp + int(math.log(n,2))
+    v = mpf_gamma_int(n+1, wp)
+    v = mpf_mul(v, mpf_zeta_int(n, wp), wp)
+    v = mpf_mul(v, mpf_pow_int(mpf_pi(piprec), -n, wp))
+    v = mpf_shift(v, 1-n)
+    if not n & 3:
+        v = mpf_neg(v)
+    return mpf_pos(v, prec, rnd or round_fast)
+
+def bernfrac(n):
+    r"""
+    Returns a tuple of integers `(p, q)` such that `p/q = B_n` exactly,
+    where `B_n` denotes the `n`-th Bernoulli number. The fraction is
+    always reduced to lowest terms. Note that for `n > 1` and `n` odd,
+    `B_n = 0`, and `(0, 1)` is returned.
+
+    **Examples**
+
+    The first few Bernoulli numbers are exactly::
+
+        >>> from mpmath import *
+        >>> for n in range(15):
+        ...     p, q = bernfrac(n)
+        ...     print("%s %s/%s" % (n, p, q))
+        ...
+        0 1/1
+        1 -1/2
+        2 1/6
+        3 0/1
+        4 -1/30
+        5 0/1
+        6 1/42
+        7 0/1
+        8 -1/30
+        9 0/1
+        10 5/66
+        11 0/1
+        12 -691/2730
+        13 0/1
+        14 7/6
+
+    This function works for arbitrarily large `n`::
+
+        >>> p, q = bernfrac(10**4)
+        >>> print(q)
+        2338224387510
+        >>> print(len(str(p)))
+        27692
+        >>> mp.dps = 15
+        >>> print(mpf(p) / q)
+        -9.04942396360948e+27677
+        >>> print(bernoulli(10**4))
+        -9.04942396360948e+27677
+
+    .. note ::
+
+        :func:`~mpmath.bernoulli` computes a floating-point approximation
+        directly, without computing the exact fraction first.
+        This is much faster for large `n`.
+
+    **Algorithm**
+
+    :func:`~mpmath.bernfrac` works by computing the value of `B_n` numerically
+    and then using the von Staudt-Clausen theorem [1] to reconstruct
+    the exact fraction. For large `n`, this is significantly faster than
+    computing `B_1, B_2, \ldots, B_2` recursively with exact arithmetic.
+    The implementation has been tested for `n = 10^m` up to `m = 6`.
+
+    In practice, :func:`~mpmath.bernfrac` appears to be about three times
+    slower than the specialized program calcbn.exe [2]
+
+    **References**
+
+    1. MathWorld, von Staudt-Clausen Theorem:
+       http://mathworld.wolfram.com/vonStaudt-ClausenTheorem.html
+
+    2. The Bernoulli Number Page:
+       http://www.bernoulli.org/
+
+    """
+    n = int(n)
+    if n < 3:
+        return [(1, 1), (-1, 2), (1, 6)][n]
+    if n & 1:
+        return (0, 1)
+    q = 1
+    for k in list_primes(n+1):
+        if not (n % (k-1)):
+            q *= k
+    prec = bernoulli_size(n) + int(math.log(q,2)) + 20
+    b = mpf_bernoulli(n, prec)
+    p = mpf_mul(b, from_int(q))
+    pint = to_int(p, round_nearest)
+    return (pint, q)
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                         Polygamma functions                           #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+r"""
+For all polygamma (psi) functions, we use the Euler-Maclaurin summation
+formula. It looks slightly different in the m = 0 and m > 0 cases.
+
+For m = 0, we have
+                                 oo
+                                ___   B
+       (0)                1    \       2 k    -2 k
+    psi   (z)  ~ log z + --- -  )    ------  z
+                         2 z   /___  (2 k)!
+                               k = 1
+
+Experiment shows that the minimum term of the asymptotic series
+reaches 2^(-p) when Re(z) > 0.11*p. So we simply use the recurrence
+for psi (equivalent, in fact, to summing to the first few terms
+directly before applying E-M) to obtain z large enough.
+
+Since, very crudely, log z ~= 1 for Re(z) > 1, we can use
+fixed-point arithmetic  (if z is extremely large, log(z) itself
+is a sufficient approximation, so we can stop there already).
+
+For Re(z) << 0, we could use recurrence, but this is of course
+inefficient for large negative z, so there we use the
+reflection formula instead.
+
+For m > 0, we have
+
+                  N - 1
+                   ___
+  ~~~(m)       [  \          1    ]         1            1
+  psi   (z)  ~ [   )     -------- ] +  ---------- +  -------- +
+               [  /___        m+1 ]           m+1           m
+                  k = 1  (z+k)    ]    2 (z+N)       m (z+N)
+
+      oo
+     ___    B
+    \        2 k   (m+1) (m+2) ... (m+2k-1)
+  +  )     ------  ------------------------
+    /___   (2 k)!            m + 2 k
+    k = 1               (z+N)
+
+where ~~~ denotes the function rescaled by 1/((-1)^(m+1) m!).
+
+Here again N is chosen to make z+N large enough for the minimum
+term in the last series to become smaller than eps.
+
+TODO: the current estimation of N for m > 0 is *very suboptimal*.
+
+TODO: implement the reflection formula for m > 0, Re(z) << 0.
+It is generally a combination of multiple cotangents. Need to
+figure out a reasonably simple way to generate these formulas
+on the fly.
+
+TODO: maybe use exact algorithms to compute psi for integral
+and certain rational arguments, as this can be much more
+efficient. (On the other hand, the availability of these
+special values provides a convenient way to test the general
+algorithm.)
+"""
+
+# Harmonic numbers are just shifted digamma functions
+# We should calculate these exactly when x is an integer
+# and when doing so is faster.
+
+def mpf_harmonic(x, prec, rnd):
+    if x in (fzero, fnan, finf):
+        return x
+    a = mpf_psi0(mpf_add(fone, x, prec+5), prec)
+    return mpf_add(a, mpf_euler(prec+5, rnd), prec, rnd)
+
+def mpc_harmonic(z, prec, rnd):
+    if z[1] == fzero:
+        return (mpf_harmonic(z[0], prec, rnd), fzero)
+    a = mpc_psi0(mpc_add_mpf(z, fone, prec+5), prec)
+    return mpc_add_mpf(a, mpf_euler(prec+5, rnd), prec, rnd)
+
+def mpf_psi0(x, prec, rnd=round_fast):
+    """
+    Computation of the digamma function (psi function of order 0)
+    of a real argument.
+    """
+    sign, man, exp, bc = x
+    wp = prec + 10
+    if not man:
+        if x == finf: return x
+        if x == fninf or x == fnan: return fnan
+    if x == fzero or (exp >= 0 and sign):
+        raise ValueError("polygamma pole")
+    # Near 0 -- fixed-point arithmetic becomes bad
+    if exp+bc < -5:
+        v = mpf_psi0(mpf_add(x, fone, prec, rnd), prec, rnd)
+        return mpf_sub(v, mpf_div(fone, x, wp, rnd), prec, rnd)
+    # Reflection formula
+    if sign and exp+bc > 3:
+        c, s = mpf_cos_sin_pi(x, wp)
+        q = mpf_mul(mpf_div(c, s, wp), mpf_pi(wp), wp)
+        p = mpf_psi0(mpf_sub(fone, x, wp), wp)
+        return mpf_sub(p, q, prec, rnd)
+    # The logarithmic term is accurate enough
+    if (not sign) and bc + exp > wp:
+        return mpf_log(mpf_sub(x, fone, wp), prec, rnd)
+    # Initial recurrence to obtain a large enough x
+    m = to_int(x)
+    n = int(0.11*wp) + 2
+    s = MPZ_ZERO
+    x = to_fixed(x, wp)
+    one = MPZ_ONE << wp
+    if m < n:
+        for k in xrange(m, n):
+            s -= (one << wp) // x
+            x += one
+    x -= one
+    # Logarithmic term
+    s += to_fixed(mpf_log(from_man_exp(x, -wp, wp), wp), wp)
+    # Endpoint term in Euler-Maclaurin expansion
+    s += (one << wp) // (2*x)
+    # Euler-Maclaurin remainder sum
+    x2 = (x*x) >> wp
+    t = one
+    prev = 0
+    k = 1
+    while 1:
+        t = (t*x2) >> wp
+        bsign, bman, bexp, bbc = mpf_bernoulli(2*k, wp)
+        offset = (bexp + 2*wp)
+        if offset >= 0: term = (bman << offset) // (t*(2*k))
+        else:           term = (bman >> (-offset)) // (t*(2*k))
+        if k & 1: s -= term
+        else:     s += term
+        if k > 2 and term >= prev:
+            break
+        prev = term
+        k += 1
+    return from_man_exp(s, -wp, wp, rnd)
+
+def mpc_psi0(z, prec, rnd=round_fast):
+    """
+    Computation of the digamma function (psi function of order 0)
+    of a complex argument.
+    """
+    re, im = z
+    # Fall back to the real case
+    if im == fzero:
+        return (mpf_psi0(re, prec, rnd), fzero)
+    wp = prec + 20
+    sign, man, exp, bc = re
+    # Reflection formula
+    if sign and exp+bc > 3:
+        c = mpc_cos_pi(z, wp)
+        s = mpc_sin_pi(z, wp)
+        q = mpc_mul_mpf(mpc_div(c, s, wp), mpf_pi(wp), wp)
+        p = mpc_psi0(mpc_sub(mpc_one, z, wp), wp)
+        return mpc_sub(p, q, prec, rnd)
+    # Just the logarithmic term
+    if (not sign) and bc + exp > wp:
+        return mpc_log(mpc_sub(z, mpc_one, wp), prec, rnd)
+    # Initial recurrence to obtain a large enough z
+    w = to_int(re)
+    n = int(0.11*wp) + 2
+    s = mpc_zero
+    if w < n:
+        for k in xrange(w, n):
+            s = mpc_sub(s, mpc_reciprocal(z, wp), wp)
+            z = mpc_add_mpf(z, fone, wp)
+    z = mpc_sub(z, mpc_one, wp)
+    # Logarithmic and endpoint term
+    s = mpc_add(s, mpc_log(z, wp), wp)
+    s = mpc_add(s, mpc_div(mpc_half, z, wp), wp)
+    # Euler-Maclaurin remainder sum
+    z2 = mpc_square(z, wp)
+    t = mpc_one
+    prev = mpc_zero
+    szprev = fzero
+    k = 1
+    eps = mpf_shift(fone, -wp+2)
+    while 1:
+        t = mpc_mul(t, z2, wp)
+        bern = mpf_bernoulli(2*k, wp)
+        term = mpc_mpf_div(bern, mpc_mul_int(t, 2*k, wp), wp)
+        s = mpc_sub(s, term, wp)
+        szterm = mpc_abs(term, 10)
+        if k > 2 and (mpf_le(szterm, eps) or mpf_le(szprev, szterm)):
+            break
+        prev = term
+        szprev = szterm
+        k += 1
+    return s
+
+# Currently unoptimized
+def mpf_psi(m, x, prec, rnd=round_fast):
+    """
+    Computation of the polygamma function of arbitrary integer order
+    m >= 0, for a real argument x.
+    """
+    if m == 0:
+        return mpf_psi0(x, prec, rnd=round_fast)
+    return mpc_psi(m, (x, fzero), prec, rnd)[0]
+
+def mpc_psi(m, z, prec, rnd=round_fast):
+    """
+    Computation of the polygamma function of arbitrary integer order
+    m >= 0, for a complex argument z.
+    """
+    if m == 0:
+        return mpc_psi0(z, prec, rnd)
+    re, im = z
+    wp = prec + 20
+    sign, man, exp, bc = re
+    if not im[1]:
+        if im in (finf, fninf, fnan):
+            return (fnan, fnan)
+    if not man:
+        if re == finf and im == fzero:
+            return (fzero, fzero)
+        if re == fnan:
+            return (fnan, fnan)
+    # Recurrence
+    w = to_int(re)
+    n = int(0.4*wp + 4*m)
+    s = mpc_zero
+    if w < n:
+        for k in xrange(w, n):
+            t = mpc_pow_int(z, -m-1, wp)
+            s = mpc_add(s, t, wp)
+            z = mpc_add_mpf(z, fone, wp)
+    zm = mpc_pow_int(z, -m, wp)
+    z2 = mpc_pow_int(z, -2, wp)
+    # 1/m*(z+N)^m
+    integral_term = mpc_div_mpf(zm, from_int(m), wp)
+    s = mpc_add(s, integral_term, wp)
+    # 1/2*(z+N)^(-(m+1))
+    s = mpc_add(s, mpc_mul_mpf(mpc_div(zm, z, wp), fhalf, wp), wp)
+    a = m + 1
+    b = 2
+    k = 1
+    # Important: we want to sum up to the *relative* error,
+    # not the absolute error, because psi^(m)(z) might be tiny
+    magn = mpc_abs(s, 10)
+    magn = magn[2]+magn[3]
+    eps = mpf_shift(fone, magn-wp+2)
+    while 1:
+        zm = mpc_mul(zm, z2, wp)
+        bern = mpf_bernoulli(2*k, wp)
+        scal = mpf_mul_int(bern, a, wp)
+        scal = mpf_div(scal, from_int(b), wp)
+        term = mpc_mul_mpf(zm, scal, wp)
+        s = mpc_add(s, term, wp)
+        szterm = mpc_abs(term, 10)
+        if k > 2 and mpf_le(szterm, eps):
+            break
+        #print k, to_str(szterm, 10), to_str(eps, 10)
+        a *= (m+2*k)*(m+2*k+1)
+        b *= (2*k+1)*(2*k+2)
+        k += 1
+    # Scale and sign factor
+    v = mpc_mul_mpf(s, mpf_gamma(from_int(m+1), wp), prec, rnd)
+    if not (m & 1):
+        v = mpf_neg(v[0]), mpf_neg(v[1])
+    return v
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                         Riemann zeta function                         #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+r"""
+We use zeta(s) = eta(s) / (1 - 2**(1-s)) and Borwein's approximation
+
+                  n-1
+                  ___       k
+             -1  \      (-1)  (d_k - d_n)
+  eta(s) ~= ----  )     ------------------
+             d_n /___              s
+                 k = 0      (k + 1)
+where
+             k
+             ___                i
+            \     (n + i - 1)! 4
+  d_k  =  n  )    ---------------.
+            /___   (n - i)! (2i)!
+            i = 0
+
+If s = a + b*I, the absolute error for eta(s) is bounded by
+
+    3 (1 + 2|b|)
+    ------------ * exp(|b| pi/2)
+               n
+    (3+sqrt(8))
+
+Disregarding the linear term, we have approximately,
+
+  log(err) ~= log(exp(1.58*|b|)) - log(5.8**n)
+  log(err) ~= 1.58*|b| - log(5.8)*n
+  log(err) ~= 1.58*|b| - 1.76*n
+  log2(err) ~= 2.28*|b| - 2.54*n
+
+So for p bits, we should choose n > (p + 2.28*|b|) / 2.54.
+
+References:
+-----------
+
+Peter Borwein, "An Efficient Algorithm for the Riemann Zeta Function"
+http://www.cecm.sfu.ca/personal/pborwein/PAPERS/P117.ps
+
+http://en.wikipedia.org/wiki/Dirichlet_eta_function
+"""
+
+borwein_cache = {}
+
+def borwein_coefficients(n):
+    if n in borwein_cache:
+        return borwein_cache[n]
+    ds = [MPZ_ZERO] * (n+1)
+    d = MPZ_ONE
+    s = ds[0] = MPZ_ONE
+    for i in range(1, n+1):
+        d = d * 4 * (n+i-1) * (n-i+1)
+        d //= ((2*i) * ((2*i)-1))
+        s += d
+        ds[i] = s
+    borwein_cache[n] = ds
+    return ds
+
+ZETA_INT_CACHE_MAX_PREC = 1000
+zeta_int_cache = {}
+
+def mpf_zeta_int(s, prec, rnd=round_fast):
+    """
+    Optimized computation of zeta(s) for an integer s.
+    """
+    wp = prec + 20
+    s = int(s)
+    if s in zeta_int_cache and zeta_int_cache[s][0] >= wp:
+        return mpf_pos(zeta_int_cache[s][1], prec, rnd)
+    if s < 2:
+        if s == 1:
+            raise ValueError("zeta(1) pole")
+        if not s:
+            return mpf_neg(fhalf)
+        return mpf_div(mpf_bernoulli(-s+1, wp), from_int(s-1), prec, rnd)
+    # 2^-s term vanishes?
+    if s >= wp:
+        return mpf_perturb(fone, 0, prec, rnd)
+    # 5^-s term vanishes?
+    elif s >= wp*0.431:
+        t = one = 1 << wp
+        t += 1 << (wp - s)
+        t += one // (MPZ_THREE ** s)
+        t += 1 << max(0, wp - s*2)
+        return from_man_exp(t, -wp, prec, rnd)
+    else:
+        # Fast enough to sum directly?
+        # Even better, we use the Euler product (idea stolen from pari)
+        m = (float(wp)/(s-1) + 1)
+        if m < 30:
+            needed_terms = int(2.0**m + 1)
+            if needed_terms < int(wp/2.54 + 5) / 10:
+                t = fone
+                for k in list_primes(needed_terms):
+                    #print k, needed_terms
+                    powprec = int(wp - s*math.log(k,2))
+                    if powprec < 2:
+                        break
+                    a = mpf_sub(fone, mpf_pow_int(from_int(k), -s, powprec), wp)
+                    t = mpf_mul(t, a, wp)
+                return mpf_div(fone, t, wp)
+    # Use Borwein's algorithm
+    n = int(wp/2.54 + 5)
+    d = borwein_coefficients(n)
+    t = MPZ_ZERO
+    s = MPZ(s)
+    for k in xrange(n):
+        t += (((-1)**k * (d[k] - d[n])) << wp) // (k+1)**s
+    t = (t << wp) // (-d[n])
+    t = (t << wp) // ((1 << wp) - (1 << (wp+1-s)))
+    if (s in zeta_int_cache and zeta_int_cache[s][0] < wp) or (s not in zeta_int_cache):
+        zeta_int_cache[s] = (wp, from_man_exp(t, -wp-wp))
+    return from_man_exp(t, -wp-wp, prec, rnd)
+
+def mpf_zeta(s, prec, rnd=round_fast, alt=0):
+    sign, man, exp, bc = s
+    if not man:
+        if s == fzero:
+            if alt:
+                return fhalf
+            else:
+                return mpf_neg(fhalf)
+        if s == finf:
+            return fone
+        return fnan
+    wp = prec + 20
+    # First term vanishes?
+    if (not sign) and (exp + bc > (math.log(wp,2) + 2)):
+        return mpf_perturb(fone, alt, prec, rnd)
+    # Optimize for integer arguments
+    elif exp >= 0:
+        if alt:
+            if s == fone:
+                return mpf_ln2(prec, rnd)
+            z = mpf_zeta_int(to_int(s), wp, negative_rnd[rnd])
+            q = mpf_sub(fone, mpf_pow(ftwo, mpf_sub(fone, s, wp), wp), wp)
+            return mpf_mul(z, q, prec, rnd)
+        else:
+            return mpf_zeta_int(to_int(s), prec, rnd)
+    # Negative: use the reflection formula
+    # Borwein only proves the accuracy bound for x >= 1/2. However, based on
+    # tests, the accuracy without reflection is quite good even some distance
+    # to the left of 1/2. XXX: verify this.
+    if sign:
+        # XXX: could use the separate refl. formula for Dirichlet eta
+        if alt:
+            q = mpf_sub(fone, mpf_pow(ftwo, mpf_sub(fone, s, wp), wp), wp)
+            return mpf_mul(mpf_zeta(s, wp), q, prec, rnd)
+        # XXX: -1 should be done exactly
+        y = mpf_sub(fone, s, 10*wp)
+        a = mpf_gamma(y, wp)
+        b = mpf_zeta(y, wp)
+        c = mpf_sin_pi(mpf_shift(s, -1), wp)
+        wp2 = wp + max(0,exp+bc)
+        pi = mpf_pi(wp+wp2)
+        d = mpf_div(mpf_pow(mpf_shift(pi, 1), s, wp2), pi, wp2)
+        return mpf_mul(a,mpf_mul(b,mpf_mul(c,d,wp),wp),prec,rnd)
+
+    # Near pole
+    r = mpf_sub(fone, s, wp)
+    asign, aman, aexp, abc = mpf_abs(r)
+    pole_dist = -2*(aexp+abc)
+    if pole_dist > wp:
+        if alt:
+            return mpf_ln2(prec, rnd)
+        else:
+            q = mpf_neg(mpf_div(fone, r, wp))
+            return mpf_add(q, mpf_euler(wp), prec, rnd)
+    else:
+        wp += max(0, pole_dist)
+
+    t = MPZ_ZERO
+    #wp += 16 - (prec & 15)
+    # Use Borwein's algorithm
+    n = int(wp/2.54 + 5)
+    d = borwein_coefficients(n)
+    t = MPZ_ZERO
+    sf = to_fixed(s, wp)
+    ln2 = ln2_fixed(wp)
+    for k in xrange(n):
+        u = (-sf*log_int_fixed(k+1, wp, ln2)) >> wp
+        #esign, eman, eexp, ebc = mpf_exp(u, wp)
+        #offset = eexp + wp
+        #if offset >= 0:
+        #    w = ((d[k] - d[n]) * eman) << offset
+        #else:
+        #    w = ((d[k] - d[n]) * eman) >> (-offset)
+        eman = exp_fixed(u, wp, ln2)
+        w = (d[k] - d[n]) * eman
+        if k & 1:
+            t -= w
+        else:
+            t += w
+    t = t // (-d[n])
+    t = from_man_exp(t, -wp, wp)
+    if alt:
+        return mpf_pos(t, prec, rnd)
+    else:
+        q = mpf_sub(fone, mpf_pow(ftwo, mpf_sub(fone, s, wp), wp), wp)
+        return mpf_div(t, q, prec, rnd)
+
+def mpc_zeta(s, prec, rnd=round_fast, alt=0, force=False):
+    re, im = s
+    if im == fzero:
+        return mpf_zeta(re, prec, rnd, alt), fzero
+
+    # slow for large s
+    if (not force) and mpf_gt(mpc_abs(s, 10), from_int(prec)):
+        raise NotImplementedError
+
+    wp = prec + 20
+
+    # Near pole
+    r = mpc_sub(mpc_one, s, wp)
+    asign, aman, aexp, abc = mpc_abs(r, 10)
+    pole_dist = -2*(aexp+abc)
+    if pole_dist > wp:
+        if alt:
+            q = mpf_ln2(wp)
+            y = mpf_mul(q, mpf_euler(wp), wp)
+            g = mpf_shift(mpf_mul(q, q, wp), -1)
+            g = mpf_sub(y, g)
+            z = mpc_mul_mpf(r, mpf_neg(g), wp)
+            z = mpc_add_mpf(z, q, wp)
+            return mpc_pos(z, prec, rnd)
+        else:
+            q = mpc_neg(mpc_div(mpc_one, r, wp))
+            q = mpc_add_mpf(q, mpf_euler(wp), wp)
+            return mpc_pos(q, prec, rnd)
+    else:
+        wp += max(0, pole_dist)
+
+    # Reflection formula. To be rigorous, we should reflect to the left of
+    # re = 1/2 (see comments for mpf_zeta), but this leads to unnecessary
+    # slowdown for interesting values of s
+    if mpf_lt(re, fzero):
+        # XXX: could use the separate refl. formula for Dirichlet eta
+        if alt:
+            q = mpc_sub(mpc_one, mpc_pow(mpc_two, mpc_sub(mpc_one, s, wp),
+                wp), wp)
+            return mpc_mul(mpc_zeta(s, wp), q, prec, rnd)
+        # XXX: -1 should be done exactly
+        y = mpc_sub(mpc_one, s, 10*wp)
+        a = mpc_gamma(y, wp)
+        b = mpc_zeta(y, wp)
+        c = mpc_sin_pi(mpc_shift(s, -1), wp)
+        rsign, rman, rexp, rbc = re
+        isign, iman, iexp, ibc = im
+        mag = max(rexp+rbc, iexp+ibc)
+        wp2 = wp + max(0, mag)
+        pi = mpf_pi(wp+wp2)
+        pi2 = (mpf_shift(pi, 1), fzero)
+        d = mpc_div_mpf(mpc_pow(pi2, s, wp2), pi, wp2)
+        return mpc_mul(a,mpc_mul(b,mpc_mul(c,d,wp),wp),prec,rnd)
+    n = int(wp/2.54 + 5)
+    n += int(0.9*abs(to_int(im)))
+    d = borwein_coefficients(n)
+    ref = to_fixed(re, wp)
+    imf = to_fixed(im, wp)
+    tre = MPZ_ZERO
+    tim = MPZ_ZERO
+    one = MPZ_ONE << wp
+    one_2wp = MPZ_ONE << (2*wp)
+    critical_line = re == fhalf
+    ln2 = ln2_fixed(wp)
+    pi2 = pi_fixed(wp-1)
+    wp2 = wp+wp
+    for k in xrange(n):
+        log = log_int_fixed(k+1, wp, ln2)
+        # A square root is much cheaper than an exp
+        if critical_line:
+            w = one_2wp // isqrt_fast((k+1) << wp2)
+        else:
+            w = exp_fixed((-ref*log) >> wp, wp)
+        if k & 1:
+            w *= (d[n] - d[k])
+        else:
+            w *= (d[k] - d[n])
+        wre, wim = cos_sin_fixed((-imf*log)>>wp, wp, pi2)
+        tre += (w * wre) >> wp
+        tim += (w * wim) >> wp
+    tre //= (-d[n])
+    tim //= (-d[n])
+    tre = from_man_exp(tre, -wp, wp)
+    tim = from_man_exp(tim, -wp, wp)
+    if alt:
+        return mpc_pos((tre, tim), prec, rnd)
+    else:
+        q = mpc_sub(mpc_one, mpc_pow(mpc_two, r, wp), wp)
+        return mpc_div((tre, tim), q, prec, rnd)
+
+def mpf_altzeta(s, prec, rnd=round_fast):
+    return mpf_zeta(s, prec, rnd, 1)
+
+def mpc_altzeta(s, prec, rnd=round_fast):
+    return mpc_zeta(s, prec, rnd, 1)
+
+# Not optimized currently
+mpf_zetasum = None
+
+
+def pow_fixed(x, n, wp):
+    if n == 1:
+        return x
+    y = MPZ_ONE << wp
+    while n:
+        if n & 1:
+            y = (y*x) >> wp
+            n -= 1
+        x = (x*x) >> wp
+        n //= 2
+    return y
+
+# TODO: optimize / cleanup interface / unify with list_primes
+sieve_cache = []
+primes_cache = []
+mult_cache = []
+
+def primesieve(n):
+    global sieve_cache, primes_cache, mult_cache
+    if n < len(sieve_cache):
+        sieve = sieve_cache#[:n+1]
+        primes = primes_cache[:primes_cache.index(max(sieve))+1]
+        mult = mult_cache#[:n+1]
+        return sieve, primes, mult
+    sieve = [0] * (n+1)
+    mult = [0] * (n+1)
+    primes = list_primes(n)
+    for p in primes:
+        #sieve[p::p] = p
+        for k in xrange(p,n+1,p):
+            sieve[k] = p
+    for i, p in enumerate(sieve):
+        if i >= 2:
+            m = 1
+            n = i // p
+            while not n % p:
+                n //= p
+                m += 1
+            mult[i] = m
+    sieve_cache = sieve
+    primes_cache = primes
+    mult_cache = mult
+    return sieve, primes, mult
+
+def zetasum_sieved(critical_line, sre, sim, a, n, wp):
+    if a < 1:
+        raise ValueError("a cannot be less than 1")
+    sieve, primes, mult = primesieve(a+n)
+    basic_powers = {}
+    one = MPZ_ONE << wp
+    one_2wp = MPZ_ONE << (2*wp)
+    wp2 = wp+wp
+    ln2 = ln2_fixed(wp)
+    pi2 = pi_fixed(wp-1)
+    for p in primes:
+        if p*2 > a+n:
+            break
+        log = log_int_fixed(p, wp, ln2)
+        cos, sin = cos_sin_fixed((-sim*log)>>wp, wp, pi2)
+        if critical_line:
+            u = one_2wp // isqrt_fast(p<<wp2)
+        else:
+            u = exp_fixed((-sre*log)>>wp, wp)
+        pre = (u*cos) >> wp
+        pim = (u*sin) >> wp
+        basic_powers[p] = [(pre, pim)]
+        tre, tim = pre, pim
+        for m in range(1,int(math.log(a+n,p)+0.01)+1):
+            tre, tim = ((pre*tre-pim*tim)>>wp), ((pim*tre+pre*tim)>>wp)
+            basic_powers[p].append((tre,tim))
+    xre = MPZ_ZERO
+    xim = MPZ_ZERO
+    if a == 1:
+        xre += one
+    aa = max(a,2)
+    for k in xrange(aa, a+n+1):
+        p = sieve[k]
+        if p in basic_powers:
+            m = mult[k]
+            tre, tim = basic_powers[p][m-1]
+            while 1:
+                k //= p**m
+                if k == 1:
+                    break
+                p = sieve[k]
+                m = mult[k]
+                pre, pim = basic_powers[p][m-1]
+                tre, tim = ((pre*tre-pim*tim)>>wp), ((pim*tre+pre*tim)>>wp)
+        else:
+            log = log_int_fixed(k, wp, ln2)
+            cos, sin = cos_sin_fixed((-sim*log)>>wp, wp, pi2)
+            if critical_line:
+                u = one_2wp // isqrt_fast(k<<wp2)
+            else:
+                u = exp_fixed((-sre*log)>>wp, wp)
+            tre = (u*cos) >> wp
+            tim = (u*sin) >> wp
+        xre += tre
+        xim += tim
+    return xre, xim
+
+# Set to something large to disable
+ZETASUM_SIEVE_CUTOFF = 10
+
+def mpc_zetasum(s, a, n, derivatives, reflect, prec):
+    """
+    Fast version of mp._zetasum, assuming s = complex, a = integer.
+    """
+
+    wp = prec + 10
+    derivatives = list(derivatives)
+    have_derivatives = derivatives != [0]
+    have_one_derivative = len(derivatives) == 1
+
+    # parse s
+    sre, sim = s
+    critical_line = (sre == fhalf)
+    sre = to_fixed(sre, wp)
+    sim = to_fixed(sim, wp)
+
+    if a > 0 and n > ZETASUM_SIEVE_CUTOFF and not have_derivatives \
+            and not reflect and (n < 4e7 or sys.maxsize > 2**32):
+        re, im = zetasum_sieved(critical_line, sre, sim, a, n, wp)
+        xs = [(from_man_exp(re, -wp, prec, 'n'), from_man_exp(im, -wp, prec, 'n'))]
+        return xs, []
+
+    maxd = max(derivatives)
+    if not have_one_derivative:
+        derivatives = range(maxd+1)
+
+    # x_d = 0, y_d = 0
+    xre = [MPZ_ZERO for d in derivatives]
+    xim = [MPZ_ZERO for d in derivatives]
+    if reflect:
+        yre = [MPZ_ZERO for d in derivatives]
+        yim = [MPZ_ZERO for d in derivatives]
+    else:
+        yre = yim = []
+
+    one = MPZ_ONE << wp
+    one_2wp = MPZ_ONE << (2*wp)
+
+    ln2 = ln2_fixed(wp)
+    pi2 = pi_fixed(wp-1)
+    wp2 = wp+wp
+
+    for w in xrange(a, a+n+1):
+        log = log_int_fixed(w, wp, ln2)
+        cos, sin = cos_sin_fixed((-sim*log)>>wp, wp, pi2)
+        if critical_line:
+            u = one_2wp // isqrt_fast(w<<wp2)
+        else:
+            u = exp_fixed((-sre*log)>>wp, wp)
+        xterm_re = (u * cos) >> wp
+        xterm_im = (u * sin) >> wp
+        if reflect:
+            reciprocal = (one_2wp // (u*w))
+            yterm_re = (reciprocal * cos) >> wp
+            yterm_im = (reciprocal * sin) >> wp
+
+        if have_derivatives:
+            if have_one_derivative:
+                log = pow_fixed(log, maxd, wp)
+                xre[0] += (xterm_re * log) >> wp
+                xim[0] += (xterm_im * log) >> wp
+                if reflect:
+                    yre[0] += (yterm_re * log) >> wp
+                    yim[0] += (yterm_im * log) >> wp
+            else:
+                t = MPZ_ONE << wp
+                for d in derivatives:
+                    xre[d] += (xterm_re * t) >> wp
+                    xim[d] += (xterm_im * t) >> wp
+                    if reflect:
+                        yre[d] += (yterm_re * t) >> wp
+                        yim[d] += (yterm_im * t) >> wp
+                    t = (t * log) >> wp
+        else:
+            xre[0] += xterm_re
+            xim[0] += xterm_im
+            if reflect:
+                yre[0] += yterm_re
+                yim[0] += yterm_im
+    if have_derivatives:
+        if have_one_derivative:
+            if maxd % 2:
+                xre[0] = -xre[0]
+                xim[0] = -xim[0]
+                if reflect:
+                    yre[0] = -yre[0]
+                    yim[0] = -yim[0]
+        else:
+            xre = [(-1)**d * xre[d] for d in derivatives]
+            xim = [(-1)**d * xim[d] for d in derivatives]
+            if reflect:
+                yre = [(-1)**d * yre[d] for d in derivatives]
+                yim = [(-1)**d * yim[d] for d in derivatives]
+    xs = [(from_man_exp(xa, -wp, prec, 'n'), from_man_exp(xb, -wp, prec, 'n'))
+        for (xa, xb) in zip(xre, xim)]
+    ys = [(from_man_exp(ya, -wp, prec, 'n'), from_man_exp(yb, -wp, prec, 'n'))
+        for (ya, yb) in zip(yre, yim)]
+    return xs, ys
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#              The gamma function  (NEW IMPLEMENTATION)                 #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# Higher means faster, but more precomputation time
+MAX_GAMMA_TAYLOR_PREC = 5000
+# Need to derive higher bounds for Taylor series to go higher
+assert MAX_GAMMA_TAYLOR_PREC < 15000
+
+# Use Stirling's series if abs(x) > beta*prec
+# Important: must be large enough for convergence!
+GAMMA_STIRLING_BETA = 0.2
+
+SMALL_FACTORIAL_CACHE_SIZE = 150
+
+gamma_taylor_cache = {}
+gamma_stirling_cache = {}
+
+small_factorial_cache = [from_int(ifac(n)) for \
+    n in range(SMALL_FACTORIAL_CACHE_SIZE+1)]
+
+def zeta_array(N, prec):
+    """
+    zeta(n) = A * pi**n / n! + B
+
+    where A is a rational number (A = Bernoulli number
+    for n even) and B is an infinite sum over powers of exp(2*pi).
+    (B = 0 for n even).
+
+    TODO: this is currently only used for gamma, but could
+    be very useful elsewhere.
+    """
+    extra = 30
+    wp = prec+extra
+    zeta_values = [MPZ_ZERO] * (N+2)
+    pi = pi_fixed(wp)
+    # STEP 1:
+    one = MPZ_ONE << wp
+    zeta_values[0] = -one//2
+    f_2pi = mpf_shift(mpf_pi(wp),1)
+    exp_2pi_k = exp_2pi = mpf_exp(f_2pi, wp)
+    # Compute exponential series
+    # Store values of 1/(exp(2*pi*k)-1),
+    # exp(2*pi*k)/(exp(2*pi*k)-1)**2, 1/(exp(2*pi*k)-1)**2
+    # pi*k*exp(2*pi*k)/(exp(2*pi*k)-1)**2
+    exps3 = []
+    k = 1
+    while 1:
+        tp = wp - 9*k
+        if tp < 1:
+            break
+        # 1/(exp(2*pi*k-1)
+        q1 = mpf_div(fone, mpf_sub(exp_2pi_k, fone, tp), tp)
+        # pi*k*exp(2*pi*k)/(exp(2*pi*k)-1)**2
+        q2 = mpf_mul(exp_2pi_k, mpf_mul(q1,q1,tp), tp)
+        q1 = to_fixed(q1, wp)
+        q2 = to_fixed(q2, wp)
+        q2 = (k * q2 * pi) >> wp
+        exps3.append((q1, q2))
+        # Multiply for next round
+        exp_2pi_k = mpf_mul(exp_2pi_k, exp_2pi, wp)
+        k += 1
+    # Exponential sum
+    for n in xrange(3, N+1, 2):
+        s = MPZ_ZERO
+        k = 1
+        for e1, e2 in exps3:
+            if n%4 == 3:
+                t = e1 // k**n
+            else:
+                U = (n-1)//4
+                t = (e1 + e2//U) // k**n
+            if not t:
+                break
+            s += t
+            k += 1
+        zeta_values[n] = -2*s
+    # Even zeta values
+    B = [mpf_abs(mpf_bernoulli(k,wp)) for k in xrange(N+2)]
+    pi_pow = fpi = mpf_pow_int(mpf_shift(mpf_pi(wp), 1), 2, wp)
+    pi_pow = mpf_div(pi_pow, from_int(4), wp)
+    for n in xrange(2,N+2,2):
+        z = mpf_mul(B[n], pi_pow, wp)
+        zeta_values[n] = to_fixed(z, wp)
+        pi_pow = mpf_mul(pi_pow, fpi, wp)
+        pi_pow = mpf_div(pi_pow, from_int((n+1)*(n+2)), wp)
+    # Zeta sum
+    reciprocal_pi = (one << wp) // pi
+    for n in xrange(3, N+1, 4):
+        U = (n-3)//4
+        s = zeta_values[4*U+4]*(4*U+7)//4
+        for k in xrange(1, U+1):
+            s -= (zeta_values[4*k] * zeta_values[4*U+4-4*k]) >> wp
+        zeta_values[n] += (2*s*reciprocal_pi) >> wp
+    for n in xrange(5, N+1, 4):
+        U = (n-1)//4
+        s = zeta_values[4*U+2]*(2*U+1)
+        for k in xrange(1, 2*U+1):
+            s += ((-1)**k*2*k* zeta_values[2*k] * zeta_values[4*U+2-2*k])>>wp
+        zeta_values[n] += ((s*reciprocal_pi)>>wp)//(2*U)
+    return [x>>extra for x in zeta_values]
+
+def gamma_taylor_coefficients(inprec):
+    """
+    Gives the Taylor coefficients of 1/gamma(1+x) as
+    a list of fixed-point numbers. Enough coefficients are returned
+    to ensure that the series converges to the given precision
+    when x is in [0.5, 1.5].
+    """
+    # Reuse nearby cache values (small case)
+    if inprec < 400:
+        prec = inprec + (10-(inprec%10))
+    elif inprec < 1000:
+        prec = inprec + (30-(inprec%30))
+    else:
+        prec = inprec
+    if prec in gamma_taylor_cache:
+        return gamma_taylor_cache[prec], prec
+
+    # Experimentally determined bounds
+    if prec < 1000:
+        N = int(prec**0.76 + 2)
+    else:
+        # Valid to at least 15000 bits
+        N = int(prec**0.787 + 2)
+
+    # Reuse higher precision values
+    for cprec in gamma_taylor_cache:
+        if cprec > prec:
+            coeffs = [x>>(cprec-prec) for x in gamma_taylor_cache[cprec][-N:]]
+            if inprec < 1000:
+                gamma_taylor_cache[prec] = coeffs
+            return coeffs, prec
+
+    # Cache at a higher precision (large case)
+    if prec > 1000:
+        prec = int(prec * 1.2)
+
+    wp = prec + 20
+    A = [0] * N
+    A[0] = MPZ_ZERO
+    A[1] = MPZ_ONE << wp
+    A[2] = euler_fixed(wp)
+    # SLOW, reference implementation
+    #zeta_values = [0,0]+[to_fixed(mpf_zeta_int(k,wp),wp) for k in xrange(2,N)]
+    zeta_values = zeta_array(N, wp)
+    for k in xrange(3, N):
+        a = (-A[2]*A[k-1])>>wp
+        for j in xrange(2,k):
+            a += ((-1)**j * zeta_values[j] * A[k-j]) >> wp
+        a //= (1-k)
+        A[k] = a
+    A = [a>>20 for a in A]
+    A = A[::-1]
+    A = A[:-1]
+    gamma_taylor_cache[prec] = A
+    #return A, prec
+    return gamma_taylor_coefficients(inprec)
+
+def gamma_fixed_taylor(xmpf, x, wp, prec, rnd, type):
+    # Determine nearest multiple of N/2
+    #n = int(x >> (wp-1))
+    #steps = (n-1)>>1
+    nearest_int = ((x >> (wp-1)) + MPZ_ONE) >> 1
+    one = MPZ_ONE << wp
+    coeffs, cwp = gamma_taylor_coefficients(wp)
+    if nearest_int > 0:
+        r = one
+        for i in xrange(nearest_int-1):
+            x -= one
+            r = (r*x) >> wp
+        x -= one
+        p = MPZ_ZERO
+        for c in coeffs:
+            p = c + ((x*p)>>wp)
+        p >>= (cwp-wp)
+        if type == 0:
+            return from_man_exp((r<<wp)//p, -wp, prec, rnd)
+        if type == 2:
+            return mpf_shift(from_rational(p, (r<<wp), prec, rnd), wp)
+        if type == 3:
+            return mpf_log(mpf_abs(from_man_exp((r<<wp)//p, -wp)), prec, rnd)
+    else:
+        r = one
+        for i in xrange(-nearest_int):
+            r = (r*x) >> wp
+            x += one
+        p = MPZ_ZERO
+        for c in coeffs:
+            p = c + ((x*p)>>wp)
+        p >>= (cwp-wp)
+        if wp - bitcount(abs(x)) > 10:
+            # pass very close to 0, so do floating-point multiply
+            g = mpf_add(xmpf, from_int(-nearest_int))  # exact
+            r = from_man_exp(p*r,-wp-wp)
+            r = mpf_mul(r, g, wp)
+            if type == 0:
+                return mpf_div(fone, r, prec, rnd)
+            if type == 2:
+                return mpf_pos(r, prec, rnd)
+            if type == 3:
+                return mpf_log(mpf_abs(mpf_div(fone, r, wp)), prec, rnd)
+        else:
+            r = from_man_exp(x*p*r,-3*wp)
+            if type == 0: return mpf_div(fone, r, prec, rnd)
+            if type == 2: return mpf_pos(r, prec, rnd)
+            if type == 3: return mpf_neg(mpf_log(mpf_abs(r), prec, rnd))
+
+def stirling_coefficient(n):
+    if n in gamma_stirling_cache:
+        return gamma_stirling_cache[n]
+    p, q = bernfrac(n)
+    q *= MPZ(n*(n-1))
+    gamma_stirling_cache[n] = p, q, bitcount(abs(p)), bitcount(q)
+    return gamma_stirling_cache[n]
+
+def real_stirling_series(x, prec):
+    """
+    Sums the rational part of Stirling's expansion,
+
+    log(sqrt(2*pi)) - z + 1/(12*z) - 1/(360*z^3) + ...
+
+    """
+    t = (MPZ_ONE<<(prec+prec)) // x   # t = 1/x
+    u = (t*t)>>prec                  # u = 1/x**2
+    s = ln_sqrt2pi_fixed(prec) - x
+    # Add initial terms of Stirling's series
+    s += t//12;            t = (t*u)>>prec
+    s -= t//360;           t = (t*u)>>prec
+    s += t//1260;          t = (t*u)>>prec
+    s -= t//1680;          t = (t*u)>>prec
+    if not t: return s
+    s += t//1188;          t = (t*u)>>prec
+    s -= 691*t//360360;    t = (t*u)>>prec
+    s += t//156;           t = (t*u)>>prec
+    if not t: return s
+    s -= 3617*t//122400;   t = (t*u)>>prec
+    s += 43867*t//244188;  t = (t*u)>>prec
+    s -= 174611*t//125400;  t = (t*u)>>prec
+    if not t: return s
+    k = 22
+    # From here on, the coefficients are growing, so we
+    # have to keep t at a roughly constant size
+    usize = bitcount(abs(u))
+    tsize = bitcount(abs(t))
+    texp = 0
+    while 1:
+        p, q, pb, qb = stirling_coefficient(k)
+        term_mag = tsize + pb + texp
+        shift = -texp
+        m = pb - term_mag
+        if m > 0 and shift < m:
+            p >>= m
+            shift -= m
+        m = tsize - term_mag
+        if m > 0 and shift < m:
+            w = t >> m
+            shift -= m
+        else:
+            w = t
+        term = (t*p//q) >> shift
+        if not term:
+            break
+        s += term
+        t = (t*u) >> usize
+        texp -= (prec - usize)
+        k += 2
+    return s
+
+def complex_stirling_series(x, y, prec):
+    # t = 1/z
+    _m = (x*x + y*y) >> prec
+    tre = (x << prec) // _m
+    tim = (-y << prec) // _m
+    # u = 1/z**2
+    ure = (tre*tre - tim*tim) >> prec
+    uim = tim*tre >> (prec-1)
+    # s = log(sqrt(2*pi)) - z
+    sre = ln_sqrt2pi_fixed(prec) - x
+    sim = -y
+
+    # Add initial terms of Stirling's series
+    sre += tre//12; sim += tim//12;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= tre//360; sim -= tim//360;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre += tre//1260; sim += tim//1260;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= tre//1680; sim -= tim//1680;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    if abs(tre) + abs(tim) < 5: return sre, sim
+    sre += tre//1188; sim += tim//1188;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= 691*tre//360360; sim -= 691*tim//360360;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre += tre//156; sim += tim//156;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    if abs(tre) + abs(tim) < 5: return sre, sim
+    sre -= 3617*tre//122400; sim -= 3617*tim//122400;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre += 43867*tre//244188; sim += 43867*tim//244188;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    sre -= 174611*tre//125400; sim -= 174611*tim//125400;
+    tre, tim = ((tre*ure-tim*uim)>>prec), ((tre*uim+tim*ure)>>prec)
+    if abs(tre) + abs(tim) < 5: return sre, sim
+
+    k = 22
+    # From here on, the coefficients are growing, so we
+    # have to keep t at a roughly constant size
+    usize = bitcount(max(abs(ure), abs(uim)))
+    tsize = bitcount(max(abs(tre), abs(tim)))
+    texp = 0
+    while 1:
+        p, q, pb, qb = stirling_coefficient(k)
+        term_mag = tsize + pb + texp
+        shift = -texp
+        m = pb - term_mag
+        if m > 0 and shift < m:
+            p >>= m
+            shift -= m
+        m = tsize - term_mag
+        if m > 0 and shift < m:
+            wre = tre >> m
+            wim = tim >> m
+            shift -= m
+        else:
+            wre = tre
+            wim = tim
+        termre = (tre*p//q) >> shift
+        termim = (tim*p//q) >> shift
+        if abs(termre) + abs(termim) < 5:
+            break
+        sre += termre
+        sim += termim
+        tre, tim = ((tre*ure - tim*uim)>>usize), \
+            ((tre*uim + tim*ure)>>usize)
+        texp -= (prec - usize)
+        k += 2
+    return sre, sim
+
+
+def mpf_gamma(x, prec, rnd='d', type=0):
+    """
+    This function implements multipurpose evaluation of the gamma
+    function, G(x), as well as the following versions of the same:
+
+    type = 0 -- G(x)                    [standard gamma function]
+    type = 1 -- G(x+1) = x*G(x+1) = x!  [factorial]
+    type = 2 -- 1/G(x)                  [reciprocal gamma function]
+    type = 3 -- log(|G(x)|)             [log-gamma function, real part]
+    """
+
+    # Specal values
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero:
+            if type == 1: return fone
+            if type == 2: return fzero
+            raise ValueError("gamma function pole")
+        if x == finf:
+            if type == 2: return fzero
+            return finf
+        return fnan
+
+    # First of all, for log gamma, numbers can be well beyond the fixed-point
+    # range, so we must take care of huge numbers before e.g. trying
+    # to convert x to the nearest integer
+    if type == 3:
+        wp = prec+20
+        if exp+bc > wp and not sign:
+            return mpf_sub(mpf_mul(x, mpf_log(x, wp), wp), x, prec, rnd)
+
+    # We strongly want to special-case small integers
+    is_integer = exp >= 0
+    if is_integer:
+        # Poles
+        if sign:
+            if type == 2:
+                return fzero
+            raise ValueError("gamma function pole")
+        # n = x
+        n = man << exp
+        if n < SMALL_FACTORIAL_CACHE_SIZE:
+            if type == 0:
+                return mpf_pos(small_factorial_cache[n-1], prec, rnd)
+            if type == 1:
+                return mpf_pos(small_factorial_cache[n], prec, rnd)
+            if type == 2:
+                return mpf_div(fone, small_factorial_cache[n-1], prec, rnd)
+            if type == 3:
+                return mpf_log(small_factorial_cache[n-1], prec, rnd)
+    else:
+        # floor(abs(x))
+        n = int(man >> (-exp))
+
+    # Estimate size and precision
+    # Estimate log(gamma(|x|),2) as x*log(x,2)
+    mag = exp + bc
+    gamma_size = n*mag
+
+    if type == 3:
+        wp = prec + 20
+    else:
+        wp = prec + bitcount(gamma_size) + 20
+
+    # Very close to 0, pole
+    if mag < -wp:
+        if type == 0:
+            return mpf_sub(mpf_div(fone,x, wp),mpf_shift(fone,-wp),prec,rnd)
+        if type == 1: return mpf_sub(fone, x, prec, rnd)
+        if type == 2: return mpf_add(x, mpf_shift(fone,mag-wp), prec, rnd)
+        if type == 3: return mpf_neg(mpf_log(mpf_abs(x), prec, rnd))
+
+    # From now on, we assume having a gamma function
+    if type == 1:
+        return mpf_gamma(mpf_add(x, fone), prec, rnd, 0)
+
+    # Special case integers (those not small enough to be caught above,
+    # but still small enough for an exact factorial to be faster
+    # than an approximate algorithm), and half-integers
+    if exp >= -1:
+        if is_integer:
+            if gamma_size < 10*wp:
+                if type == 0:
+                    return from_int(ifac(n-1), prec, rnd)
+                if type == 2:
+                    return from_rational(MPZ_ONE, ifac(n-1), prec, rnd)
+                if type == 3:
+                    return mpf_log(from_int(ifac(n-1)), prec, rnd)
+        # half-integer
+        if n < 100 or gamma_size < 10*wp:
+            if sign:
+                w = sqrtpi_fixed(wp)
+                if n % 2: f = ifac2(2*n+1)
+                else:     f = -ifac2(2*n+1)
+                if type == 0:
+                    return mpf_shift(from_rational(w, f, prec, rnd), -wp+n+1)
+                if type == 2:
+                    return mpf_shift(from_rational(f, w, prec, rnd), wp-n-1)
+                if type == 3:
+                    return mpf_log(mpf_shift(from_rational(w, abs(f),
+                        prec, rnd), -wp+n+1), prec, rnd)
+            elif n == 0:
+                if type == 0: return mpf_sqrtpi(prec, rnd)
+                if type == 2: return mpf_div(fone, mpf_sqrtpi(wp), prec, rnd)
+                if type == 3: return mpf_log(mpf_sqrtpi(wp), prec, rnd)
+            else:
+                w = sqrtpi_fixed(wp)
+                w = from_man_exp(w * ifac2(2*n-1), -wp-n)
+                if type == 0: return mpf_pos(w, prec, rnd)
+                if type == 2: return mpf_div(fone, w, prec, rnd)
+                if type == 3: return mpf_log(mpf_abs(w), prec, rnd)
+
+    # Convert to fixed point
+    offset = exp + wp
+    if offset >= 0: absxman = man << offset
+    else:           absxman = man >> (-offset)
+
+    # For log gamma, provide accurate evaluation for x = 1+eps and 2+eps
+    if type == 3 and not sign:
+        one = MPZ_ONE << wp
+        one_dist = abs(absxman-one)
+        two_dist = abs(absxman-2*one)
+        cancellation = (wp - bitcount(min(one_dist, two_dist)))
+        if cancellation > 10:
+            xsub1 = mpf_sub(fone, x)
+            xsub2 = mpf_sub(ftwo, x)
+            xsub1mag = xsub1[2]+xsub1[3]
+            xsub2mag = xsub2[2]+xsub2[3]
+            if xsub1mag < -wp:
+                return mpf_mul(mpf_euler(wp), mpf_sub(fone, x), prec, rnd)
+            if xsub2mag < -wp:
+                return mpf_mul(mpf_sub(fone, mpf_euler(wp)),
+                    mpf_sub(x, ftwo), prec, rnd)
+            # Proceed but increase precision
+            wp += max(-xsub1mag, -xsub2mag)
+            offset = exp + wp
+            if offset >= 0: absxman = man << offset
+            else:           absxman = man >> (-offset)
+
+    # Use Taylor series if appropriate
+    n_for_stirling = int(GAMMA_STIRLING_BETA*wp)
+    if n < max(100, n_for_stirling) and wp < MAX_GAMMA_TAYLOR_PREC:
+        if sign:
+            absxman = -absxman
+        return gamma_fixed_taylor(x, absxman, wp, prec, rnd, type)
+
+    # Use Stirling's series
+    # First ensure that |x| is large enough for rapid convergence
+    xorig = x
+
+    # Argument reduction
+    r = 0
+    if n < n_for_stirling:
+        r = one = MPZ_ONE << wp
+        d = n_for_stirling - n
+        for k in xrange(d):
+            r = (r * absxman) >> wp
+            absxman += one
+        x = xabs = from_man_exp(absxman, -wp)
+        if sign:
+            x = mpf_neg(x)
+    else:
+        xabs = mpf_abs(x)
+
+    # Asymptotic series
+    y = real_stirling_series(absxman, wp)
+    u = to_fixed(mpf_log(xabs, wp), wp)
+    u = ((absxman - (MPZ_ONE<<(wp-1))) * u) >> wp
+    y += u
+    w = from_man_exp(y, -wp)
+
+    # Compute final value
+    if sign:
+        # Reflection formula
+        A = mpf_mul(mpf_sin_pi(xorig, wp), xorig, wp)
+        B = mpf_neg(mpf_pi(wp))
+        if type == 0 or type == 2:
+            A = mpf_mul(A, mpf_exp(w, wp))
+            if r:
+                B = mpf_mul(B, from_man_exp(r, -wp), wp)
+            if type == 0:
+                return mpf_div(B, A, prec, rnd)
+            if type == 2:
+                return mpf_div(A, B, prec, rnd)
+        if type == 3:
+            if r:
+                B = mpf_mul(B, from_man_exp(r, -wp), wp)
+            A = mpf_add(mpf_log(mpf_abs(A), wp), w, wp)
+            return mpf_sub(mpf_log(mpf_abs(B), wp), A, prec, rnd)
+    else:
+        if type == 0:
+            if r:
+                return mpf_div(mpf_exp(w, wp),
+                    from_man_exp(r, -wp), prec, rnd)
+            return mpf_exp(w, prec, rnd)
+        if type == 2:
+            if r:
+                return mpf_div(from_man_exp(r, -wp),
+                    mpf_exp(w, wp), prec, rnd)
+            return mpf_exp(mpf_neg(w), prec, rnd)
+        if type == 3:
+            if r:
+                return mpf_sub(w, mpf_log(from_man_exp(r,-wp), wp), prec, rnd)
+            return mpf_pos(w, prec, rnd)
+
+
+def mpc_gamma(z, prec, rnd='d', type=0):
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+
+    if b == fzero:
+        # Imaginary part on negative half-axis for log-gamma function
+        if type == 3 and asign:
+            re = mpf_gamma(a, prec, rnd, 3)
+            n = (-aman) >> (-aexp)
+            im = mpf_mul_int(mpf_pi(prec+10), n, prec, rnd)
+            return re, im
+        return mpf_gamma(a, prec, rnd, type), fzero
+
+    # Some kind of complex inf/nan
+    if (not aman and aexp) or (not bman and bexp):
+        return (fnan, fnan)
+
+    # Initial working precision
+    wp = prec + 20
+
+    amag = aexp+abc
+    bmag = bexp+bbc
+    if aman:
+        mag = max(amag, bmag)
+    else:
+        mag = bmag
+
+    # Close to 0
+    if mag < -8:
+        if mag < -wp:
+            # 1/gamma(z) = z + euler*z^2 + O(z^3)
+            v = mpc_add(z, mpc_mul_mpf(mpc_mul(z,z,wp),mpf_euler(wp),wp), wp)
+            if type == 0: return mpc_reciprocal(v, prec, rnd)
+            if type == 1: return mpc_div(z, v, prec, rnd)
+            if type == 2: return mpc_pos(v, prec, rnd)
+            if type == 3: return mpc_log(mpc_reciprocal(v, prec), prec, rnd)
+        elif type != 1:
+            wp += (-mag)
+
+    # Handle huge log-gamma values; must do this before converting to
+    # a fixed-point value. TODO: determine a precise cutoff of validity
+    # depending on amag and bmag
+    if type == 3 and mag > wp and ((not asign) or (bmag >= amag)):
+        return mpc_sub(mpc_mul(z, mpc_log(z, wp), wp), z, prec, rnd)
+
+    # From now on, we assume having a gamma function
+    if type == 1:
+        return mpc_gamma((mpf_add(a, fone), b), prec, rnd, 0)
+
+    an = abs(to_int(a))
+    bn = abs(to_int(b))
+    absn = max(an, bn)
+    gamma_size = absn*mag
+    if type == 3:
+        pass
+    else:
+        wp += bitcount(gamma_size)
+
+    # Reflect to the right half-plane. Note that Stirling's expansion
+    # is valid in the left half-plane too, as long as we're not too close
+    # to the real axis, but in order to use this argument reduction
+    # in the negative direction must be implemented.
+    #need_reflection = asign and ((bmag < 0) or (amag-bmag > 4))
+    need_reflection = asign
+    zorig = z
+    if need_reflection:
+        z = mpc_neg(z)
+        asign, aman, aexp, abc = a = z[0]
+        bsign, bman, bexp, bbc = b = z[1]
+
+    # Imaginary part very small compared to real one?
+    yfinal = 0
+    balance_prec = 0
+    if bmag < -10:
+        # Check z ~= 1 and z ~= 2 for loggamma
+        if type == 3:
+            zsub1 = mpc_sub_mpf(z, fone)
+            if zsub1[0] == fzero:
+                cancel1 = -bmag
+            else:
+                cancel1 = -max(zsub1[0][2]+zsub1[0][3], bmag)
+            if cancel1 > wp:
+                pi = mpf_pi(wp)
+                x = mpc_mul_mpf(zsub1, pi, wp)
+                x = mpc_mul(x, x, wp)
+                x = mpc_div_mpf(x, from_int(12), wp)
+                y = mpc_mul_mpf(zsub1, mpf_neg(mpf_euler(wp)), wp)
+                yfinal = mpc_add(x, y, wp)
+                if not need_reflection:
+                    return mpc_pos(yfinal, prec, rnd)
+            elif cancel1 > 0:
+                wp += cancel1
+            zsub2 = mpc_sub_mpf(z, ftwo)
+            if zsub2[0] == fzero:
+                cancel2 = -bmag
+            else:
+                cancel2 = -max(zsub2[0][2]+zsub2[0][3], bmag)
+            if cancel2 > wp:
+                pi = mpf_pi(wp)
+                t = mpf_sub(mpf_mul(pi, pi), from_int(6))
+                x = mpc_mul_mpf(mpc_mul(zsub2, zsub2, wp), t, wp)
+                x = mpc_div_mpf(x, from_int(12), wp)
+                y = mpc_mul_mpf(zsub2, mpf_sub(fone, mpf_euler(wp)), wp)
+                yfinal = mpc_add(x, y, wp)
+                if not need_reflection:
+                    return mpc_pos(yfinal, prec, rnd)
+            elif cancel2 > 0:
+                wp += cancel2
+        if bmag < -wp:
+            # Compute directly from the real gamma function.
+            pp = 2*(wp+10)
+            aabs = mpf_abs(a)
+            eps = mpf_shift(fone, amag-wp)
+            x1 = mpf_gamma(aabs, pp, type=type)
+            x2 = mpf_gamma(mpf_add(aabs, eps), pp, type=type)
+            xprime = mpf_div(mpf_sub(x2, x1, pp), eps, pp)
+            y = mpf_mul(b, xprime, prec, rnd)
+            yfinal = (x1, y)
+            # Note: we still need to use the reflection formula for
+            # near-poles, and the correct branch of the log-gamma function
+            if not need_reflection:
+                return mpc_pos(yfinal, prec, rnd)
+        else:
+            balance_prec += (-bmag)
+
+    wp += balance_prec
+    n_for_stirling = int(GAMMA_STIRLING_BETA*wp)
+    need_reduction = absn < n_for_stirling
+
+    afix = to_fixed(a, wp)
+    bfix = to_fixed(b, wp)
+
+    r = 0
+    if not yfinal:
+        zprered = z
+        # Argument reduction
+        if absn < n_for_stirling:
+            absn = complex(an, bn)
+            d = int((1 + n_for_stirling**2 - bn**2)**0.5 - an)
+            rre = one = MPZ_ONE << wp
+            rim = MPZ_ZERO
+            for k in xrange(d):
+                rre, rim = ((afix*rre-bfix*rim)>>wp), ((afix*rim + bfix*rre)>>wp)
+                afix += one
+            r = from_man_exp(rre, -wp), from_man_exp(rim, -wp)
+            a = from_man_exp(afix, -wp)
+            z = a, b
+
+        yre, yim = complex_stirling_series(afix, bfix, wp)
+        # (z-1/2)*log(z) + S
+        lre, lim = mpc_log(z, wp)
+        lre = to_fixed(lre, wp)
+        lim = to_fixed(lim, wp)
+        yre = ((lre*afix - lim*bfix)>>wp) - (lre>>1) + yre
+        yim = ((lre*bfix + lim*afix)>>wp) - (lim>>1) + yim
+        y = from_man_exp(yre, -wp), from_man_exp(yim, -wp)
+
+        if r and type == 3:
+            # If re(z) > 0 and abs(z) <= 4, the branches of loggamma(z)
+            # and log(gamma(z)) coincide. Otherwise, use the zeroth order
+            # Stirling expansion to compute the correct imaginary part.
+            y = mpc_sub(y, mpc_log(r, wp), wp)
+            zfa = to_float(zprered[0])
+            zfb = to_float(zprered[1])
+            zfabs = math.hypot(zfa,zfb)
+            #if not (zfa > 0.0 and zfabs <= 4):
+            yfb = to_float(y[1])
+            u = math.atan2(zfb, zfa)
+            if zfabs <= 0.5:
+                gi = 0.577216*zfb - u
+            else:
+                gi = -zfb - 0.5*u + zfa*u + zfb*math.log(zfabs)
+            n = int(math.floor((gi-yfb)/(2*math.pi)+0.5))
+            y = (y[0], mpf_add(y[1], mpf_mul_int(mpf_pi(wp), 2*n, wp), wp))
+
+    if need_reflection:
+        if type == 0 or type == 2:
+            A = mpc_mul(mpc_sin_pi(zorig, wp), zorig, wp)
+            B = (mpf_neg(mpf_pi(wp)), fzero)
+            if yfinal:
+                if type == 2:
+                    A = mpc_div(A, yfinal, wp)
+                else:
+                    A = mpc_mul(A, yfinal, wp)
+            else:
+                A = mpc_mul(A, mpc_exp(y, wp), wp)
+            if r:
+                B = mpc_mul(B, r, wp)
+            if type == 0: return mpc_div(B, A, prec, rnd)
+            if type == 2: return mpc_div(A, B, prec, rnd)
+
+        # Reflection formula for the log-gamma function with correct branch
+        # http://functions.wolfram.com/GammaBetaErf/LogGamma/16/01/01/0006/
+        # LogGamma[z] == -LogGamma[-z] - Log[-z] +
+        # Sign[Im[z]] Floor[Re[z]] Pi I + Log[Pi] -
+        #      Log[Sin[Pi (z - Floor[Re[z]])]] -
+        # Pi I (1 - Abs[Sign[Im[z]]]) Abs[Floor[Re[z]]]
+        if type == 3:
+            if yfinal:
+                s1 = mpc_neg(yfinal)
+            else:
+                s1 = mpc_neg(y)
+            # s -= log(-z)
+            s1 = mpc_sub(s1, mpc_log(mpc_neg(zorig), wp), wp)
+            # floor(re(z))
+            rezfloor = mpf_floor(zorig[0])
+            imzsign = mpf_sign(zorig[1])
+            pi = mpf_pi(wp)
+            t = mpf_mul(pi, rezfloor)
+            t = mpf_mul_int(t, imzsign, wp)
+            s1 = (s1[0], mpf_add(s1[1], t, wp))
+            s1 = mpc_add_mpf(s1, mpf_log(pi, wp), wp)
+            t = mpc_sin_pi(mpc_sub_mpf(zorig, rezfloor), wp)
+            t = mpc_log(t, wp)
+            s1 = mpc_sub(s1, t, wp)
+            # Note: may actually be unused, because we fall back
+            # to the mpf_ function for real arguments
+            if not imzsign:
+                t = mpf_mul(pi, mpf_floor(rezfloor), wp)
+                s1 = (s1[0], mpf_sub(s1[1], t, wp))
+            return mpc_pos(s1, prec, rnd)
+    else:
+        if type == 0:
+            if r:
+                return mpc_div(mpc_exp(y, wp), r, prec, rnd)
+            return mpc_exp(y, prec, rnd)
+        if type == 2:
+            if r:
+                return mpc_div(r, mpc_exp(y, wp), prec, rnd)
+            return mpc_exp(mpc_neg(y), prec, rnd)
+        if type == 3:
+            return mpc_pos(y, prec, rnd)
+
+def mpf_factorial(x, prec, rnd='d'):
+    return mpf_gamma(x, prec, rnd, 1)
+
+def mpc_factorial(x, prec, rnd='d'):
+    return mpc_gamma(x, prec, rnd, 1)
+
+def mpf_rgamma(x, prec, rnd='d'):
+    return mpf_gamma(x, prec, rnd, 2)
+
+def mpc_rgamma(x, prec, rnd='d'):
+    return mpc_gamma(x, prec, rnd, 2)
+
+def mpf_loggamma(x, prec, rnd='d'):
+    sign, man, exp, bc = x
+    if sign:
+        raise ComplexResult
+    return mpf_gamma(x, prec, rnd, 3)
+
+def mpc_loggamma(z, prec, rnd='d'):
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if b == fzero and asign:
+        re = mpf_gamma(a, prec, rnd, 3)
+        n = (-aman) >> (-aexp)
+        im = mpf_mul_int(mpf_pi(prec+10), n, prec, rnd)
+        return re, im
+    return mpc_gamma(z, prec, rnd, 3)
+
+def mpf_gamma_int(n, prec, rnd=round_fast):
+    if n < SMALL_FACTORIAL_CACHE_SIZE:
+        return mpf_pos(small_factorial_cache[n-1], prec, rnd)
+    return mpf_gamma(from_int(n), prec, rnd)
diff --git a/lib/python3.11/site-packages/mpmath/libmp/libelefun.py b/lib/python3.11/site-packages/mpmath/libmp/libelefun.py
new file mode 100644
index 0000000000000000000000000000000000000000..3de2e5aaef02296ed03dec3df3021b56823f3728
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/libelefun.py
@@ -0,0 +1,1428 @@
+"""
+This module implements computation of elementary transcendental
+functions (powers, logarithms, trigonometric and hyperbolic
+functions, inverse trigonometric and hyperbolic) for real
+floating-point numbers.
+
+For complex and interval implementations of the same functions,
+see libmpc and libmpi.
+
+"""
+
+import math
+from bisect import bisect
+
+from .backend import xrange
+from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_FIVE, BACKEND
+
+from .libmpf import (
+    round_floor, round_ceiling, round_down, round_up,
+    round_nearest, round_fast,
+    ComplexResult,
+    bitcount, bctable, lshift, rshift, giant_steps, sqrt_fixed,
+    from_int, to_int, from_man_exp, to_fixed, to_float, from_float,
+    from_rational, normalize,
+    fzero, fone, fnone, fhalf, finf, fninf, fnan,
+    mpf_cmp, mpf_sign, mpf_abs,
+    mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_div, mpf_shift,
+    mpf_rdiv_int, mpf_pow_int, mpf_sqrt,
+    reciprocal_rnd, negative_rnd, mpf_perturb,
+    isqrt_fast
+)
+
+from .libintmath import ifib
+
+
+#-------------------------------------------------------------------------------
+# Tuning parameters
+#-------------------------------------------------------------------------------
+
+# Cutoff for computing exp from cosh+sinh. This reduces the
+# number of terms by half, but also requires a square root which
+# is expensive with the pure-Python square root code.
+if BACKEND == 'python':
+    EXP_COSH_CUTOFF = 600
+else:
+    EXP_COSH_CUTOFF = 400
+# Cutoff for using more than 2 series
+EXP_SERIES_U_CUTOFF = 1500
+
+# Also basically determined by sqrt
+if BACKEND == 'python':
+    COS_SIN_CACHE_PREC = 400
+else:
+    COS_SIN_CACHE_PREC = 200
+COS_SIN_CACHE_STEP = 8
+cos_sin_cache = {}
+
+# Number of integer logarithms to cache (for zeta sums)
+MAX_LOG_INT_CACHE = 2000
+log_int_cache = {}
+
+LOG_TAYLOR_PREC = 2500  # Use Taylor series with caching up to this prec
+LOG_TAYLOR_SHIFT = 9    # Cache log values in steps of size 2^-N
+log_taylor_cache = {}
+# prec/size ratio of x for fastest convergence in AGM formula
+LOG_AGM_MAG_PREC_RATIO = 20
+
+ATAN_TAYLOR_PREC = 3000  # Same as for log
+ATAN_TAYLOR_SHIFT = 7   # steps of size 2^-N
+atan_taylor_cache = {}
+
+
+# ~= next power of two + 20
+cache_prec_steps = [22,22]
+for k in xrange(1, bitcount(LOG_TAYLOR_PREC)+1):
+    cache_prec_steps += [min(2**k,LOG_TAYLOR_PREC)+20] * 2**(k-1)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                   Elementary mathematical constants                        #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def constant_memo(f):
+    """
+    Decorator for caching computed values of mathematical
+    constants. This decorator should be applied to a
+    function taking a single argument prec as input and
+    returning a fixed-point value with the given precision.
+    """
+    f.memo_prec = -1
+    f.memo_val = None
+    def g(prec, **kwargs):
+        memo_prec = f.memo_prec
+        if prec <= memo_prec:
+            return f.memo_val >> (memo_prec-prec)
+        newprec = int(prec*1.05+10)
+        f.memo_val = f(newprec, **kwargs)
+        f.memo_prec = newprec
+        return f.memo_val >> (newprec-prec)
+    g.__name__ = f.__name__
+    g.__doc__ = f.__doc__
+    return g
+
+def def_mpf_constant(fixed):
+    """
+    Create a function that computes the mpf value for a mathematical
+    constant, given a function that computes the fixed-point value.
+
+    Assumptions: the constant is positive and has magnitude ~= 1;
+    the fixed-point function rounds to floor.
+    """
+    def f(prec, rnd=round_fast):
+        wp = prec + 20
+        v = fixed(wp)
+        if rnd in (round_up, round_ceiling):
+            v += 1
+        return normalize(0, v, -wp, bitcount(v), prec, rnd)
+    f.__doc__ = fixed.__doc__
+    return f
+
+def bsp_acot(q, a, b, hyperbolic):
+    if b - a == 1:
+        a1 = MPZ(2*a + 3)
+        if hyperbolic or a&1:
+            return MPZ_ONE, a1 * q**2, a1
+        else:
+            return -MPZ_ONE, a1 * q**2, a1
+    m = (a+b)//2
+    p1, q1, r1 = bsp_acot(q, a, m, hyperbolic)
+    p2, q2, r2 = bsp_acot(q, m, b, hyperbolic)
+    return q2*p1 + r1*p2, q1*q2, r1*r2
+
+# the acoth(x) series converges like the geometric series for x^2
+# N = ceil(p*log(2)/(2*log(x)))
+def acot_fixed(a, prec, hyperbolic):
+    """
+    Compute acot(a) or acoth(a) for an integer a with binary splitting; see
+    http://numbers.computation.free.fr/Constants/Algorithms/splitting.html
+    """
+    N = int(0.35 * prec/math.log(a) + 20)
+    p, q, r = bsp_acot(a, 0,N, hyperbolic)
+    return ((p+q)<<prec)//(q*a)
+
+def machin(coefs, prec, hyperbolic=False):
+    """
+    Evaluate a Machin-like formula, i.e., a linear combination of
+    acot(n) or acoth(n) for specific integer values of n, using fixed-
+    point arithmetic. The input should be a list [(c, n), ...], giving
+    c*acot[h](n) + ...
+    """
+    extraprec = 10
+    s = MPZ_ZERO
+    for a, b in coefs:
+        s += MPZ(a) * acot_fixed(MPZ(b), prec+extraprec, hyperbolic)
+    return (s >> extraprec)
+
+# Logarithms of integers are needed for various computations involving
+# logarithms, powers, radix conversion, etc
+
+@constant_memo
+def ln2_fixed(prec):
+    """
+    Computes ln(2). This is done with a hyperbolic Machin-type formula,
+    with binary splitting at high precision.
+    """
+    return machin([(18, 26), (-2, 4801), (8, 8749)], prec, True)
+
+@constant_memo
+def ln10_fixed(prec):
+    """
+    Computes ln(10). This is done with a hyperbolic Machin-type formula.
+    """
+    return machin([(46, 31), (34, 49), (20, 161)], prec, True)
+
+
+r"""
+For computation of pi, we use the Chudnovsky series:
+
+             oo
+             ___        k
+      1     \       (-1)  (6 k)! (A + B k)
+    ----- =  )     -----------------------
+    12 pi   /___               3  3k+3/2
+                    (3 k)! (k!)  C
+            k = 0
+
+where A, B, and C are certain integer constants. This series adds roughly
+14 digits per term. Note that C^(3/2) can be extracted so that the
+series contains only rational terms. This makes binary splitting very
+efficient.
+
+The recurrence formulas for the binary splitting were taken from
+ftp://ftp.gmplib.org/pub/src/gmp-chudnovsky.c
+
+Previously, Machin's formula was used at low precision and the AGM iteration
+was used at high precision. However, the Chudnovsky series is essentially as
+fast as the Machin formula at low precision and in practice about 3x faster
+than the AGM at high precision (despite theoretically having a worse
+asymptotic complexity), so there is no reason not to use it in all cases.
+
+"""
+
+# Constants in Chudnovsky's series
+CHUD_A = MPZ(13591409)
+CHUD_B = MPZ(545140134)
+CHUD_C = MPZ(640320)
+CHUD_D = MPZ(12)
+
+def bs_chudnovsky(a, b, level, verbose):
+    """
+    Computes the sum from a to b of the series in the Chudnovsky
+    formula. Returns g, p, q where p/q is the sum as an exact
+    fraction and g is a temporary value used to save work
+    for recursive calls.
+    """
+    if b-a == 1:
+        g = MPZ((6*b-5)*(2*b-1)*(6*b-1))
+        p = b**3 * CHUD_C**3 // 24
+        q = (-1)**b * g * (CHUD_A+CHUD_B*b)
+    else:
+        if verbose and level < 4:
+            print("  binary splitting", a, b)
+        mid = (a+b)//2
+        g1, p1, q1 = bs_chudnovsky(a, mid, level+1, verbose)
+        g2, p2, q2 = bs_chudnovsky(mid, b, level+1, verbose)
+        p = p1*p2
+        g = g1*g2
+        q = q1*p2 + q2*g1
+    return g, p, q
+
+@constant_memo
+def pi_fixed(prec, verbose=False, verbose_base=None):
+    """
+    Compute floor(pi * 2**prec) as a big integer.
+
+    This is done using Chudnovsky's series (see comments in
+    libelefun.py for details).
+    """
+    # The Chudnovsky series gives 14.18 digits per term
+    N = int(prec/3.3219280948/14.181647462 + 2)
+    if verbose:
+        print("binary splitting with N =", N)
+    g, p, q = bs_chudnovsky(0, N, 0, verbose)
+    sqrtC = isqrt_fast(CHUD_C<<(2*prec))
+    v = p*CHUD_C*sqrtC//((q+CHUD_A*p)*CHUD_D)
+    return v
+
+def degree_fixed(prec):
+    return pi_fixed(prec)//180
+
+def bspe(a, b):
+    """
+    Sum series for exp(1)-1 between a, b, returning the result
+    as an exact fraction (p, q).
+    """
+    if b-a == 1:
+        return MPZ_ONE, MPZ(b)
+    m = (a+b)//2
+    p1, q1 = bspe(a, m)
+    p2, q2 = bspe(m, b)
+    return p1*q2+p2, q1*q2
+
+@constant_memo
+def e_fixed(prec):
+    """
+    Computes exp(1). This is done using the ordinary Taylor series for
+    exp, with binary splitting. For a description of the algorithm,
+    see:
+
+        http://numbers.computation.free.fr/Constants/
+            Algorithms/splitting.html
+    """
+    # Slight overestimate of N needed for 1/N! < 2**(-prec)
+    # This could be tightened for large N.
+    N = int(1.1*prec/math.log(prec) + 20)
+    p, q = bspe(0,N)
+    return ((p+q)<<prec)//q
+
+@constant_memo
+def phi_fixed(prec):
+    """
+    Computes the golden ratio, (1+sqrt(5))/2
+    """
+    prec += 10
+    a = isqrt_fast(MPZ_FIVE<<(2*prec)) + (MPZ_ONE << prec)
+    return a >> 11
+
+mpf_phi    = def_mpf_constant(phi_fixed)
+mpf_pi     = def_mpf_constant(pi_fixed)
+mpf_e      = def_mpf_constant(e_fixed)
+mpf_degree = def_mpf_constant(degree_fixed)
+mpf_ln2    = def_mpf_constant(ln2_fixed)
+mpf_ln10   = def_mpf_constant(ln10_fixed)
+
+
+@constant_memo
+def ln_sqrt2pi_fixed(prec):
+    wp = prec + 10
+    # ln(sqrt(2*pi)) = ln(2*pi)/2
+    return to_fixed(mpf_log(mpf_shift(mpf_pi(wp), 1), wp), prec-1)
+
+@constant_memo
+def sqrtpi_fixed(prec):
+    return sqrt_fixed(pi_fixed(prec), prec)
+
+mpf_sqrtpi   = def_mpf_constant(sqrtpi_fixed)
+mpf_ln_sqrt2pi   = def_mpf_constant(ln_sqrt2pi_fixed)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                    Powers                                  #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def mpf_pow(s, t, prec, rnd=round_fast):
+    """
+    Compute s**t. Raises ComplexResult if s is negative and t is
+    fractional.
+    """
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    if ssign and texp < 0:
+        raise ComplexResult("negative number raised to a fractional power")
+    if texp >= 0:
+        return mpf_pow_int(s, (-1)**tsign * (tman<<texp), prec, rnd)
+    # s**(n/2) = sqrt(s)**n
+    if texp == -1:
+        if tman == 1:
+            if tsign:
+                return mpf_div(fone, mpf_sqrt(s, prec+10,
+                    reciprocal_rnd[rnd]), prec, rnd)
+            return mpf_sqrt(s, prec, rnd)
+        else:
+            if tsign:
+                return mpf_pow_int(mpf_sqrt(s, prec+10,
+                    reciprocal_rnd[rnd]), -tman, prec, rnd)
+            return mpf_pow_int(mpf_sqrt(s, prec+10, rnd), tman, prec, rnd)
+    # General formula: s**t = exp(t*log(s))
+    # TODO: handle rnd direction of the logarithm carefully
+    c = mpf_log(s, prec+10, rnd)
+    return mpf_exp(mpf_mul(t, c), prec, rnd)
+
+def int_pow_fixed(y, n, prec):
+    """n-th power of a fixed point number with precision prec
+
+       Returns the power in the form man, exp,
+       man * 2**exp ~= y**n
+    """
+    if n == 2:
+        return (y*y), 0
+    bc = bitcount(y)
+    exp = 0
+    workprec = 2 * (prec + 4*bitcount(n) + 4)
+    _, pm, pe, pbc = fone
+    while 1:
+        if n & 1:
+            pm = pm*y
+            pe = pe+exp
+            pbc += bc - 2
+            pbc = pbc + bctable[int(pm >> pbc)]
+            if pbc > workprec:
+                pm = pm >> (pbc-workprec)
+                pe += pbc - workprec
+                pbc = workprec
+            n -= 1
+            if not n:
+                break
+        y = y*y
+        exp = exp+exp
+        bc = bc + bc - 2
+        bc = bc + bctable[int(y >> bc)]
+        if bc > workprec:
+            y = y >> (bc-workprec)
+            exp += bc - workprec
+            bc = workprec
+        n = n // 2
+    return pm, pe
+
+# froot(s, n, prec, rnd) computes the real n-th root of a
+# positive mpf tuple s.
+# To compute the root we start from a 50-bit estimate for r
+# generated with ordinary floating-point arithmetic, and then refine
+# the value to full accuracy using the iteration
+
+#            1  /                     y       \
+#   r     = --- | (n-1)  * r   +  ----------  |
+#    n+1     n  \           n     r_n**(n-1)  /
+
+# which is simply Newton's method applied to the equation r**n = y.
+# With giant_steps(start, prec+extra) = [p0,...,pm, prec+extra]
+# and y = man * 2**-shift  one has
+# (man * 2**exp)**(1/n) =
+# y**(1/n) * 2**(start-prec/n) * 2**(p0-start) * ... * 2**(prec+extra-pm) *
+# 2**((exp+shift-(n-1)*prec)/n -extra))
+# The last factor is accounted for in the last line of froot.
+
+def nthroot_fixed(y, n, prec, exp1):
+    start = 50
+    try:
+        y1 = rshift(y, prec - n*start)
+        r = MPZ(int(y1**(1.0/n)))
+    except OverflowError:
+        y1 = from_int(y1, start)
+        fn = from_int(n)
+        fn = mpf_rdiv_int(1, fn, start)
+        r = mpf_pow(y1, fn, start)
+        r = to_int(r)
+    extra = 10
+    extra1 = n
+    prevp = start
+    for p in giant_steps(start, prec+extra):
+        pm, pe = int_pow_fixed(r, n-1, prevp)
+        r2 = rshift(pm, (n-1)*prevp - p - pe - extra1)
+        B = lshift(y, 2*p-prec+extra1)//r2
+        r = (B + (n-1) * lshift(r, p-prevp))//n
+        prevp = p
+    return r
+
+def mpf_nthroot(s, n, prec, rnd=round_fast):
+    """nth-root of a positive number
+
+    Use the Newton method when faster, otherwise use x**(1/n)
+    """
+    sign, man, exp, bc = s
+    if sign:
+        raise ComplexResult("nth root of a negative number")
+    if not man:
+        if s == fnan:
+            return fnan
+        if s == fzero:
+            if n > 0:
+                return fzero
+            if n == 0:
+                return fone
+            return finf
+        # Infinity
+        if not n:
+            return fnan
+        if n < 0:
+            return fzero
+        return finf
+    flag_inverse = False
+    if n < 2:
+        if n == 0:
+            return fone
+        if n == 1:
+            return mpf_pos(s, prec, rnd)
+        if n == -1:
+            return mpf_div(fone, s, prec, rnd)
+        # n < 0
+        rnd = reciprocal_rnd[rnd]
+        flag_inverse = True
+        extra_inverse = 5
+        prec += extra_inverse
+        n = -n
+    if n > 20 and (n >= 20000 or prec < int(233 + 28.3 * n**0.62)):
+        prec2 = prec + 10
+        fn = from_int(n)
+        nth = mpf_rdiv_int(1, fn, prec2)
+        r = mpf_pow(s, nth, prec2, rnd)
+        s = normalize(r[0], r[1], r[2], r[3], prec, rnd)
+        if flag_inverse:
+            return mpf_div(fone, s, prec-extra_inverse, rnd)
+        else:
+            return s
+    # Convert to a fixed-point number with prec2 bits.
+    prec2 = prec + 2*n - (prec%n)
+    # a few tests indicate that
+    # for 10 < n < 10**4 a bit more precision is needed
+    if n > 10:
+        prec2 += prec2//10
+        prec2 = prec2 - prec2%n
+    # Mantissa may have more bits than we need. Trim it down.
+    shift = bc - prec2
+    # Adjust exponents to make prec2 and exp+shift multiples of n.
+    sign1 = 0
+    es = exp+shift
+    if es < 0:
+        sign1 = 1
+        es = -es
+    if sign1:
+        shift += es%n
+    else:
+        shift -= es%n
+    man = rshift(man, shift)
+    extra = 10
+    exp1 = ((exp+shift-(n-1)*prec2)//n) - extra
+    rnd_shift = 0
+    if flag_inverse:
+        if rnd == 'u' or rnd == 'c':
+            rnd_shift = 1
+    else:
+        if rnd == 'd' or rnd == 'f':
+            rnd_shift = 1
+    man = nthroot_fixed(man+rnd_shift, n, prec2, exp1)
+    s = from_man_exp(man, exp1, prec, rnd)
+    if flag_inverse:
+        return mpf_div(fone, s, prec-extra_inverse, rnd)
+    else:
+        return s
+
+def mpf_cbrt(s, prec, rnd=round_fast):
+    """cubic root of a positive number"""
+    return mpf_nthroot(s, 3, prec, rnd)
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                Logarithms                                  #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def log_int_fixed(n, prec, ln2=None):
+    """
+    Fast computation of log(n), caching the value for small n,
+    intended for zeta sums.
+    """
+    if n in log_int_cache:
+        value, vprec = log_int_cache[n]
+        if vprec >= prec:
+            return value >> (vprec - prec)
+    wp = prec + 10
+    if wp <= LOG_TAYLOR_SHIFT:
+        if ln2 is None:
+            ln2 = ln2_fixed(wp)
+        r = bitcount(n)
+        x = n << (wp-r)
+        v = log_taylor_cached(x, wp) + r*ln2
+    else:
+        v = to_fixed(mpf_log(from_int(n), wp+5), wp)
+    if n < MAX_LOG_INT_CACHE:
+        log_int_cache[n] = (v, wp)
+    return v >> (wp-prec)
+
+def agm_fixed(a, b, prec):
+    """
+    Fixed-point computation of agm(a,b), assuming
+    a, b both close to unit magnitude.
+    """
+    i = 0
+    while 1:
+        anew = (a+b)>>1
+        if i > 4 and abs(a-anew) < 8:
+            return a
+        b = isqrt_fast(a*b)
+        a = anew
+        i += 1
+    return a
+
+def log_agm(x, prec):
+    """
+    Fixed-point computation of -log(x) = log(1/x), suitable
+    for large precision. It is required that 0 < x < 1. The
+    algorithm used is the Sasaki-Kanada formula
+
+        -log(x) = pi/agm(theta2(x)^2,theta3(x)^2). [1]
+
+    For faster convergence in the theta functions, x should
+    be chosen closer to 0.
+
+    Guard bits must be added by the caller.
+
+    HYPOTHESIS: if x = 2^(-n), n bits need to be added to
+    account for the truncation to a fixed-point number,
+    and this is the only significant cancellation error.
+
+    The number of bits lost to roundoff is small and can be
+    considered constant.
+
+    [1] Richard P. Brent, "Fast Algorithms for High-Precision
+        Computation of Elementary Functions (extended abstract)",
+        http://wwwmaths.anu.edu.au/~brent/pd/RNC7-Brent.pdf
+
+    """
+    x2 = (x*x) >> prec
+    # Compute jtheta2(x)**2
+    s = a = b = x2
+    while a:
+        b = (b*x2) >> prec
+        a = (a*b) >> prec
+        s += a
+    s += (MPZ_ONE<<prec)
+    s = (s*s)>>(prec-2)
+    s = (s*isqrt_fast(x<<prec))>>prec
+    # Compute jtheta3(x)**2
+    t = a = b = x
+    while a:
+        b = (b*x2) >> prec
+        a = (a*b) >> prec
+        t += a
+    t = (MPZ_ONE<<prec) + (t<<1)
+    t = (t*t)>>prec
+    # Final formula
+    p = agm_fixed(s, t, prec)
+    return (pi_fixed(prec) << prec) // p
+
+def log_taylor(x, prec, r=0):
+    """
+    Fixed-point calculation of log(x). It is assumed that x is close
+    enough to 1 for the Taylor series to converge quickly. Convergence
+    can be improved by specifying r > 0 to compute
+    log(x^(1/2^r))*2^r, at the cost of performing r square roots.
+
+    The caller must provide sufficient guard bits.
+    """
+    for i in xrange(r):
+        x = isqrt_fast(x<<prec)
+    one = MPZ_ONE << prec
+    v = ((x-one)<<prec)//(x+one)
+    sign = v < 0
+    if sign:
+        v = -v
+    v2 = (v*v) >> prec
+    v4 = (v2*v2) >> prec
+    s0 = v
+    s1 = v//3
+    v = (v*v4) >> prec
+    k = 5
+    while v:
+        s0 += v // k
+        k += 2
+        s1 += v // k
+        v = (v*v4) >> prec
+        k += 2
+    s1 = (s1*v2) >> prec
+    s = (s0+s1) << (1+r)
+    if sign:
+        return -s
+    return s
+
+def log_taylor_cached(x, prec):
+    """
+    Fixed-point computation of log(x), assuming x in (0.5, 2)
+    and prec <= LOG_TAYLOR_PREC.
+    """
+    n = x >> (prec-LOG_TAYLOR_SHIFT)
+    cached_prec = cache_prec_steps[prec]
+    dprec = cached_prec - prec
+    if (n, cached_prec) in log_taylor_cache:
+        a, log_a = log_taylor_cache[n, cached_prec]
+    else:
+        a = n << (cached_prec - LOG_TAYLOR_SHIFT)
+        log_a = log_taylor(a, cached_prec, 8)
+        log_taylor_cache[n, cached_prec] = (a, log_a)
+    a >>= dprec
+    log_a >>= dprec
+    u = ((x - a) << prec) // a
+    v = (u << prec) // ((MPZ_TWO << prec) + u)
+    v2 = (v*v) >> prec
+    v4 = (v2*v2) >> prec
+    s0 = v
+    s1 = v//3
+    v = (v*v4) >> prec
+    k = 5
+    while v:
+        s0 += v//k
+        k += 2
+        s1 += v//k
+        v = (v*v4) >> prec
+        k += 2
+    s1 = (s1*v2) >> prec
+    s = (s0+s1) << 1
+    return log_a + s
+
+def mpf_log(x, prec, rnd=round_fast):
+    """
+    Compute the natural logarithm of the mpf value x. If x is negative,
+    ComplexResult is raised.
+    """
+    sign, man, exp, bc = x
+    #------------------------------------------------------------------
+    # Handle special values
+    if not man:
+        if x == fzero: return fninf
+        if x == finf: return finf
+        if x == fnan: return fnan
+    if sign:
+        raise ComplexResult("logarithm of a negative number")
+    wp = prec + 20
+    #------------------------------------------------------------------
+    # Handle log(2^n) = log(n)*2.
+    # Here we catch the only possible exact value, log(1) = 0
+    if man == 1:
+        if not exp:
+            return fzero
+        return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)
+    mag = exp+bc
+    abs_mag = abs(mag)
+    #------------------------------------------------------------------
+    # Handle x = 1+eps, where log(x) ~ x. We need to check for
+    # cancellation when moving to fixed-point math and compensate
+    # by increasing the precision. Note that abs_mag in (0, 1) <=>
+    # 0.5 < x < 2 and x != 1
+    if abs_mag <= 1:
+        # Calculate t = x-1 to measure distance from 1 in bits
+        tsign = 1-abs_mag
+        if tsign:
+            tman = (MPZ_ONE<<bc) - man
+        else:
+            tman = man - (MPZ_ONE<<(bc-1))
+        tbc = bitcount(tman)
+        cancellation = bc - tbc
+        if cancellation > wp:
+            t = normalize(tsign, tman, abs_mag-bc, tbc, tbc, 'n')
+            return mpf_perturb(t, tsign, prec, rnd)
+        else:
+            wp += cancellation
+        # TODO: if close enough to 1, we could use Taylor series
+        # even in the AGM precision range, since the Taylor series
+        # converges rapidly
+    #------------------------------------------------------------------
+    # Another special case:
+    # n*log(2) is a good enough approximation
+    if abs_mag > 10000:
+        if bitcount(abs_mag) > wp:
+            return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)
+    #------------------------------------------------------------------
+    # General case.
+    # Perform argument reduction using log(x) = log(x*2^n) - n*log(2):
+    # If we are in the Taylor precision range, choose magnitude 0 or 1.
+    # If we are in the AGM precision range, choose magnitude -m for
+    # some large m; benchmarking on one machine showed m = prec/20 to be
+    # optimal between 1000 and 100,000 digits.
+    if wp <= LOG_TAYLOR_PREC:
+        m = log_taylor_cached(lshift(man, wp-bc), wp)
+        if mag:
+            m += mag*ln2_fixed(wp)
+    else:
+        optimal_mag = -wp//LOG_AGM_MAG_PREC_RATIO
+        n = optimal_mag - mag
+        x = mpf_shift(x, n)
+        wp += (-optimal_mag)
+        m = -log_agm(to_fixed(x, wp), wp)
+        m -= n*ln2_fixed(wp)
+    return from_man_exp(m, -wp, prec, rnd)
+
+def mpf_log_hypot(a, b, prec, rnd):
+    """
+    Computes log(sqrt(a^2+b^2)) accurately.
+    """
+    # If either a or b is inf/nan/0, assume it to be a
+    if not b[1]:
+        a, b = b, a
+    # a is inf/nan/0
+    if not a[1]:
+        # both are inf/nan/0
+        if not b[1]:
+            if a == b == fzero:
+                return fninf
+            if fnan in (a, b):
+                return fnan
+            # at least one term is (+/- inf)^2
+            return finf
+        # only a is inf/nan/0
+        if a == fzero:
+            # log(sqrt(0+b^2)) = log(|b|)
+            return mpf_log(mpf_abs(b), prec, rnd)
+        if a == fnan:
+            return fnan
+        return finf
+    # Exact
+    a2 = mpf_mul(a,a)
+    b2 = mpf_mul(b,b)
+    extra = 20
+    # Not exact
+    h2 = mpf_add(a2, b2, prec+extra)
+    cancelled = mpf_add(h2, fnone, 10)
+    mag_cancelled = cancelled[2]+cancelled[3]
+    # Just redo the sum exactly if necessary (could be smarter
+    # and avoid memory allocation when a or b is precisely 1
+    # and the other is tiny...)
+    if cancelled == fzero or mag_cancelled < -extra//2:
+        h2 = mpf_add(a2, b2, prec+extra-min(a2[2],b2[2]))
+    return mpf_shift(mpf_log(h2, prec, rnd), -1)
+
+
+#----------------------------------------------------------------------
+# Inverse tangent
+#
+
+def atan_newton(x, prec):
+    if prec >= 100:
+        r = math.atan(int((x>>(prec-53)))/2.0**53)
+    else:
+        r = math.atan(int(x)/2.0**prec)
+    prevp = 50
+    r = MPZ(int(r * 2.0**53) >> (53-prevp))
+    extra_p = 50
+    for wp in giant_steps(prevp, prec):
+        wp += extra_p
+        r = r << (wp-prevp)
+        cos, sin = cos_sin_fixed(r, wp)
+        tan = (sin << wp) // cos
+        a = ((tan-rshift(x, prec-wp)) << wp) // ((MPZ_ONE<<wp) + ((tan**2)>>wp))
+        r = r - a
+        prevp = wp
+    return rshift(r, prevp-prec)
+
+def atan_taylor_get_cached(n, prec):
+    # Taylor series with caching wins up to huge precisions
+    # To avoid unnecessary precomputation at low precision, we
+    # do it in steps
+    # Round to next power of 2
+    prec2 = (1<<(bitcount(prec-1))) + 20
+    dprec = prec2 - prec
+    if (n, prec2) in atan_taylor_cache:
+        a, atan_a = atan_taylor_cache[n, prec2]
+    else:
+        a = n << (prec2 - ATAN_TAYLOR_SHIFT)
+        atan_a = atan_newton(a, prec2)
+        atan_taylor_cache[n, prec2] = (a, atan_a)
+    return (a >> dprec), (atan_a >> dprec)
+
+def atan_taylor(x, prec):
+    n = (x >> (prec-ATAN_TAYLOR_SHIFT))
+    a, atan_a = atan_taylor_get_cached(n, prec)
+    d = x - a
+    s0 = v = (d << prec) // ((a**2 >> prec) + (a*d >> prec) + (MPZ_ONE << prec))
+    v2 = (v**2 >> prec)
+    v4 = (v2 * v2) >> prec
+    s1 = v//3
+    v = (v * v4) >> prec
+    k = 5
+    while v:
+        s0 += v // k
+        k += 2
+        s1 += v // k
+        v = (v * v4) >> prec
+        k += 2
+    s1 = (s1 * v2) >> prec
+    s = s0 - s1
+    return atan_a + s
+
+def atan_inf(sign, prec, rnd):
+    if not sign:
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    return mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+
+def mpf_atan(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fzero
+        if x == finf: return atan_inf(0, prec, rnd)
+        if x == fninf: return atan_inf(1, prec, rnd)
+        return fnan
+    mag = exp + bc
+    # Essentially infinity
+    if mag > prec+20:
+        return atan_inf(sign, prec, rnd)
+    # Essentially ~ x
+    if -mag > prec+20:
+        return mpf_perturb(x, 1-sign, prec, rnd)
+    wp = prec + 30 + abs(mag)
+    # For large x, use atan(x) = pi/2 - atan(1/x)
+    if mag >= 2:
+        x = mpf_rdiv_int(1, x, wp)
+        reciprocal = True
+    else:
+        reciprocal = False
+    t = to_fixed(x, wp)
+    if sign:
+        t = -t
+    if wp < ATAN_TAYLOR_PREC:
+        a = atan_taylor(t, wp)
+    else:
+        a = atan_newton(t, wp)
+    if reciprocal:
+        a = ((pi_fixed(wp)>>1)+1) - a
+    if sign:
+        a = -a
+    return from_man_exp(a, -wp, prec, rnd)
+
+# TODO: cleanup the special cases
+def mpf_atan2(y, x, prec, rnd=round_fast):
+    xsign, xman, xexp, xbc = x
+    ysign, yman, yexp, ybc = y
+    if not yman:
+        if y == fzero and x != fnan:
+            if mpf_sign(x) >= 0:
+                return fzero
+            return mpf_pi(prec, rnd)
+        if y in (finf, fninf):
+            if x in (finf, fninf):
+                return fnan
+            # pi/2
+            if y == finf:
+                return mpf_shift(mpf_pi(prec, rnd), -1)
+            # -pi/2
+            return mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+        return fnan
+    if ysign:
+        return mpf_neg(mpf_atan2(mpf_neg(y), x, prec, negative_rnd[rnd]))
+    if not xman:
+        if x == fnan:
+            return fnan
+        if x == finf:
+            return fzero
+        if x == fninf:
+            return mpf_pi(prec, rnd)
+        if y == fzero:
+            return fzero
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    tquo = mpf_atan(mpf_div(y, x, prec+4), prec+4)
+    if xsign:
+        return mpf_add(mpf_pi(prec+4), tquo, prec, rnd)
+    else:
+        return mpf_pos(tquo, prec, rnd)
+
+def mpf_asin(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if bc+exp > 0 and x not in (fone, fnone):
+        raise ComplexResult("asin(x) is real only for -1 <= x <= 1")
+    # asin(x) = 2*atan(x/(1+sqrt(1-x**2)))
+    wp = prec + 15
+    a = mpf_mul(x, x)
+    b = mpf_add(fone, mpf_sqrt(mpf_sub(fone, a, wp), wp), wp)
+    c = mpf_div(x, b, wp)
+    return mpf_shift(mpf_atan(c, prec, rnd), 1)
+
+def mpf_acos(x, prec, rnd=round_fast):
+    # acos(x) = 2*atan(sqrt(1-x**2)/(1+x))
+    sign, man, exp, bc = x
+    if bc + exp > 0:
+        if x not in (fone, fnone):
+            raise ComplexResult("acos(x) is real only for -1 <= x <= 1")
+        if x == fnone:
+            return mpf_pi(prec, rnd)
+    wp = prec + 15
+    a = mpf_mul(x, x)
+    b = mpf_sqrt(mpf_sub(fone, a, wp), wp)
+    c = mpf_div(b, mpf_add(fone, x, wp), wp)
+    return mpf_shift(mpf_atan(c, prec, rnd), 1)
+
+def mpf_asinh(x, prec, rnd=round_fast):
+    wp = prec + 20
+    sign, man, exp, bc = x
+    mag = exp+bc
+    if mag < -8:
+        if mag < -wp:
+            return mpf_perturb(x, 1-sign, prec, rnd)
+        wp += (-mag)
+    # asinh(x) = log(x+sqrt(x**2+1))
+    # use reflection symmetry to avoid cancellation
+    q = mpf_sqrt(mpf_add(mpf_mul(x, x), fone, wp), wp)
+    q = mpf_add(mpf_abs(x), q, wp)
+    if sign:
+        return mpf_neg(mpf_log(q, prec, negative_rnd[rnd]))
+    else:
+        return mpf_log(q, prec, rnd)
+
+def mpf_acosh(x, prec, rnd=round_fast):
+    # acosh(x) = log(x+sqrt(x**2-1))
+    wp = prec + 15
+    if mpf_cmp(x, fone) == -1:
+        raise ComplexResult("acosh(x) is real only for x >= 1")
+    q = mpf_sqrt(mpf_add(mpf_mul(x,x), fnone, wp), wp)
+    return mpf_log(mpf_add(x, q, wp), prec, rnd)
+
+def mpf_atanh(x, prec, rnd=round_fast):
+    # atanh(x) = log((1+x)/(1-x))/2
+    sign, man, exp, bc = x
+    if (not man) and exp:
+        if x in (fzero, fnan):
+            return x
+        raise ComplexResult("atanh(x) is real only for -1 <= x <= 1")
+    mag = bc + exp
+    if mag > 0:
+        if mag == 1 and man == 1:
+            return [finf, fninf][sign]
+        raise ComplexResult("atanh(x) is real only for -1 <= x <= 1")
+    wp = prec + 15
+    if mag < -8:
+        if mag < -wp:
+            return mpf_perturb(x, sign, prec, rnd)
+        wp += (-mag)
+    a = mpf_add(x, fone, wp)
+    b = mpf_sub(fone, x, wp)
+    return mpf_shift(mpf_log(mpf_div(a, b, wp), prec, rnd), -1)
+
+def mpf_fibonacci(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fninf:
+            return fnan
+        return x
+    # F(2^n) ~= 2^(2^n)
+    size = abs(exp+bc)
+    if exp >= 0:
+        # Exact
+        if size < 10 or size <= bitcount(prec):
+            return from_int(ifib(to_int(x)), prec, rnd)
+    # Use the modified Binet formula
+    wp = prec + size + 20
+    a = mpf_phi(wp)
+    b = mpf_add(mpf_shift(a, 1), fnone, wp)
+    u = mpf_pow(a, x, wp)
+    v = mpf_cos_pi(x, wp)
+    v = mpf_div(v, u, wp)
+    u = mpf_sub(u, v, wp)
+    u = mpf_div(u, b, prec, rnd)
+    return u
+
+
+#-------------------------------------------------------------------------------
+# Exponential-type functions
+#-------------------------------------------------------------------------------
+
+def exponential_series(x, prec, type=0):
+    """
+    Taylor series for cosh/sinh or cos/sin.
+
+    type = 0 -- returns exp(x)  (slightly faster than cosh+sinh)
+    type = 1 -- returns (cosh(x), sinh(x))
+    type = 2 -- returns (cos(x), sin(x))
+    """
+    if x < 0:
+        x = -x
+        sign = 1
+    else:
+        sign = 0
+    r = int(0.5*prec**0.5)
+    xmag = bitcount(x) - prec
+    r = max(0, xmag + r)
+    extra = 10 + 2*max(r,-xmag)
+    wp = prec + extra
+    x <<= (extra - r)
+    one = MPZ_ONE << wp
+    alt = (type == 2)
+    if prec < EXP_SERIES_U_CUTOFF:
+        x2 = a = (x*x) >> wp
+        x4 = (x2*x2) >> wp
+        s0 = s1 = MPZ_ZERO
+        k = 2
+        while a:
+            a //= (k-1)*k; s0 += a; k += 2
+            a //= (k-1)*k; s1 += a; k += 2
+            a = (a*x4) >> wp
+        s1 = (x2*s1) >> wp
+        if alt:
+            c = s1 - s0 + one
+        else:
+            c = s1 + s0 + one
+    else:
+        u = int(0.3*prec**0.35)
+        x2 = a = (x*x) >> wp
+        xpowers = [one, x2]
+        for i in xrange(1, u):
+            xpowers.append((xpowers[-1]*x2)>>wp)
+        sums = [MPZ_ZERO] * u
+        k = 2
+        while a:
+            for i in xrange(u):
+                a //= (k-1)*k
+                if alt and k & 2: sums[i] -= a
+                else:             sums[i] += a
+                k += 2
+            a = (a*xpowers[-1]) >> wp
+        for i in xrange(1, u):
+            sums[i] = (sums[i]*xpowers[i]) >> wp
+        c = sum(sums) + one
+    if type == 0:
+        s = isqrt_fast(c*c - (one<<wp))
+        if sign:
+            v = c - s
+        else:
+            v = c + s
+        for i in xrange(r):
+            v = (v*v) >> wp
+        return v >> extra
+    else:
+        # Repeatedly apply the double-angle formula
+        # cosh(2*x) = 2*cosh(x)^2 - 1
+        # cos(2*x) = 2*cos(x)^2 - 1
+        pshift = wp-1
+        for i in xrange(r):
+            c = ((c*c) >> pshift) - one
+        # With the abs, this is the same for sinh and sin
+        s = isqrt_fast(abs((one<<wp) - c*c))
+        if sign:
+            s = -s
+        return (c>>extra), (s>>extra)
+
+def exp_basecase(x, prec):
+    """
+    Compute exp(x) as a fixed-point number. Works for any x,
+    but for speed should have |x| < 1. For an arbitrary number,
+    use exp(x) = exp(x-m*log(2)) * 2^m where m = floor(x/log(2)).
+    """
+    if prec > EXP_COSH_CUTOFF:
+        return exponential_series(x, prec, 0)
+    r = int(prec**0.5)
+    prec += r
+    s0 = s1 = (MPZ_ONE << prec)
+    k = 2
+    a = x2 = (x*x) >> prec
+    while a:
+        a //= k; s0 += a; k += 1
+        a //= k; s1 += a; k += 1
+        a = (a*x2) >> prec
+    s1 = (s1*x) >> prec
+    s = s0 + s1
+    u = r
+    while r:
+        s = (s*s) >> prec
+        r -= 1
+    return s >> u
+
+def exp_expneg_basecase(x, prec):
+    """
+    Computation of exp(x), exp(-x)
+    """
+    if prec > EXP_COSH_CUTOFF:
+        cosh, sinh = exponential_series(x, prec, 1)
+        return cosh+sinh, cosh-sinh
+    a = exp_basecase(x, prec)
+    b = (MPZ_ONE << (prec+prec)) // a
+    return a, b
+
+def cos_sin_basecase(x, prec):
+    """
+    Compute cos(x), sin(x) as fixed-point numbers, assuming x
+    in [0, pi/2). For an arbitrary number, use x' = x - m*(pi/2)
+    where m = floor(x/(pi/2)) along with quarter-period symmetries.
+    """
+    if prec > COS_SIN_CACHE_PREC:
+        return exponential_series(x, prec, 2)
+    precs = prec - COS_SIN_CACHE_STEP
+    t = x >> precs
+    n = int(t)
+    if n not in cos_sin_cache:
+        w = t<<(10+COS_SIN_CACHE_PREC-COS_SIN_CACHE_STEP)
+        cos_t, sin_t = exponential_series(w, 10+COS_SIN_CACHE_PREC, 2)
+        cos_sin_cache[n] = (cos_t>>10), (sin_t>>10)
+    cos_t, sin_t = cos_sin_cache[n]
+    offset = COS_SIN_CACHE_PREC - prec
+    cos_t >>= offset
+    sin_t >>= offset
+    x -= t << precs
+    cos = MPZ_ONE << prec
+    sin = x
+    k = 2
+    a = -((x*x) >> prec)
+    while a:
+        a //= k; cos += a; k += 1; a = (a*x) >> prec
+        a //= k; sin += a; k += 1; a = -((a*x) >> prec)
+    return ((cos*cos_t-sin*sin_t) >> prec), ((sin*cos_t+cos*sin_t) >> prec)
+
+def mpf_exp(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if man:
+        mag = bc + exp
+        wp = prec + 14
+        if sign:
+            man = -man
+        # TODO: the best cutoff depends on both x and the precision.
+        if prec > 600 and exp >= 0:
+            # Need about log2(exp(n)) ~= 1.45*mag extra precision
+            e = mpf_e(wp+int(1.45*mag))
+            return mpf_pow_int(e, man<<exp, prec, rnd)
+        if mag < -wp:
+            return mpf_perturb(fone, sign, prec, rnd)
+        # |x| >= 2
+        if mag > 1:
+            # For large arguments: exp(2^mag*(1+eps)) =
+            # exp(2^mag)*exp(2^mag*eps) = exp(2^mag)*(1 + 2^mag*eps + ...)
+            # so about mag extra bits is required.
+            wpmod = wp + mag
+            offset = exp + wpmod
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            lg2 = ln2_fixed(wpmod)
+            n, t = divmod(t, lg2)
+            n = int(n)
+            t >>= mag
+        else:
+            offset = exp + wp
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            n = 0
+        man = exp_basecase(t, wp)
+        return from_man_exp(man, n-wp, prec, rnd)
+    if not exp:
+        return fone
+    if x == fninf:
+        return fzero
+    return x
+
+
+def mpf_cosh_sinh(x, prec, rnd=round_fast, tanh=0):
+    """Simultaneously compute (cosh(x), sinh(x)) for real x"""
+    sign, man, exp, bc = x
+    if (not man) and exp:
+        if tanh:
+            if x == finf: return fone
+            if x == fninf: return fnone
+            return fnan
+        if x == finf: return (finf, finf)
+        if x == fninf: return (finf, fninf)
+        return fnan, fnan
+    mag = exp+bc
+    wp = prec+14
+    if mag < -4:
+        # Extremely close to 0, sinh(x) ~= x and cosh(x) ~= 1
+        if mag < -wp:
+            if tanh:
+                return mpf_perturb(x, 1-sign, prec, rnd)
+            cosh = mpf_perturb(fone, 0, prec, rnd)
+            sinh = mpf_perturb(x, sign, prec, rnd)
+            return cosh, sinh
+        # Fix for cancellation when computing sinh
+        wp += (-mag)
+    # Does exp(-2*x) vanish?
+    if mag > 10:
+        if 3*(1<<(mag-1)) > wp:
+            # XXX: rounding
+            if tanh:
+                return mpf_perturb([fone,fnone][sign], 1-sign, prec, rnd)
+            c = s = mpf_shift(mpf_exp(mpf_abs(x), prec, rnd), -1)
+            if sign:
+                s = mpf_neg(s)
+            return c, s
+    # |x| > 1
+    if mag > 1:
+        wpmod = wp + mag
+        offset = exp + wpmod
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        lg2 = ln2_fixed(wpmod)
+        n, t = divmod(t, lg2)
+        n = int(n)
+        t >>= mag
+    else:
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        n = 0
+    a, b = exp_expneg_basecase(t, wp)
+    # TODO: optimize division precision
+    cosh = a + (b>>(2*n))
+    sinh = a - (b>>(2*n))
+    if sign:
+        sinh = -sinh
+    if tanh:
+        man = (sinh << wp) // cosh
+        return from_man_exp(man, -wp, prec, rnd)
+    else:
+        cosh = from_man_exp(cosh, n-wp-1, prec, rnd)
+        sinh = from_man_exp(sinh, n-wp-1, prec, rnd)
+        return cosh, sinh
+
+
+def mod_pi2(man, exp, mag, wp):
+    # Reduce to standard interval
+    if mag > 0:
+        i = 0
+        while 1:
+            cancellation_prec = 20 << i
+            wpmod = wp + mag + cancellation_prec
+            pi2 = pi_fixed(wpmod-1)
+            pi4 = pi2 >> 1
+            offset = wpmod + exp
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            n, y = divmod(t, pi2)
+            if y > pi4:
+                small = pi2 - y
+            else:
+                small = y
+            if small >> (wp+mag-10):
+                n = int(n)
+                t = y >> mag
+                wp = wpmod - mag
+                break
+            i += 1
+    else:
+        wp += (-mag)
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        n = 0
+    return t, n, wp
+
+
+def mpf_cos_sin(x, prec, rnd=round_fast, which=0, pi=False):
+    """
+    which:
+    0 -- return cos(x), sin(x)
+    1 -- return cos(x)
+    2 -- return sin(x)
+    3 -- return tan(x)
+
+    if pi=True, compute for pi*x
+    """
+    sign, man, exp, bc = x
+    if not man:
+        if exp:
+            c, s = fnan, fnan
+        else:
+            c, s = fone, fzero
+        if which == 0: return c, s
+        if which == 1: return c
+        if which == 2: return s
+        if which == 3: return s
+
+    mag = bc + exp
+    wp = prec + 10
+
+    # Extremely small?
+    if mag < 0:
+        if mag < -wp:
+            if pi:
+                x = mpf_mul(x, mpf_pi(wp))
+            c = mpf_perturb(fone, 1, prec, rnd)
+            s = mpf_perturb(x, 1-sign, prec, rnd)
+            if which == 0: return c, s
+            if which == 1: return c
+            if which == 2: return s
+            if which == 3: return mpf_perturb(x, sign, prec, rnd)
+    if pi:
+        if exp >= -1:
+            if exp == -1:
+                c = fzero
+                s = (fone, fnone)[bool(man & 2) ^ sign]
+            elif exp == 0:
+                c, s = (fnone, fzero)
+            else:
+                c, s = (fone, fzero)
+            if which == 0: return c, s
+            if which == 1: return c
+            if which == 2: return s
+            if which == 3: return mpf_div(s, c, prec, rnd)
+        # Subtract nearest half-integer (= mod by pi/2)
+        n = ((man >> (-exp-2)) + 1) >> 1
+        man = man - (n << (-exp-1))
+        mag2 = bitcount(man) + exp
+        wp = prec + 10 - mag2
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        t = (t*pi_fixed(wp)) >> wp
+    else:
+        t, n, wp = mod_pi2(man, exp, mag, wp)
+    c, s = cos_sin_basecase(t, wp)
+    m = n & 3
+    if   m == 1: c, s = -s, c
+    elif m == 2: c, s = -c, -s
+    elif m == 3: c, s = s, -c
+    if sign:
+        s = -s
+    if which == 0:
+        c = from_man_exp(c, -wp, prec, rnd)
+        s = from_man_exp(s, -wp, prec, rnd)
+        return c, s
+    if which == 1:
+        return from_man_exp(c, -wp, prec, rnd)
+    if which == 2:
+        return from_man_exp(s, -wp, prec, rnd)
+    if which == 3:
+        return from_rational(s, c, prec, rnd)
+
+def mpf_cos(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 1)
+def mpf_sin(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 2)
+def mpf_tan(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 3)
+def mpf_cos_sin_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 0, 1)
+def mpf_cos_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 1, 1)
+def mpf_sin_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 2, 1)
+def mpf_cosh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd)[0]
+def mpf_sinh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd)[1]
+def mpf_tanh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd, tanh=1)
+
+
+# Low-overhead fixed-point versions
+
+def cos_sin_fixed(x, prec, pi2=None):
+    if pi2 is None:
+        pi2 = pi_fixed(prec-1)
+    n, t = divmod(x, pi2)
+    n = int(n)
+    c, s = cos_sin_basecase(t, prec)
+    m = n & 3
+    if m == 0: return c, s
+    if m == 1: return -s, c
+    if m == 2: return -c, -s
+    if m == 3: return s, -c
+
+def exp_fixed(x, prec, ln2=None):
+    if ln2 is None:
+        ln2 = ln2_fixed(prec)
+    n, t = divmod(x, ln2)
+    n = int(n)
+    v = exp_basecase(t, prec)
+    if n >= 0:
+        return v << n
+    else:
+        return v >> (-n)
+
+
+if BACKEND == 'sage':
+    try:
+        import sage.libs.mpmath.ext_libmp as _lbmp
+        mpf_sqrt = _lbmp.mpf_sqrt
+        mpf_exp = _lbmp.mpf_exp
+        mpf_log = _lbmp.mpf_log
+        mpf_cos = _lbmp.mpf_cos
+        mpf_sin = _lbmp.mpf_sin
+        mpf_pow = _lbmp.mpf_pow
+        exp_fixed = _lbmp.exp_fixed
+        cos_sin_fixed = _lbmp.cos_sin_fixed
+        log_int_fixed = _lbmp.log_int_fixed
+    except (ImportError, AttributeError):
+        print("Warning: Sage imports in libelefun failed")
diff --git a/lib/python3.11/site-packages/mpmath/libmp/libhyper.py b/lib/python3.11/site-packages/mpmath/libmp/libhyper.py
new file mode 100644
index 0000000000000000000000000000000000000000..04f52d59710be77819066aea5c1cf4b0883f72d7
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/libhyper.py
@@ -0,0 +1,1150 @@
+"""
+This module implements computation of hypergeometric and related
+functions. In particular, it provides code for generic summation
+of hypergeometric series. Optimized versions for various special
+cases are also provided.
+"""
+
+import operator
+import math
+
+from .backend import MPZ_ZERO, MPZ_ONE, BACKEND, xrange, exec_
+
+from .libintmath import gcd
+
+from .libmpf import (\
+    ComplexResult, round_fast, round_nearest,
+    negative_rnd, bitcount, to_fixed, from_man_exp, from_int, to_int,
+    from_rational,
+    fzero, fone, fnone, ftwo, finf, fninf, fnan,
+    mpf_sign, mpf_add, mpf_abs, mpf_pos,
+    mpf_cmp, mpf_lt, mpf_le, mpf_gt, mpf_min_max,
+    mpf_perturb, mpf_neg, mpf_shift, mpf_sub, mpf_mul, mpf_div,
+    sqrt_fixed, mpf_sqrt, mpf_rdiv_int, mpf_pow_int,
+    to_rational,
+)
+
+from .libelefun import (\
+    mpf_pi, mpf_exp, mpf_log, pi_fixed, mpf_cos_sin, mpf_cos, mpf_sin,
+    mpf_sqrt, agm_fixed,
+)
+
+from .libmpc import (\
+    mpc_one, mpc_sub, mpc_mul_mpf, mpc_mul, mpc_neg, complex_int_pow,
+    mpc_div, mpc_add_mpf, mpc_sub_mpf,
+    mpc_log, mpc_add, mpc_pos, mpc_shift,
+    mpc_is_infnan, mpc_zero, mpc_sqrt, mpc_abs,
+    mpc_mpf_div, mpc_square, mpc_exp
+)
+
+from .libintmath import ifac
+from .gammazeta import mpf_gamma_int, mpf_euler, euler_fixed
+
+class NoConvergence(Exception):
+    pass
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                     Generic hypergeometric series                     #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+"""
+TODO:
+
+1. proper mpq parsing
+2. imaginary z special-cased (also: rational, integer?)
+3. more clever handling of series that don't converge because of stupid
+   upwards rounding
+4. checking for cancellation
+
+"""
+
+def make_hyp_summator(key):
+    """
+    Returns a function that sums a generalized hypergeometric series,
+    for given parameter types (integer, rational, real, complex).
+
+    """
+    p, q, param_types, ztype = key
+
+    pstring = "".join(param_types)
+    fname = "hypsum_%i_%i_%s_%s_%s" % (p, q, pstring[:p], pstring[p:], ztype)
+    #print "generating hypsum", fname
+
+    have_complex_param = 'C' in param_types
+    have_complex_arg = ztype == 'C'
+    have_complex = have_complex_param or have_complex_arg
+
+    source = []
+    add = source.append
+
+    aint = []
+    arat = []
+    bint = []
+    brat = []
+    areal = []
+    breal = []
+    acomplex = []
+    bcomplex = []
+
+    #add("wp = prec + 40")
+    add("MAX = kwargs.get('maxterms', wp*100)")
+    add("HIGH = MPZ_ONE<<epsshift")
+    add("LOW = -HIGH")
+
+    # Setup code
+    add("SRE = PRE = one = (MPZ_ONE << wp)")
+    if have_complex:
+        add("SIM = PIM = MPZ_ZERO")
+
+    if have_complex_arg:
+        add("xsign, xm, xe, xbc = z[0]")
+        add("if xsign: xm = -xm")
+        add("ysign, ym, ye, ybc = z[1]")
+        add("if ysign: ym = -ym")
+    else:
+        add("xsign, xm, xe, xbc = z")
+        add("if xsign: xm = -xm")
+
+    add("offset = xe + wp")
+    add("if offset >= 0:")
+    add("    ZRE = xm << offset")
+    add("else:")
+    add("    ZRE = xm >> (-offset)")
+    if have_complex_arg:
+        add("offset = ye + wp")
+        add("if offset >= 0:")
+        add("    ZIM = ym << offset")
+        add("else:")
+        add("    ZIM = ym >> (-offset)")
+
+    for i, flag in enumerate(param_types):
+        W = ["A", "B"][i >= p]
+        if flag == 'Z':
+            ([aint,bint][i >= p]).append(i)
+            add("%sINT_%i = coeffs[%i]" % (W, i, i))
+        elif flag == 'Q':
+            ([arat,brat][i >= p]).append(i)
+            add("%sP_%i, %sQ_%i = coeffs[%i]._mpq_" % (W, i, W, i, i))
+        elif flag == 'R':
+            ([areal,breal][i >= p]).append(i)
+            add("xsign, xm, xe, xbc = coeffs[%i]._mpf_" % i)
+            add("if xsign: xm = -xm")
+            add("offset = xe + wp")
+            add("if offset >= 0:")
+            add("    %sREAL_%i = xm << offset" % (W, i))
+            add("else:")
+            add("    %sREAL_%i = xm >> (-offset)" % (W, i))
+        elif flag == 'C':
+            ([acomplex,bcomplex][i >= p]).append(i)
+            add("__re, __im = coeffs[%i]._mpc_" % i)
+            add("xsign, xm, xe, xbc = __re")
+            add("if xsign: xm = -xm")
+            add("ysign, ym, ye, ybc = __im")
+            add("if ysign: ym = -ym")
+
+            add("offset = xe + wp")
+            add("if offset >= 0:")
+            add("    %sCRE_%i = xm << offset" % (W, i))
+            add("else:")
+            add("    %sCRE_%i = xm >> (-offset)" % (W, i))
+            add("offset = ye + wp")
+            add("if offset >= 0:")
+            add("    %sCIM_%i = ym << offset" % (W, i))
+            add("else:")
+            add("    %sCIM_%i = ym >> (-offset)" % (W, i))
+        else:
+            raise ValueError
+
+    l_areal = len(areal)
+    l_breal = len(breal)
+    cancellable_real = min(l_areal, l_breal)
+    noncancellable_real_num = areal[cancellable_real:]
+    noncancellable_real_den = breal[cancellable_real:]
+
+    # LOOP
+    add("for n in xrange(1,10**8):")
+
+    add("    if n in magnitude_check:")
+    add("        p_mag = bitcount(abs(PRE))")
+    if have_complex:
+        add("        p_mag = max(p_mag, bitcount(abs(PIM)))")
+    add("        magnitude_check[n] = wp-p_mag")
+
+    # Real factors
+    multiplier = " * ".join(["AINT_#".replace("#", str(i)) for i in aint] + \
+                            ["AP_#".replace("#", str(i)) for i in arat] + \
+                            ["BQ_#".replace("#", str(i)) for i in brat])
+
+    divisor    = " * ".join(["BINT_#".replace("#", str(i)) for i in bint] + \
+                            ["BP_#".replace("#", str(i)) for i in brat] + \
+                            ["AQ_#".replace("#", str(i)) for i in arat] + ["n"])
+
+    if multiplier:
+        add("    mul = " + multiplier)
+    add("    div = " + divisor)
+
+    # Check for singular terms
+    add("    if not div:")
+    if multiplier:
+        add("        if not mul:")
+        add("            break")
+    add("        raise ZeroDivisionError")
+
+    # Update product
+    if have_complex:
+
+        # TODO: when there are several real parameters and just a few complex
+        # (maybe just the complex argument), we only need to do about
+        # half as many ops if we accumulate the real factor in a single real variable
+        for k in range(cancellable_real): add("    PRE = PRE * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PRE = (PRE * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PRE = (PRE << wp) // BREAL_#".replace("#", str(i)))
+        for k in range(cancellable_real): add("    PIM = PIM * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PIM = (PIM * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PIM = (PIM << wp) // BREAL_#".replace("#", str(i)))
+
+        if multiplier:
+            if have_complex_arg:
+                add("    PRE, PIM = (mul*(PRE*ZRE-PIM*ZIM))//div, (mul*(PIM*ZRE+PRE*ZIM))//div")
+                add("    PRE >>= wp")
+                add("    PIM >>= wp")
+            else:
+                add("    PRE = ((mul * PRE * ZRE) >> wp) // div")
+                add("    PIM = ((mul * PIM * ZRE) >> wp) // div")
+        else:
+            if have_complex_arg:
+                add("    PRE, PIM = (PRE*ZRE-PIM*ZIM)//div, (PIM*ZRE+PRE*ZIM)//div")
+                add("    PRE >>= wp")
+                add("    PIM >>= wp")
+            else:
+                add("    PRE = ((PRE * ZRE) >> wp) // div")
+                add("    PIM = ((PIM * ZRE) >> wp) // div")
+
+        for i in acomplex:
+            add("    PRE, PIM = PRE*ACRE_#-PIM*ACIM_#, PIM*ACRE_#+PRE*ACIM_#".replace("#", str(i)))
+            add("    PRE >>= wp")
+            add("    PIM >>= wp")
+
+        for i in bcomplex:
+            add("    mag = BCRE_#*BCRE_#+BCIM_#*BCIM_#".replace("#", str(i)))
+            add("    re = PRE*BCRE_# + PIM*BCIM_#".replace("#", str(i)))
+            add("    im = PIM*BCRE_# - PRE*BCIM_#".replace("#", str(i)))
+            add("    PRE = (re << wp) // mag".replace("#", str(i)))
+            add("    PIM = (im << wp) // mag".replace("#", str(i)))
+
+    else:
+        for k in range(cancellable_real): add("    PRE = PRE * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PRE = (PRE * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PRE = (PRE << wp) // BREAL_#".replace("#", str(i)))
+        if multiplier:
+            add("    PRE = ((PRE * mul * ZRE) >> wp) // div")
+        else:
+            add("    PRE = ((PRE * ZRE) >> wp) // div")
+
+    # Add product to sum
+    if have_complex:
+        add("    SRE += PRE")
+        add("    SIM += PIM")
+        add("    if (HIGH > PRE > LOW) and (HIGH > PIM > LOW):")
+        add("        break")
+    else:
+        add("    SRE += PRE")
+        add("    if HIGH > PRE > LOW:")
+        add("        break")
+
+    #add("    from mpmath import nprint, log, ldexp")
+    #add("    nprint([n, log(abs(PRE),2), ldexp(PRE,-wp)])")
+
+    add("    if n > MAX:")
+    add("        raise NoConvergence('Hypergeometric series converges too slowly. Try increasing maxterms.')")
+
+    # +1 all parameters for next loop
+    for i in aint:     add("    AINT_# += 1".replace("#", str(i)))
+    for i in bint:     add("    BINT_# += 1".replace("#", str(i)))
+    for i in arat:     add("    AP_# += AQ_#".replace("#", str(i)))
+    for i in brat:     add("    BP_# += BQ_#".replace("#", str(i)))
+    for i in areal:    add("    AREAL_# += one".replace("#", str(i)))
+    for i in breal:    add("    BREAL_# += one".replace("#", str(i)))
+    for i in acomplex: add("    ACRE_# += one".replace("#", str(i)))
+    for i in bcomplex: add("    BCRE_# += one".replace("#", str(i)))
+
+    if have_complex:
+        add("a = from_man_exp(SRE, -wp, prec, 'n')")
+        add("b = from_man_exp(SIM, -wp, prec, 'n')")
+
+        add("if SRE:")
+        add("    if SIM:")
+        add("        magn = max(a[2]+a[3], b[2]+b[3])")
+        add("    else:")
+        add("        magn = a[2]+a[3]")
+        add("elif SIM:")
+        add("    magn = b[2]+b[3]")
+        add("else:")
+        add("    magn = -wp+1")
+
+        add("return (a, b), True, magn")
+    else:
+        add("a = from_man_exp(SRE, -wp, prec, 'n')")
+
+        add("if SRE:")
+        add("    magn = a[2]+a[3]")
+        add("else:")
+        add("    magn = -wp+1")
+
+        add("return a, False, magn")
+
+    source = "\n".join(("    " + line) for line in source)
+    source = ("def %s(coeffs, z, prec, wp, epsshift, magnitude_check, **kwargs):\n" % fname) + source
+
+    namespace = {}
+
+    exec_(source, globals(), namespace)
+
+    #print source
+    return source, namespace[fname]
+
+
+if BACKEND == 'sage':
+
+    def make_hyp_summator(key):
+        """
+        Returns a function that sums a generalized hypergeometric series,
+        for given parameter types (integer, rational, real, complex).
+        """
+        from sage.libs.mpmath.ext_main import hypsum_internal
+        p, q, param_types, ztype = key
+        def _hypsum(coeffs, z, prec, wp, epsshift, magnitude_check, **kwargs):
+            return hypsum_internal(p, q, param_types, ztype, coeffs, z,
+                prec, wp, epsshift, magnitude_check, kwargs)
+
+        return "(none)", _hypsum
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                              Error functions                          #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# TODO: mpf_erf should call mpf_erfc when appropriate (currently
+#    only the converse delegation is implemented)
+
+def mpf_erf(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fzero
+        if x == finf: return fone
+        if x== fninf: return fnone
+        return fnan
+    size = exp + bc
+    lg = math.log
+    # The approximation erf(x) = 1 is accurate to > x^2 * log(e,2) bits
+    if size > 3 and 2*(size-1) + 0.528766 > lg(prec,2):
+        if sign:
+            return mpf_perturb(fnone, 0, prec, rnd)
+        else:
+            return mpf_perturb(fone, 1, prec, rnd)
+    # erf(x) ~ 2*x/sqrt(pi) close to 0
+    if size < -prec:
+        # 2*x
+        x = mpf_shift(x,1)
+        c = mpf_sqrt(mpf_pi(prec+20), prec+20)
+        # TODO: interval rounding
+        return mpf_div(x, c, prec, rnd)
+    wp = prec + abs(size) + 25
+    # Taylor series for erf, fixed-point summation
+    t = abs(to_fixed(x, wp))
+    t2 = (t*t) >> wp
+    s, term, k = t, 12345, 1
+    while term:
+        t = ((t * t2) >> wp) // k
+        term = t // (2*k+1)
+        if k & 1:
+            s -= term
+        else:
+            s += term
+        k += 1
+    s = (s << (wp+1)) // sqrt_fixed(pi_fixed(wp), wp)
+    if sign:
+        s = -s
+    return from_man_exp(s, -wp, prec, rnd)
+
+# If possible, we use the asymptotic series for erfc.
+# This is an alternating divergent asymptotic series, so
+# the error is at most equal to the first omitted term.
+# Here we check if the smallest term is small enough
+# for a given x and precision
+def erfc_check_series(x, prec):
+    n = to_int(x)
+    if n**2 * 1.44 > prec:
+        return True
+    return False
+
+def mpf_erfc(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fone
+        if x == finf: return fzero
+        if x == fninf: return ftwo
+        return fnan
+    wp = prec + 20
+    mag = bc+exp
+    # Preserve full accuracy when exponent grows huge
+    wp += max(0, 2*mag)
+    regular_erf = sign or mag < 2
+    if regular_erf or not erfc_check_series(x, wp):
+        if regular_erf:
+            return mpf_sub(fone, mpf_erf(x, prec+10, negative_rnd[rnd]), prec, rnd)
+        # 1-erf(x) ~ exp(-x^2), increase prec to deal with cancellation
+        n = to_int(x)+1
+        return mpf_sub(fone, mpf_erf(x, prec + int(n**2*1.44) + 10), prec, rnd)
+    s = term = MPZ_ONE << wp
+    term_prev = 0
+    t = (2 * to_fixed(x, wp) ** 2) >> wp
+    k = 1
+    while 1:
+        term = ((term * (2*k - 1)) << wp) // t
+        if k > 4 and term > term_prev or not term:
+            break
+        if k & 1:
+            s -= term
+        else:
+            s += term
+        term_prev = term
+        #print k, to_str(from_man_exp(term, -wp, 50), 10)
+        k += 1
+    s = (s << wp) // sqrt_fixed(pi_fixed(wp), wp)
+    s = from_man_exp(s, -wp, wp)
+    z = mpf_exp(mpf_neg(mpf_mul(x,x,wp),wp),wp)
+    y = mpf_div(mpf_mul(z, s, wp), x, prec, rnd)
+    return y
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                         Exponential integrals                         #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+def ei_taylor(x, prec):
+    s = t = x
+    k = 2
+    while t:
+        t = ((t*x) >> prec) // k
+        s += t // k
+        k += 1
+    return s
+
+def complex_ei_taylor(zre, zim, prec):
+    _abs = abs
+    sre = tre = zre
+    sim = tim = zim
+    k = 2
+    while _abs(tre) + _abs(tim) > 5:
+        tre, tim = ((tre*zre-tim*zim)//k)>>prec, ((tre*zim+tim*zre)//k)>>prec
+        sre += tre // k
+        sim += tim // k
+        k += 1
+    return sre, sim
+
+def ei_asymptotic(x, prec):
+    one = MPZ_ONE << prec
+    x = t = ((one << prec) // x)
+    s = one + x
+    k = 2
+    while t:
+        t = (k*t*x) >> prec
+        s += t
+        k += 1
+    return s
+
+def complex_ei_asymptotic(zre, zim, prec):
+    _abs = abs
+    one = MPZ_ONE << prec
+    M = (zim*zim + zre*zre) >> prec
+    # 1 / z
+    xre = tre = (zre << prec) // M
+    xim = tim = ((-zim) << prec) // M
+    sre = one + xre
+    sim = xim
+    k = 2
+    while _abs(tre) + _abs(tim) > 1000:
+        #print tre, tim
+        tre, tim = ((tre*xre-tim*xim)*k)>>prec, ((tre*xim+tim*xre)*k)>>prec
+        sre += tre
+        sim += tim
+        k += 1
+        if k > prec:
+            raise NoConvergence
+    return sre, sim
+
+def mpf_ei(x, prec, rnd=round_fast, e1=False):
+    if e1:
+        x = mpf_neg(x)
+    sign, man, exp, bc = x
+    if e1 and not sign:
+        if x == fzero:
+            return finf
+        raise ComplexResult("E1(x) for x < 0")
+    if man:
+        xabs = 0, man, exp, bc
+        xmag = exp+bc
+        wp = prec + 20
+        can_use_asymp = xmag > wp
+        if not can_use_asymp:
+            if exp >= 0:
+                xabsint = man << exp
+            else:
+                xabsint = man >> (-exp)
+            can_use_asymp = xabsint > int(wp*0.693) + 10
+        if can_use_asymp:
+            if xmag > wp:
+                v = fone
+            else:
+                v = from_man_exp(ei_asymptotic(to_fixed(x, wp), wp), -wp)
+            v = mpf_mul(v, mpf_exp(x, wp), wp)
+            v = mpf_div(v, x, prec, rnd)
+        else:
+            wp += 2*int(to_int(xabs))
+            u = to_fixed(x, wp)
+            v = ei_taylor(u, wp) + euler_fixed(wp)
+            t1 = from_man_exp(v,-wp)
+            t2 = mpf_log(xabs,wp)
+            v = mpf_add(t1, t2, prec, rnd)
+    else:
+        if x == fzero: v = fninf
+        elif x == finf: v = finf
+        elif x == fninf: v = fzero
+        else: v = fnan
+    if e1:
+        v = mpf_neg(v)
+    return v
+
+def mpc_ei(z, prec, rnd=round_fast, e1=False):
+    if e1:
+        z = mpc_neg(z)
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if b == fzero:
+        if e1:
+            x = mpf_neg(mpf_ei(a, prec, rnd))
+            if not asign:
+                y = mpf_neg(mpf_pi(prec, rnd))
+            else:
+                y = fzero
+            return x, y
+        else:
+            return mpf_ei(a, prec, rnd), fzero
+    if a != fzero:
+        if not aman or not bman:
+            return (fnan, fnan)
+    wp = prec + 40
+    amag = aexp+abc
+    bmag = bexp+bbc
+    zmag = max(amag, bmag)
+    can_use_asymp = zmag > wp
+    if not can_use_asymp:
+        zabsint = abs(to_int(a)) + abs(to_int(b))
+        can_use_asymp = zabsint > int(wp*0.693) + 20
+    try:
+        if can_use_asymp:
+            if zmag > wp:
+                v = fone, fzero
+            else:
+                zre = to_fixed(a, wp)
+                zim = to_fixed(b, wp)
+                vre, vim = complex_ei_asymptotic(zre, zim, wp)
+                v = from_man_exp(vre, -wp), from_man_exp(vim, -wp)
+            v = mpc_mul(v, mpc_exp(z, wp), wp)
+            v = mpc_div(v, z, wp)
+            if e1:
+                v = mpc_neg(v, prec, rnd)
+            else:
+                x, y = v
+                if bsign:
+                    v = mpf_pos(x, prec, rnd), mpf_sub(y, mpf_pi(wp), prec, rnd)
+                else:
+                    v = mpf_pos(x, prec, rnd), mpf_add(y, mpf_pi(wp), prec, rnd)
+            return v
+    except NoConvergence:
+        pass
+    #wp += 2*max(0,zmag)
+    wp += 2*int(to_int(mpc_abs(z, 5)))
+    zre = to_fixed(a, wp)
+    zim = to_fixed(b, wp)
+    vre, vim = complex_ei_taylor(zre, zim, wp)
+    vre += euler_fixed(wp)
+    v = from_man_exp(vre,-wp), from_man_exp(vim,-wp)
+    if e1:
+        u = mpc_log(mpc_neg(z),wp)
+    else:
+        u = mpc_log(z,wp)
+    v = mpc_add(v, u, prec, rnd)
+    if e1:
+        v = mpc_neg(v)
+    return v
+
+def mpf_e1(x, prec, rnd=round_fast):
+    return mpf_ei(x, prec, rnd, True)
+
+def mpc_e1(x, prec, rnd=round_fast):
+    return mpc_ei(x, prec, rnd, True)
+
+def mpf_expint(n, x, prec, rnd=round_fast, gamma=False):
+    """
+    E_n(x), n an integer, x real
+
+    With gamma=True, computes Gamma(n,x)   (upper incomplete gamma function)
+
+    Returns (real, None) if real, otherwise (real, imag)
+    The imaginary part is an optional branch cut term
+
+    """
+    sign, man, exp, bc = x
+    if not man:
+        if gamma:
+            if x == fzero:
+                # Actually gamma function pole
+                if n <= 0:
+                    return finf, None
+                return mpf_gamma_int(n, prec, rnd), None
+            if x == finf:
+                return fzero, None
+            # TODO: could return finite imaginary value at -inf
+            return fnan, fnan
+        else:
+            if x == fzero:
+                if n > 1:
+                    return from_rational(1, n-1, prec, rnd), None
+                else:
+                    return finf, None
+            if x == finf:
+                return fzero, None
+            return fnan, fnan
+    n_orig = n
+    if gamma:
+        n = 1-n
+    wp = prec + 20
+    xmag = exp + bc
+    # Beware of near-poles
+    if xmag < -10:
+        raise NotImplementedError
+    nmag = bitcount(abs(n))
+    have_imag = n > 0 and sign
+    negx = mpf_neg(x)
+    # Skip series if direct convergence
+    if n == 0 or 2*nmag - xmag < -wp:
+        if gamma:
+            v = mpf_exp(negx, wp)
+            re = mpf_mul(v, mpf_pow_int(x, n_orig-1, wp), prec, rnd)
+        else:
+            v = mpf_exp(negx, wp)
+            re = mpf_div(v, x, prec, rnd)
+    else:
+        # Finite number of terms, or...
+        can_use_asymptotic_series = -3*wp < n <= 0
+        # ...large enough?
+        if not can_use_asymptotic_series:
+            xi = abs(to_int(x))
+            m = min(max(1, xi-n), 2*wp)
+            siz = -n*nmag + (m+n)*bitcount(abs(m+n)) - m*xmag - (144*m//100)
+            tol = -wp-10
+            can_use_asymptotic_series = siz < tol
+        if can_use_asymptotic_series:
+            r = ((-MPZ_ONE) << (wp+wp)) // to_fixed(x, wp)
+            m = n
+            t = r*m
+            s = MPZ_ONE << wp
+            while m and t:
+                s += t
+                m += 1
+                t = (m*r*t) >> wp
+            v = mpf_exp(negx, wp)
+            if gamma:
+                # ~ exp(-x) * x^(n-1) * (1 + ...)
+                v = mpf_mul(v, mpf_pow_int(x, n_orig-1, wp), wp)
+            else:
+                # ~ exp(-x)/x * (1 + ...)
+                v = mpf_div(v, x, wp)
+            re = mpf_mul(v, from_man_exp(s, -wp), prec, rnd)
+        elif n == 1:
+            re = mpf_neg(mpf_ei(negx, prec, rnd))
+        elif n > 0 and n < 3*wp:
+            T1 = mpf_neg(mpf_ei(negx, wp))
+            if gamma:
+                if n_orig & 1:
+                    T1 = mpf_neg(T1)
+            else:
+                T1 = mpf_mul(T1, mpf_pow_int(negx, n-1, wp), wp)
+            r = t = to_fixed(x, wp)
+            facs = [1] * (n-1)
+            for k in range(1,n-1):
+                facs[k] = facs[k-1] * k
+            facs = facs[::-1]
+            s = facs[0] << wp
+            for k in range(1, n-1):
+                if k & 1:
+                    s -= facs[k] * t
+                else:
+                    s += facs[k] * t
+                t = (t*r) >> wp
+            T2 = from_man_exp(s, -wp, wp)
+            T2 = mpf_mul(T2, mpf_exp(negx, wp))
+            if gamma:
+                T2 = mpf_mul(T2, mpf_pow_int(x, n_orig, wp), wp)
+            R = mpf_add(T1, T2)
+            re = mpf_div(R, from_int(ifac(n-1)), prec, rnd)
+        else:
+            raise NotImplementedError
+    if have_imag:
+        M = from_int(-ifac(n-1))
+        if gamma:
+            im = mpf_div(mpf_pi(wp), M, prec, rnd)
+            if n_orig & 1:
+                im = mpf_neg(im)
+        else:
+            im = mpf_div(mpf_mul(mpf_pi(wp), mpf_pow_int(negx, n_orig-1, wp), wp), M, prec, rnd)
+        return re, im
+    else:
+        return re, None
+
+def mpf_ci_si_taylor(x, wp, which=0):
+    """
+    0 - Ci(x) - (euler+log(x))
+    1 - Si(x)
+    """
+    x = to_fixed(x, wp)
+    x2 = -(x*x) >> wp
+    if which == 0:
+        s, t, k = 0, (MPZ_ONE<<wp), 2
+    else:
+        s, t, k = x, x, 3
+    while t:
+        t = (t*x2//(k*(k-1)))>>wp
+        s += t//k
+        k += 2
+    return from_man_exp(s, -wp)
+
+def mpc_ci_si_taylor(re, im, wp, which=0):
+    # The following code is only designed for small arguments,
+    # and not too small arguments (for relative accuracy)
+    if re[1]:
+        mag = re[2]+re[3]
+    elif im[1]:
+        mag = im[2]+im[3]
+    if im[1]:
+        mag = max(mag, im[2]+im[3])
+    if mag > 2 or mag < -wp:
+        raise NotImplementedError
+    wp += (2-mag)
+    zre = to_fixed(re, wp)
+    zim = to_fixed(im, wp)
+    z2re = (zim*zim-zre*zre)>>wp
+    z2im = (-2*zre*zim)>>wp
+    tre = zre
+    tim = zim
+    one = MPZ_ONE<<wp
+    if which == 0:
+        sre, sim, tre, tim, k = 0, 0, (MPZ_ONE<<wp), 0, 2
+    else:
+        sre, sim, tre, tim, k = zre, zim, zre, zim, 3
+    while max(abs(tre), abs(tim)) > 2:
+        f = k*(k-1)
+        tre, tim = ((tre*z2re-tim*z2im)//f)>>wp, ((tre*z2im+tim*z2re)//f)>>wp
+        sre += tre//k
+        sim += tim//k
+        k += 2
+    return from_man_exp(sre, -wp), from_man_exp(sim, -wp)
+
+def mpf_ci_si(x, prec, rnd=round_fast, which=2):
+    """
+    Calculation of Ci(x), Si(x) for real x.
+
+    which = 0 -- returns (Ci(x), -)
+    which = 1 -- returns (Si(x), -)
+    which = 2 -- returns (Ci(x), Si(x))
+
+    Note: if x < 0, Ci(x) needs an additional imaginary term, pi*i.
+    """
+    wp = prec + 20
+    sign, man, exp, bc = x
+    ci, si = None, None
+    if not man:
+        if x == fzero:
+            return (fninf, fzero)
+        if x == fnan:
+            return (x, x)
+        ci = fzero
+        if which != 0:
+            if x == finf:
+                si = mpf_shift(mpf_pi(prec, rnd), -1)
+            if x == fninf:
+                si = mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+        return (ci, si)
+    # For small x: Ci(x) ~ euler + log(x), Si(x) ~ x
+    mag = exp+bc
+    if mag < -wp:
+        if which != 0:
+            si = mpf_perturb(x, 1-sign, prec, rnd)
+        if which != 1:
+            y = mpf_euler(wp)
+            xabs = mpf_abs(x)
+            ci = mpf_add(y, mpf_log(xabs, wp), prec, rnd)
+        return ci, si
+    # For huge x: Ci(x) ~ sin(x)/x, Si(x) ~ pi/2
+    elif mag > wp:
+        if which != 0:
+            if sign:
+                si = mpf_neg(mpf_pi(prec, negative_rnd[rnd]))
+            else:
+                si = mpf_pi(prec, rnd)
+            si = mpf_shift(si, -1)
+        if which != 1:
+            ci = mpf_div(mpf_sin(x, wp), x, prec, rnd)
+        return ci, si
+    else:
+        wp += abs(mag)
+    # Use an asymptotic series? The smallest value of n!/x^n
+    # occurs for n ~ x, where the magnitude is ~ exp(-x).
+    asymptotic = mag-1 > math.log(wp, 2)
+    # Case 1: convergent series near 0
+    if not asymptotic:
+        if which != 0:
+            si = mpf_pos(mpf_ci_si_taylor(x, wp, 1), prec, rnd)
+        if which != 1:
+            ci = mpf_ci_si_taylor(x, wp, 0)
+            ci = mpf_add(ci, mpf_euler(wp), wp)
+            ci = mpf_add(ci, mpf_log(mpf_abs(x), wp), prec, rnd)
+        return ci, si
+    x = mpf_abs(x)
+    # Case 2: asymptotic series for x >> 1
+    xf = to_fixed(x, wp)
+    xr = (MPZ_ONE<<(2*wp)) // xf   # 1/x
+    s1 = (MPZ_ONE << wp)
+    s2 = xr
+    t = xr
+    k = 2
+    while t:
+        t = -t
+        t = (t*xr*k)>>wp
+        k += 1
+        s1 += t
+        t = (t*xr*k)>>wp
+        k += 1
+        s2 += t
+    s1 = from_man_exp(s1, -wp)
+    s2 = from_man_exp(s2, -wp)
+    s1 = mpf_div(s1, x, wp)
+    s2 = mpf_div(s2, x, wp)
+    cos, sin = mpf_cos_sin(x, wp)
+    # Ci(x) = sin(x)*s1-cos(x)*s2
+    # Si(x) = pi/2-cos(x)*s1-sin(x)*s2
+    if which != 0:
+        si = mpf_add(mpf_mul(cos, s1), mpf_mul(sin, s2), wp)
+        si = mpf_sub(mpf_shift(mpf_pi(wp), -1), si, wp)
+        if sign:
+            si = mpf_neg(si)
+        si = mpf_pos(si, prec, rnd)
+    if which != 1:
+        ci = mpf_sub(mpf_mul(sin, s1), mpf_mul(cos, s2), prec, rnd)
+    return ci, si
+
+def mpf_ci(x, prec, rnd=round_fast):
+    if mpf_sign(x) < 0:
+        raise ComplexResult
+    return mpf_ci_si(x, prec, rnd, 0)[0]
+
+def mpf_si(x, prec, rnd=round_fast):
+    return mpf_ci_si(x, prec, rnd, 1)[1]
+
+def mpc_ci(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        ci = mpf_ci_si(re, prec, rnd, 0)[0]
+        if mpf_sign(re) < 0:
+            return (ci, mpf_pi(prec, rnd))
+        return (ci, fzero)
+    wp = prec + 20
+    cre, cim = mpc_ci_si_taylor(re, im, wp, 0)
+    cre = mpf_add(cre, mpf_euler(wp), wp)
+    ci = mpc_add((cre, cim), mpc_log(z, wp), prec, rnd)
+    return ci
+
+def mpc_si(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        return (mpf_ci_si(re, prec, rnd, 1)[1], fzero)
+    wp = prec + 20
+    z = mpc_ci_si_taylor(re, im, wp, 1)
+    return mpc_pos(z, prec, rnd)
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                             Bessel functions                          #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# A Bessel function of the first kind of integer order, J_n(x), is
+# given by the power series
+
+#             oo
+#             ___         k         2 k + n
+#            \        (-1)     / x \
+#    J_n(x) = )    ----------- | - |
+#            /___  k! (k + n)! \ 2 /
+#            k = 0
+
+# Simplifying the quotient between two successive terms gives the
+# ratio x^2 / (-4*k*(k+n)). Hence, we only need one full-precision
+# multiplication and one division by a small integer per term.
+# The complex version is very similar, the only difference being
+# that the multiplication is actually 4 multiplies.
+
+# In the general case, we have
+# J_v(x) = (x/2)**v / v! * 0F1(v+1, (-1/4)*z**2)
+
+# TODO: for extremely large x, we could use an asymptotic
+# trigonometric approximation.
+
+# TODO: recompute at higher precision if the fixed-point mantissa
+# is very small
+
+def mpf_besseljn(n, x, prec, rounding=round_fast):
+    prec += 50
+    negate = n < 0 and n & 1
+    mag = x[2]+x[3]
+    n = abs(n)
+    wp = prec + 20 + n*bitcount(n)
+    if mag < 0:
+        wp -= n * mag
+    x = to_fixed(x, wp)
+    x2 = (x**2) >> wp
+    if not n:
+        s = t = MPZ_ONE << wp
+    else:
+        s = t = (x**n // ifac(n)) >> ((n-1)*wp + n)
+    k = 1
+    while t:
+        t = ((t * x2) // (-4*k*(k+n))) >> wp
+        s += t
+        k += 1
+    if negate:
+        s = -s
+    return from_man_exp(s, -wp, prec, rounding)
+
+def mpc_besseljn(n, z, prec, rounding=round_fast):
+    negate = n < 0 and n & 1
+    n = abs(n)
+    origprec = prec
+    zre, zim = z
+    mag = max(zre[2]+zre[3], zim[2]+zim[3])
+    prec += 20 + n*bitcount(n) + abs(mag)
+    if mag < 0:
+        prec -= n * mag
+    zre = to_fixed(zre, prec)
+    zim = to_fixed(zim, prec)
+    z2re = (zre**2 - zim**2) >> prec
+    z2im = (zre*zim) >> (prec-1)
+    if not n:
+        sre = tre = MPZ_ONE << prec
+        sim = tim = MPZ_ZERO
+    else:
+        re, im = complex_int_pow(zre, zim, n)
+        sre = tre = (re // ifac(n)) >> ((n-1)*prec + n)
+        sim = tim = (im // ifac(n)) >> ((n-1)*prec + n)
+    k = 1
+    while abs(tre) + abs(tim) > 3:
+        p = -4*k*(k+n)
+        tre, tim = tre*z2re - tim*z2im, tim*z2re + tre*z2im
+        tre = (tre // p) >> prec
+        tim = (tim // p) >> prec
+        sre += tre
+        sim += tim
+        k += 1
+    if negate:
+        sre = -sre
+        sim = -sim
+    re = from_man_exp(sre, -prec, origprec, rounding)
+    im = from_man_exp(sim, -prec, origprec, rounding)
+    return (re, im)
+
+def mpf_agm(a, b, prec, rnd=round_fast):
+    """
+    Computes the arithmetic-geometric mean agm(a,b) for
+    nonnegative mpf values a, b.
+    """
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if asign or bsign:
+        raise ComplexResult("agm of a negative number")
+    # Handle inf, nan or zero in either operand
+    if not (aman and bman):
+        if a == fnan or b == fnan:
+            return fnan
+        if a == finf:
+            if b == fzero:
+                return fnan
+            return finf
+        if b == finf:
+            if a == fzero:
+                return fnan
+            return finf
+        # agm(0,x) = agm(x,0) = 0
+        return fzero
+    wp = prec + 20
+    amag = aexp+abc
+    bmag = bexp+bbc
+    mag_delta = amag - bmag
+    # Reduce to roughly the same magnitude using floating-point AGM
+    abs_mag_delta = abs(mag_delta)
+    if abs_mag_delta > 10:
+        while abs_mag_delta > 10:
+            a, b = mpf_shift(mpf_add(a,b,wp),-1), \
+                mpf_sqrt(mpf_mul(a,b,wp),wp)
+            abs_mag_delta //= 2
+        asign, aman, aexp, abc = a
+        bsign, bman, bexp, bbc = b
+        amag = aexp+abc
+        bmag = bexp+bbc
+        mag_delta = amag - bmag
+    #print to_float(a), to_float(b)
+    # Use agm(a,b) = agm(x*a,x*b)/x to obtain a, b ~= 1
+    min_mag = min(amag,bmag)
+    max_mag = max(amag,bmag)
+    n = 0
+    # If too small, we lose precision when going to fixed-point
+    if min_mag < -8:
+        n = -min_mag
+    # If too large, we waste time using fixed-point with large numbers
+    elif max_mag > 20:
+        n = -max_mag
+    if n:
+        a = mpf_shift(a, n)
+        b = mpf_shift(b, n)
+    #print to_float(a), to_float(b)
+    af = to_fixed(a, wp)
+    bf = to_fixed(b, wp)
+    g = agm_fixed(af, bf, wp)
+    return from_man_exp(g, -wp-n, prec, rnd)
+
+def mpf_agm1(a, prec, rnd=round_fast):
+    """
+    Computes the arithmetic-geometric mean agm(1,a) for a nonnegative
+    mpf value a.
+    """
+    return mpf_agm(fone, a, prec, rnd)
+
+def mpc_agm(a, b, prec, rnd=round_fast):
+    """
+    Complex AGM.
+
+    TODO:
+    * check that convergence works as intended
+    * optimize
+    * select a nonarbitrary branch
+    """
+    if mpc_is_infnan(a) or mpc_is_infnan(b):
+        return fnan, fnan
+    if mpc_zero in (a, b):
+        return fzero, fzero
+    if mpc_neg(a) == b:
+        return fzero, fzero
+    wp = prec+20
+    eps = mpf_shift(fone, -wp+10)
+    while 1:
+        a1 = mpc_shift(mpc_add(a, b, wp), -1)
+        b1 = mpc_sqrt(mpc_mul(a, b, wp), wp)
+        a, b = a1, b1
+        size = mpf_min_max([mpc_abs(a,10), mpc_abs(b,10)])[1]
+        err = mpc_abs(mpc_sub(a, b, 10), 10)
+        if size == fzero or mpf_lt(err, mpf_mul(eps, size)):
+            return a
+
+def mpc_agm1(a, prec, rnd=round_fast):
+    return mpc_agm(mpc_one, a, prec, rnd)
+
+def mpf_ellipk(x, prec, rnd=round_fast):
+    if not x[1]:
+        if x == fzero:
+            return mpf_shift(mpf_pi(prec, rnd), -1)
+        if x == fninf:
+            return fzero
+        if x == fnan:
+            return x
+    if x == fone:
+        return finf
+    # TODO: for |x| << 1/2, one could use fall back to
+    # pi/2 * hyp2f1_rat((1,2),(1,2),(1,1), x)
+    wp = prec + 15
+    # Use K(x) = pi/2/agm(1,a) where a = sqrt(1-x)
+    # The sqrt raises ComplexResult if x > 0
+    a = mpf_sqrt(mpf_sub(fone, x, wp), wp)
+    v = mpf_agm1(a, wp)
+    r = mpf_div(mpf_pi(wp), v, prec, rnd)
+    return mpf_shift(r, -1)
+
+def mpc_ellipk(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        if re == finf:
+            return mpc_zero
+        if mpf_le(re, fone):
+            return mpf_ellipk(re, prec, rnd), fzero
+    wp = prec + 15
+    a = mpc_sqrt(mpc_sub(mpc_one, z, wp), wp)
+    v = mpc_agm1(a, wp)
+    r = mpc_mpf_div(mpf_pi(wp), v, prec, rnd)
+    return mpc_shift(r, -1)
+
+def mpf_ellipe(x, prec, rnd=round_fast):
+    # http://functions.wolfram.com/EllipticIntegrals/
+    # EllipticK/20/01/0001/
+    # E = (1-m)*(K'(m)*2*m + K(m))
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero:
+            return mpf_shift(mpf_pi(prec, rnd), -1)
+        if x == fninf:
+            return finf
+        if x == fnan:
+            return x
+        if x == finf:
+            raise ComplexResult
+    if x == fone:
+        return fone
+    wp = prec+20
+    mag = exp+bc
+    if mag < -wp:
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    # Compute a finite difference for K'
+    p = max(mag, 0) - wp
+    h = mpf_shift(fone, p)
+    K = mpf_ellipk(x, 2*wp)
+    Kh = mpf_ellipk(mpf_sub(x, h), 2*wp)
+    Kdiff = mpf_shift(mpf_sub(K, Kh), -p)
+    t = mpf_sub(fone, x)
+    b = mpf_mul(Kdiff, mpf_shift(x,1), wp)
+    return mpf_mul(t, mpf_add(K, b), prec, rnd)
+
+def mpc_ellipe(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        if re == finf:
+            return (fzero, finf)
+        if mpf_le(re, fone):
+            return mpf_ellipe(re, prec, rnd), fzero
+    wp = prec + 15
+    mag = mpc_abs(z, 1)
+    p = max(mag[2]+mag[3], 0) - wp
+    h = mpf_shift(fone, p)
+    K = mpc_ellipk(z, 2*wp)
+    Kh = mpc_ellipk(mpc_add_mpf(z, h, 2*wp), 2*wp)
+    Kdiff = mpc_shift(mpc_sub(Kh, K, wp), -p)
+    t = mpc_sub(mpc_one, z, wp)
+    b = mpc_mul(Kdiff, mpc_shift(z,1), wp)
+    return mpc_mul(t, mpc_add(K, b, wp), prec, rnd)
diff --git a/lib/python3.11/site-packages/mpmath/libmp/libintmath.py b/lib/python3.11/site-packages/mpmath/libmp/libintmath.py
new file mode 100644
index 0000000000000000000000000000000000000000..7880546e135639208d136488408b102ad41682a2
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/libintmath.py
@@ -0,0 +1,584 @@
+"""
+Utility functions for integer math.
+
+TODO: rename, cleanup, perhaps move the gmpy wrapper code
+here from settings.py
+
+"""
+
+import math
+from bisect import bisect
+
+from .backend import xrange
+from .backend import BACKEND, gmpy, sage, sage_utils, MPZ, MPZ_ONE, MPZ_ZERO
+
+small_trailing = [0] * 256
+for j in range(1,8):
+    small_trailing[1<<j::1<<(j+1)] = [j] * (1<<(7-j))
+
+def giant_steps(start, target, n=2):
+    """
+    Return a list of integers ~=
+
+    [start, n*start, ..., target/n^2, target/n, target]
+
+    but conservatively rounded so that the quotient between two
+    successive elements is actually slightly less than n.
+
+    With n = 2, this describes suitable precision steps for a
+    quadratically convergent algorithm such as Newton's method;
+    with n = 3 steps for cubic convergence (Halley's method), etc.
+
+        >>> giant_steps(50,1000)
+        [66, 128, 253, 502, 1000]
+        >>> giant_steps(50,1000,4)
+        [65, 252, 1000]
+
+    """
+    L = [target]
+    while L[-1] > start*n:
+        L = L + [L[-1]//n + 2]
+    return L[::-1]
+
+def rshift(x, n):
+    """For an integer x, calculate x >> n with the fastest (floor)
+    rounding. Unlike the plain Python expression (x >> n), n is
+    allowed to be negative, in which case a left shift is performed."""
+    if n >= 0: return x >> n
+    else:      return x << (-n)
+
+def lshift(x, n):
+    """For an integer x, calculate x << n. Unlike the plain Python
+    expression (x << n), n is allowed to be negative, in which case a
+    right shift with default (floor) rounding is performed."""
+    if n >= 0: return x << n
+    else:      return x >> (-n)
+
+if BACKEND == 'sage':
+    import operator
+    rshift = operator.rshift
+    lshift = operator.lshift
+
+def python_trailing(n):
+    """Count the number of trailing zero bits in abs(n)."""
+    if not n:
+        return 0
+    low_byte = n & 0xff
+    if low_byte:
+        return small_trailing[low_byte]
+    t = 8
+    n >>= 8
+    while not n & 0xff:
+        n >>= 8
+        t += 8
+    return t + small_trailing[n & 0xff]
+
+if BACKEND == 'gmpy':
+    if gmpy.version() >= '2':
+        def gmpy_trailing(n):
+            """Count the number of trailing zero bits in abs(n) using gmpy."""
+            if n: return MPZ(n).bit_scan1()
+            else: return 0
+    else:
+        def gmpy_trailing(n):
+            """Count the number of trailing zero bits in abs(n) using gmpy."""
+            if n: return MPZ(n).scan1()
+            else: return 0
+
+# Small powers of 2
+powers = [1<<_ for _ in range(300)]
+
+def python_bitcount(n):
+    """Calculate bit size of the nonnegative integer n."""
+    bc = bisect(powers, n)
+    if bc != 300:
+        return bc
+    bc = int(math.log(n, 2)) - 4
+    return bc + bctable[n>>bc]
+
+def gmpy_bitcount(n):
+    """Calculate bit size of the nonnegative integer n."""
+    if n: return MPZ(n).numdigits(2)
+    else: return 0
+
+#def sage_bitcount(n):
+#    if n: return MPZ(n).nbits()
+#    else: return 0
+
+def sage_trailing(n):
+    return MPZ(n).trailing_zero_bits()
+
+if BACKEND == 'gmpy':
+    bitcount = gmpy_bitcount
+    trailing = gmpy_trailing
+elif BACKEND == 'sage':
+    sage_bitcount = sage_utils.bitcount
+    bitcount = sage_bitcount
+    trailing = sage_trailing
+else:
+    bitcount = python_bitcount
+    trailing = python_trailing
+
+if BACKEND == 'gmpy' and 'bit_length' in dir(gmpy):
+    bitcount = gmpy.bit_length
+
+# Used to avoid slow function calls as far as possible
+trailtable = [trailing(n) for n in range(256)]
+bctable = [bitcount(n) for n in range(1024)]
+
+# TODO: speed up for bases 2, 4, 8, 16, ...
+
+def bin_to_radix(x, xbits, base, bdigits):
+    """Changes radix of a fixed-point number; i.e., converts
+    x * 2**xbits to floor(x * 10**bdigits)."""
+    return x * (MPZ(base)**bdigits) >> xbits
+
+stddigits = '0123456789abcdefghijklmnopqrstuvwxyz'
+
+def small_numeral(n, base=10, digits=stddigits):
+    """Return the string numeral of a positive integer in an arbitrary
+    base. Most efficient for small input."""
+    if base == 10:
+        return str(n)
+    digs = []
+    while n:
+        n, digit = divmod(n, base)
+        digs.append(digits[digit])
+    return "".join(digs[::-1])
+
+def numeral_python(n, base=10, size=0, digits=stddigits):
+    """Represent the integer n as a string of digits in the given base.
+    Recursive division is used to make this function about 3x faster
+    than Python's str() for converting integers to decimal strings.
+
+    The 'size' parameters specifies the number of digits in n; this
+    number is only used to determine splitting points and need not be
+    exact."""
+    if n <= 0:
+        if not n:
+            return "0"
+        return "-" + numeral(-n, base, size, digits)
+    # Fast enough to do directly
+    if size < 250:
+        return small_numeral(n, base, digits)
+    # Divide in half
+    half = (size // 2) + (size & 1)
+    A, B = divmod(n, base**half)
+    ad = numeral(A, base, half, digits)
+    bd = numeral(B, base, half, digits).rjust(half, "0")
+    return ad + bd
+
+def numeral_gmpy(n, base=10, size=0, digits=stddigits):
+    """Represent the integer n as a string of digits in the given base.
+    Recursive division is used to make this function about 3x faster
+    than Python's str() for converting integers to decimal strings.
+
+    The 'size' parameters specifies the number of digits in n; this
+    number is only used to determine splitting points and need not be
+    exact."""
+    if n < 0:
+        return "-" + numeral(-n, base, size, digits)
+    # gmpy.digits() may cause a segmentation fault when trying to convert
+    # extremely large values to a string. The size limit may need to be
+    # adjusted on some platforms, but 1500000 works on Windows and Linux.
+    if size < 1500000:
+        return gmpy.digits(n, base)
+    # Divide in half
+    half = (size // 2) + (size & 1)
+    A, B = divmod(n, MPZ(base)**half)
+    ad = numeral(A, base, half, digits)
+    bd = numeral(B, base, half, digits).rjust(half, "0")
+    return ad + bd
+
+if BACKEND == "gmpy":
+    numeral = numeral_gmpy
+else:
+    numeral = numeral_python
+
+_1_800 = 1<<800
+_1_600 = 1<<600
+_1_400 = 1<<400
+_1_200 = 1<<200
+_1_100 = 1<<100
+_1_50 = 1<<50
+
+def isqrt_small_python(x):
+    """
+    Correctly (floor) rounded integer square root, using
+    division. Fast up to ~200 digits.
+    """
+    if not x:
+        return x
+    if x < _1_800:
+        # Exact with IEEE double precision arithmetic
+        if x < _1_50:
+            return int(x**0.5)
+        # Initial estimate can be any integer >= the true root; round up
+        r = int(x**0.5 * 1.00000000000001) + 1
+    else:
+        bc = bitcount(x)
+        n = bc//2
+        r = int((x>>(2*n-100))**0.5+2)<<(n-50)  # +2 is to round up
+    # The following iteration now precisely computes floor(sqrt(x))
+    # See e.g. Crandall & Pomerance, "Prime Numbers: A Computational
+    # Perspective"
+    while 1:
+        y = (r+x//r)>>1
+        if y >= r:
+            return r
+        r = y
+
+def isqrt_fast_python(x):
+    """
+    Fast approximate integer square root, computed using division-free
+    Newton iteration for large x. For random integers the result is almost
+    always correct (floor(sqrt(x))), but is 1 ulp too small with a roughly
+    0.1% probability. If x is very close to an exact square, the answer is
+    1 ulp wrong with high probability.
+
+    With 0 guard bits, the largest error over a set of 10^5 random
+    inputs of size 1-10^5 bits was 3 ulp. The use of 10 guard bits
+    almost certainly guarantees a max 1 ulp error.
+    """
+    # Use direct division-based iteration if sqrt(x) < 2^400
+    # Assume floating-point square root accurate to within 1 ulp, then:
+    # 0 Newton iterations good to 52 bits
+    # 1 Newton iterations good to 104 bits
+    # 2 Newton iterations good to 208 bits
+    # 3 Newton iterations good to 416 bits
+    if x < _1_800:
+        y = int(x**0.5)
+        if x >= _1_100:
+            y = (y + x//y) >> 1
+            if x >= _1_200:
+                y = (y + x//y) >> 1
+                if x >= _1_400:
+                    y = (y + x//y) >> 1
+        return y
+    bc = bitcount(x)
+    guard_bits = 10
+    x <<= 2*guard_bits
+    bc += 2*guard_bits
+    bc += (bc&1)
+    hbc = bc//2
+    startprec = min(50, hbc)
+    # Newton iteration for 1/sqrt(x), with floating-point starting value
+    r = int(2.0**(2*startprec) * (x >> (bc-2*startprec)) ** -0.5)
+    pp = startprec
+    for p in giant_steps(startprec, hbc):
+        # r**2, scaled from real size 2**(-bc) to 2**p
+        r2 = (r*r) >> (2*pp - p)
+        # x*r**2, scaled from real size ~1.0 to 2**p
+        xr2 = ((x >> (bc-p)) * r2) >> p
+        # New value of r, scaled from real size 2**(-bc/2) to 2**p
+        r = (r * ((3<<p) - xr2)) >> (pp+1)
+        pp = p
+    # (1/sqrt(x))*x = sqrt(x)
+    return (r*(x>>hbc)) >> (p+guard_bits)
+
+def sqrtrem_python(x):
+    """Correctly rounded integer (floor) square root with remainder."""
+    # to check cutoff:
+    # plot(lambda x: timing(isqrt, 2**int(x)), [0,2000])
+    if x < _1_600:
+        y = isqrt_small_python(x)
+        return y, x - y*y
+    y = isqrt_fast_python(x) + 1
+    rem = x - y*y
+    # Correct remainder
+    while rem < 0:
+        y -= 1
+        rem += (1+2*y)
+    else:
+        if rem:
+            while rem > 2*(1+y):
+                y += 1
+                rem -= (1+2*y)
+    return y, rem
+
+def isqrt_python(x):
+    """Integer square root with correct (floor) rounding."""
+    return sqrtrem_python(x)[0]
+
+def sqrt_fixed(x, prec):
+    return isqrt_fast(x<<prec)
+
+sqrt_fixed2 = sqrt_fixed
+
+if BACKEND == 'gmpy':
+    if gmpy.version() >= '2':
+        isqrt_small = isqrt_fast = isqrt = gmpy.isqrt
+        sqrtrem = gmpy.isqrt_rem
+    else:
+        isqrt_small = isqrt_fast = isqrt = gmpy.sqrt
+        sqrtrem = gmpy.sqrtrem
+elif BACKEND == 'sage':
+    isqrt_small = isqrt_fast = isqrt = \
+        getattr(sage_utils, "isqrt", lambda n: MPZ(n).isqrt())
+    sqrtrem = lambda n: MPZ(n).sqrtrem()
+else:
+    isqrt_small = isqrt_small_python
+    isqrt_fast = isqrt_fast_python
+    isqrt = isqrt_python
+    sqrtrem = sqrtrem_python
+
+
+def ifib(n, _cache={}):
+    """Computes the nth Fibonacci number as an integer, for
+    integer n."""
+    if n < 0:
+        return (-1)**(-n+1) * ifib(-n)
+    if n in _cache:
+        return _cache[n]
+    m = n
+    # Use Dijkstra's logarithmic algorithm
+    # The following implementation is basically equivalent to
+    # http://en.literateprograms.org/Fibonacci_numbers_(Scheme)
+    a, b, p, q = MPZ_ONE, MPZ_ZERO, MPZ_ZERO, MPZ_ONE
+    while n:
+        if n & 1:
+            aq = a*q
+            a, b = b*q+aq+a*p, b*p+aq
+            n -= 1
+        else:
+            qq = q*q
+            p, q = p*p+qq, qq+2*p*q
+            n >>= 1
+    if m < 250:
+        _cache[m] = b
+    return b
+
+MAX_FACTORIAL_CACHE = 1000
+
+def ifac(n, memo={0:1, 1:1}):
+    """Return n factorial (for integers n >= 0 only)."""
+    f = memo.get(n)
+    if f:
+        return f
+    k = len(memo)
+    p = memo[k-1]
+    MAX = MAX_FACTORIAL_CACHE
+    while k <= n:
+        p *= k
+        if k <= MAX:
+            memo[k] = p
+        k += 1
+    return p
+
+def ifac2(n, memo_pair=[{0:1}, {1:1}]):
+    """Return n!! (double factorial), integers n >= 0 only."""
+    memo = memo_pair[n&1]
+    f = memo.get(n)
+    if f:
+        return f
+    k = max(memo)
+    p = memo[k]
+    MAX = MAX_FACTORIAL_CACHE
+    while k < n:
+        k += 2
+        p *= k
+        if k <= MAX:
+            memo[k] = p
+    return p
+
+if BACKEND == 'gmpy':
+    ifac = gmpy.fac
+elif BACKEND == 'sage':
+    ifac = lambda n: int(sage.factorial(n))
+    ifib = sage.fibonacci
+
+def list_primes(n):
+    n = n + 1
+    sieve = list(xrange(n))
+    sieve[:2] = [0, 0]
+    for i in xrange(2, int(n**0.5)+1):
+        if sieve[i]:
+            for j in xrange(i**2, n, i):
+                sieve[j] = 0
+    return [p for p in sieve if p]
+
+if BACKEND == 'sage':
+    # Note: it is *VERY* important for performance that we convert
+    # the list to Python ints.
+    def list_primes(n):
+        return [int(_) for _ in sage.primes(n+1)]
+
+small_odd_primes = (3,5,7,11,13,17,19,23,29,31,37,41,43,47)
+small_odd_primes_set = set(small_odd_primes)
+
+def isprime(n):
+    """
+    Determines whether n is a prime number. A probabilistic test is
+    performed if n is very large. No special trick is used for detecting
+    perfect powers.
+
+        >>> sum(list_primes(100000))
+        454396537
+        >>> sum(n*isprime(n) for n in range(100000))
+        454396537
+
+    """
+    n = int(n)
+    if not n & 1:
+        return n == 2
+    if n < 50:
+        return n in small_odd_primes_set
+    for p in small_odd_primes:
+        if not n % p:
+            return False
+    m = n-1
+    s = trailing(m)
+    d = m >> s
+    def test(a):
+        x = pow(a,d,n)
+        if x == 1 or x == m:
+            return True
+        for r in xrange(1,s):
+            x = x**2 % n
+            if x == m:
+                return True
+        return False
+    # See http://primes.utm.edu/prove/prove2_3.html
+    if n < 1373653:
+        witnesses = [2,3]
+    elif n < 341550071728321:
+        witnesses = [2,3,5,7,11,13,17]
+    else:
+        witnesses = small_odd_primes
+    for a in witnesses:
+        if not test(a):
+            return False
+    return True
+
+def moebius(n):
+    """
+    Evaluates the Moebius function which is `mu(n) = (-1)^k` if `n`
+    is a product of `k` distinct primes and `mu(n) = 0` otherwise.
+
+    TODO: speed up using factorization
+    """
+    n = abs(int(n))
+    if n < 2:
+        return n
+    factors = []
+    for p in xrange(2, n+1):
+        if not (n % p):
+            if not (n % p**2):
+                return 0
+            if not sum(p % f for f in factors):
+                factors.append(p)
+    return (-1)**len(factors)
+
+def gcd(*args):
+    a = 0
+    for b in args:
+        if a:
+            while b:
+                a, b = b, a % b
+        else:
+            a = b
+    return a
+
+
+#  Comment by Juan Arias de Reyna:
+#
+#  I learn this method to compute EulerE[2n] from van de Lune.
+#
+#  We apply the formula   EulerE[2n] = (-1)^n 2**(-2n) sum_{j=0}^n a(2n,2j+1)
+#
+#  where the numbers a(n,j) vanish for  j > n+1 or j <= -1  and satisfies
+#
+#  a(0,-1) = a(0,0) = 0;  a(0,1)= 1; a(0,2) = a(0,3) = 0
+#
+#  a(n,j) = a(n-1,j)                              when n+j is even
+#  a(n,j) = (j-1) a(n-1,j-1) + (j+1) a(n-1,j+1)   when n+j is odd
+#
+#
+#  But we can use only one array unidimensional a(j) since to compute
+#  a(n,j) we only need to know a(n-1,k) where k and j are of different parity
+#  and we have not to conserve the used values.
+#
+#  We cached up the values of Euler numbers to sufficiently high order.
+#
+#  Important Observation: If we pretend to use the numbers
+#     EulerE[1], EulerE[2], ... , EulerE[n]
+#     it is convenient to compute first EulerE[n], since the algorithm
+#     computes first all
+#     the previous ones, and keeps them in the CACHE
+
+MAX_EULER_CACHE = 500
+
+def eulernum(m, _cache={0:MPZ_ONE}):
+    r"""
+    Computes the Euler numbers `E(n)`, which can be defined as
+    coefficients of the Taylor expansion of `1/cosh x`:
+
+    .. math ::
+
+        \frac{1}{\cosh x} = \sum_{n=0}^\infty \frac{E_n}{n!} x^n
+
+    Example::
+
+        >>> [int(eulernum(n)) for n in range(11)]
+        [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+        >>> [int(eulernum(n)) for n in range(11)]   # test cache
+        [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+
+    """
+    # for odd m > 1, the Euler numbers are zero
+    if m & 1:
+        return MPZ_ZERO
+    f = _cache.get(m)
+    if f:
+        return f
+    MAX = MAX_EULER_CACHE
+    n = m
+    a = [MPZ(_) for _ in [0,0,1,0,0,0]]
+    for  n in range(1, m+1):
+        for j in range(n+1, -1, -2):
+            a[j+1] = (j-1)*a[j] + (j+1)*a[j+2]
+        a.append(0)
+        suma = 0
+        for k in range(n+1, -1, -2):
+            suma += a[k+1]
+            if n <= MAX:
+                _cache[n] = ((-1)**(n//2))*(suma // 2**n)
+        if n == m:
+            return ((-1)**(n//2))*suma // 2**n
+
+def stirling1(n, k):
+    """
+    Stirling number of the first kind.
+    """
+    if n < 0 or k < 0:
+        raise ValueError
+    if k >= n:
+        return MPZ(n == k)
+    if k < 1:
+        return MPZ_ZERO
+    L = [MPZ_ZERO] * (k+1)
+    L[1] = MPZ_ONE
+    for m in xrange(2, n+1):
+        for j in xrange(min(k, m), 0, -1):
+            L[j] = (m-1) * L[j] + L[j-1]
+    return (-1)**(n+k) * L[k]
+
+def stirling2(n, k):
+    """
+    Stirling number of the second kind.
+    """
+    if n < 0 or k < 0:
+        raise ValueError
+    if k >= n:
+        return MPZ(n == k)
+    if k <= 1:
+        return MPZ(k == 1)
+    s = MPZ_ZERO
+    t = MPZ_ONE
+    for j in xrange(k+1):
+        if (k + j) & 1:
+            s -= t * MPZ(j)**n
+        else:
+            s += t * MPZ(j)**n
+        t = t * (k - j) // (j + 1)
+    return s // ifac(k)
diff --git a/lib/python3.11/site-packages/mpmath/libmp/libmpc.py b/lib/python3.11/site-packages/mpmath/libmp/libmpc.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc22d0e73674676c8a9249ebc2d48da7f3be8b0d
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/libmpc.py
@@ -0,0 +1,835 @@
+"""
+Low-level functions for complex arithmetic.
+"""
+
+import sys
+
+from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_TWO, BACKEND
+
+from .libmpf import (\
+    round_floor, round_ceiling, round_down, round_up,
+    round_nearest, round_fast, bitcount,
+    bctable, normalize, normalize1, reciprocal_rnd, rshift, lshift, giant_steps,
+    negative_rnd,
+    to_str, to_fixed, from_man_exp, from_float, to_float, from_int, to_int,
+    fzero, fone, ftwo, fhalf, finf, fninf, fnan, fnone,
+    mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul,
+    mpf_div, mpf_mul_int, mpf_shift, mpf_sqrt, mpf_hypot,
+    mpf_rdiv_int, mpf_floor, mpf_ceil, mpf_nint, mpf_frac,
+    mpf_sign, mpf_hash,
+    ComplexResult
+)
+
+from .libelefun import (\
+    mpf_pi, mpf_exp, mpf_log, mpf_cos_sin, mpf_cosh_sinh, mpf_tan, mpf_pow_int,
+    mpf_log_hypot,
+    mpf_cos_sin_pi, mpf_phi,
+    mpf_cos, mpf_sin, mpf_cos_pi, mpf_sin_pi,
+    mpf_atan, mpf_atan2, mpf_cosh, mpf_sinh, mpf_tanh,
+    mpf_asin, mpf_acos, mpf_acosh, mpf_nthroot, mpf_fibonacci
+)
+
+# An mpc value is a (real, imag) tuple
+mpc_one = fone, fzero
+mpc_zero = fzero, fzero
+mpc_two = ftwo, fzero
+mpc_half = (fhalf, fzero)
+
+_infs = (finf, fninf)
+_infs_nan = (finf, fninf, fnan)
+
+def mpc_is_inf(z):
+    """Check if either real or imaginary part is infinite"""
+    re, im = z
+    if re in _infs: return True
+    if im in _infs: return True
+    return False
+
+def mpc_is_infnan(z):
+    """Check if either real or imaginary part is infinite or nan"""
+    re, im = z
+    if re in _infs_nan: return True
+    if im in _infs_nan: return True
+    return False
+
+def mpc_to_str(z, dps, **kwargs):
+    re, im = z
+    rs = to_str(re, dps)
+    if im[0]:
+        return rs + " - " + to_str(mpf_neg(im), dps, **kwargs) + "j"
+    else:
+        return rs + " + " + to_str(im, dps, **kwargs) + "j"
+
+def mpc_to_complex(z, strict=False, rnd=round_fast):
+    re, im = z
+    return complex(to_float(re, strict, rnd), to_float(im, strict, rnd))
+
+def mpc_hash(z):
+    if sys.version_info >= (3, 2):
+        re, im = z
+        h = mpf_hash(re) + sys.hash_info.imag * mpf_hash(im)
+        # Need to reduce either module 2^32 or 2^64
+        h = h % (2**sys.hash_info.width)
+        return int(h)
+    else:
+        try:
+            return hash(mpc_to_complex(z, strict=True))
+        except OverflowError:
+            return hash(z)
+
+def mpc_conjugate(z, prec, rnd=round_fast):
+    re, im = z
+    return re, mpf_neg(im, prec, rnd)
+
+def mpc_is_nonzero(z):
+    return z != mpc_zero
+
+def mpc_add(z, w, prec, rnd=round_fast):
+    a, b = z
+    c, d = w
+    return mpf_add(a, c, prec, rnd), mpf_add(b, d, prec, rnd)
+
+def mpc_add_mpf(z, x, prec, rnd=round_fast):
+    a, b = z
+    return mpf_add(a, x, prec, rnd), b
+
+def mpc_sub(z, w, prec=0, rnd=round_fast):
+    a, b = z
+    c, d = w
+    return mpf_sub(a, c, prec, rnd), mpf_sub(b, d, prec, rnd)
+
+def mpc_sub_mpf(z, p, prec=0, rnd=round_fast):
+    a, b = z
+    return mpf_sub(a, p, prec, rnd), b
+
+def mpc_pos(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_pos(a, prec, rnd), mpf_pos(b, prec, rnd)
+
+def mpc_neg(z, prec=None, rnd=round_fast):
+    a, b = z
+    return mpf_neg(a, prec, rnd), mpf_neg(b, prec, rnd)
+
+def mpc_shift(z, n):
+    a, b = z
+    return mpf_shift(a, n), mpf_shift(b, n)
+
+def mpc_abs(z, prec, rnd=round_fast):
+    """Absolute value of a complex number, |a+bi|.
+    Returns an mpf value."""
+    a, b = z
+    return mpf_hypot(a, b, prec, rnd)
+
+def mpc_arg(z, prec, rnd=round_fast):
+    """Argument of a complex number. Returns an mpf value."""
+    a, b = z
+    return mpf_atan2(b, a, prec, rnd)
+
+def mpc_floor(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_floor(a, prec, rnd), mpf_floor(b, prec, rnd)
+
+def mpc_ceil(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_ceil(a, prec, rnd), mpf_ceil(b, prec, rnd)
+
+def mpc_nint(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_nint(a, prec, rnd), mpf_nint(b, prec, rnd)
+
+def mpc_frac(z, prec, rnd=round_fast):
+    a, b = z
+    return mpf_frac(a, prec, rnd), mpf_frac(b, prec, rnd)
+
+
+def mpc_mul(z, w, prec, rnd=round_fast):
+    """
+    Complex multiplication.
+
+    Returns the real and imaginary part of (a+bi)*(c+di), rounded to
+    the specified precision. The rounding mode applies to the real and
+    imaginary parts separately.
+    """
+    a, b = z
+    c, d = w
+    p = mpf_mul(a, c)
+    q = mpf_mul(b, d)
+    r = mpf_mul(a, d)
+    s = mpf_mul(b, c)
+    re = mpf_sub(p, q, prec, rnd)
+    im = mpf_add(r, s, prec, rnd)
+    return re, im
+
+def mpc_square(z, prec, rnd=round_fast):
+    # (a+b*I)**2 == a**2 - b**2 + 2*I*a*b
+    a, b = z
+    p = mpf_mul(a,a)
+    q = mpf_mul(b,b)
+    r = mpf_mul(a,b, prec, rnd)
+    re = mpf_sub(p, q, prec, rnd)
+    im = mpf_shift(r, 1)
+    return re, im
+
+def mpc_mul_mpf(z, p, prec, rnd=round_fast):
+    a, b = z
+    re = mpf_mul(a, p, prec, rnd)
+    im = mpf_mul(b, p, prec, rnd)
+    return re, im
+
+def mpc_mul_imag_mpf(z, x, prec, rnd=round_fast):
+    """
+    Multiply the mpc value z by I*x where x is an mpf value.
+    """
+    a, b = z
+    re = mpf_neg(mpf_mul(b, x, prec, rnd))
+    im = mpf_mul(a, x, prec, rnd)
+    return re, im
+
+def mpc_mul_int(z, n, prec, rnd=round_fast):
+    a, b = z
+    re = mpf_mul_int(a, n, prec, rnd)
+    im = mpf_mul_int(b, n, prec, rnd)
+    return re, im
+
+def mpc_div(z, w, prec, rnd=round_fast):
+    a, b = z
+    c, d = w
+    wp = prec + 10
+    # mag = c*c + d*d
+    mag = mpf_add(mpf_mul(c, c), mpf_mul(d, d), wp)
+    # (a*c+b*d)/mag, (b*c-a*d)/mag
+    t = mpf_add(mpf_mul(a,c), mpf_mul(b,d), wp)
+    u = mpf_sub(mpf_mul(b,c), mpf_mul(a,d), wp)
+    return mpf_div(t,mag,prec,rnd), mpf_div(u,mag,prec,rnd)
+
+def mpc_div_mpf(z, p, prec, rnd=round_fast):
+    """Calculate z/p where p is real"""
+    a, b = z
+    re = mpf_div(a, p, prec, rnd)
+    im = mpf_div(b, p, prec, rnd)
+    return re, im
+
+def mpc_reciprocal(z, prec, rnd=round_fast):
+    """Calculate 1/z efficiently"""
+    a, b = z
+    m = mpf_add(mpf_mul(a,a),mpf_mul(b,b),prec+10)
+    re = mpf_div(a, m, prec, rnd)
+    im = mpf_neg(mpf_div(b, m, prec, rnd))
+    return re, im
+
+def mpc_mpf_div(p, z, prec, rnd=round_fast):
+    """Calculate p/z where p is real efficiently"""
+    a, b = z
+    m = mpf_add(mpf_mul(a,a),mpf_mul(b,b), prec+10)
+    re = mpf_div(mpf_mul(a,p), m, prec, rnd)
+    im = mpf_div(mpf_neg(mpf_mul(b,p)), m, prec, rnd)
+    return re, im
+
+def complex_int_pow(a, b, n):
+    """Complex integer power: computes (a+b*I)**n exactly for
+    nonnegative n (a and b must be Python ints)."""
+    wre = 1
+    wim = 0
+    while n:
+        if n & 1:
+            wre, wim = wre*a - wim*b, wim*a + wre*b
+            n -= 1
+        a, b = a*a - b*b, 2*a*b
+        n //= 2
+    return wre, wim
+
+def mpc_pow(z, w, prec, rnd=round_fast):
+    if w[1] == fzero:
+        return mpc_pow_mpf(z, w[0], prec, rnd)
+    return mpc_exp(mpc_mul(mpc_log(z, prec+10), w, prec+10), prec, rnd)
+
+def mpc_pow_mpf(z, p, prec, rnd=round_fast):
+    psign, pman, pexp, pbc = p
+    if pexp >= 0:
+        return mpc_pow_int(z, (-1)**psign * (pman<<pexp), prec, rnd)
+    if pexp == -1:
+        sqrtz = mpc_sqrt(z, prec+10)
+        return mpc_pow_int(sqrtz, (-1)**psign * pman, prec, rnd)
+    return mpc_exp(mpc_mul_mpf(mpc_log(z, prec+10), p, prec+10), prec, rnd)
+
+def mpc_pow_int(z, n, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        return mpf_pow_int(a, n, prec, rnd), fzero
+    if a == fzero:
+        v = mpf_pow_int(b, n, prec, rnd)
+        n %= 4
+        if n == 0:
+            return v, fzero
+        elif n == 1:
+            return fzero, v
+        elif n == 2:
+            return mpf_neg(v), fzero
+        elif n == 3:
+            return fzero, mpf_neg(v)
+    if n == 0: return mpc_one
+    if n == 1: return mpc_pos(z, prec, rnd)
+    if n == 2: return mpc_square(z, prec, rnd)
+    if n == -1: return mpc_reciprocal(z, prec, rnd)
+    if n < 0: return mpc_reciprocal(mpc_pow_int(z, -n, prec+4), prec, rnd)
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if asign: aman = -aman
+    if bsign: bman = -bman
+    de = aexp - bexp
+    abs_de = abs(de)
+    exact_size = n*(abs_de + max(abc, bbc))
+    if exact_size < 10000:
+        if de > 0:
+            aman <<= de
+            aexp = bexp
+        else:
+            bman <<= (-de)
+            bexp = aexp
+        re, im = complex_int_pow(aman, bman, n)
+        re = from_man_exp(re, int(n*aexp), prec, rnd)
+        im = from_man_exp(im, int(n*bexp), prec, rnd)
+        return re, im
+    return mpc_exp(mpc_mul_int(mpc_log(z, prec+10), n, prec+10), prec, rnd)
+
+def mpc_sqrt(z, prec, rnd=round_fast):
+    """Complex square root (principal branch).
+
+    We have sqrt(a+bi) = sqrt((r+a)/2) + b/sqrt(2*(r+a))*i where
+    r = abs(a+bi), when a+bi is not a negative real number."""
+    a, b = z
+    if b == fzero:
+        if a == fzero:
+            return (a, b)
+        # When a+bi is a negative real number, we get a real sqrt times i
+        if a[0]:
+            im = mpf_sqrt(mpf_neg(a), prec, rnd)
+            return (fzero, im)
+        else:
+            re = mpf_sqrt(a, prec, rnd)
+            return (re, fzero)
+    wp = prec+20
+    if not a[0]:                               # case a positive
+        t  = mpf_add(mpc_abs((a, b), wp), a, wp)  # t = abs(a+bi) + a
+        u = mpf_shift(t, -1)                      # u = t/2
+        re = mpf_sqrt(u, prec, rnd)               # re = sqrt(u)
+        v = mpf_shift(t, 1)                       # v = 2*t
+        w  = mpf_sqrt(v, wp)                      # w = sqrt(v)
+        im = mpf_div(b, w, prec, rnd)             # im = b / w
+    else:                                      # case a negative
+        t = mpf_sub(mpc_abs((a, b), wp), a, wp)   # t = abs(a+bi) - a
+        u = mpf_shift(t, -1)                      # u = t/2
+        im = mpf_sqrt(u, prec, rnd)               # im = sqrt(u)
+        v = mpf_shift(t, 1)                       # v = 2*t
+        w  = mpf_sqrt(v, wp)                      # w = sqrt(v)
+        re = mpf_div(b, w, prec, rnd)             # re = b/w
+        if b[0]:
+            re = mpf_neg(re)
+            im = mpf_neg(im)
+    return re, im
+
+def mpc_nthroot_fixed(a, b, n, prec):
+    # a, b signed integers at fixed precision prec
+    start = 50
+    a1 = int(rshift(a, prec - n*start))
+    b1 = int(rshift(b, prec - n*start))
+    try:
+        r = (a1 + 1j * b1)**(1.0/n)
+        re = r.real
+        im = r.imag
+        re = MPZ(int(re))
+        im = MPZ(int(im))
+    except OverflowError:
+        a1 = from_int(a1, start)
+        b1 = from_int(b1, start)
+        fn = from_int(n)
+        nth = mpf_rdiv_int(1, fn, start)
+        re, im = mpc_pow((a1, b1), (nth, fzero), start)
+        re = to_int(re)
+        im = to_int(im)
+    extra = 10
+    prevp = start
+    extra1 = n
+    for p in giant_steps(start, prec+extra):
+        # this is slow for large n, unlike int_pow_fixed
+        re2, im2 = complex_int_pow(re, im, n-1)
+        re2 = rshift(re2, (n-1)*prevp - p - extra1)
+        im2 = rshift(im2, (n-1)*prevp - p - extra1)
+        r4 = (re2*re2 + im2*im2) >> (p + extra1)
+        ap = rshift(a, prec - p)
+        bp = rshift(b, prec - p)
+        rec = (ap * re2 + bp * im2) >> p
+        imc = (-ap * im2 + bp * re2) >> p
+        reb = (rec << p) // r4
+        imb = (imc << p) // r4
+        re = (reb + (n-1)*lshift(re, p-prevp))//n
+        im = (imb + (n-1)*lshift(im, p-prevp))//n
+        prevp = p
+    return re, im
+
+def mpc_nthroot(z, n, prec, rnd=round_fast):
+    """
+    Complex n-th root.
+
+    Use Newton method as in the real case when it is faster,
+    otherwise use z**(1/n)
+    """
+    a, b = z
+    if a[0] == 0 and b == fzero:
+        re = mpf_nthroot(a, n, prec, rnd)
+        return (re, fzero)
+    if n < 2:
+        if n == 0:
+            return mpc_one
+        if n == 1:
+            return mpc_pos((a, b), prec, rnd)
+        if n == -1:
+            return mpc_div(mpc_one, (a, b), prec, rnd)
+        inverse = mpc_nthroot((a, b), -n, prec+5, reciprocal_rnd[rnd])
+        return mpc_div(mpc_one, inverse, prec, rnd)
+    if n <= 20:
+        prec2 = int(1.2 * (prec + 10))
+        asign, aman, aexp, abc = a
+        bsign, bman, bexp, bbc = b
+        pf = mpc_abs((a,b), prec)
+        if pf[-2] + pf[-1] > -10  and pf[-2] + pf[-1] < prec:
+            af = to_fixed(a, prec2)
+            bf = to_fixed(b, prec2)
+            re, im = mpc_nthroot_fixed(af, bf, n, prec2)
+            extra = 10
+            re = from_man_exp(re, -prec2-extra, prec2, rnd)
+            im = from_man_exp(im, -prec2-extra, prec2, rnd)
+            return re, im
+    fn = from_int(n)
+    prec2 = prec+10 + 10
+    nth = mpf_rdiv_int(1, fn, prec2)
+    re, im = mpc_pow((a, b), (nth, fzero), prec2, rnd)
+    re = normalize(re[0], re[1], re[2], re[3], prec, rnd)
+    im = normalize(im[0], im[1], im[2], im[3], prec, rnd)
+    return re, im
+
+def mpc_cbrt(z, prec, rnd=round_fast):
+    """
+    Complex cubic root.
+    """
+    return mpc_nthroot(z, 3, prec, rnd)
+
+def mpc_exp(z, prec, rnd=round_fast):
+    """
+    Complex exponential function.
+
+    We use the direct formula exp(a+bi) = exp(a) * (cos(b) + sin(b)*i)
+    for the computation. This formula is very nice because it is
+    pefectly stable; since we just do real multiplications, the only
+    numerical errors that can creep in are single-ulp rounding errors.
+
+    The formula is efficient since mpmath's real exp is quite fast and
+    since we can compute cos and sin simultaneously.
+
+    It is no problem if a and b are large; if the implementations of
+    exp/cos/sin are accurate and efficient for all real numbers, then
+    so is this function for all complex numbers.
+    """
+    a, b = z
+    if a == fzero:
+        return mpf_cos_sin(b, prec, rnd)
+    if b == fzero:
+        return mpf_exp(a, prec, rnd), fzero
+    mag = mpf_exp(a, prec+4, rnd)
+    c, s = mpf_cos_sin(b, prec+4, rnd)
+    re = mpf_mul(mag, c, prec, rnd)
+    im = mpf_mul(mag, s, prec, rnd)
+    return re, im
+
+def mpc_log(z, prec, rnd=round_fast):
+    re = mpf_log_hypot(z[0], z[1], prec, rnd)
+    im = mpc_arg(z, prec, rnd)
+    return re, im
+
+def mpc_cos(z, prec, rnd=round_fast):
+    """Complex cosine. The formula used is cos(a+bi) = cos(a)*cosh(b) -
+    sin(a)*sinh(b)*i.
+
+    The same comments apply as for the complex exp: only real
+    multiplications are pewrormed, so no cancellation errors are
+    possible. The formula is also efficient since we can compute both
+    pairs (cos, sin) and (cosh, sinh) in single stwps."""
+    a, b = z
+    if b == fzero:
+        return mpf_cos(a, prec, rnd), fzero
+    if a == fzero:
+        return mpf_cosh(b, prec, rnd), fzero
+    wp = prec + 6
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(c, ch, prec, rnd)
+    im = mpf_mul(s, sh, prec, rnd)
+    return re, mpf_neg(im)
+
+def mpc_sin(z, prec, rnd=round_fast):
+    """Complex sine. We have sin(a+bi) = sin(a)*cosh(b) +
+    cos(a)*sinh(b)*i. See the docstring for mpc_cos for additional
+    comments."""
+    a, b = z
+    if b == fzero:
+        return mpf_sin(a, prec, rnd), fzero
+    if a == fzero:
+        return fzero, mpf_sinh(b, prec, rnd)
+    wp = prec + 6
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(s, ch, prec, rnd)
+    im = mpf_mul(c, sh, prec, rnd)
+    return re, im
+
+def mpc_tan(z, prec, rnd=round_fast):
+    """Complex tangent. Computed as tan(a+bi) = sin(2a)/M + sinh(2b)/M*i
+    where M = cos(2a) + cosh(2b)."""
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if b == fzero: return mpf_tan(a, prec, rnd), fzero
+    if a == fzero: return fzero, mpf_tanh(b, prec, rnd)
+    wp = prec + 15
+    a = mpf_shift(a, 1)
+    b = mpf_shift(b, 1)
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    # TODO: handle cancellation when c ~=  -1 and ch ~= 1
+    mag = mpf_add(c, ch, wp)
+    re = mpf_div(s, mag, prec, rnd)
+    im = mpf_div(sh, mag, prec, rnd)
+    return re, im
+
+def mpc_cos_pi(z, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        return mpf_cos_pi(a, prec, rnd), fzero
+    b = mpf_mul(b, mpf_pi(prec+5), prec+5)
+    if a == fzero:
+        return mpf_cosh(b, prec, rnd), fzero
+    wp = prec + 6
+    c, s = mpf_cos_sin_pi(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(c, ch, prec, rnd)
+    im = mpf_mul(s, sh, prec, rnd)
+    return re, mpf_neg(im)
+
+def mpc_sin_pi(z, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        return mpf_sin_pi(a, prec, rnd), fzero
+    b = mpf_mul(b, mpf_pi(prec+5), prec+5)
+    if a == fzero:
+        return fzero, mpf_sinh(b, prec, rnd)
+    wp = prec + 6
+    c, s = mpf_cos_sin_pi(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    re = mpf_mul(s, ch, prec, rnd)
+    im = mpf_mul(c, sh, prec, rnd)
+    return re, im
+
+def mpc_cos_sin(z, prec, rnd=round_fast):
+    a, b = z
+    if a == fzero:
+        ch, sh = mpf_cosh_sinh(b, prec, rnd)
+        return (ch, fzero), (fzero, sh)
+    if b == fzero:
+        c, s = mpf_cos_sin(a, prec, rnd)
+        return (c, fzero), (s, fzero)
+    wp = prec + 6
+    c, s = mpf_cos_sin(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    cre = mpf_mul(c, ch, prec, rnd)
+    cim = mpf_mul(s, sh, prec, rnd)
+    sre = mpf_mul(s, ch, prec, rnd)
+    sim = mpf_mul(c, sh, prec, rnd)
+    return (cre, mpf_neg(cim)), (sre, sim)
+
+def mpc_cos_sin_pi(z, prec, rnd=round_fast):
+    a, b = z
+    if b == fzero:
+        c, s = mpf_cos_sin_pi(a, prec, rnd)
+        return (c, fzero), (s, fzero)
+    b = mpf_mul(b, mpf_pi(prec+5), prec+5)
+    if a == fzero:
+        ch, sh = mpf_cosh_sinh(b, prec, rnd)
+        return (ch, fzero), (fzero, sh)
+    wp = prec + 6
+    c, s = mpf_cos_sin_pi(a, wp)
+    ch, sh = mpf_cosh_sinh(b, wp)
+    cre = mpf_mul(c, ch, prec, rnd)
+    cim = mpf_mul(s, sh, prec, rnd)
+    sre = mpf_mul(s, ch, prec, rnd)
+    sim = mpf_mul(c, sh, prec, rnd)
+    return (cre, mpf_neg(cim)), (sre, sim)
+
+def mpc_cosh(z, prec, rnd=round_fast):
+    """Complex hyperbolic cosine. Computed as cosh(z) = cos(z*i)."""
+    a, b = z
+    return mpc_cos((b, mpf_neg(a)), prec, rnd)
+
+def mpc_sinh(z, prec, rnd=round_fast):
+    """Complex hyperbolic sine. Computed as sinh(z) = -i*sin(z*i)."""
+    a, b = z
+    b, a = mpc_sin((b, a), prec, rnd)
+    return a, b
+
+def mpc_tanh(z, prec, rnd=round_fast):
+    """Complex hyperbolic tangent. Computed as tanh(z) = -i*tan(z*i)."""
+    a, b = z
+    b, a = mpc_tan((b, a), prec, rnd)
+    return a, b
+
+# TODO: avoid loss of accuracy
+def mpc_atan(z, prec, rnd=round_fast):
+    a, b = z
+    # atan(z) = (I/2)*(log(1-I*z) - log(1+I*z))
+    # x = 1-I*z = 1 + b - I*a
+    # y = 1+I*z = 1 - b + I*a
+    wp = prec + 15
+    x = mpf_add(fone, b, wp), mpf_neg(a)
+    y = mpf_sub(fone, b, wp), a
+    l1 = mpc_log(x, wp)
+    l2 = mpc_log(y, wp)
+    a, b = mpc_sub(l1, l2, prec, rnd)
+    # (I/2) * (a+b*I) = (-b/2 + a/2*I)
+    v = mpf_neg(mpf_shift(b,-1)), mpf_shift(a,-1)
+    # Subtraction at infinity gives correct real part but
+    # wrong imaginary part (should be zero)
+    if v[1] == fnan and mpc_is_inf(z):
+        v = (v[0], fzero)
+    return v
+
+beta_crossover = from_float(0.6417)
+alpha_crossover = from_float(1.5)
+
+def acos_asin(z, prec, rnd, n):
+    """ complex acos for n = 0, asin for n = 1
+    The algorithm is described in
+    T.E. Hull, T.F. Fairgrieve and P.T.P. Tang
+    'Implementing the Complex Arcsine and Arcosine Functions
+    using Exception Handling',
+    ACM Trans. on Math. Software Vol. 23 (1997), p299
+    The complex acos and asin can be defined as
+    acos(z) = acos(beta) - I*sign(a)* log(alpha + sqrt(alpha**2 -1))
+    asin(z) = asin(beta) + I*sign(a)* log(alpha + sqrt(alpha**2 -1))
+    where z = a + I*b
+    alpha = (1/2)*(r + s); beta = (1/2)*(r - s) = a/alpha
+    r = sqrt((a+1)**2 + y**2); s = sqrt((a-1)**2 + y**2)
+    These expressions are rewritten in different ways in different
+    regions, delimited by two crossovers alpha_crossover and beta_crossover,
+    and by abs(a) <= 1, in order to improve the numerical accuracy.
+    """
+    a, b = z
+    wp = prec + 10
+    # special cases with real argument
+    if b == fzero:
+        am = mpf_sub(fone, mpf_abs(a), wp)
+        # case abs(a) <= 1
+        if not am[0]:
+            if n == 0:
+                return mpf_acos(a, prec, rnd), fzero
+            else:
+                return mpf_asin(a, prec, rnd), fzero
+        # cases abs(a) > 1
+        else:
+            # case a < -1
+            if a[0]:
+                pi = mpf_pi(prec, rnd)
+                c = mpf_acosh(mpf_neg(a), prec, rnd)
+                if n == 0:
+                    return pi, mpf_neg(c)
+                else:
+                    return mpf_neg(mpf_shift(pi, -1)), c
+            # case a > 1
+            else:
+                c = mpf_acosh(a, prec, rnd)
+                if n == 0:
+                    return fzero, c
+                else:
+                    pi = mpf_pi(prec, rnd)
+                    return mpf_shift(pi, -1), mpf_neg(c)
+    asign = bsign = 0
+    if a[0]:
+        a = mpf_neg(a)
+        asign = 1
+    if b[0]:
+        b = mpf_neg(b)
+        bsign = 1
+    am = mpf_sub(fone, a, wp)
+    ap = mpf_add(fone, a, wp)
+    r = mpf_hypot(ap, b, wp)
+    s = mpf_hypot(am, b, wp)
+    alpha = mpf_shift(mpf_add(r, s, wp), -1)
+    beta = mpf_div(a, alpha, wp)
+    b2 = mpf_mul(b,b, wp)
+    # case beta <= beta_crossover
+    if not mpf_sub(beta_crossover, beta, wp)[0]:
+        if n == 0:
+            re = mpf_acos(beta, wp)
+        else:
+            re = mpf_asin(beta, wp)
+    else:
+        # to compute the real part in this region use the identity
+        # asin(beta) = atan(beta/sqrt(1-beta**2))
+        # beta/sqrt(1-beta**2) = (alpha + a) * (alpha - a)
+        # alpha + a is numerically accurate; alpha - a can have
+        # cancellations leading to numerical inaccuracies, so rewrite
+        # it in differente ways according to the region
+        Ax = mpf_add(alpha, a, wp)
+        # case a <= 1
+        if not am[0]:
+            # c = b*b/(r + (a+1)); d = (s + (1-a))
+            # alpha - a = (1/2)*(c + d)
+            # case n=0: re = atan(sqrt((1/2) * Ax * (c + d))/a)
+            # case n=1: re = atan(a/sqrt((1/2) * Ax * (c + d)))
+            c = mpf_div(b2, mpf_add(r, ap, wp), wp)
+            d = mpf_add(s, am, wp)
+            re = mpf_shift(mpf_mul(Ax, mpf_add(c, d, wp), wp), -1)
+            if n == 0:
+                re = mpf_atan(mpf_div(mpf_sqrt(re, wp), a, wp), wp)
+            else:
+                re = mpf_atan(mpf_div(a, mpf_sqrt(re, wp), wp), wp)
+        else:
+            # c = Ax/(r + (a+1)); d = Ax/(s - (1-a))
+            # alpha - a = (1/2)*(c + d)
+            # case n = 0: re = atan(b*sqrt(c + d)/2/a)
+            # case n = 1: re = atan(a/(b*sqrt(c + d)/2)
+            c = mpf_div(Ax, mpf_add(r, ap, wp), wp)
+            d = mpf_div(Ax, mpf_sub(s, am, wp), wp)
+            re = mpf_shift(mpf_add(c, d, wp), -1)
+            re = mpf_mul(b, mpf_sqrt(re, wp), wp)
+            if n == 0:
+                re = mpf_atan(mpf_div(re, a, wp), wp)
+            else:
+                re = mpf_atan(mpf_div(a, re, wp), wp)
+    # to compute alpha + sqrt(alpha**2 - 1), if alpha <= alpha_crossover
+    # replace it with 1 + Am1 + sqrt(Am1*(alpha+1)))
+    # where Am1 = alpha -1
+    # if alpha <= alpha_crossover:
+    if not mpf_sub(alpha_crossover, alpha, wp)[0]:
+        c1 = mpf_div(b2, mpf_add(r, ap, wp), wp)
+        # case a < 1
+        if mpf_neg(am)[0]:
+            # Am1 = (1/2) * (b*b/(r + (a+1)) + b*b/(s + (1-a))
+            c2 = mpf_add(s, am, wp)
+            c2 = mpf_div(b2, c2, wp)
+            Am1 = mpf_shift(mpf_add(c1, c2, wp), -1)
+        else:
+            # Am1 = (1/2) * (b*b/(r + (a+1)) + (s - (1-a)))
+            c2 = mpf_sub(s, am, wp)
+            Am1 = mpf_shift(mpf_add(c1, c2, wp), -1)
+        # im = log(1 + Am1 + sqrt(Am1*(alpha+1)))
+        im = mpf_mul(Am1, mpf_add(alpha, fone, wp), wp)
+        im = mpf_log(mpf_add(fone, mpf_add(Am1, mpf_sqrt(im, wp), wp), wp), wp)
+    else:
+        # im = log(alpha + sqrt(alpha*alpha - 1))
+        im = mpf_sqrt(mpf_sub(mpf_mul(alpha, alpha, wp), fone, wp), wp)
+        im = mpf_log(mpf_add(alpha, im, wp), wp)
+    if asign:
+        if n == 0:
+            re = mpf_sub(mpf_pi(wp), re, wp)
+        else:
+            re = mpf_neg(re)
+    if not bsign and n == 0:
+        im = mpf_neg(im)
+    if bsign and n == 1:
+        im = mpf_neg(im)
+    re = normalize(re[0], re[1], re[2], re[3], prec, rnd)
+    im = normalize(im[0], im[1], im[2], im[3], prec, rnd)
+    return re, im
+
+def mpc_acos(z, prec, rnd=round_fast):
+    return acos_asin(z, prec, rnd, 0)
+
+def mpc_asin(z, prec, rnd=round_fast):
+    return acos_asin(z, prec, rnd, 1)
+
+def mpc_asinh(z, prec, rnd=round_fast):
+    # asinh(z) = I * asin(-I z)
+    a, b = z
+    a, b =  mpc_asin((b, mpf_neg(a)), prec, rnd)
+    return mpf_neg(b), a
+
+def mpc_acosh(z, prec, rnd=round_fast):
+    # acosh(z) = -I * acos(z)   for Im(acos(z)) <= 0
+    #            +I * acos(z)   otherwise
+    a, b = mpc_acos(z, prec, rnd)
+    if b[0] or b == fzero:
+        return mpf_neg(b), a
+    else:
+        return b, mpf_neg(a)
+
+def mpc_atanh(z, prec, rnd=round_fast):
+    # atanh(z) = (log(1+z)-log(1-z))/2
+    wp = prec + 15
+    a = mpc_add(z, mpc_one, wp)
+    b = mpc_sub(mpc_one, z, wp)
+    a = mpc_log(a, wp)
+    b = mpc_log(b, wp)
+    v = mpc_shift(mpc_sub(a, b, wp), -1)
+    # Subtraction at infinity gives correct imaginary part but
+    # wrong real part (should be zero)
+    if v[0] == fnan and mpc_is_inf(z):
+        v = (fzero, v[1])
+    return v
+
+def mpc_fibonacci(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        return (mpf_fibonacci(re, prec, rnd), fzero)
+    size = max(abs(re[2]+re[3]), abs(re[2]+re[3]))
+    wp = prec + size + 20
+    a = mpf_phi(wp)
+    b = mpf_add(mpf_shift(a, 1), fnone, wp)
+    u = mpc_pow((a, fzero), z, wp)
+    v = mpc_cos_pi(z, wp)
+    v = mpc_div(v, u, wp)
+    u = mpc_sub(u, v, wp)
+    u = mpc_div_mpf(u, b, prec, rnd)
+    return u
+
+def mpf_expj(x, prec, rnd='f'):
+    raise ComplexResult
+
+def mpc_expj(z, prec, rnd='f'):
+    re, im = z
+    if im == fzero:
+        return mpf_cos_sin(re, prec, rnd)
+    if re == fzero:
+        return mpf_exp(mpf_neg(im), prec, rnd), fzero
+    ey = mpf_exp(mpf_neg(im), prec+10)
+    c, s = mpf_cos_sin(re, prec+10)
+    re = mpf_mul(ey, c, prec, rnd)
+    im = mpf_mul(ey, s, prec, rnd)
+    return re, im
+
+def mpf_expjpi(x, prec, rnd='f'):
+    raise ComplexResult
+
+def mpc_expjpi(z, prec, rnd='f'):
+    re, im = z
+    if im == fzero:
+        return mpf_cos_sin_pi(re, prec, rnd)
+    sign, man, exp, bc = im
+    wp = prec+10
+    if man:
+        wp += max(0, exp+bc)
+    im = mpf_neg(mpf_mul(mpf_pi(wp), im, wp))
+    if re == fzero:
+        return mpf_exp(im, prec, rnd), fzero
+    ey = mpf_exp(im, prec+10)
+    c, s = mpf_cos_sin_pi(re, prec+10)
+    re = mpf_mul(ey, c, prec, rnd)
+    im = mpf_mul(ey, s, prec, rnd)
+    return re, im
+
+
+if BACKEND == 'sage':
+    try:
+        import sage.libs.mpmath.ext_libmp as _lbmp
+        mpc_exp = _lbmp.mpc_exp
+        mpc_sqrt = _lbmp.mpc_sqrt
+    except (ImportError, AttributeError):
+        print("Warning: Sage imports in libmpc failed")
diff --git a/lib/python3.11/site-packages/mpmath/libmp/libmpf.py b/lib/python3.11/site-packages/mpmath/libmp/libmpf.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c162e17d4f688c71dc3476b944e2d31c65faab7
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/libmpf.py
@@ -0,0 +1,1414 @@
+"""
+Low-level functions for arbitrary-precision floating-point arithmetic.
+"""
+
+__docformat__ = 'plaintext'
+
+import math
+
+from bisect import bisect
+
+import sys
+
+# Importing random is slow
+#from random import getrandbits
+getrandbits = None
+
+from .backend import (MPZ, MPZ_TYPE, MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_FIVE,
+    BACKEND, STRICT, HASH_MODULUS, HASH_BITS, gmpy, sage, sage_utils)
+
+from .libintmath import (giant_steps,
+    trailtable, bctable, lshift, rshift, bitcount, trailing,
+    sqrt_fixed, numeral, isqrt, isqrt_fast, sqrtrem,
+    bin_to_radix)
+
+# We don't pickle tuples directly for the following reasons:
+#   1: pickle uses str() for ints, which is inefficient when they are large
+#   2: pickle doesn't work for gmpy mpzs
+# Both problems are solved by using hex()
+
+if BACKEND == 'sage':
+    def to_pickable(x):
+        sign, man, exp, bc = x
+        return sign, hex(man), exp, bc
+else:
+    def to_pickable(x):
+        sign, man, exp, bc = x
+        return sign, hex(man)[2:], exp, bc
+
+def from_pickable(x):
+    sign, man, exp, bc = x
+    return (sign, MPZ(man, 16), exp, bc)
+
+class ComplexResult(ValueError):
+    pass
+
+try:
+    intern
+except NameError:
+    intern = lambda x: x
+
+# All supported rounding modes
+round_nearest = intern('n')
+round_floor = intern('f')
+round_ceiling = intern('c')
+round_up = intern('u')
+round_down = intern('d')
+round_fast = round_down
+
+def prec_to_dps(n):
+    """Return number of accurate decimals that can be represented
+    with a precision of n bits."""
+    return max(1, int(round(int(n)/3.3219280948873626)-1))
+
+def dps_to_prec(n):
+    """Return the number of bits required to represent n decimals
+    accurately."""
+    return max(1, int(round((int(n)+1)*3.3219280948873626)))
+
+def repr_dps(n):
+    """Return the number of decimal digits required to represent
+    a number with n-bit precision so that it can be uniquely
+    reconstructed from the representation."""
+    dps = prec_to_dps(n)
+    if dps == 15:
+        return 17
+    return dps + 3
+
+#----------------------------------------------------------------------------#
+#                    Some commonly needed float values                       #
+#----------------------------------------------------------------------------#
+
+# Regular number format:
+# (-1)**sign * mantissa * 2**exponent, plus bitcount of mantissa
+fzero = (0, MPZ_ZERO, 0, 0)
+fnzero = (1, MPZ_ZERO, 0, 0)
+fone = (0, MPZ_ONE, 0, 1)
+fnone = (1, MPZ_ONE, 0, 1)
+ftwo = (0, MPZ_ONE, 1, 1)
+ften = (0, MPZ_FIVE, 1, 3)
+fhalf = (0, MPZ_ONE, -1, 1)
+
+# Arbitrary encoding for special numbers: zero mantissa, nonzero exponent
+fnan = (0, MPZ_ZERO, -123, -1)
+finf = (0, MPZ_ZERO, -456, -2)
+fninf = (1, MPZ_ZERO, -789, -3)
+
+# Was 1e1000; this is broken in Python 2.4
+math_float_inf = 1e300 * 1e300
+
+
+#----------------------------------------------------------------------------#
+#                                  Rounding                                  #
+#----------------------------------------------------------------------------#
+
+# This function can be used to round a mantissa generally. However,
+# we will try to do most rounding inline for efficiency.
+def round_int(x, n, rnd):
+    if rnd == round_nearest:
+        if x >= 0:
+            t = x >> (n-1)
+            if t & 1 and ((t & 2) or (x & h_mask[n<300][n])):
+                return (t>>1)+1
+            else:
+                return t>>1
+        else:
+            return -round_int(-x, n, rnd)
+    if rnd == round_floor:
+        return x >> n
+    if rnd == round_ceiling:
+        return -((-x) >> n)
+    if rnd == round_down:
+        if x >= 0:
+            return x >> n
+        return -((-x) >> n)
+    if rnd == round_up:
+        if x >= 0:
+            return -((-x) >> n)
+        return x >> n
+
+# These masks are used to pick out segments of numbers to determine
+# which direction to round when rounding to nearest.
+class h_mask_big:
+    def __getitem__(self, n):
+        return (MPZ_ONE<<(n-1))-1
+
+h_mask_small = [0]+[((MPZ_ONE<<(_-1))-1) for _ in range(1, 300)]
+h_mask = [h_mask_big(), h_mask_small]
+
+# The >> operator rounds to floor. shifts_down[rnd][sign]
+# tells whether this is the right direction to use, or if the
+# number should be negated before shifting
+shifts_down = {round_floor:(1,0), round_ceiling:(0,1),
+    round_down:(1,1), round_up:(0,0)}
+
+
+#----------------------------------------------------------------------------#
+#                          Normalization of raw mpfs                         #
+#----------------------------------------------------------------------------#
+
+# This function is called almost every time an mpf is created.
+# It has been optimized accordingly.
+
+def _normalize(sign, man, exp, bc, prec, rnd):
+    """
+    Create a raw mpf tuple with value (-1)**sign * man * 2**exp and
+    normalized mantissa. The mantissa is rounded in the specified
+    direction if its size exceeds the precision. Trailing zero bits
+    are also stripped from the mantissa to ensure that the
+    representation is canonical.
+
+    Conditions on the input:
+    * The input must represent a regular (finite) number
+    * The sign bit must be 0 or 1
+    * The mantissa must be positive
+    * The exponent must be an integer
+    * The bitcount must be exact
+
+    If these conditions are not met, use from_man_exp, mpf_pos, or any
+    of the conversion functions to create normalized raw mpf tuples.
+    """
+    if not man:
+        return fzero
+    # Cut mantissa down to size if larger than target precision
+    n = bc - prec
+    if n > 0:
+        if rnd == round_nearest:
+            t = man >> (n-1)
+            if t & 1 and ((t & 2) or (man & h_mask[n<300][n])):
+                man = (t>>1)+1
+            else:
+                man = t>>1
+        elif shifts_down[rnd][sign]:
+            man >>= n
+        else:
+            man = -((-man)>>n)
+        exp += n
+        bc = prec
+    # Strip trailing bits
+    if not man & 1:
+        t = trailtable[int(man & 255)]
+        if not t:
+            while not man & 255:
+                man >>= 8
+                exp += 8
+                bc -= 8
+            t = trailtable[int(man & 255)]
+        man >>= t
+        exp += t
+        bc -= t
+    # Bit count can be wrong if the input mantissa was 1 less than
+    # a power of 2 and got rounded up, thereby adding an extra bit.
+    # With trailing bits removed, all powers of two have mantissa 1,
+    # so this is easy to check for.
+    if man == 1:
+        bc = 1
+    return sign, man, exp, bc
+
+def _normalize1(sign, man, exp, bc, prec, rnd):
+    """same as normalize, but with the added condition that
+       man is odd or zero
+    """
+    if not man:
+        return fzero
+    if bc <= prec:
+        return sign, man, exp, bc
+    n = bc - prec
+    if rnd == round_nearest:
+        t = man >> (n-1)
+        if t & 1 and ((t & 2) or (man & h_mask[n<300][n])):
+            man = (t>>1)+1
+        else:
+            man = t>>1
+    elif shifts_down[rnd][sign]:
+        man >>= n
+    else:
+        man = -((-man)>>n)
+    exp += n
+    bc = prec
+    # Strip trailing bits
+    if not man & 1:
+        t = trailtable[int(man & 255)]
+        if not t:
+            while not man & 255:
+                man >>= 8
+                exp += 8
+                bc -= 8
+            t = trailtable[int(man & 255)]
+        man >>= t
+        exp += t
+        bc -= t
+    # Bit count can be wrong if the input mantissa was 1 less than
+    # a power of 2 and got rounded up, thereby adding an extra bit.
+    # With trailing bits removed, all powers of two have mantissa 1,
+    # so this is easy to check for.
+    if man == 1:
+        bc = 1
+    return sign, man, exp, bc
+
+try:
+    _exp_types = (int, long)
+except NameError:
+    _exp_types = (int,)
+
+def strict_normalize(sign, man, exp, bc, prec, rnd):
+    """Additional checks on the components of an mpf. Enable tests by setting
+       the environment variable MPMATH_STRICT to Y."""
+    assert type(man) == MPZ_TYPE
+    assert type(bc) in _exp_types
+    assert type(exp) in _exp_types
+    assert bc == bitcount(man)
+    return _normalize(sign, man, exp, bc, prec, rnd)
+
+def strict_normalize1(sign, man, exp, bc, prec, rnd):
+    """Additional checks on the components of an mpf. Enable tests by setting
+       the environment variable MPMATH_STRICT to Y."""
+    assert type(man) == MPZ_TYPE
+    assert type(bc) in _exp_types
+    assert type(exp) in _exp_types
+    assert bc == bitcount(man)
+    assert (not man) or (man & 1)
+    return _normalize1(sign, man, exp, bc, prec, rnd)
+
+if BACKEND == 'gmpy' and '_mpmath_normalize' in dir(gmpy):
+    _normalize = gmpy._mpmath_normalize
+    _normalize1 = gmpy._mpmath_normalize
+
+if BACKEND == 'sage':
+    _normalize = _normalize1 = sage_utils.normalize
+
+if STRICT:
+    normalize = strict_normalize
+    normalize1 = strict_normalize1
+else:
+    normalize = _normalize
+    normalize1 = _normalize1
+
+#----------------------------------------------------------------------------#
+#                            Conversion functions                            #
+#----------------------------------------------------------------------------#
+
+def from_man_exp(man, exp, prec=None, rnd=round_fast):
+    """Create raw mpf from (man, exp) pair. The mantissa may be signed.
+    If no precision is specified, the mantissa is stored exactly."""
+    man = MPZ(man)
+    sign = 0
+    if man < 0:
+        sign = 1
+        man = -man
+    if man < 1024:
+        bc = bctable[int(man)]
+    else:
+        bc = bitcount(man)
+    if not prec:
+        if not man:
+            return fzero
+        if not man & 1:
+            if man & 2:
+                return (sign, man >> 1, exp + 1, bc - 1)
+            t = trailtable[int(man & 255)]
+            if not t:
+                while not man & 255:
+                    man >>= 8
+                    exp += 8
+                    bc -= 8
+                t = trailtable[int(man & 255)]
+            man >>= t
+            exp += t
+            bc -= t
+        return (sign, man, exp, bc)
+    return normalize(sign, man, exp, bc, prec, rnd)
+
+int_cache = dict((n, from_man_exp(n, 0)) for n in range(-10, 257))
+
+if BACKEND == 'gmpy' and '_mpmath_create' in dir(gmpy):
+    from_man_exp = gmpy._mpmath_create
+
+if BACKEND == 'sage':
+    from_man_exp = sage_utils.from_man_exp
+
+def from_int(n, prec=0, rnd=round_fast):
+    """Create a raw mpf from an integer. If no precision is specified,
+    the mantissa is stored exactly."""
+    if not prec:
+        if n in int_cache:
+            return int_cache[n]
+    return from_man_exp(n, 0, prec, rnd)
+
+def to_man_exp(s):
+    """Return (man, exp) of a raw mpf. Raise an error if inf/nan."""
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        raise ValueError("mantissa and exponent are undefined for %s" % man)
+    return man, exp
+
+def to_int(s, rnd=None):
+    """Convert a raw mpf to the nearest int. Rounding is done down by
+    default (same as int(float) in Python), but can be changed. If the
+    input is inf/nan, an exception is raised."""
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        raise ValueError("cannot convert inf or nan to int")
+    if exp >= 0:
+        if sign:
+            return (-man) << exp
+        return man << exp
+    # Make default rounding fast
+    if not rnd:
+        if sign:
+            return -(man >> (-exp))
+        else:
+            return man >> (-exp)
+    if sign:
+        return round_int(-man, -exp, rnd)
+    else:
+        return round_int(man, -exp, rnd)
+
+def mpf_round_int(s, rnd):
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        return s
+    if exp >= 0:
+        return s
+    mag = exp+bc
+    if mag < 1:
+        if rnd == round_ceiling:
+            if sign: return fzero
+            else:    return fone
+        elif rnd == round_floor:
+            if sign: return fnone
+            else:    return fzero
+        elif rnd == round_nearest:
+            if mag < 0 or man == MPZ_ONE: return fzero
+            elif sign: return fnone
+            else:      return fone
+        else:
+            raise NotImplementedError
+    return mpf_pos(s, min(bc, mag), rnd)
+
+def mpf_floor(s, prec=0, rnd=round_fast):
+    v = mpf_round_int(s, round_floor)
+    if prec:
+        v = mpf_pos(v, prec, rnd)
+    return v
+
+def mpf_ceil(s, prec=0, rnd=round_fast):
+    v = mpf_round_int(s, round_ceiling)
+    if prec:
+        v = mpf_pos(v, prec, rnd)
+    return v
+
+def mpf_nint(s, prec=0, rnd=round_fast):
+    v = mpf_round_int(s, round_nearest)
+    if prec:
+        v = mpf_pos(v, prec, rnd)
+    return v
+
+def mpf_frac(s, prec=0, rnd=round_fast):
+    return mpf_sub(s, mpf_floor(s), prec, rnd)
+
+def from_float(x, prec=53, rnd=round_fast):
+    """Create a raw mpf from a Python float, rounding if necessary.
+    If prec >= 53, the result is guaranteed to represent exactly the
+    same number as the input. If prec is not specified, use prec=53."""
+    # frexp only raises an exception for nan on some platforms
+    if x != x:
+        return fnan
+    # in Python2.5 math.frexp gives an exception for float infinity
+    # in Python2.6 it returns (float infinity, 0)
+    try:
+        m, e = math.frexp(x)
+    except:
+        if x == math_float_inf: return finf
+        if x == -math_float_inf: return fninf
+        return fnan
+    if x == math_float_inf: return finf
+    if x == -math_float_inf: return fninf
+    return from_man_exp(int(m*(1<<53)), e-53, prec, rnd)
+
+def from_npfloat(x, prec=113, rnd=round_fast):
+    """Create a raw mpf from a numpy float, rounding if necessary.
+    If prec >= 113, the result is guaranteed to represent exactly the
+    same number as the input. If prec is not specified, use prec=113."""
+    y = float(x)
+    if x == y: # ldexp overflows for float16
+        return from_float(y, prec, rnd)
+    import numpy as np
+    if np.isfinite(x):
+        m, e = np.frexp(x)
+        return from_man_exp(int(np.ldexp(m, 113)), int(e-113), prec, rnd)
+    if np.isposinf(x): return finf
+    if np.isneginf(x): return fninf
+    return fnan
+
+def from_Decimal(x, prec=None, rnd=round_fast):
+    """Create a raw mpf from a Decimal, rounding if necessary.
+    If prec is not specified, use the equivalent bit precision
+    of the number of significant digits in x."""
+    if x.is_nan(): return fnan
+    if x.is_infinite(): return fninf if x.is_signed() else finf
+    if prec is None:
+        prec = int(len(x.as_tuple()[1])*3.3219280948873626)
+    return from_str(str(x), prec, rnd)
+
+def to_float(s, strict=False, rnd=round_fast):
+    """
+    Convert a raw mpf to a Python float. The result is exact if the
+    bitcount of s is <= 53 and no underflow/overflow occurs.
+
+    If the number is too large or too small to represent as a regular
+    float, it will be converted to inf or 0.0. Setting strict=True
+    forces an OverflowError to be raised instead.
+
+    Warning: with a directed rounding mode, the correct nearest representable
+    floating-point number in the specified direction might not be computed
+    in case of overflow or (gradual) underflow.
+    """
+    sign, man, exp, bc = s
+    if not man:
+        if s == fzero: return 0.0
+        if s == finf: return math_float_inf
+        if s == fninf: return -math_float_inf
+        return math_float_inf/math_float_inf
+    if bc > 53:
+        sign, man, exp, bc = normalize1(sign, man, exp, bc, 53, rnd)
+    if sign:
+        man = -man
+    try:
+        return math.ldexp(man, exp)
+    except OverflowError:
+        if strict:
+            raise
+        # Overflow to infinity
+        if exp + bc > 0:
+            if sign:
+                return -math_float_inf
+            else:
+                return math_float_inf
+        # Underflow to zero
+        return 0.0
+
+def from_rational(p, q, prec, rnd=round_fast):
+    """Create a raw mpf from a rational number p/q, round if
+    necessary."""
+    return mpf_div(from_int(p), from_int(q), prec, rnd)
+
+def to_rational(s):
+    """Convert a raw mpf to a rational number. Return integers (p, q)
+    such that s = p/q exactly."""
+    sign, man, exp, bc = s
+    if sign:
+        man = -man
+    if bc == -1:
+        raise ValueError("cannot convert %s to a rational number" % man)
+    if exp >= 0:
+        return man * (1<<exp), 1
+    else:
+        return man, 1<<(-exp)
+
+def to_fixed(s, prec):
+    """Convert a raw mpf to a fixed-point big integer"""
+    sign, man, exp, bc = s
+    offset = exp + prec
+    if sign:
+        if offset >= 0: return (-man) << offset
+        else:           return (-man) >> (-offset)
+    else:
+        if offset >= 0: return man << offset
+        else:           return man >> (-offset)
+
+
+##############################################################################
+##############################################################################
+
+#----------------------------------------------------------------------------#
+#                       Arithmetic operations, etc.                          #
+#----------------------------------------------------------------------------#
+
+def mpf_rand(prec):
+    """Return a raw mpf chosen randomly from [0, 1), with prec bits
+    in the mantissa."""
+    global getrandbits
+    if not getrandbits:
+        import random
+        getrandbits = random.getrandbits
+    return from_man_exp(getrandbits(prec), -prec, prec, round_floor)
+
+def mpf_eq(s, t):
+    """Test equality of two raw mpfs. This is simply tuple comparison
+    unless either number is nan, in which case the result is False."""
+    if not s[1] or not t[1]:
+        if s == fnan or t == fnan:
+            return False
+    return s == t
+
+def mpf_hash(s):
+    # Duplicate the new hash algorithm introduces in Python 3.2.
+    if sys.version_info >= (3, 2):
+        ssign, sman, sexp, sbc = s
+
+        # Handle special numbers
+        if not sman:
+            if s == fnan: return sys.hash_info.nan
+            if s == finf: return sys.hash_info.inf
+            if s == fninf: return -sys.hash_info.inf
+        h = sman % HASH_MODULUS
+        if sexp >= 0:
+            sexp = sexp % HASH_BITS
+        else:
+            sexp = HASH_BITS - 1 - ((-1 - sexp) % HASH_BITS)
+        h = (h << sexp) % HASH_MODULUS
+        if ssign: h = -h
+        if h == -1: h = -2
+        return int(h)
+    else:
+        try:
+            # Try to be compatible with hash values for floats and ints
+            return hash(to_float(s, strict=1))
+        except OverflowError:
+            # We must unfortunately sacrifice compatibility with ints here.
+            # We could do hash(man << exp) when the exponent is positive, but
+            # this would cause unreasonable inefficiency for large numbers.
+            return hash(s)
+
+def mpf_cmp(s, t):
+    """Compare the raw mpfs s and t. Return -1 if s < t, 0 if s == t,
+    and 1 if s > t. (Same convention as Python's cmp() function.)"""
+
+    # In principle, a comparison amounts to determining the sign of s-t.
+    # A full subtraction is relatively slow, however, so we first try to
+    # look at the components.
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+
+    # Handle zeros and special numbers
+    if not sman or not tman:
+        if s == fzero: return -mpf_sign(t)
+        if t == fzero: return mpf_sign(s)
+        if s == t: return 0
+        # Follow same convention as Python's cmp for float nan
+        if t == fnan: return 1
+        if s == finf: return 1
+        if t == fninf: return 1
+        return -1
+    # Different sides of zero
+    if ssign != tsign:
+        if not ssign: return 1
+        return -1
+    # This reduces to direct integer comparison
+    if sexp == texp:
+        if sman == tman:
+            return 0
+        if sman > tman:
+            if ssign: return -1
+            else:     return 1
+        else:
+            if ssign: return 1
+            else:     return -1
+    # Check position of the highest set bit in each number. If
+    # different, there is certainly an inequality.
+    a = sbc + sexp
+    b = tbc + texp
+    if ssign:
+        if a < b: return 1
+        if a > b: return -1
+    else:
+        if a < b: return -1
+        if a > b: return 1
+
+    # Both numbers have the same highest bit. Subtract to find
+    # how the lower bits compare.
+    delta = mpf_sub(s, t, 5, round_floor)
+    if delta[0]:
+        return -1
+    return 1
+
+def mpf_lt(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) < 0
+
+def mpf_le(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) <= 0
+
+def mpf_gt(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) > 0
+
+def mpf_ge(s, t):
+    if s == fnan or t == fnan:
+        return False
+    return mpf_cmp(s, t) >= 0
+
+def mpf_min_max(seq):
+    min = max = seq[0]
+    for x in seq[1:]:
+        if mpf_lt(x, min): min = x
+        if mpf_gt(x, max): max = x
+    return min, max
+
+def mpf_pos(s, prec=0, rnd=round_fast):
+    """Calculate 0+s for a raw mpf (i.e., just round s to the specified
+    precision)."""
+    if prec:
+        sign, man, exp, bc = s
+        if (not man) and exp:
+            return s
+        return normalize1(sign, man, exp, bc, prec, rnd)
+    return s
+
+def mpf_neg(s, prec=None, rnd=round_fast):
+    """Negate a raw mpf (return -s), rounding the result to the
+    specified precision. The prec argument can be omitted to do the
+    operation exactly."""
+    sign, man, exp, bc = s
+    if not man:
+        if exp:
+            if s == finf: return fninf
+            if s == fninf: return finf
+        return s
+    if not prec:
+        return (1-sign, man, exp, bc)
+    return normalize1(1-sign, man, exp, bc, prec, rnd)
+
+def mpf_abs(s, prec=None, rnd=round_fast):
+    """Return abs(s) of the raw mpf s, rounded to the specified
+    precision. The prec argument can be omitted to generate an
+    exact result."""
+    sign, man, exp, bc = s
+    if (not man) and exp:
+        if s == fninf:
+            return finf
+        return s
+    if not prec:
+        if sign:
+            return (0, man, exp, bc)
+        return s
+    return normalize1(0, man, exp, bc, prec, rnd)
+
+def mpf_sign(s):
+    """Return -1, 0, or 1 (as a Python int, not a raw mpf) depending on
+    whether s is negative, zero, or positive. (Nan is taken to give 0.)"""
+    sign, man, exp, bc = s
+    if not man:
+        if s == finf: return 1
+        if s == fninf: return -1
+        return 0
+    return (-1) ** sign
+
+def mpf_add(s, t, prec=0, rnd=round_fast, _sub=0):
+    """
+    Add the two raw mpf values s and t.
+
+    With prec=0, no rounding is performed. Note that this can
+    produce a very large mantissa (potentially too large to fit
+    in memory) if exponents are far apart.
+    """
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    tsign ^= _sub
+    # Standard case: two nonzero, regular numbers
+    if sman and tman:
+        offset = sexp - texp
+        if offset:
+            if offset > 0:
+                # Outside precision range; only need to perturb
+                if offset > 100 and prec:
+                    delta = sbc + sexp - tbc - texp
+                    if delta > prec + 4:
+                        offset = prec + 4
+                        sman <<= offset
+                        if tsign == ssign: sman += 1
+                        else:              sman -= 1
+                        return normalize1(ssign, sman, sexp-offset,
+                            bitcount(sman), prec, rnd)
+                # Add
+                if ssign == tsign:
+                    man = tman + (sman << offset)
+                # Subtract
+                else:
+                    if ssign: man = tman - (sman << offset)
+                    else:     man = (sman << offset) - tman
+                    if man >= 0:
+                        ssign = 0
+                    else:
+                        man = -man
+                        ssign = 1
+                bc = bitcount(man)
+                return normalize1(ssign, man, texp, bc, prec or bc, rnd)
+            elif offset < 0:
+                # Outside precision range; only need to perturb
+                if offset < -100 and prec:
+                    delta = tbc + texp - sbc - sexp
+                    if delta > prec + 4:
+                        offset = prec + 4
+                        tman <<= offset
+                        if ssign == tsign: tman += 1
+                        else:              tman -= 1
+                        return normalize1(tsign, tman, texp-offset,
+                            bitcount(tman), prec, rnd)
+                # Add
+                if ssign == tsign:
+                    man = sman + (tman << -offset)
+                # Subtract
+                else:
+                    if tsign: man = sman - (tman << -offset)
+                    else:     man = (tman << -offset) - sman
+                    if man >= 0:
+                        ssign = 0
+                    else:
+                        man = -man
+                        ssign = 1
+                bc = bitcount(man)
+                return normalize1(ssign, man, sexp, bc, prec or bc, rnd)
+        # Equal exponents; no shifting necessary
+        if ssign == tsign:
+            man = tman + sman
+        else:
+            if ssign: man = tman - sman
+            else:     man = sman - tman
+            if man >= 0:
+                ssign = 0
+            else:
+                man = -man
+                ssign = 1
+        bc = bitcount(man)
+        return normalize(ssign, man, texp, bc, prec or bc, rnd)
+    # Handle zeros and special numbers
+    if _sub:
+        t = mpf_neg(t)
+    if not sman:
+        if sexp:
+            if s == t or tman or not texp:
+                return s
+            return fnan
+        if tman:
+            return normalize1(tsign, tman, texp, tbc, prec or tbc, rnd)
+        return t
+    if texp:
+        return t
+    if sman:
+        return normalize1(ssign, sman, sexp, sbc, prec or sbc, rnd)
+    return s
+
+def mpf_sub(s, t, prec=0, rnd=round_fast):
+    """Return the difference of two raw mpfs, s-t. This function is
+    simply a wrapper of mpf_add that changes the sign of t."""
+    return mpf_add(s, t, prec, rnd, 1)
+
+def mpf_sum(xs, prec=0, rnd=round_fast, absolute=False):
+    """
+    Sum a list of mpf values efficiently and accurately
+    (typically no temporary roundoff occurs). If prec=0,
+    the final result will not be rounded either.
+
+    There may be roundoff error or cancellation if extremely
+    large exponent differences occur.
+
+    With absolute=True, sums the absolute values.
+    """
+    man = 0
+    exp = 0
+    max_extra_prec = prec*2 or 1000000  # XXX
+    special = None
+    for x in xs:
+        xsign, xman, xexp, xbc = x
+        if xman:
+            if xsign and not absolute:
+                xman = -xman
+            delta = xexp - exp
+            if xexp >= exp:
+                # x much larger than existing sum?
+                # first: quick test
+                if (delta > max_extra_prec) and \
+                    ((not man) or delta-bitcount(abs(man)) > max_extra_prec):
+                    man = xman
+                    exp = xexp
+                else:
+                    man += (xman << delta)
+            else:
+                delta = -delta
+                # x much smaller than existing sum?
+                if delta-xbc > max_extra_prec:
+                    if not man:
+                        man, exp = xman, xexp
+                else:
+                    man = (man << delta) + xman
+                    exp = xexp
+        elif xexp:
+            if absolute:
+                x = mpf_abs(x)
+            special = mpf_add(special or fzero, x, 1)
+    # Will be inf or nan
+    if special:
+        return special
+    return from_man_exp(man, exp, prec, rnd)
+
+def gmpy_mpf_mul(s, t, prec=0, rnd=round_fast):
+    """Multiply two raw mpfs"""
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    sign = ssign ^ tsign
+    man = sman*tman
+    if man:
+        bc = bitcount(man)
+        if prec:
+            return normalize1(sign, man, sexp+texp, bc, prec, rnd)
+        else:
+            return (sign, man, sexp+texp, bc)
+    s_special = (not sman) and sexp
+    t_special = (not tman) and texp
+    if not s_special and not t_special:
+        return fzero
+    if fnan in (s, t): return fnan
+    if (not tman) and texp: s, t = t, s
+    if t == fzero: return fnan
+    return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
+
+def gmpy_mpf_mul_int(s, n, prec, rnd=round_fast):
+    """Multiply by a Python integer."""
+    sign, man, exp, bc = s
+    if not man:
+        return mpf_mul(s, from_int(n), prec, rnd)
+    if not n:
+        return fzero
+    if n < 0:
+        sign ^= 1
+        n = -n
+    man *= n
+    return normalize(sign, man, exp, bitcount(man), prec, rnd)
+
+def python_mpf_mul(s, t, prec=0, rnd=round_fast):
+    """Multiply two raw mpfs"""
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    sign = ssign ^ tsign
+    man = sman*tman
+    if man:
+        bc = sbc + tbc - 1
+        bc += int(man>>bc)
+        if prec:
+            return normalize1(sign, man, sexp+texp, bc, prec, rnd)
+        else:
+            return (sign, man, sexp+texp, bc)
+    s_special = (not sman) and sexp
+    t_special = (not tman) and texp
+    if not s_special and not t_special:
+        return fzero
+    if fnan in (s, t): return fnan
+    if (not tman) and texp: s, t = t, s
+    if t == fzero: return fnan
+    return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
+
+def python_mpf_mul_int(s, n, prec, rnd=round_fast):
+    """Multiply by a Python integer."""
+    sign, man, exp, bc = s
+    if not man:
+        return mpf_mul(s, from_int(n), prec, rnd)
+    if not n:
+        return fzero
+    if n < 0:
+        sign ^= 1
+        n = -n
+    man *= n
+    # Generally n will be small
+    if n < 1024:
+        bc += bctable[int(n)] - 1
+    else:
+        bc += bitcount(n) - 1
+    bc += int(man>>bc)
+    return normalize(sign, man, exp, bc, prec, rnd)
+
+
+if BACKEND == 'gmpy':
+    mpf_mul = gmpy_mpf_mul
+    mpf_mul_int = gmpy_mpf_mul_int
+else:
+    mpf_mul = python_mpf_mul
+    mpf_mul_int = python_mpf_mul_int
+
+def mpf_shift(s, n):
+    """Quickly multiply the raw mpf s by 2**n without rounding."""
+    sign, man, exp, bc = s
+    if not man:
+        return s
+    return sign, man, exp+n, bc
+
+def mpf_frexp(x):
+    """Convert x = y*2**n to (y, n) with abs(y) in [0.5, 1) if nonzero"""
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero:
+            return (fzero, 0)
+        else:
+            raise ValueError
+    return mpf_shift(x, -bc-exp), bc+exp
+
+def mpf_div(s, t, prec, rnd=round_fast):
+    """Floating-point division"""
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    if not sman or not tman:
+        if s == fzero:
+            if t == fzero: raise ZeroDivisionError
+            if t == fnan: return fnan
+            return fzero
+        if t == fzero:
+            raise ZeroDivisionError
+        s_special = (not sman) and sexp
+        t_special = (not tman) and texp
+        if s_special and t_special:
+            return fnan
+        if s == fnan or t == fnan:
+            return fnan
+        if not t_special:
+            if t == fzero:
+                return fnan
+            return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
+        return fzero
+    sign = ssign ^ tsign
+    if tman == 1:
+        return normalize1(sign, sman, sexp-texp, sbc, prec, rnd)
+    # Same strategy as for addition: if there is a remainder, perturb
+    # the result a few bits outside the precision range before rounding
+    extra = prec - sbc + tbc + 5
+    if extra < 5:
+        extra = 5
+    quot, rem = divmod(sman<<extra, tman)
+    if rem:
+        quot = (quot<<1) + 1
+        extra += 1
+        return normalize1(sign, quot, sexp-texp-extra, bitcount(quot), prec, rnd)
+    return normalize(sign, quot, sexp-texp-extra, bitcount(quot), prec, rnd)
+
+def mpf_rdiv_int(n, t, prec, rnd=round_fast):
+    """Floating-point division n/t with a Python integer as numerator"""
+    sign, man, exp, bc = t
+    if not n or not man:
+        return mpf_div(from_int(n), t, prec, rnd)
+    if n < 0:
+        sign ^= 1
+        n = -n
+    extra = prec + bc + 5
+    quot, rem = divmod(n<<extra, man)
+    if rem:
+        quot = (quot<<1) + 1
+        extra += 1
+        return normalize1(sign, quot, -exp-extra, bitcount(quot), prec, rnd)
+    return normalize(sign, quot, -exp-extra, bitcount(quot), prec, rnd)
+
+def mpf_mod(s, t, prec, rnd=round_fast):
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    if ((not sman) and sexp) or ((not tman) and texp):
+        return fnan
+    # Important special case: do nothing if t is larger
+    if ssign == tsign and texp > sexp+sbc:
+        return s
+    # Another important special case: this allows us to do e.g. x % 1.0
+    # to find the fractional part of x, and it will work when x is huge.
+    if tman == 1 and sexp > texp+tbc:
+        return fzero
+    base = min(sexp, texp)
+    sman = (-1)**ssign * sman
+    tman = (-1)**tsign * tman
+    man = (sman << (sexp-base)) % (tman << (texp-base))
+    if man >= 0:
+        sign = 0
+    else:
+        man = -man
+        sign = 1
+    return normalize(sign, man, base, bitcount(man), prec, rnd)
+
+reciprocal_rnd = {
+  round_down : round_up,
+  round_up : round_down,
+  round_floor : round_ceiling,
+  round_ceiling : round_floor,
+  round_nearest : round_nearest
+}
+
+negative_rnd = {
+  round_down : round_down,
+  round_up : round_up,
+  round_floor : round_ceiling,
+  round_ceiling : round_floor,
+  round_nearest : round_nearest
+}
+
+def mpf_pow_int(s, n, prec, rnd=round_fast):
+    """Compute s**n, where s is a raw mpf and n is a Python integer."""
+    sign, man, exp, bc = s
+
+    if (not man) and exp:
+        if s == finf:
+            if n > 0: return s
+            if n == 0: return fnan
+            return fzero
+        if s == fninf:
+            if n > 0: return [finf, fninf][n & 1]
+            if n == 0: return fnan
+            return fzero
+        return fnan
+
+    n = int(n)
+    if n == 0: return fone
+    if n == 1: return mpf_pos(s, prec, rnd)
+    if n == 2:
+        _, man, exp, bc = s
+        if not man:
+            return fzero
+        man = man*man
+        if man == 1:
+            return (0, MPZ_ONE, exp+exp, 1)
+        bc = bc + bc - 2
+        bc += bctable[int(man>>bc)]
+        return normalize1(0, man, exp+exp, bc, prec, rnd)
+    if n == -1: return mpf_div(fone, s, prec, rnd)
+    if n < 0:
+        inverse = mpf_pow_int(s, -n, prec+5, reciprocal_rnd[rnd])
+        return mpf_div(fone, inverse, prec, rnd)
+
+    result_sign = sign & n
+
+    # Use exact integer power when the exact mantissa is small
+    if man == 1:
+        return (result_sign, MPZ_ONE, exp*n, 1)
+    if bc*n < 1000:
+        man **= n
+        return normalize1(result_sign, man, exp*n, bitcount(man), prec, rnd)
+
+    # Use directed rounding all the way through to maintain rigorous
+    # bounds for interval arithmetic
+    rounds_down = (rnd == round_nearest) or \
+        shifts_down[rnd][result_sign]
+
+    # Now we perform binary exponentiation. Need to estimate precision
+    # to avoid rounding errors from temporary operations. Roughly log_2(n)
+    # operations are performed.
+    workprec = prec + 4*bitcount(n) + 4
+    _, pm, pe, pbc = fone
+    while 1:
+        if n & 1:
+            pm = pm*man
+            pe = pe+exp
+            pbc += bc - 2
+            pbc = pbc + bctable[int(pm >> pbc)]
+            if pbc > workprec:
+                if rounds_down:
+                    pm = pm >> (pbc-workprec)
+                else:
+                    pm = -((-pm) >> (pbc-workprec))
+                pe += pbc - workprec
+                pbc = workprec
+            n -= 1
+            if not n:
+                break
+        man = man*man
+        exp = exp+exp
+        bc = bc + bc - 2
+        bc = bc + bctable[int(man >> bc)]
+        if bc > workprec:
+            if rounds_down:
+                man = man >> (bc-workprec)
+            else:
+                man = -((-man) >> (bc-workprec))
+            exp += bc - workprec
+            bc = workprec
+        n = n // 2
+
+    return normalize(result_sign, pm, pe, pbc, prec, rnd)
+
+
+def mpf_perturb(x, eps_sign, prec, rnd):
+    """
+    For nonzero x, calculate x + eps with directed rounding, where
+    eps < prec relatively and eps has the given sign (0 for
+    positive, 1 for negative).
+
+    With rounding to nearest, this is taken to simply normalize
+    x to the given precision.
+    """
+    if rnd == round_nearest:
+        return mpf_pos(x, prec, rnd)
+    sign, man, exp, bc = x
+    eps = (eps_sign, MPZ_ONE, exp+bc-prec-1, 1)
+    if sign:
+        away = (rnd in (round_down, round_ceiling)) ^ eps_sign
+    else:
+        away = (rnd in (round_up, round_ceiling)) ^ eps_sign
+    if away:
+        return mpf_add(x, eps, prec, rnd)
+    else:
+        return mpf_pos(x, prec, rnd)
+
+
+#----------------------------------------------------------------------------#
+#                              Radix conversion                              #
+#----------------------------------------------------------------------------#
+
+def to_digits_exp(s, dps):
+    """Helper function for representing the floating-point number s as
+    a decimal with dps digits. Returns (sign, string, exponent) where
+    sign is '' or '-', string is the digit string, and exponent is
+    the decimal exponent as an int.
+
+    If inexact, the decimal representation is rounded toward zero."""
+
+    # Extract sign first so it doesn't mess up the string digit count
+    if s[0]:
+        sign = '-'
+        s = mpf_neg(s)
+    else:
+        sign = ''
+    _sign, man, exp, bc = s
+
+    if not man:
+        return '', '0', 0
+
+    bitprec = int(dps * math.log(10,2)) + 10
+
+    # Cut down to size
+    # TODO: account for precision when doing this
+    exp_from_1 = exp + bc
+    if abs(exp_from_1) > 3500:
+        from .libelefun import mpf_ln2, mpf_ln10
+        # Set b = int(exp * log(2)/log(10))
+        # If exp is huge, we must use high-precision arithmetic to
+        # find the nearest power of ten
+        expprec = bitcount(abs(exp)) + 5
+        tmp = from_int(exp)
+        tmp = mpf_mul(tmp, mpf_ln2(expprec))
+        tmp = mpf_div(tmp, mpf_ln10(expprec), expprec)
+        b = to_int(tmp)
+        s = mpf_div(s, mpf_pow_int(ften, b, bitprec), bitprec)
+        _sign, man, exp, bc = s
+        exponent = b
+    else:
+        exponent = 0
+
+    # First, calculate mantissa digits by converting to a binary
+    # fixed-point number and then converting that number to
+    # a decimal fixed-point number.
+    fixprec = max(bitprec - exp - bc, 0)
+    fixdps = int(fixprec / math.log(10,2) + 0.5)
+    sf = to_fixed(s, fixprec)
+    sd = bin_to_radix(sf, fixprec, 10, fixdps)
+    digits = numeral(sd, base=10, size=dps)
+
+    exponent += len(digits) - fixdps - 1
+    return sign, digits, exponent
+
+def to_str(s, dps, strip_zeros=True, min_fixed=None, max_fixed=None,
+    show_zero_exponent=False):
+    """
+    Convert a raw mpf to a decimal floating-point literal with at
+    most `dps` decimal digits in the mantissa (not counting extra zeros
+    that may be inserted for visual purposes).
+
+    The number will be printed in fixed-point format if the position
+    of the leading digit is strictly between min_fixed
+    (default = min(-dps/3,-5)) and max_fixed (default = dps).
+
+    To force fixed-point format always, set min_fixed = -inf,
+    max_fixed = +inf. To force floating-point format, set
+    min_fixed >= max_fixed.
+
+    The literal is formatted so that it can be parsed back to a number
+    by to_str, float() or Decimal().
+    """
+
+    # Special numbers
+    if not s[1]:
+        if s == fzero:
+            if dps: t = '0.0'
+            else:   t = '.0'
+            if show_zero_exponent:
+                t += 'e+0'
+            return t
+        if s == finf: return '+inf'
+        if s == fninf: return '-inf'
+        if s == fnan: return 'nan'
+        raise ValueError
+
+    if min_fixed is None: min_fixed = min(-(dps//3), -5)
+    if max_fixed is None: max_fixed = dps
+
+    # to_digits_exp rounds to floor.
+    # This sometimes kills some instances of "...00001"
+    sign, digits, exponent = to_digits_exp(s, dps+3)
+
+    # No digits: show only .0; round exponent to nearest
+    if not dps:
+        if digits[0] in '56789':
+            exponent += 1
+        digits = ".0"
+
+    else:
+        # Rounding up kills some instances of "...99999"
+        if len(digits) > dps and digits[dps] in '56789':
+            digits = digits[:dps]
+            i = dps - 1
+            while i >= 0 and digits[i] == '9':
+                i -= 1
+            if i >= 0:
+                digits = digits[:i] + str(int(digits[i]) + 1) + '0' * (dps - i - 1)
+            else:
+                digits = '1' + '0' * (dps - 1)
+                exponent += 1
+        else:
+            digits = digits[:dps]
+
+        # Prettify numbers close to unit magnitude
+        if min_fixed < exponent < max_fixed:
+            if exponent < 0:
+                digits = ("0"*int(-exponent)) + digits
+                split = 1
+            else:
+                split = exponent + 1
+                if split > dps:
+                    digits += "0"*(split-dps)
+            exponent = 0
+        else:
+            split = 1
+
+        digits = (digits[:split] + "." + digits[split:])
+
+        if strip_zeros:
+            # Clean up trailing zeros
+            digits = digits.rstrip('0')
+            if digits[-1] == ".":
+                digits += "0"
+
+    if exponent == 0 and dps and not show_zero_exponent: return sign + digits
+    if exponent >= 0: return sign + digits + "e+" + str(exponent)
+    if exponent < 0: return sign + digits + "e" + str(exponent)
+
+def str_to_man_exp(x, base=10):
+    """Helper function for from_str."""
+    x = x.lower().rstrip('l')
+    # Verify that the input is a valid float literal
+    float(x)
+    # Split into mantissa, exponent
+    parts = x.split('e')
+    if len(parts) == 1:
+        exp = 0
+    else: # == 2
+        x = parts[0]
+        exp = int(parts[1])
+    # Look for radix point in mantissa
+    parts = x.split('.')
+    if len(parts) == 2:
+        a, b = parts[0], parts[1].rstrip('0')
+        exp -= len(b)
+        x = a + b
+    x = MPZ(int(x, base))
+    return x, exp
+
+special_str = {'inf':finf, '+inf':finf, '-inf':fninf, 'nan':fnan}
+
+def from_str(x, prec, rnd=round_fast):
+    """Create a raw mpf from a decimal literal, rounding in the
+    specified direction if the input number cannot be represented
+    exactly as a binary floating-point number with the given number of
+    bits. The literal syntax accepted is the same as for Python
+    floats.
+
+    TODO: the rounding does not work properly for large exponents.
+    """
+    x = x.lower().strip()
+    if x in special_str:
+        return special_str[x]
+
+    if '/' in x:
+        p, q = x.split('/')
+        p, q = p.rstrip('l'), q.rstrip('l')
+        return from_rational(int(p), int(q), prec, rnd)
+
+    man, exp = str_to_man_exp(x, base=10)
+
+    # XXX: appropriate cutoffs & track direction
+    # note no factors of 5
+    if abs(exp) > 400:
+        s = from_int(man, prec+10)
+        s = mpf_mul(s, mpf_pow_int(ften, exp, prec+10), prec, rnd)
+    else:
+        if exp >= 0:
+            s = from_int(man * 10**exp, prec, rnd)
+        else:
+            s = from_rational(man, 10**-exp, prec, rnd)
+    return s
+
+# Binary string conversion. These are currently mainly used for debugging
+# and could use some improvement in the future
+
+def from_bstr(x):
+    man, exp = str_to_man_exp(x, base=2)
+    man = MPZ(man)
+    sign = 0
+    if man < 0:
+        man = -man
+        sign = 1
+    bc = bitcount(man)
+    return normalize(sign, man, exp, bc, bc, round_floor)
+
+def to_bstr(x):
+    sign, man, exp, bc = x
+    return ['','-'][sign] + numeral(man, size=bitcount(man), base=2) + ("e%i" % exp)
+
+
+#----------------------------------------------------------------------------#
+#                                Square roots                                #
+#----------------------------------------------------------------------------#
+
+
+def mpf_sqrt(s, prec, rnd=round_fast):
+    """
+    Compute the square root of a nonnegative mpf value. The
+    result is correctly rounded.
+    """
+    sign, man, exp, bc = s
+    if sign:
+        raise ComplexResult("square root of a negative number")
+    if not man:
+        return s
+    if exp & 1:
+        exp -= 1
+        man <<= 1
+        bc += 1
+    elif man == 1:
+        return normalize1(sign, man, exp//2, bc, prec, rnd)
+    shift = max(4, 2*prec-bc+4)
+    shift += shift & 1
+    if rnd in 'fd':
+        man = isqrt(man<<shift)
+    else:
+        man, rem = sqrtrem(man<<shift)
+        # Perturb up
+        if rem:
+            man = (man<<1)+1
+            shift += 2
+    return from_man_exp(man, (exp-shift)//2, prec, rnd)
+
+def mpf_hypot(x, y, prec, rnd=round_fast):
+    """Compute the Euclidean norm sqrt(x**2 + y**2) of two raw mpfs
+    x and y."""
+    if y == fzero: return mpf_abs(x, prec, rnd)
+    if x == fzero: return mpf_abs(y, prec, rnd)
+    hypot2 = mpf_add(mpf_mul(x,x), mpf_mul(y,y), prec+4)
+    return mpf_sqrt(hypot2, prec, rnd)
+
+
+if BACKEND == 'sage':
+    try:
+        import sage.libs.mpmath.ext_libmp as ext_lib
+        mpf_add = ext_lib.mpf_add
+        mpf_sub = ext_lib.mpf_sub
+        mpf_mul = ext_lib.mpf_mul
+        mpf_div = ext_lib.mpf_div
+        mpf_sqrt = ext_lib.mpf_sqrt
+    except ImportError:
+        pass
diff --git a/lib/python3.11/site-packages/mpmath/libmp/libmpi.py b/lib/python3.11/site-packages/mpmath/libmp/libmpi.py
new file mode 100644
index 0000000000000000000000000000000000000000..31377642b50b7e7a1e430e0cad5c84eeb00ec19c
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/libmp/libmpi.py
@@ -0,0 +1,935 @@
+"""
+Computational functions for interval arithmetic.
+
+"""
+
+from .backend import xrange
+
+from .libmpf import (
+    ComplexResult,
+    round_down, round_up, round_floor, round_ceiling, round_nearest,
+    prec_to_dps, repr_dps, dps_to_prec,
+    bitcount,
+    from_float,
+    fnan, finf, fninf, fzero, fhalf, fone, fnone,
+    mpf_sign, mpf_lt, mpf_le, mpf_gt, mpf_ge, mpf_eq, mpf_cmp,
+    mpf_min_max,
+    mpf_floor, from_int, to_int, to_str, from_str,
+    mpf_abs, mpf_neg, mpf_pos, mpf_add, mpf_sub, mpf_mul, mpf_mul_int,
+    mpf_div, mpf_shift, mpf_pow_int,
+    from_man_exp, MPZ_ONE)
+
+from .libelefun import (
+    mpf_log, mpf_exp, mpf_sqrt, mpf_atan, mpf_atan2,
+    mpf_pi, mod_pi2, mpf_cos_sin
+)
+
+from .gammazeta import mpf_gamma, mpf_rgamma, mpf_loggamma, mpc_loggamma
+
+def mpi_str(s, prec):
+    sa, sb = s
+    dps = prec_to_dps(prec) + 5
+    return "[%s, %s]" % (to_str(sa, dps), to_str(sb, dps))
+    #dps = prec_to_dps(prec)
+    #m = mpi_mid(s, prec)
+    #d = mpf_shift(mpi_delta(s, 20), -1)
+    #return "%s +/- %s" % (to_str(m, dps), to_str(d, 3))
+
+mpi_zero = (fzero, fzero)
+mpi_one = (fone, fone)
+
+def mpi_eq(s, t):
+    return s == t
+
+def mpi_ne(s, t):
+    return s != t
+
+def mpi_lt(s, t):
+    sa, sb = s
+    ta, tb = t
+    if mpf_lt(sb, ta): return True
+    if mpf_ge(sa, tb): return False
+    return None
+
+def mpi_le(s, t):
+    sa, sb = s
+    ta, tb = t
+    if mpf_le(sb, ta): return True
+    if mpf_gt(sa, tb): return False
+    return None
+
+def mpi_gt(s, t): return mpi_lt(t, s)
+def mpi_ge(s, t): return mpi_le(t, s)
+
+def mpi_add(s, t, prec=0):
+    sa, sb = s
+    ta, tb = t
+    a = mpf_add(sa, ta, prec, round_floor)
+    b = mpf_add(sb, tb, prec, round_ceiling)
+    if a == fnan: a = fninf
+    if b == fnan: b = finf
+    return a, b
+
+def mpi_sub(s, t, prec=0):
+    sa, sb = s
+    ta, tb = t
+    a = mpf_sub(sa, tb, prec, round_floor)
+    b = mpf_sub(sb, ta, prec, round_ceiling)
+    if a == fnan: a = fninf
+    if b == fnan: b = finf
+    return a, b
+
+def mpi_delta(s, prec):
+    sa, sb = s
+    return mpf_sub(sb, sa, prec, round_up)
+
+def mpi_mid(s, prec):
+    sa, sb = s
+    return mpf_shift(mpf_add(sa, sb, prec, round_nearest), -1)
+
+def mpi_pos(s, prec):
+    sa, sb = s
+    a = mpf_pos(sa, prec, round_floor)
+    b = mpf_pos(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_neg(s, prec=0):
+    sa, sb = s
+    a = mpf_neg(sb, prec, round_floor)
+    b = mpf_neg(sa, prec, round_ceiling)
+    return a, b
+
+def mpi_abs(s, prec=0):
+    sa, sb = s
+    sas = mpf_sign(sa)
+    sbs = mpf_sign(sb)
+    # Both points nonnegative?
+    if sas >= 0:
+        a = mpf_pos(sa, prec, round_floor)
+        b = mpf_pos(sb, prec, round_ceiling)
+    # Upper point nonnegative?
+    elif sbs >= 0:
+        a = fzero
+        negsa = mpf_neg(sa)
+        if mpf_lt(negsa, sb):
+            b = mpf_pos(sb, prec, round_ceiling)
+        else:
+            b = mpf_pos(negsa, prec, round_ceiling)
+    # Both negative?
+    else:
+        a = mpf_neg(sb, prec, round_floor)
+        b = mpf_neg(sa, prec, round_ceiling)
+    return a, b
+
+# TODO: optimize
+def mpi_mul_mpf(s, t, prec):
+    return mpi_mul(s, (t, t), prec)
+
+def mpi_div_mpf(s, t, prec):
+    return mpi_div(s, (t, t), prec)
+
+def mpi_mul(s, t, prec=0):
+    sa, sb = s
+    ta, tb = t
+    sas = mpf_sign(sa)
+    sbs = mpf_sign(sb)
+    tas = mpf_sign(ta)
+    tbs = mpf_sign(tb)
+    if sas == sbs == 0:
+        # Should maybe be undefined
+        if ta == fninf or tb == finf:
+            return fninf, finf
+        return fzero, fzero
+    if tas == tbs == 0:
+        # Should maybe be undefined
+        if sa == fninf or sb == finf:
+            return fninf, finf
+        return fzero, fzero
+    if sas >= 0:
+        # positive * positive
+        if tas >= 0:
+            a = mpf_mul(sa, ta, prec, round_floor)
+            b = mpf_mul(sb, tb, prec, round_ceiling)
+            if a == fnan: a = fzero
+            if b == fnan: b = finf
+        # positive * negative
+        elif tbs <= 0:
+            a = mpf_mul(sb, ta, prec, round_floor)
+            b = mpf_mul(sa, tb, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = fzero
+        # positive * both signs
+        else:
+            a = mpf_mul(sb, ta, prec, round_floor)
+            b = mpf_mul(sb, tb, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = finf
+    elif sbs <= 0:
+        # negative * positive
+        if tas >= 0:
+            a = mpf_mul(sa, tb, prec, round_floor)
+            b = mpf_mul(sb, ta, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = fzero
+        # negative * negative
+        elif tbs <= 0:
+            a = mpf_mul(sb, tb, prec, round_floor)
+            b = mpf_mul(sa, ta, prec, round_ceiling)
+            if a == fnan: a = fzero
+            if b == fnan: b = finf
+        # negative * both signs
+        else:
+            a = mpf_mul(sa, tb, prec, round_floor)
+            b = mpf_mul(sa, ta, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = finf
+    else:
+        # General case: perform all cross-multiplications and compare
+        # Since the multiplications can be done exactly, we need only
+        # do 4 (instead of 8: two for each rounding mode)
+        cases = [mpf_mul(sa, ta), mpf_mul(sa, tb), mpf_mul(sb, ta), mpf_mul(sb, tb)]
+        if fnan in cases:
+            a, b = (fninf, finf)
+        else:
+            a, b = mpf_min_max(cases)
+            a = mpf_pos(a, prec, round_floor)
+            b = mpf_pos(b, prec, round_ceiling)
+    return a, b
+
+def mpi_square(s, prec=0):
+    sa, sb = s
+    if mpf_ge(sa, fzero):
+        a = mpf_mul(sa, sa, prec, round_floor)
+        b = mpf_mul(sb, sb, prec, round_ceiling)
+    elif mpf_le(sb, fzero):
+        a = mpf_mul(sb, sb, prec, round_floor)
+        b = mpf_mul(sa, sa, prec, round_ceiling)
+    else:
+        sa = mpf_neg(sa)
+        sa, sb = mpf_min_max([sa, sb])
+        a = fzero
+        b = mpf_mul(sb, sb, prec, round_ceiling)
+    return a, b
+
+def mpi_div(s, t, prec):
+    sa, sb = s
+    ta, tb = t
+    sas = mpf_sign(sa)
+    sbs = mpf_sign(sb)
+    tas = mpf_sign(ta)
+    tbs = mpf_sign(tb)
+    # 0 / X
+    if sas == sbs == 0:
+        # 0 / <interval containing 0>
+        if (tas < 0 and tbs > 0) or (tas == 0 or tbs == 0):
+            return fninf, finf
+        return fzero, fzero
+    # Denominator contains both negative and positive numbers;
+    # this should properly be a multi-interval, but the closest
+    # match is the entire (extended) real line
+    if tas < 0 and tbs > 0:
+        return fninf, finf
+    # Assume denominator to be nonnegative
+    if tas < 0:
+        return mpi_div(mpi_neg(s), mpi_neg(t), prec)
+    # Division by zero
+    # XXX: make sure all results make sense
+    if tas == 0:
+        # Numerator contains both signs?
+        if sas < 0 and sbs > 0:
+            return fninf, finf
+        if tas == tbs:
+            return fninf, finf
+        # Numerator positive?
+        if sas >= 0:
+            a = mpf_div(sa, tb, prec, round_floor)
+            b = finf
+        if sbs <= 0:
+            a = fninf
+            b = mpf_div(sb, tb, prec, round_ceiling)
+    # Division with positive denominator
+    # We still have to handle nans resulting from inf/0 or inf/inf
+    else:
+        # Nonnegative numerator
+        if sas >= 0:
+            a = mpf_div(sa, tb, prec, round_floor)
+            b = mpf_div(sb, ta, prec, round_ceiling)
+            if a == fnan: a = fzero
+            if b == fnan: b = finf
+        # Nonpositive numerator
+        elif sbs <= 0:
+            a = mpf_div(sa, ta, prec, round_floor)
+            b = mpf_div(sb, tb, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = fzero
+        # Numerator contains both signs?
+        else:
+            a = mpf_div(sa, ta, prec, round_floor)
+            b = mpf_div(sb, ta, prec, round_ceiling)
+            if a == fnan: a = fninf
+            if b == fnan: b = finf
+    return a, b
+
+def mpi_pi(prec):
+    a = mpf_pi(prec, round_floor)
+    b = mpf_pi(prec, round_ceiling)
+    return a, b
+
+def mpi_exp(s, prec):
+    sa, sb = s
+    # exp is monotonic
+    a = mpf_exp(sa, prec, round_floor)
+    b = mpf_exp(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_log(s, prec):
+    sa, sb = s
+    # log is monotonic
+    a = mpf_log(sa, prec, round_floor)
+    b = mpf_log(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_sqrt(s, prec):
+    sa, sb = s
+    # sqrt is monotonic
+    a = mpf_sqrt(sa, prec, round_floor)
+    b = mpf_sqrt(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_atan(s, prec):
+    sa, sb = s
+    a = mpf_atan(sa, prec, round_floor)
+    b = mpf_atan(sb, prec, round_ceiling)
+    return a, b
+
+def mpi_pow_int(s, n, prec):
+    sa, sb = s
+    if n < 0:
+        return mpi_div((fone, fone), mpi_pow_int(s, -n, prec+20), prec)
+    if n == 0:
+        return (fone, fone)
+    if n == 1:
+        return s
+    if n == 2:
+        return mpi_square(s, prec)
+    # Odd -- signs are preserved
+    if n & 1:
+        a = mpf_pow_int(sa, n, prec, round_floor)
+        b = mpf_pow_int(sb, n, prec, round_ceiling)
+    # Even -- important to ensure positivity
+    else:
+        sas = mpf_sign(sa)
+        sbs = mpf_sign(sb)
+        # Nonnegative?
+        if sas >= 0:
+            a = mpf_pow_int(sa, n, prec, round_floor)
+            b = mpf_pow_int(sb, n, prec, round_ceiling)
+        # Nonpositive?
+        elif sbs <= 0:
+            a = mpf_pow_int(sb, n, prec, round_floor)
+            b = mpf_pow_int(sa, n, prec, round_ceiling)
+        # Mixed signs?
+        else:
+            a = fzero
+            # max(-a,b)**n
+            sa = mpf_neg(sa)
+            if mpf_ge(sa, sb):
+                b = mpf_pow_int(sa, n, prec, round_ceiling)
+            else:
+                b = mpf_pow_int(sb, n, prec, round_ceiling)
+    return a, b
+
+def mpi_pow(s, t, prec):
+    ta, tb = t
+    if ta == tb and ta not in (finf, fninf):
+        if ta == from_int(to_int(ta)):
+            return mpi_pow_int(s, to_int(ta), prec)
+        if ta == fhalf:
+            return mpi_sqrt(s, prec)
+    u = mpi_log(s, prec + 20)
+    v = mpi_mul(u, t, prec + 20)
+    return mpi_exp(v, prec)
+
+def MIN(x, y):
+    if mpf_le(x, y):
+        return x
+    return y
+
+def MAX(x, y):
+    if mpf_ge(x, y):
+        return x
+    return y
+
+def cos_sin_quadrant(x, wp):
+    sign, man, exp, bc = x
+    if x == fzero:
+        return fone, fzero, 0
+    # TODO: combine evaluation code to avoid duplicate modulo
+    c, s = mpf_cos_sin(x, wp)
+    t, n, wp_ = mod_pi2(man, exp, exp+bc, 15)
+    if sign:
+        n = -1-n
+    return c, s, n
+
+def mpi_cos_sin(x, prec):
+    a, b = x
+    if a == b == fzero:
+        return (fone, fone), (fzero, fzero)
+    # Guaranteed to contain both -1 and 1
+    if (finf in x) or (fninf in x):
+        return (fnone, fone), (fnone, fone)
+    wp = prec + 20
+    ca, sa, na = cos_sin_quadrant(a, wp)
+    cb, sb, nb = cos_sin_quadrant(b, wp)
+    ca, cb = mpf_min_max([ca, cb])
+    sa, sb = mpf_min_max([sa, sb])
+    # Both functions are monotonic within one quadrant
+    if na == nb:
+        pass
+    # Guaranteed to contain both -1 and 1
+    elif nb - na >= 4:
+        return (fnone, fone), (fnone, fone)
+    else:
+        # cos has maximum between a and b
+        if na//4 != nb//4:
+            cb = fone
+        # cos has minimum
+        if (na-2)//4 != (nb-2)//4:
+            ca = fnone
+        # sin has maximum
+        if (na-1)//4 != (nb-1)//4:
+            sb = fone
+        # sin has minimum
+        if (na-3)//4 != (nb-3)//4:
+            sa = fnone
+    # Perturb to force interval rounding
+    more = from_man_exp((MPZ_ONE<<wp) + (MPZ_ONE<<10), -wp)
+    less = from_man_exp((MPZ_ONE<<wp) - (MPZ_ONE<<10), -wp)
+    def finalize(v, rounding):
+        if bool(v[0]) == (rounding == round_floor):
+            p = more
+        else:
+            p = less
+        v = mpf_mul(v, p, prec, rounding)
+        sign, man, exp, bc = v
+        if exp+bc >= 1:
+            if sign:
+                return fnone
+            return fone
+        return v
+    ca = finalize(ca, round_floor)
+    cb = finalize(cb, round_ceiling)
+    sa = finalize(sa, round_floor)
+    sb = finalize(sb, round_ceiling)
+    return (ca,cb), (sa,sb)
+
+def mpi_cos(x, prec):
+    return mpi_cos_sin(x, prec)[0]
+
+def mpi_sin(x, prec):
+    return mpi_cos_sin(x, prec)[1]
+
+def mpi_tan(x, prec):
+    cos, sin = mpi_cos_sin(x, prec+20)
+    return mpi_div(sin, cos, prec)
+
+def mpi_cot(x, prec):
+    cos, sin = mpi_cos_sin(x, prec+20)
+    return mpi_div(cos, sin, prec)
+
+def mpi_from_str_a_b(x, y, percent, prec):
+    wp = prec + 20
+    xa = from_str(x, wp, round_floor)
+    xb = from_str(x, wp, round_ceiling)
+    #ya = from_str(y, wp, round_floor)
+    y = from_str(y, wp, round_ceiling)
+    assert mpf_ge(y, fzero)
+    if percent:
+        y = mpf_mul(MAX(mpf_abs(xa), mpf_abs(xb)), y, wp, round_ceiling)
+        y = mpf_div(y, from_int(100), wp, round_ceiling)
+    a = mpf_sub(xa, y, prec, round_floor)
+    b = mpf_add(xb, y, prec, round_ceiling)
+    return a, b
+
+def mpi_from_str(s, prec):
+    """
+    Parse an interval number given as a string.
+
+    Allowed forms are
+
+    "-1.23e-27"
+        Any single decimal floating-point literal.
+    "a +- b"  or  "a (b)"
+        a is the midpoint of the interval and b is the half-width
+    "a +- b%"  or  "a (b%)"
+        a is the midpoint of the interval and the half-width
+        is b percent of a (`a \times b / 100`).
+    "[a, b]"
+        The interval indicated directly.
+    "x[y,z]e"
+        x are shared digits, y and z are unequal digits, e is the exponent.
+
+    """
+    e = ValueError("Improperly formed interval number '%s'" % s)
+    s = s.replace(" ", "")
+    wp = prec + 20
+    if "+-" in s:
+        x, y = s.split("+-")
+        return mpi_from_str_a_b(x, y, False, prec)
+    # case 2
+    elif "(" in s:
+        # Don't confuse with a complex number (x,y)
+        if s[0] == "(" or ")" not in s:
+            raise e
+        s = s.replace(")", "")
+        percent = False
+        if "%" in s:
+            if s[-1] != "%":
+                raise e
+            percent = True
+            s = s.replace("%", "")
+        x, y = s.split("(")
+        return mpi_from_str_a_b(x, y, percent, prec)
+    elif "," in s:
+        if ('[' not in s) or (']' not in s):
+            raise e
+        if s[0] == '[':
+            # case 3
+            s = s.replace("[", "")
+            s = s.replace("]", "")
+            a, b = s.split(",")
+            a = from_str(a, prec, round_floor)
+            b = from_str(b, prec, round_ceiling)
+            return a, b
+        else:
+            # case 4
+            x, y = s.split('[')
+            y, z = y.split(',')
+            if 'e' in s:
+                z, e = z.split(']')
+            else:
+                z, e = z.rstrip(']'), ''
+            a = from_str(x+y+e, prec, round_floor)
+            b = from_str(x+z+e, prec, round_ceiling)
+            return a, b
+    else:
+        a = from_str(s, prec, round_floor)
+        b = from_str(s, prec, round_ceiling)
+        return a, b
+
+def mpi_to_str(x, dps, use_spaces=True, brackets='[]', mode='brackets', error_dps=4, **kwargs):
+    """
+    Convert a mpi interval to a string.
+
+    **Arguments**
+
+    *dps*
+        decimal places to use for printing
+    *use_spaces*
+        use spaces for more readable output, defaults to true
+    *brackets*
+        pair of strings (or two-character string) giving left and right brackets
+    *mode*
+        mode of display: 'plusminus', 'percent', 'brackets' (default) or 'diff'
+    *error_dps*
+        limit the error to *error_dps* digits (mode 'plusminus and 'percent')
+
+    Additional keyword arguments are forwarded to the mpf-to-string conversion
+    for the components of the output.
+
+    **Examples**
+
+        >>> from mpmath import mpi, mp
+        >>> mp.dps = 30
+        >>> x = mpi(1, 2)._mpi_
+        >>> mpi_to_str(x, 2, mode='plusminus')
+        '1.5 +- 0.5'
+        >>> mpi_to_str(x, 2, mode='percent')
+        '1.5 (33.33%)'
+        >>> mpi_to_str(x, 2, mode='brackets')
+        '[1.0, 2.0]'
+        >>> mpi_to_str(x, 2, mode='brackets' , brackets=('<', '>'))
+        '<1.0, 2.0>'
+        >>> x = mpi('5.2582327113062393041', '5.2582327113062749951')._mpi_
+        >>> mpi_to_str(x, 15, mode='diff')
+        '5.2582327113062[4, 7]'
+        >>> mpi_to_str(mpi(0)._mpi_, 2, mode='percent')
+        '0.0 (0.0%)'
+
+    """
+    prec = dps_to_prec(dps)
+    wp = prec + 20
+    a, b = x
+    mid = mpi_mid(x, prec)
+    delta = mpi_delta(x, prec)
+    a_str = to_str(a, dps, **kwargs)
+    b_str = to_str(b, dps, **kwargs)
+    mid_str = to_str(mid, dps, **kwargs)
+    sp = ""
+    if use_spaces:
+        sp = " "
+    br1, br2 = brackets
+    if mode == 'plusminus':
+        delta_str = to_str(mpf_shift(delta,-1), dps, **kwargs)
+        s = mid_str + sp + "+-" + sp + delta_str
+    elif mode == 'percent':
+        if mid == fzero:
+            p = fzero
+        else:
+            # p = 100 * delta(x) / (2*mid(x))
+            p = mpf_mul(delta, from_int(100))
+            p = mpf_div(p, mpf_mul(mid, from_int(2)), wp)
+        s = mid_str + sp + "(" + to_str(p, error_dps) + "%)"
+    elif mode == 'brackets':
+        s = br1 + a_str + "," + sp + b_str + br2
+    elif mode == 'diff':
+        # use more digits if str(x.a) and str(x.b) are equal
+        if a_str == b_str:
+            a_str = to_str(a, dps+3, **kwargs)
+            b_str = to_str(b, dps+3, **kwargs)
+        # separate mantissa and exponent
+        a = a_str.split('e')
+        if len(a) == 1:
+            a.append('')
+        b = b_str.split('e')
+        if len(b) == 1:
+            b.append('')
+        if a[1] == b[1]:
+            if a[0] != b[0]:
+                for i in xrange(len(a[0]) + 1):
+                    if a[0][i] != b[0][i]:
+                        break
+                s = (a[0][:i] + br1 + a[0][i:] + ',' + sp + b[0][i:] + br2
+                     + 'e'*min(len(a[1]), 1) + a[1])
+            else: # no difference
+                s = a[0] + br1 + br2 + 'e'*min(len(a[1]), 1) + a[1]
+        else:
+            s = br1 + 'e'.join(a) + ',' + sp + 'e'.join(b) + br2
+    else:
+        raise ValueError("'%s' is unknown mode for printing mpi" % mode)
+    return s
+
+def mpci_add(x, y, prec):
+    a, b = x
+    c, d = y
+    return mpi_add(a, c, prec), mpi_add(b, d, prec)
+
+def mpci_sub(x, y, prec):
+    a, b = x
+    c, d = y
+    return mpi_sub(a, c, prec), mpi_sub(b, d, prec)
+
+def mpci_neg(x, prec=0):
+    a, b = x
+    return mpi_neg(a, prec), mpi_neg(b, prec)
+
+def mpci_pos(x, prec):
+    a, b = x
+    return mpi_pos(a, prec), mpi_pos(b, prec)
+
+def mpci_mul(x, y, prec):
+    # TODO: optimize for real/imag cases
+    a, b = x
+    c, d = y
+    r1 = mpi_mul(a,c)
+    r2 = mpi_mul(b,d)
+    re = mpi_sub(r1,r2,prec)
+    i1 = mpi_mul(a,d)
+    i2 = mpi_mul(b,c)
+    im = mpi_add(i1,i2,prec)
+    return re, im
+
+def mpci_div(x, y, prec):
+    # TODO: optimize for real/imag cases
+    a, b = x
+    c, d = y
+    wp = prec+20
+    m1 = mpi_square(c)
+    m2 = mpi_square(d)
+    m = mpi_add(m1,m2,wp)
+    re = mpi_add(mpi_mul(a,c), mpi_mul(b,d), wp)
+    im = mpi_sub(mpi_mul(b,c), mpi_mul(a,d), wp)
+    re = mpi_div(re, m, prec)
+    im = mpi_div(im, m, prec)
+    return re, im
+
+def mpci_exp(x, prec):
+    a, b = x
+    wp = prec+20
+    r = mpi_exp(a, wp)
+    c, s = mpi_cos_sin(b, wp)
+    a = mpi_mul(r, c, prec)
+    b = mpi_mul(r, s, prec)
+    return a, b
+
+def mpi_shift(x, n):
+    a, b = x
+    return mpf_shift(a,n), mpf_shift(b,n)
+
+def mpi_cosh_sinh(x, prec):
+    # TODO: accuracy for small x
+    wp = prec+20
+    e1 = mpi_exp(x, wp)
+    e2 = mpi_div(mpi_one, e1, wp)
+    c = mpi_add(e1, e2, prec)
+    s = mpi_sub(e1, e2, prec)
+    c = mpi_shift(c, -1)
+    s = mpi_shift(s, -1)
+    return c, s
+
+def mpci_cos(x, prec):
+    a, b = x
+    wp = prec+10
+    c, s = mpi_cos_sin(a, wp)
+    ch, sh = mpi_cosh_sinh(b, wp)
+    re = mpi_mul(c, ch, prec)
+    im = mpi_mul(s, sh, prec)
+    return re, mpi_neg(im)
+
+def mpci_sin(x, prec):
+    a, b = x
+    wp = prec+10
+    c, s = mpi_cos_sin(a, wp)
+    ch, sh = mpi_cosh_sinh(b, wp)
+    re = mpi_mul(s, ch, prec)
+    im = mpi_mul(c, sh, prec)
+    return re, im
+
+def mpci_abs(x, prec):
+    a, b = x
+    if a == mpi_zero:
+        return mpi_abs(b)
+    if b == mpi_zero:
+        return mpi_abs(a)
+    # Important: nonnegative
+    a = mpi_square(a)
+    b = mpi_square(b)
+    t = mpi_add(a, b, prec+20)
+    return mpi_sqrt(t, prec)
+
+def mpi_atan2(y, x, prec):
+    ya, yb = y
+    xa, xb = x
+    # Constrained to the real line
+    if ya == yb == fzero:
+        if mpf_ge(xa, fzero):
+            return mpi_zero
+        return mpi_pi(prec)
+    # Right half-plane
+    if mpf_ge(xa, fzero):
+        if mpf_ge(ya, fzero):
+            a = mpf_atan2(ya, xb, prec, round_floor)
+        else:
+            a = mpf_atan2(ya, xa, prec, round_floor)
+        if mpf_ge(yb, fzero):
+            b = mpf_atan2(yb, xa, prec, round_ceiling)
+        else:
+            b = mpf_atan2(yb, xb, prec, round_ceiling)
+    # Upper half-plane
+    elif mpf_ge(ya, fzero):
+        b = mpf_atan2(ya, xa, prec, round_ceiling)
+        if mpf_le(xb, fzero):
+            a = mpf_atan2(yb, xb, prec, round_floor)
+        else:
+            a = mpf_atan2(ya, xb, prec, round_floor)
+    # Lower half-plane
+    elif mpf_le(yb, fzero):
+        a = mpf_atan2(yb, xa, prec, round_floor)
+        if mpf_le(xb, fzero):
+            b = mpf_atan2(ya, xb, prec, round_ceiling)
+        else:
+            b = mpf_atan2(yb, xb, prec, round_ceiling)
+    # Covering the origin
+    else:
+        b = mpf_pi(prec, round_ceiling)
+        a = mpf_neg(b)
+    return a, b
+
+def mpci_arg(z, prec):
+    x, y = z
+    return mpi_atan2(y, x, prec)
+
+def mpci_log(z, prec):
+    x, y = z
+    re = mpi_log(mpci_abs(z, prec+20), prec)
+    im = mpci_arg(z, prec)
+    return re, im
+
+def mpci_pow(x, y, prec):
+    # TODO: recognize/speed up real cases, integer y
+    yre, yim = y
+    if yim == mpi_zero:
+        ya, yb = yre
+        if ya == yb:
+            sign, man, exp, bc = yb
+            if man and exp >= 0:
+                return mpci_pow_int(x, (-1)**sign * int(man<<exp), prec)
+            # x^0
+            if yb == fzero:
+                return mpci_pow_int(x, 0, prec)
+    wp = prec+20
+    return mpci_exp(mpci_mul(y, mpci_log(x, wp), wp), prec)
+
+def mpci_square(x, prec):
+    a, b = x
+    # (a+bi)^2 = (a^2-b^2) + 2abi
+    re = mpi_sub(mpi_square(a), mpi_square(b), prec)
+    im = mpi_mul(a, b, prec)
+    im = mpi_shift(im, 1)
+    return re, im
+
+def mpci_pow_int(x, n, prec):
+    if n < 0:
+        return mpci_div((mpi_one,mpi_zero), mpci_pow_int(x, -n, prec+20), prec)
+    if n == 0:
+        return mpi_one, mpi_zero
+    if n == 1:
+        return mpci_pos(x, prec)
+    if n == 2:
+        return mpci_square(x, prec)
+    wp = prec + 20
+    result = (mpi_one, mpi_zero)
+    while n:
+        if n & 1:
+            result = mpci_mul(result, x, wp)
+            n -= 1
+        x = mpci_square(x, wp)
+        n >>= 1
+    return mpci_pos(result, prec)
+
+gamma_min_a = from_float(1.46163214496)
+gamma_min_b = from_float(1.46163214497)
+gamma_min = (gamma_min_a, gamma_min_b)
+gamma_mono_imag_a = from_float(-1.1)
+gamma_mono_imag_b = from_float(1.1)
+
+def mpi_overlap(x, y):
+    a, b = x
+    c, d = y
+    if mpf_lt(d, a): return False
+    if mpf_gt(c, b): return False
+    return True
+
+# type = 0 -- gamma
+# type = 1 -- factorial
+# type = 2 -- 1/gamma
+# type = 3 -- log-gamma
+
+def mpi_gamma(z, prec, type=0):
+    a, b = z
+    wp = prec+20
+
+    if type == 1:
+        return mpi_gamma(mpi_add(z, mpi_one, wp), prec, 0)
+
+    # increasing
+    if mpf_gt(a, gamma_min_b):
+        if type == 0:
+            c = mpf_gamma(a, prec, round_floor)
+            d = mpf_gamma(b, prec, round_ceiling)
+        elif type == 2:
+            c = mpf_rgamma(b, prec, round_floor)
+            d = mpf_rgamma(a, prec, round_ceiling)
+        elif type == 3:
+            c = mpf_loggamma(a, prec, round_floor)
+            d = mpf_loggamma(b, prec, round_ceiling)
+    # decreasing
+    elif mpf_gt(a, fzero) and mpf_lt(b, gamma_min_a):
+        if type == 0:
+            c = mpf_gamma(b, prec, round_floor)
+            d = mpf_gamma(a, prec, round_ceiling)
+        elif type == 2:
+            c = mpf_rgamma(a, prec, round_floor)
+            d = mpf_rgamma(b, prec, round_ceiling)
+        elif type == 3:
+            c = mpf_loggamma(b, prec, round_floor)
+            d = mpf_loggamma(a, prec, round_ceiling)
+    else:
+        # TODO: reflection formula
+        znew = mpi_add(z, mpi_one, wp)
+        if type == 0: return mpi_div(mpi_gamma(znew, prec+2, 0), z, prec)
+        if type == 2: return mpi_mul(mpi_gamma(znew, prec+2, 2), z, prec)
+        if type == 3: return mpi_sub(mpi_gamma(znew, prec+2, 3), mpi_log(z, prec+2), prec)
+    return c, d
+
+def mpci_gamma(z, prec, type=0):
+    (a1,a2), (b1,b2) = z
+
+    # Real case
+    if b1 == b2 == fzero and (type != 3 or mpf_gt(a1,fzero)):
+        return mpi_gamma(z, prec, type), mpi_zero
+
+    # Estimate precision
+    wp = prec+20
+    if type != 3:
+        amag = a2[2]+a2[3]
+        bmag = b2[2]+b2[3]
+        if a2 != fzero:
+            mag = max(amag, bmag)
+        else:
+            mag = bmag
+        an = abs(to_int(a2))
+        bn = abs(to_int(b2))
+        absn = max(an, bn)
+        gamma_size = max(0,absn*mag)
+        wp += bitcount(gamma_size)
+
+    # Assume type != 1
+    if type == 1:
+        (a1,a2) = mpi_add((a1,a2), mpi_one, wp); z = (a1,a2), (b1,b2)
+        type = 0
+
+    # Avoid non-monotonic region near the negative real axis
+    if mpf_lt(a1, gamma_min_b):
+        if mpi_overlap((b1,b2), (gamma_mono_imag_a, gamma_mono_imag_b)):
+            # TODO: reflection formula
+            #if mpf_lt(a2, mpf_shift(fone,-1)):
+            #    znew = mpci_sub((mpi_one,mpi_zero),z,wp)
+            #    ...
+            # Recurrence:
+            # gamma(z) = gamma(z+1)/z
+            znew = mpi_add((a1,a2), mpi_one, wp), (b1,b2)
+            if type == 0: return mpci_div(mpci_gamma(znew, prec+2, 0), z, prec)
+            if type == 2: return mpci_mul(mpci_gamma(znew, prec+2, 2), z, prec)
+            if type == 3: return mpci_sub(mpci_gamma(znew, prec+2, 3), mpci_log(z,prec+2), prec)
+
+    # Use monotonicity (except for a small region close to the
+    # origin and near poles)
+    # upper half-plane
+    if mpf_ge(b1, fzero):
+        minre = mpc_loggamma((a1,b2), wp, round_floor)
+        maxre = mpc_loggamma((a2,b1), wp, round_ceiling)
+        minim = mpc_loggamma((a1,b1), wp, round_floor)
+        maxim = mpc_loggamma((a2,b2), wp, round_ceiling)
+    # lower half-plane
+    elif mpf_le(b2, fzero):
+        minre = mpc_loggamma((a1,b1), wp, round_floor)
+        maxre = mpc_loggamma((a2,b2), wp, round_ceiling)
+        minim = mpc_loggamma((a2,b1), wp, round_floor)
+        maxim = mpc_loggamma((a1,b2), wp, round_ceiling)
+    # crosses real axis
+    else:
+        maxre = mpc_loggamma((a2,fzero), wp, round_ceiling)
+        # stretches more into the lower half-plane
+        if mpf_gt(mpf_neg(b1), b2):
+            minre = mpc_loggamma((a1,b1), wp, round_ceiling)
+        else:
+            minre = mpc_loggamma((a1,b2), wp, round_ceiling)
+        minim = mpc_loggamma((a2,b1), wp, round_floor)
+        maxim = mpc_loggamma((a2,b2), wp, round_floor)
+
+    w = (minre[0], maxre[0]), (minim[1], maxim[1])
+    if type == 3:
+        return mpi_pos(w[0], prec), mpi_pos(w[1], prec)
+    if type == 2:
+        w = mpci_neg(w)
+    return mpci_exp(w, prec)
+
+def mpi_loggamma(z, prec): return mpi_gamma(z, prec, type=3)
+def mpci_loggamma(z, prec): return mpci_gamma(z, prec, type=3)
+
+def mpi_rgamma(z, prec): return mpi_gamma(z, prec, type=2)
+def mpci_rgamma(z, prec): return mpci_gamma(z, prec, type=2)
+
+def mpi_factorial(z, prec): return mpi_gamma(z, prec, type=1)
+def mpci_factorial(z, prec): return mpci_gamma(z, prec, type=1)
diff --git a/lib/python3.11/site-packages/mpmath/math2.py b/lib/python3.11/site-packages/mpmath/math2.py
new file mode 100644
index 0000000000000000000000000000000000000000..302e25f509c18b2c76a2b62611f2765db84ab13e
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/math2.py
@@ -0,0 +1,672 @@
+"""
+This module complements the math and cmath builtin modules by providing
+fast machine precision versions of some additional functions (gamma, ...)
+and wrapping math/cmath functions so that they can be called with either
+real or complex arguments.
+"""
+
+import operator
+import math
+import cmath
+
+# Irrational (?) constants
+pi = 3.1415926535897932385
+e = 2.7182818284590452354
+sqrt2 = 1.4142135623730950488
+sqrt5 = 2.2360679774997896964
+phi = 1.6180339887498948482
+ln2 = 0.69314718055994530942
+ln10 = 2.302585092994045684
+euler = 0.57721566490153286061
+catalan = 0.91596559417721901505
+khinchin = 2.6854520010653064453
+apery = 1.2020569031595942854
+
+logpi = 1.1447298858494001741
+
+def _mathfun_real(f_real, f_complex):
+    def f(x, **kwargs):
+        if type(x) is float:
+            return f_real(x)
+        if type(x) is complex:
+            return f_complex(x)
+        try:
+            x = float(x)
+            return f_real(x)
+        except (TypeError, ValueError):
+            x = complex(x)
+            return f_complex(x)
+    f.__name__ = f_real.__name__
+    return f
+
+def _mathfun(f_real, f_complex):
+    def f(x, **kwargs):
+        if type(x) is complex:
+            return f_complex(x)
+        try:
+            return f_real(float(x))
+        except (TypeError, ValueError):
+            return f_complex(complex(x))
+    f.__name__ = f_real.__name__
+    return f
+
+def _mathfun_n(f_real, f_complex):
+    def f(*args, **kwargs):
+        try:
+            return f_real(*(float(x) for x in args))
+        except (TypeError, ValueError):
+            return f_complex(*(complex(x) for x in args))
+    f.__name__ = f_real.__name__
+    return f
+
+# Workaround for non-raising log and sqrt in Python 2.5 and 2.4
+# on Unix system
+try:
+    math.log(-2.0)
+    def math_log(x):
+        if x <= 0.0:
+            raise ValueError("math domain error")
+        return math.log(x)
+    def math_sqrt(x):
+        if x < 0.0:
+            raise ValueError("math domain error")
+        return math.sqrt(x)
+except (ValueError, TypeError):
+    math_log = math.log
+    math_sqrt = math.sqrt
+
+pow = _mathfun_n(operator.pow, lambda x, y: complex(x)**y)
+log = _mathfun_n(math_log, cmath.log)
+sqrt = _mathfun(math_sqrt, cmath.sqrt)
+exp = _mathfun_real(math.exp, cmath.exp)
+
+cos = _mathfun_real(math.cos, cmath.cos)
+sin = _mathfun_real(math.sin, cmath.sin)
+tan = _mathfun_real(math.tan, cmath.tan)
+
+acos = _mathfun(math.acos, cmath.acos)
+asin = _mathfun(math.asin, cmath.asin)
+atan = _mathfun_real(math.atan, cmath.atan)
+
+cosh = _mathfun_real(math.cosh, cmath.cosh)
+sinh = _mathfun_real(math.sinh, cmath.sinh)
+tanh = _mathfun_real(math.tanh, cmath.tanh)
+
+floor = _mathfun_real(math.floor,
+    lambda z: complex(math.floor(z.real), math.floor(z.imag)))
+ceil = _mathfun_real(math.ceil,
+    lambda z: complex(math.ceil(z.real), math.ceil(z.imag)))
+
+
+cos_sin = _mathfun_real(lambda x: (math.cos(x), math.sin(x)),
+                        lambda z: (cmath.cos(z), cmath.sin(z)))
+
+cbrt = _mathfun(lambda x: x**(1./3), lambda z: z**(1./3))
+
+def nthroot(x, n):
+    r = 1./n
+    try:
+        return float(x) ** r
+    except (ValueError, TypeError):
+        return complex(x) ** r
+
+def _sinpi_real(x):
+    if x < 0:
+        return -_sinpi_real(-x)
+    n, r = divmod(x, 0.5)
+    r *= pi
+    n %= 4
+    if n == 0: return math.sin(r)
+    if n == 1: return math.cos(r)
+    if n == 2: return -math.sin(r)
+    if n == 3: return -math.cos(r)
+
+def _cospi_real(x):
+    if x < 0:
+        x = -x
+    n, r = divmod(x, 0.5)
+    r *= pi
+    n %= 4
+    if n == 0: return math.cos(r)
+    if n == 1: return -math.sin(r)
+    if n == 2: return -math.cos(r)
+    if n == 3: return math.sin(r)
+
+def _sinpi_complex(z):
+    if z.real < 0:
+        return -_sinpi_complex(-z)
+    n, r = divmod(z.real, 0.5)
+    z = pi*complex(r, z.imag)
+    n %= 4
+    if n == 0: return cmath.sin(z)
+    if n == 1: return cmath.cos(z)
+    if n == 2: return -cmath.sin(z)
+    if n == 3: return -cmath.cos(z)
+
+def _cospi_complex(z):
+    if z.real < 0:
+        z = -z
+    n, r = divmod(z.real, 0.5)
+    z = pi*complex(r, z.imag)
+    n %= 4
+    if n == 0: return cmath.cos(z)
+    if n == 1: return -cmath.sin(z)
+    if n == 2: return -cmath.cos(z)
+    if n == 3: return cmath.sin(z)
+
+cospi = _mathfun_real(_cospi_real, _cospi_complex)
+sinpi = _mathfun_real(_sinpi_real, _sinpi_complex)
+
+def tanpi(x):
+    try:
+        return sinpi(x) / cospi(x)
+    except OverflowError:
+        if complex(x).imag > 10:
+            return 1j
+        if complex(x).imag < 10:
+            return -1j
+        raise
+
+def cotpi(x):
+    try:
+        return cospi(x) / sinpi(x)
+    except OverflowError:
+        if complex(x).imag > 10:
+            return -1j
+        if complex(x).imag < 10:
+            return 1j
+        raise
+
+INF = 1e300*1e300
+NINF = -INF
+NAN = INF-INF
+EPS = 2.2204460492503131e-16
+
+_exact_gamma = (INF, 1.0, 1.0, 2.0, 6.0, 24.0, 120.0, 720.0, 5040.0, 40320.0,
+  362880.0, 3628800.0, 39916800.0, 479001600.0, 6227020800.0, 87178291200.0,
+  1307674368000.0, 20922789888000.0, 355687428096000.0, 6402373705728000.0,
+  121645100408832000.0, 2432902008176640000.0)
+
+_max_exact_gamma = len(_exact_gamma)-1
+
+# Lanczos coefficients used by the GNU Scientific Library
+_lanczos_g = 7
+_lanczos_p = (0.99999999999980993, 676.5203681218851, -1259.1392167224028,
+     771.32342877765313, -176.61502916214059, 12.507343278686905,
+     -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7)
+
+def _gamma_real(x):
+    _intx = int(x)
+    if _intx == x:
+        if _intx <= 0:
+            #return (-1)**_intx * INF
+            raise ZeroDivisionError("gamma function pole")
+        if _intx <= _max_exact_gamma:
+            return _exact_gamma[_intx]
+    if x < 0.5:
+        # TODO: sinpi
+        return pi / (_sinpi_real(x)*_gamma_real(1-x))
+    else:
+        x -= 1.0
+        r = _lanczos_p[0]
+        for i in range(1, _lanczos_g+2):
+            r += _lanczos_p[i]/(x+i)
+        t = x + _lanczos_g + 0.5
+        return 2.506628274631000502417 * t**(x+0.5) * math.exp(-t) * r
+
+def _gamma_complex(x):
+    if not x.imag:
+        return complex(_gamma_real(x.real))
+    if x.real < 0.5:
+        # TODO: sinpi
+        return pi / (_sinpi_complex(x)*_gamma_complex(1-x))
+    else:
+        x -= 1.0
+        r = _lanczos_p[0]
+        for i in range(1, _lanczos_g+2):
+            r += _lanczos_p[i]/(x+i)
+        t = x + _lanczos_g + 0.5
+        return 2.506628274631000502417 * t**(x+0.5) * cmath.exp(-t) * r
+
+gamma = _mathfun_real(_gamma_real, _gamma_complex)
+
+def rgamma(x):
+    try:
+        return 1./gamma(x)
+    except ZeroDivisionError:
+        return x*0.0
+
+def factorial(x):
+    return gamma(x+1.0)
+
+def arg(x):
+    if type(x) is float:
+        return math.atan2(0.0,x)
+    return math.atan2(x.imag,x.real)
+
+# XXX: broken for negatives
+def loggamma(x):
+    if type(x) not in (float, complex):
+        try:
+            x = float(x)
+        except (ValueError, TypeError):
+            x = complex(x)
+    try:
+        xreal = x.real
+        ximag = x.imag
+    except AttributeError:   # py2.5
+        xreal = x
+        ximag = 0.0
+    # Reflection formula
+    # http://functions.wolfram.com/GammaBetaErf/LogGamma/16/01/01/0003/
+    if xreal < 0.0:
+        if abs(x) < 0.5:
+            v = log(gamma(x))
+            if ximag == 0:
+                v = v.conjugate()
+            return v
+        z = 1-x
+        try:
+            re = z.real
+            im = z.imag
+        except AttributeError:   # py2.5
+            re = z
+            im = 0.0
+        refloor = floor(re)
+        if im == 0.0:
+            imsign = 0
+        elif im < 0.0:
+            imsign = -1
+        else:
+            imsign = 1
+        return (-pi*1j)*abs(refloor)*(1-abs(imsign)) + logpi - \
+            log(sinpi(z-refloor)) - loggamma(z) + 1j*pi*refloor*imsign
+    if x == 1.0 or x == 2.0:
+        return x*0
+    p = 0.
+    while abs(x) < 11:
+        p -= log(x)
+        x += 1.0
+    s = 0.918938533204672742 + (x-0.5)*log(x) - x
+    r = 1./x
+    r2 = r*r
+    s += 0.083333333333333333333*r; r *= r2
+    s += -0.0027777777777777777778*r; r *= r2
+    s += 0.00079365079365079365079*r; r *= r2
+    s += -0.0005952380952380952381*r; r *= r2
+    s += 0.00084175084175084175084*r; r *= r2
+    s += -0.0019175269175269175269*r; r *= r2
+    s += 0.0064102564102564102564*r; r *= r2
+    s += -0.02955065359477124183*r
+    return s + p
+
+_psi_coeff = [
+0.083333333333333333333,
+-0.0083333333333333333333,
+0.003968253968253968254,
+-0.0041666666666666666667,
+0.0075757575757575757576,
+-0.021092796092796092796,
+0.083333333333333333333,
+-0.44325980392156862745,
+3.0539543302701197438,
+-26.456212121212121212]
+
+def _digamma_real(x):
+    _intx = int(x)
+    if _intx == x:
+        if _intx <= 0:
+            raise ZeroDivisionError("polygamma pole")
+    if x < 0.5:
+        x = 1.0-x
+        s = pi*cotpi(x)
+    else:
+        s = 0.0
+    while x < 10.0:
+        s -= 1.0/x
+        x += 1.0
+    x2 = x**-2
+    t = x2
+    for c in _psi_coeff:
+        s -= c*t
+        if t < 1e-20:
+            break
+        t *= x2
+    return s + math_log(x) - 0.5/x
+
+def _digamma_complex(x):
+    if not x.imag:
+        return complex(_digamma_real(x.real))
+    if x.real < 0.5:
+        x = 1.0-x
+        s = pi*cotpi(x)
+    else:
+        s = 0.0
+    while abs(x) < 10.0:
+        s -= 1.0/x
+        x += 1.0
+    x2 = x**-2
+    t = x2
+    for c in _psi_coeff:
+        s -= c*t
+        if abs(t) < 1e-20:
+            break
+        t *= x2
+    return s + cmath.log(x) - 0.5/x
+
+digamma = _mathfun_real(_digamma_real, _digamma_complex)
+
+# TODO: could implement complex erf and erfc here. Need
+# to find an accurate method (avoiding cancellation)
+# for approx. 1 < abs(x) < 9.
+
+_erfc_coeff_P = [
+    1.0000000161203922312,
+    2.1275306946297962644,
+    2.2280433377390253297,
+    1.4695509105618423961,
+    0.66275911699770787537,
+    0.20924776504163751585,
+    0.045459713768411264339,
+    0.0063065951710717791934,
+    0.00044560259661560421715][::-1]
+
+_erfc_coeff_Q = [
+    1.0000000000000000000,
+    3.2559100272784894318,
+    4.9019435608903239131,
+    4.4971472894498014205,
+    2.7845640601891186528,
+    1.2146026030046904138,
+    0.37647108453729465912,
+    0.080970149639040548613,
+    0.011178148899483545902,
+    0.00078981003831980423513][::-1]
+
+def _polyval(coeffs, x):
+    p = coeffs[0]
+    for c in coeffs[1:]:
+        p = c + x*p
+    return p
+
+def _erf_taylor(x):
+    # Taylor series assuming 0 <= x <= 1
+    x2 = x*x
+    s = t = x
+    n = 1
+    while abs(t) > 1e-17:
+        t *= x2/n
+        s -= t/(n+n+1)
+        n += 1
+        t *= x2/n
+        s += t/(n+n+1)
+        n += 1
+    return 1.1283791670955125739*s
+
+def _erfc_mid(x):
+    # Rational approximation assuming 0 <= x <= 9
+    return exp(-x*x)*_polyval(_erfc_coeff_P,x)/_polyval(_erfc_coeff_Q,x)
+
+def _erfc_asymp(x):
+    # Asymptotic expansion assuming x >= 9
+    x2 = x*x
+    v = exp(-x2)/x*0.56418958354775628695
+    r = t = 0.5 / x2
+    s = 1.0
+    for n in range(1,22,4):
+        s -= t
+        t *= r * (n+2)
+        s += t
+        t *= r * (n+4)
+        if abs(t) < 1e-17:
+            break
+    return s * v
+
+def erf(x):
+    """
+    erf of a real number.
+    """
+    x = float(x)
+    if x != x:
+        return x
+    if x < 0.0:
+        return -erf(-x)
+    if x >= 1.0:
+        if x >= 6.0:
+            return 1.0
+        return 1.0 - _erfc_mid(x)
+    return _erf_taylor(x)
+
+def erfc(x):
+    """
+    erfc of a real number.
+    """
+    x = float(x)
+    if x != x:
+        return x
+    if x < 0.0:
+        if x < -6.0:
+            return 2.0
+        return 2.0-erfc(-x)
+    if x > 9.0:
+        return _erfc_asymp(x)
+    if x >= 1.0:
+        return _erfc_mid(x)
+    return 1.0 - _erf_taylor(x)
+
+gauss42 = [\
+(0.99839961899006235, 0.0041059986046490839),
+(-0.99839961899006235, 0.0041059986046490839),
+(0.9915772883408609, 0.009536220301748501),
+(-0.9915772883408609,0.009536220301748501),
+(0.97934250806374812, 0.014922443697357493),
+(-0.97934250806374812, 0.014922443697357493),
+(0.96175936533820439,0.020227869569052644),
+(-0.96175936533820439, 0.020227869569052644),
+(0.93892355735498811, 0.025422959526113047),
+(-0.93892355735498811,0.025422959526113047),
+(0.91095972490412735, 0.030479240699603467),
+(-0.91095972490412735, 0.030479240699603467),
+(0.87802056981217269,0.03536907109759211),
+(-0.87802056981217269, 0.03536907109759211),
+(0.8402859832618168, 0.040065735180692258),
+(-0.8402859832618168,0.040065735180692258),
+(0.7979620532554873, 0.044543577771965874),
+(-0.7979620532554873, 0.044543577771965874),
+(0.75127993568948048,0.048778140792803244),
+(-0.75127993568948048, 0.048778140792803244),
+(0.70049459055617114, 0.052746295699174064),
+(-0.70049459055617114,0.052746295699174064),
+(0.64588338886924779, 0.056426369358018376),
+(-0.64588338886924779, 0.056426369358018376),
+(0.58774459748510932, 0.059798262227586649),
+(-0.58774459748510932, 0.059798262227586649),
+(0.5263957499311922, 0.062843558045002565),
+(-0.5263957499311922, 0.062843558045002565),
+(0.46217191207042191, 0.065545624364908975),
+(-0.46217191207042191, 0.065545624364908975),
+(0.39542385204297503, 0.067889703376521934),
+(-0.39542385204297503, 0.067889703376521934),
+(0.32651612446541151, 0.069862992492594159),
+(-0.32651612446541151, 0.069862992492594159),
+(0.25582507934287907, 0.071454714265170971),
+(-0.25582507934287907, 0.071454714265170971),
+(0.18373680656485453, 0.072656175243804091),
+(-0.18373680656485453, 0.072656175243804091),
+(0.11064502720851986, 0.073460813453467527),
+(-0.11064502720851986, 0.073460813453467527),
+(0.036948943165351772, 0.073864234232172879),
+(-0.036948943165351772, 0.073864234232172879)]
+
+EI_ASYMP_CONVERGENCE_RADIUS = 40.0
+
+def ei_asymp(z, _e1=False):
+    r = 1./z
+    s = t = 1.0
+    k = 1
+    while 1:
+        t *= k*r
+        s += t
+        if abs(t) < 1e-16:
+            break
+        k += 1
+    v = s*exp(z)/z
+    if _e1:
+        if type(z) is complex:
+            zreal = z.real
+            zimag = z.imag
+        else:
+            zreal = z
+            zimag = 0.0
+        if zimag == 0.0 and zreal > 0.0:
+            v += pi*1j
+    else:
+        if type(z) is complex:
+            if z.imag > 0:
+                v += pi*1j
+            if z.imag < 0:
+                v -= pi*1j
+    return v
+
+def ei_taylor(z, _e1=False):
+    s = t = z
+    k = 2
+    while 1:
+        t = t*z/k
+        term = t/k
+        if abs(term) < 1e-17:
+            break
+        s += term
+        k += 1
+    s += euler
+    if _e1:
+        s += log(-z)
+    else:
+        if type(z) is float or z.imag == 0.0:
+            s += math_log(abs(z))
+        else:
+            s += cmath.log(z)
+    return s
+
+def ei(z, _e1=False):
+    typez = type(z)
+    if typez not in (float, complex):
+        try:
+            z = float(z)
+            typez = float
+        except (TypeError, ValueError):
+            z = complex(z)
+            typez = complex
+    if not z:
+        return -INF
+    absz = abs(z)
+    if absz > EI_ASYMP_CONVERGENCE_RADIUS:
+        return ei_asymp(z, _e1)
+    elif absz <= 2.0 or (typez is float and z > 0.0):
+        return ei_taylor(z, _e1)
+    # Integrate, starting from whichever is smaller of a Taylor
+    # series value or an asymptotic series value
+    if typez is complex and z.real > 0.0:
+        zref = z / absz
+        ref = ei_taylor(zref, _e1)
+    else:
+        zref = EI_ASYMP_CONVERGENCE_RADIUS * z / absz
+        ref = ei_asymp(zref, _e1)
+    C = (zref-z)*0.5
+    D = (zref+z)*0.5
+    s = 0.0
+    if type(z) is complex:
+        _exp = cmath.exp
+    else:
+        _exp = math.exp
+    for x,w in gauss42:
+        t = C*x+D
+        s += w*_exp(t)/t
+    ref -= C*s
+    return ref
+
+def e1(z):
+    # hack to get consistent signs if the imaginary part if 0
+    # and signed
+    typez = type(z)
+    if type(z) not in (float, complex):
+        try:
+            z = float(z)
+            typez = float
+        except (TypeError, ValueError):
+            z = complex(z)
+            typez = complex
+    if typez is complex and not z.imag:
+        z = complex(z.real, 0.0)
+    # end hack
+    return -ei(-z, _e1=True)
+
+_zeta_int = [\
+-0.5,
+0.0,
+1.6449340668482264365,1.2020569031595942854,1.0823232337111381915,
+1.0369277551433699263,1.0173430619844491397,1.0083492773819228268,
+1.0040773561979443394,1.0020083928260822144,1.0009945751278180853,
+1.0004941886041194646,1.0002460865533080483,1.0001227133475784891,
+1.0000612481350587048,1.0000305882363070205,1.0000152822594086519,
+1.0000076371976378998,1.0000038172932649998,1.0000019082127165539,
+1.0000009539620338728,1.0000004769329867878,1.0000002384505027277,
+1.0000001192199259653,1.0000000596081890513,1.0000000298035035147,
+1.0000000149015548284]
+
+_zeta_P = [-3.50000000087575873, -0.701274355654678147,
+-0.0672313458590012612, -0.00398731457954257841,
+-0.000160948723019303141, -4.67633010038383371e-6,
+-1.02078104417700585e-7, -1.68030037095896287e-9,
+-1.85231868742346722e-11][::-1]
+
+_zeta_Q = [1.00000000000000000, -0.936552848762465319,
+-0.0588835413263763741, -0.00441498861482948666,
+-0.000143416758067432622, -5.10691659585090782e-6,
+-9.58813053268913799e-8, -1.72963791443181972e-9,
+-1.83527919681474132e-11][::-1]
+
+_zeta_1 = [3.03768838606128127e-10, -1.21924525236601262e-8,
+2.01201845887608893e-7, -1.53917240683468381e-6,
+-5.09890411005967954e-7, 0.000122464707271619326,
+-0.000905721539353130232, -0.00239315326074843037,
+0.084239750013159168, 0.418938517907442414, 0.500000001921884009]
+
+_zeta_0 = [-3.46092485016748794e-10, -6.42610089468292485e-9,
+1.76409071536679773e-7, -1.47141263991560698e-6, -6.38880222546167613e-7,
+0.000122641099800668209, -0.000905894913516772796, -0.00239303348507992713,
+0.0842396947501199816, 0.418938533204660256, 0.500000000000000052]
+
+def zeta(s):
+    """
+    Riemann zeta function, real argument
+    """
+    if not isinstance(s, (float, int)):
+        try:
+            s = float(s)
+        except (ValueError, TypeError):
+            try:
+                s = complex(s)
+                if not s.imag:
+                    return complex(zeta(s.real))
+            except (ValueError, TypeError):
+                pass
+            raise NotImplementedError
+    if s == 1:
+        raise ValueError("zeta(1) pole")
+    if s >= 27:
+        return 1.0 + 2.0**(-s) + 3.0**(-s)
+    n = int(s)
+    if n == s:
+        if n >= 0:
+            return _zeta_int[n]
+        if not (n % 2):
+            return 0.0
+    if s <= 0.0:
+        return 2.**s*pi**(s-1)*_sinpi_real(0.5*s)*_gamma_real(1-s)*zeta(1-s)
+    if s <= 2.0:
+        if s <= 1.0:
+            return _polyval(_zeta_0,s)/(s-1)
+        return _polyval(_zeta_1,s)/(s-1)
+    z = _polyval(_zeta_P,s) / _polyval(_zeta_Q,s)
+    return 1.0 + 2.0**(-s) + 3.0**(-s) + 4.0**(-s)*z
diff --git a/lib/python3.11/site-packages/mpmath/matrices/__init__.py b/lib/python3.11/site-packages/mpmath/matrices/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..293697b9fcf8bd82d58ac4ff45acd73fadac82f9
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/matrices/__init__.py
@@ -0,0 +1,2 @@
+from . import eigen           # to set methods
+from . import eigen_symmetric # to set methods
diff --git a/lib/python3.11/site-packages/mpmath/matrices/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c7b4359b691ba9d539dcefcc5c3fd54526e709f9
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/matrices/__pycache__/calculus.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/calculus.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7073a162e89095ac46cee0cf107fdf903089bf33
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/calculus.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/matrices/__pycache__/eigen.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/eigen.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfe38bf0f9c48f34a30e5419fb432bb278e5c416
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/eigen.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/matrices/__pycache__/eigen_symmetric.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/eigen_symmetric.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95e8f2714f091fe2562a4e58f141a88dd890eaf4
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/eigen_symmetric.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/matrices/__pycache__/linalg.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/linalg.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aeabe9272eca36ff30299bc7757d2c9a8fa4ad42
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/linalg.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/matrices/__pycache__/matrices.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/matrices.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0f160a7504f4cd672a0e8fbf5ce7955a3fb6015e
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/matrices/__pycache__/matrices.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/matrices/calculus.py b/lib/python3.11/site-packages/mpmath/matrices/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fae2a7a9a29898241ed41810331b480ff70798f
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/matrices/calculus.py
@@ -0,0 +1,531 @@
+from ..libmp.backend import xrange
+
+# TODO: should use diagonalization-based algorithms
+
+class MatrixCalculusMethods(object):
+
+    def _exp_pade(ctx, a):
+        """
+        Exponential of a matrix using Pade approximants.
+
+        See G. H. Golub, C. F. van Loan 'Matrix Computations',
+        third Ed., page 572
+
+        TODO:
+         - find a good estimate for q
+         - reduce the number of matrix multiplications to improve
+           performance
+        """
+        def eps_pade(p):
+            return ctx.mpf(2)**(3-2*p) * \
+                ctx.factorial(p)**2/(ctx.factorial(2*p)**2 * (2*p + 1))
+        q = 4
+        extraq = 8
+        while 1:
+            if eps_pade(q) < ctx.eps:
+                break
+            q += 1
+        q += extraq
+        j = int(max(1, ctx.mag(ctx.mnorm(a,'inf'))))
+        extra = q
+        prec = ctx.prec
+        ctx.dps += extra + 3
+        try:
+            a = a/2**j
+            na = a.rows
+            den = ctx.eye(na)
+            num = ctx.eye(na)
+            x = ctx.eye(na)
+            c = ctx.mpf(1)
+            for k in range(1, q+1):
+                c *= ctx.mpf(q - k + 1)/((2*q - k + 1) * k)
+                x = a*x
+                cx = c*x
+                num += cx
+                den += (-1)**k * cx
+            f = ctx.lu_solve_mat(den, num)
+            for k in range(j):
+                f = f*f
+        finally:
+            ctx.prec = prec
+        return f*1
+
+    def expm(ctx, A, method='taylor'):
+        r"""
+        Computes the matrix exponential of a square matrix `A`, which is defined
+        by the power series
+
+        .. math ::
+
+            \exp(A) = I + A + \frac{A^2}{2!} + \frac{A^3}{3!} + \ldots
+
+        With method='taylor', the matrix exponential is computed
+        using the Taylor series. With method='pade', Pade approximants
+        are used instead.
+
+        **Examples**
+
+        Basic examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> expm(zeros(3))
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+            >>> expm(eye(3))
+            [2.71828182845905               0.0               0.0]
+            [             0.0  2.71828182845905               0.0]
+            [             0.0               0.0  2.71828182845905]
+            >>> expm([[1,1,0],[1,0,1],[0,1,0]])
+            [ 3.86814500615414  2.26812870852145  0.841130841230196]
+            [ 2.26812870852145  2.44114713886289   1.42699786729125]
+            [0.841130841230196  1.42699786729125    1.6000162976327]
+            >>> expm([[1,1,0],[1,0,1],[0,1,0]], method='pade')
+            [ 3.86814500615414  2.26812870852145  0.841130841230196]
+            [ 2.26812870852145  2.44114713886289   1.42699786729125]
+            [0.841130841230196  1.42699786729125    1.6000162976327]
+            >>> expm([[1+j, 0], [1+j,1]])
+            [(1.46869393991589 + 2.28735528717884j)                        0.0]
+            [  (1.03776739863568 + 3.536943175722j)  (2.71828182845905 + 0.0j)]
+
+        Matrices with large entries are allowed::
+
+            >>> expm(matrix([[1,2],[2,3]])**25)
+            [5.65024064048415e+2050488462815550  9.14228140091932e+2050488462815550]
+            [9.14228140091932e+2050488462815550  1.47925220414035e+2050488462815551]
+
+        The identity `\exp(A+B) = \exp(A) \exp(B)` does not hold for
+        noncommuting matrices::
+
+            >>> A = hilbert(3)
+            >>> B = A + eye(3)
+            >>> chop(mnorm(A*B - B*A))
+            0.0
+            >>> chop(mnorm(expm(A+B) - expm(A)*expm(B)))
+            0.0
+            >>> B = A + ones(3)
+            >>> mnorm(A*B - B*A)
+            1.8
+            >>> mnorm(expm(A+B) - expm(A)*expm(B))
+            42.0927851137247
+
+        """
+        if method == 'pade':
+            prec = ctx.prec
+            try:
+                A = ctx.matrix(A)
+                ctx.prec += 2*A.rows
+                res = ctx._exp_pade(A)
+            finally:
+                ctx.prec = prec
+            return res
+        A = ctx.matrix(A)
+        prec = ctx.prec
+        j = int(max(1, ctx.mag(ctx.mnorm(A,'inf'))))
+        j += int(0.5*prec**0.5)
+        try:
+            ctx.prec += 10 + 2*j
+            tol = +ctx.eps
+            A = A/2**j
+            T = A
+            Y = A**0 + A
+            k = 2
+            while 1:
+                T *= A * (1/ctx.mpf(k))
+                if ctx.mnorm(T, 'inf') < tol:
+                    break
+                Y += T
+                k += 1
+            for k in xrange(j):
+                Y = Y*Y
+        finally:
+            ctx.prec = prec
+        Y *= 1
+        return Y
+
+    def cosm(ctx, A):
+        r"""
+        Gives the cosine of a square matrix `A`, defined in analogy
+        with the matrix exponential.
+
+        Examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> cosm(X)
+            [0.54030230586814               0.0               0.0]
+            [             0.0  0.54030230586814               0.0]
+            [             0.0               0.0  0.54030230586814]
+            >>> X = hilbert(3)
+            >>> cosm(X)
+            [ 0.424403834569555  -0.316643413047167  -0.221474945949293]
+            [-0.316643413047167   0.820646708837824  -0.127183694770039]
+            [-0.221474945949293  -0.127183694770039   0.909236687217541]
+            >>> X = matrix([[1+j,-2],[0,-j]])
+            >>> cosm(X)
+            [(0.833730025131149 - 0.988897705762865j)  (1.07485840848393 - 0.17192140544213j)]
+            [                                     0.0               (1.54308063481524 + 0.0j)]
+        """
+        B = 0.5 * (ctx.expm(A*ctx.j) + ctx.expm(A*(-ctx.j)))
+        if not sum(A.apply(ctx.im).apply(abs)):
+            B = B.apply(ctx.re)
+        return B
+
+    def sinm(ctx, A):
+        r"""
+        Gives the sine of a square matrix `A`, defined in analogy
+        with the matrix exponential.
+
+        Examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> sinm(X)
+            [0.841470984807897                0.0                0.0]
+            [              0.0  0.841470984807897                0.0]
+            [              0.0                0.0  0.841470984807897]
+            >>> X = hilbert(3)
+            >>> sinm(X)
+            [0.711608512150994  0.339783913247439  0.220742837314741]
+            [0.339783913247439  0.244113865695532  0.187231271174372]
+            [0.220742837314741  0.187231271174372  0.155816730769635]
+            >>> X = matrix([[1+j,-2],[0,-j]])
+            >>> sinm(X)
+            [(1.29845758141598 + 0.634963914784736j)  (-1.96751511930922 + 0.314700021761367j)]
+            [                                    0.0                  (0.0 - 1.1752011936438j)]
+        """
+        B = (-0.5j) * (ctx.expm(A*ctx.j) - ctx.expm(A*(-ctx.j)))
+        if not sum(A.apply(ctx.im).apply(abs)):
+            B = B.apply(ctx.re)
+        return B
+
+    def _sqrtm_rot(ctx, A, _may_rotate):
+        # If the iteration fails to converge, cheat by performing
+        # a rotation by a complex number
+        u = ctx.j**0.3
+        return ctx.sqrtm(u*A, _may_rotate) / ctx.sqrt(u)
+
+    def sqrtm(ctx, A, _may_rotate=2):
+        r"""
+        Computes a square root of the square matrix `A`, i.e. returns
+        a matrix `B = A^{1/2}` such that `B^2 = A`. The square root
+        of a matrix, if it exists, is not unique.
+
+        **Examples**
+
+        Square roots of some simple matrices::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> sqrtm([[1,0], [0,1]])
+            [1.0  0.0]
+            [0.0  1.0]
+            >>> sqrtm([[0,0], [0,0]])
+            [0.0  0.0]
+            [0.0  0.0]
+            >>> sqrtm([[2,0],[0,1]])
+            [1.4142135623731  0.0]
+            [            0.0  1.0]
+            >>> sqrtm([[1,1],[1,0]])
+            [ (0.920442065259926 - 0.21728689675164j)  (0.568864481005783 + 0.351577584254143j)]
+            [(0.568864481005783 + 0.351577584254143j)  (0.351577584254143 - 0.568864481005783j)]
+            >>> sqrtm([[1,0],[0,1]])
+            [1.0  0.0]
+            [0.0  1.0]
+            >>> sqrtm([[-1,0],[0,1]])
+            [(0.0 - 1.0j)           0.0]
+            [         0.0  (1.0 + 0.0j)]
+            >>> sqrtm([[j,0],[0,j]])
+            [(0.707106781186547 + 0.707106781186547j)                                       0.0]
+            [                                     0.0  (0.707106781186547 + 0.707106781186547j)]
+
+        A square root of a rotation matrix, giving the corresponding
+        half-angle rotation matrix::
+
+            >>> t1 = 0.75
+            >>> t2 = t1 * 0.5
+            >>> A1 = matrix([[cos(t1), -sin(t1)], [sin(t1), cos(t1)]])
+            >>> A2 = matrix([[cos(t2), -sin(t2)], [sin(t2), cos(t2)]])
+            >>> sqrtm(A1)
+            [0.930507621912314  -0.366272529086048]
+            [0.366272529086048   0.930507621912314]
+            >>> A2
+            [0.930507621912314  -0.366272529086048]
+            [0.366272529086048   0.930507621912314]
+
+        The identity `(A^2)^{1/2} = A` does not necessarily hold::
+
+            >>> A = matrix([[4,1,4],[7,8,9],[10,2,11]])
+            >>> sqrtm(A**2)
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> sqrtm(A)**2
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> A = matrix([[-4,1,4],[7,-8,9],[10,2,11]])
+            >>> sqrtm(A**2)
+            [  7.43715112194995  -0.324127569985474   1.8481718827526]
+            [-0.251549715716942    9.32699765900402  2.48221180985147]
+            [  4.11609388833616   0.775751877098258   13.017955697342]
+            >>> chop(sqrtm(A)**2)
+            [-4.0   1.0   4.0]
+            [ 7.0  -8.0   9.0]
+            [10.0   2.0  11.0]
+
+        For some matrices, a square root does not exist::
+
+            >>> sqrtm([[0,1], [0,0]])
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError: matrix is numerically singular
+
+        Two examples from the documentation for Matlab's ``sqrtm``::
+
+            >>> mp.dps = 15; mp.pretty = True
+            >>> sqrtm([[7,10],[15,22]])
+            [1.56669890360128  1.74077655955698]
+            [2.61116483933547  4.17786374293675]
+            >>>
+            >>> X = matrix(\
+            ...   [[5,-4,1,0,0],
+            ...   [-4,6,-4,1,0],
+            ...   [1,-4,6,-4,1],
+            ...   [0,1,-4,6,-4],
+            ...   [0,0,1,-4,5]])
+            >>> Y = matrix(\
+            ...   [[2,-1,-0,-0,-0],
+            ...   [-1,2,-1,0,-0],
+            ...   [0,-1,2,-1,0],
+            ...   [-0,0,-1,2,-1],
+            ...   [-0,-0,-0,-1,2]])
+            >>> mnorm(sqrtm(X) - Y)
+            4.53155328326114e-19
+
+        """
+        A = ctx.matrix(A)
+        # Trivial
+        if A*0 == A:
+            return A
+        prec = ctx.prec
+        if _may_rotate:
+            d = ctx.det(A)
+            if abs(ctx.im(d)) < 16*ctx.eps and ctx.re(d) < 0:
+                return ctx._sqrtm_rot(A, _may_rotate-1)
+        try:
+            ctx.prec += 10
+            tol = ctx.eps * 128
+            Y = A
+            Z = I = A**0
+            k = 0
+            # Denman-Beavers iteration
+            while 1:
+                Yprev = Y
+                try:
+                    Y, Z = 0.5*(Y+ctx.inverse(Z)), 0.5*(Z+ctx.inverse(Y))
+                except ZeroDivisionError:
+                    if _may_rotate:
+                        Y = ctx._sqrtm_rot(A, _may_rotate-1)
+                        break
+                    else:
+                        raise
+                mag1 = ctx.mnorm(Y-Yprev, 'inf')
+                mag2 = ctx.mnorm(Y, 'inf')
+                if mag1 <= mag2*tol:
+                    break
+                if _may_rotate and k > 6 and not mag1 < mag2 * 0.001:
+                    return ctx._sqrtm_rot(A, _may_rotate-1)
+                k += 1
+                if k > ctx.prec:
+                    raise ctx.NoConvergence
+        finally:
+            ctx.prec = prec
+        Y *= 1
+        return Y
+
+    def logm(ctx, A):
+        r"""
+        Computes a logarithm of the square matrix `A`, i.e. returns
+        a matrix `B = \log(A)` such that `\exp(B) = A`. The logarithm
+        of a matrix, if it exists, is not unique.
+
+        **Examples**
+
+        Logarithms of some simple matrices::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> logm(X)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            >>> logm(2*X)
+            [0.693147180559945                0.0                0.0]
+            [              0.0  0.693147180559945                0.0]
+            [              0.0                0.0  0.693147180559945]
+            >>> logm(expm(X))
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+
+        A logarithm of a complex matrix::
+
+            >>> X = matrix([[2+j, 1, 3], [1-j, 1-2*j, 1], [-4, -5, j]])
+            >>> B = logm(X)
+            >>> nprint(B)
+            [ (0.808757 + 0.107759j)    (2.20752 + 0.202762j)   (1.07376 - 0.773874j)]
+            [ (0.905709 - 0.107795j)  (0.0287395 - 0.824993j)  (0.111619 + 0.514272j)]
+            [(-0.930151 + 0.399512j)   (-2.06266 - 0.674397j)  (0.791552 + 0.519839j)]
+            >>> chop(expm(B))
+            [(2.0 + 1.0j)           1.0           3.0]
+            [(1.0 - 1.0j)  (1.0 - 2.0j)           1.0]
+            [        -4.0          -5.0  (0.0 + 1.0j)]
+
+        A matrix `X` close to the identity matrix, for which
+        `\log(\exp(X)) = \exp(\log(X)) = X` holds::
+
+            >>> X = eye(3) + hilbert(3)/4
+            >>> X
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+            >>> logm(expm(X))
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+            >>> expm(logm(X))
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+
+        A logarithm of a rotation matrix, giving back the angle of
+        the rotation::
+
+            >>> t = 3.7
+            >>> A = matrix([[cos(t),sin(t)],[-sin(t),cos(t)]])
+            >>> chop(logm(A))
+            [             0.0  -2.58318530717959]
+            [2.58318530717959                0.0]
+            >>> (2*pi-t)
+            2.58318530717959
+
+        For some matrices, a logarithm does not exist::
+
+            >>> logm([[1,0], [0,0]])
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError: matrix is numerically singular
+
+        Logarithm of a matrix with large entries::
+
+            >>> logm(hilbert(3) * 10**20).apply(re)
+            [ 45.5597513593433  1.27721006042799  0.317662687717978]
+            [ 1.27721006042799  42.5222778973542   2.24003708791604]
+            [0.317662687717978  2.24003708791604    42.395212822267]
+
+        """
+        A = ctx.matrix(A)
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            tol = ctx.eps * 128
+            I = A**0
+            B = A
+            n = 0
+            while 1:
+                B = ctx.sqrtm(B)
+                n += 1
+                if ctx.mnorm(B-I, 'inf') < 0.125:
+                    break
+            T = X = B-I
+            L = X*0
+            k = 1
+            while 1:
+                if k & 1:
+                    L += T / k
+                else:
+                    L -= T / k
+                T *= X
+                if ctx.mnorm(T, 'inf') < tol:
+                    break
+                k += 1
+                if k > ctx.prec:
+                    raise ctx.NoConvergence
+        finally:
+            ctx.prec = prec
+        L *= 2**n
+        return L
+
+    def powm(ctx, A, r):
+        r"""
+        Computes `A^r = \exp(A \log r)` for a matrix `A` and complex
+        number `r`.
+
+        **Examples**
+
+        Powers and inverse powers of a matrix::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> A = matrix([[4,1,4],[7,8,9],[10,2,11]])
+            >>> powm(A, 2)
+            [ 63.0  20.0   69.0]
+            [174.0  89.0  199.0]
+            [164.0  48.0  179.0]
+            >>> chop(powm(powm(A, 4), 1/4.))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> powm(extraprec(20)(powm)(A, -4), -1/4.)
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> chop(powm(powm(A, 1+0.5j), 1/(1+0.5j)))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> powm(extraprec(5)(powm)(A, -1.5), -1/(1.5))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+
+        A Fibonacci-generating matrix::
+
+            >>> powm([[1,1],[1,0]], 10)
+            [89.0  55.0]
+            [55.0  34.0]
+            >>> fib(10)
+            55.0
+            >>> powm([[1,1],[1,0]], 6.5)
+            [(16.5166626964253 - 0.0121089837381789j)  (10.2078589271083 + 0.0195927472575932j)]
+            [(10.2078589271083 + 0.0195927472575932j)  (6.30880376931698 - 0.0317017309957721j)]
+            >>> (phi**6.5 - (1-phi)**6.5)/sqrt(5)
+            (10.2078589271083 - 0.0195927472575932j)
+            >>> powm([[1,1],[1,0]], 6.2)
+            [ (14.3076953002666 - 0.008222855781077j)  (8.81733464837593 + 0.0133048601383712j)]
+            [(8.81733464837593 + 0.0133048601383712j)  (5.49036065189071 - 0.0215277159194482j)]
+            >>> (phi**6.2 - (1-phi)**6.2)/sqrt(5)
+            (8.81733464837593 - 0.0133048601383712j)
+
+        """
+        A = ctx.matrix(A)
+        r = ctx.convert(r)
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            if ctx.isint(r):
+                v = A ** int(r)
+            elif ctx.isint(r*2):
+                y = int(r*2)
+                v = ctx.sqrtm(A) ** y
+            else:
+                v = ctx.expm(r*ctx.logm(A))
+        finally:
+            ctx.prec = prec
+        v *= 1
+        return v
diff --git a/lib/python3.11/site-packages/mpmath/matrices/eigen.py b/lib/python3.11/site-packages/mpmath/matrices/eigen.py
new file mode 100644
index 0000000000000000000000000000000000000000..885d604203195b695183329acc637de91aeaf5ea
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/matrices/eigen.py
@@ -0,0 +1,877 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+#     module for the eigenvalue problem
+#       Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+#
+# todo:
+#  - implement balancing
+#  - agressive early deflation
+#
+##################################################################################################
+
+"""
+The eigenvalue problem
+----------------------
+
+This file contains routines for the eigenvalue problem.
+
+high level routines:
+
+  hessenberg : reduction of a real or complex square matrix to upper Hessenberg form
+  schur : reduction of a real or complex square matrix to upper Schur form
+  eig : eigenvalues and eigenvectors of a real or complex square matrix
+
+low level routines:
+
+  hessenberg_reduce_0 : reduction of a real or complex square matrix to upper Hessenberg form
+  hessenberg_reduce_1 : auxiliary routine to hessenberg_reduce_0
+  qr_step : a single implicitly shifted QR step for an upper Hessenberg matrix
+  hessenberg_qr : Schur decomposition of an upper Hessenberg matrix
+  eig_tr_r : right eigenvectors of an upper triangular matrix
+  eig_tr_l : left  eigenvectors of an upper triangular matrix
+"""
+
+from ..libmp.backend import xrange
+
+class Eigen(object):
+    pass
+
+def defun(f):
+    setattr(Eigen, f.__name__, f)
+    return f
+
+def hessenberg_reduce_0(ctx, A, T):
+    """
+    This routine computes the (upper) Hessenberg decomposition of a square matrix A.
+    Given A, an unitary matrix Q is calculated such that
+
+               Q' A Q = H              and             Q' Q = Q Q' = 1
+
+    where H is an upper Hessenberg matrix, meaning that it only contains zeros
+    below the first subdiagonal. Here ' denotes the hermitian transpose (i.e.
+    transposition and conjugation).
+
+    parameters:
+      A         (input/output) On input, A contains the square matrix A of
+                dimension (n,n). On output, A contains a compressed representation
+                of Q and H.
+      T         (output) An array of length n containing the first elements of
+                the Householder reflectors.
+    """
+
+    # internally we work with householder reflections from the right.
+    # let u be a row vector (i.e. u[i]=A[i,:i]). then
+    # Q is build up by reflectors of the type (1-v'v) where v is a suitable
+    # modification of u. these reflectors are applyed to A from the right.
+    # because we work with reflectors from the right we have to start with
+    # the bottom row of A and work then upwards (this corresponds to
+    # some kind of RQ decomposition).
+    # the first part of the vectors v (i.e. A[i,:(i-1)]) are stored as row vectors
+    # in the lower left part of A (excluding the diagonal and subdiagonal).
+    # the last entry of v is stored in T.
+    # the upper right part of A (including diagonal and subdiagonal) becomes H.
+
+
+    n = A.rows
+    if n <= 2: return
+
+    for i in xrange(n-1, 1, -1):
+
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(ctx.re(A[i,k])) + abs(ctx.im(A[i,k]))
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1 / scale
+
+        if scale == 0 or ctx.isinf(scale_inv):
+            # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+            T[i] = 0
+            A[i,i-1] = 0
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[i,k] *= scale_inv
+            rr = ctx.re(A[i,k])
+            ii = ctx.im(A[i,k])
+            H += rr * rr + ii * ii
+
+        F = A[i,i-1]
+        f = abs(F)
+        G = ctx.sqrt(H)
+        A[i,i-1] = - G * scale
+
+        if f == 0:
+            T[i] = G
+        else:
+            ff = F / f
+            T[i] = F + G * ff
+            A[i,i-1] *= ff
+
+        H += G * f
+        H = 1 / ctx.sqrt(H)
+
+        T[i] *= H
+        for k in xrange(0, i - 1):
+            A[i,k] *= H
+
+        for j in xrange(0, i):
+            # apply housholder transformation (from right)
+
+            G = ctx.conj(T[i]) * A[j,i-1]
+            for k in xrange(0, i-1):
+                G += ctx.conj(A[i,k]) * A[j,k]
+
+            A[j,i-1] -= G * T[i]
+            for k in xrange(0, i-1):
+                A[j,k] -= G * A[i,k]
+
+        for j in xrange(0, n):
+            # apply housholder transformation (from left)
+
+            G = T[i] * A[i-1,j]
+            for k in xrange(0, i-1):
+                G += A[i,k] * A[k,j]
+
+            A[i-1,j] -= G * ctx.conj(T[i])
+            for k in xrange(0, i-1):
+                A[k,j] -= G * ctx.conj(A[i,k])
+
+
+
+def hessenberg_reduce_1(ctx, A, T):
+    """
+    This routine forms the unitary matrix Q described in hessenberg_reduce_0.
+
+    parameters:
+      A    (input/output) On input, A is the same matrix as delivered by
+           hessenberg_reduce_0. On output, A is set to Q.
+
+      T    (input) On input, T is the same array as delivered by hessenberg_reduce_0.
+    """
+
+    n = A.rows
+
+    if n == 1:
+        A[0,0] = 1
+        return
+
+    A[0,0] = A[1,1] = 1
+    A[0,1] = A[1,0] = 0
+
+    for i in xrange(2, n):
+        if T[i] != 0:
+
+            for j in xrange(0, i):
+                G = T[i] * A[i-1,j]
+                for k in xrange(0, i-1):
+                    G += A[i,k] * A[k,j]
+
+                A[i-1,j] -= G * ctx.conj(T[i])
+                for k in xrange(0, i-1):
+                    A[k,j] -= G * ctx.conj(A[i,k])
+
+        A[i,i] = 1
+        for j in xrange(0, i):
+            A[j,i] = A[i,j] = 0
+
+
+
+@defun
+def hessenberg(ctx, A, overwrite_a = False):
+    """
+    This routine computes the Hessenberg decomposition of a square matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = H                and               Q' Q = Q Q' = 1
+
+    where H is an upper right Hessenberg matrix. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation).
+
+    input:
+      A            : a real or complex square matrix
+      overwrite_a  : if true, allows modification of A which may improve
+                     performance. if false, A is not modified.
+
+    output:
+      Q : an unitary matrix
+      H : an upper right Hessenberg matrix
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> Q, H = mp.hessenberg(A)
+      >>> mp.nprint(H, 3) # doctest:+SKIP
+      [  3.15  2.23  4.44]
+      [-0.769  4.85  3.05]
+      [   0.0  3.61   7.0]
+      >>> print(mp.chop(A - Q * H * Q.transpose_conj()))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    return value:   (Q, H)
+    """
+
+    n = A.rows
+
+    if n == 1:
+        return (ctx.matrix([[1]]), A)
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.matrix(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+    Q = A.copy()
+    hessenberg_reduce_1(ctx, Q, T)
+
+    for x in xrange(n):
+        for y in xrange(x+2, n):
+            A[y,x] = 0
+
+    return Q, A
+
+
+###########################################################################
+
+
+def qr_step(ctx, n0, n1, A, Q, shift):
+    """
+    This subroutine executes a single implicitly shifted QR step applied to an
+    upper Hessenberg matrix A. Given A and shift as input, first an QR
+    decomposition is calculated:
+
+      Q R = A - shift * 1 .
+
+    The output is then following matrix:
+
+      R Q + shift * 1
+
+    parameters:
+      n0, n1    (input) Two integers which specify the submatrix A[n0:n1,n0:n1]
+                on which this subroutine operators. The subdiagonal elements
+                to the left and below this submatrix must be deflated (i.e. zero).
+                following restriction is imposed: n1>=n0+2
+      A         (input/output) On input, A is an upper Hessenberg matrix.
+                On output, A is replaced by "R Q + shift * 1"
+      Q         (input/output) The parameter Q is multiplied by the unitary matrix
+                Q arising from the QR decomposition. Q can also be false, in which
+                case the unitary matrix Q is not computated.
+      shift     (input) a complex number specifying the shift. idealy close to an
+                eigenvalue of the bottemmost part of the submatrix A[n0:n1,n0:n1].
+
+    references:
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+      Kresser : Numerical Methods for General and Structured Eigenvalue Problems
+    """
+
+    # implicitly shifted and bulge chasing is explained at p.398/399 in "Stoer, Bulirsch - Introduction to Numerical Analysis"
+    # for bulge chasing see also "Watkins - The Matrix Eigenvalue Problem" sec.4.5,p.173
+
+    # the Givens rotation we used is determined as follows: let c,s be two complex
+    # numbers. then we have following relation:
+    #
+    #     v = sqrt(|c|^2 + |s|^2)
+    #
+    #     1/v [ c~  s~]  [c] = [v]
+    #         [-s   c ]  [s]   [0]
+    #
+    # the matrix on the left is our Givens rotation.
+
+    n = A.rows
+
+    # first step
+
+    # calculate givens rotation
+    c = A[n0  ,n0] - shift
+    s = A[n0+1,n0]
+
+    v = ctx.hypot(ctx.hypot(ctx.re(c), ctx.im(c)), ctx.hypot(ctx.re(s), ctx.im(s)))
+
+    if v == 0:
+        v = 1
+        c = 1
+        s = 0
+    else:
+        c /= v
+        s /= v
+
+    cc = ctx.conj(c)
+    cs = ctx.conj(s)
+
+    for k in xrange(n0, n):
+        # apply givens rotation from the left
+        x = A[n0  ,k]
+        y = A[n0+1,k]
+        A[n0  ,k] = cc * x + cs * y
+        A[n0+1,k] = c * y - s * x
+
+    for k in xrange(min(n1, n0+3)):
+        # apply givens rotation from the right
+        x = A[k,n0  ]
+        y = A[k,n0+1]
+        A[k,n0  ] = c * x + s * y
+        A[k,n0+1] = cc * y - cs * x
+
+    if not isinstance(Q, bool):
+        for k in xrange(n):
+            # eigenvectors
+            x = Q[k,n0  ]
+            y = Q[k,n0+1]
+            Q[k,n0  ] = c * x + s * y
+            Q[k,n0+1] = cc * y - cs * x
+
+    # chase the bulge
+
+    for j in xrange(n0, n1 - 2):
+        # calculate givens rotation
+
+        c = A[j+1,j]
+        s = A[j+2,j]
+
+        v = ctx.hypot(ctx.hypot(ctx.re(c), ctx.im(c)), ctx.hypot(ctx.re(s), ctx.im(s)))
+
+        if v == 0:
+            A[j+1,j] = 0
+            v = 1
+            c = 1
+            s = 0
+        else:
+            A[j+1,j] = v
+            c /= v
+            s /= v
+
+        A[j+2,j] = 0
+
+        cc = ctx.conj(c)
+        cs = ctx.conj(s)
+
+        for k in xrange(j+1, n):
+            # apply givens rotation from the left
+            x = A[j+1,k]
+            y = A[j+2,k]
+            A[j+1,k] = cc * x + cs * y
+            A[j+2,k] = c * y - s * x
+
+        for k in xrange(0, min(n1, j+4)):
+            # apply givens rotation from the right
+            x = A[k,j+1]
+            y = A[k,j+2]
+            A[k,j+1] = c * x + s * y
+            A[k,j+2] = cc * y - cs * x
+
+        if not isinstance(Q, bool):
+            for k in xrange(0, n):
+                # eigenvectors
+                x = Q[k,j+1]
+                y = Q[k,j+2]
+                Q[k,j+1] = c * x + s * y
+                Q[k,j+2] = cc * y - cs * x
+
+
+
+def hessenberg_qr(ctx, A, Q):
+    """
+    This routine computes the Schur decomposition of an upper Hessenberg matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = R                   and                  Q' Q = Q Q' = 1
+
+    where R is an upper right triangular matrix. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation).
+
+    parameters:
+      A         (input/output) On input, A contains an upper Hessenberg matrix.
+                On output, A is replace by the upper right triangluar matrix R.
+
+      Q         (input/output) The parameter Q is multiplied by the unitary
+                matrix Q arising from the Schur decomposition. Q can also be
+                false, in which case the unitary matrix Q is not computated.
+    """
+
+    n = A.rows
+
+    norm = 0
+    for x in xrange(n):
+        for y in xrange(min(x+2, n)):
+            norm += ctx.re(A[y,x]) ** 2 + ctx.im(A[y,x]) ** 2
+    norm = ctx.sqrt(norm) / n
+
+    if norm == 0:
+        return
+
+    n0 = 0
+    n1 = n
+
+    eps = ctx.eps / (100 * n)
+    maxits = ctx.dps * 4
+
+    its = totalits = 0
+
+    while 1:
+        # kressner p.32 algo 3
+        # the active submatrix is A[n0:n1,n0:n1]
+
+        k = n0
+
+        while k + 1 < n1:
+            s = abs(ctx.re(A[k,k])) + abs(ctx.im(A[k,k])) + abs(ctx.re(A[k+1,k+1])) + abs(ctx.im(A[k+1,k+1]))
+            if s < eps * norm:
+                s = norm
+            if abs(A[k+1,k]) < eps * s:
+                break
+            k += 1
+
+        if k + 1 < n1:
+            # deflation found at position (k+1, k)
+
+            A[k+1,k] = 0
+            n0 = k + 1
+
+            its = 0
+
+            if n0 + 1 >= n1:
+                # block of size at most two has converged
+                n0 = 0
+                n1 = k + 1
+                if n1 < 2:
+                    # QR algorithm has converged
+                    return
+        else:
+            if (its % 30) == 10:
+                # exceptional shift
+                shift = A[n1-1,n1-2]
+            elif (its % 30) == 20:
+                # exceptional shift
+                shift = abs(A[n1-1,n1-2])
+            elif (its % 30) == 29:
+                # exceptional shift
+                shift = norm
+            else:
+                #    A = [ a b ]       det(x-A)=x*x-x*tr(A)+det(A)
+                #        [ c d ]
+                #
+                # eigenvalues bad:   (tr(A)+sqrt((tr(A))**2-4*det(A)))/2
+                #     bad because of cancellation if |c| is small and |a-d| is small, too.
+                #
+                # eigenvalues good:     (a+d+sqrt((a-d)**2+4*b*c))/2
+
+                t =  A[n1-2,n1-2] + A[n1-1,n1-1]
+                s = (A[n1-1,n1-1] - A[n1-2,n1-2]) ** 2 + 4 * A[n1-1,n1-2] * A[n1-2,n1-1]
+                if ctx.re(s) > 0:
+                    s = ctx.sqrt(s)
+                else:
+                    s = ctx.sqrt(-s) * 1j
+                a = (t + s) / 2
+                b = (t - s) / 2
+                if abs(A[n1-1,n1-1] - a) > abs(A[n1-1,n1-1] - b):
+                    shift = b
+                else:
+                    shift = a
+
+            its += 1
+            totalits += 1
+
+            qr_step(ctx, n0, n1, A, Q, shift)
+
+            if its > maxits:
+                raise RuntimeError("qr: failed to converge after %d steps" % its)
+
+
+@defun
+def schur(ctx, A, overwrite_a = False):
+    """
+    This routine computes the Schur decomposition of a square matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = R                and               Q' Q = Q Q' = 1
+
+    where R is an upper right triangular matrix. Here ' denotes the
+    hermitian transpose (i.e. transposition and conjugation).
+
+    input:
+      A            : a real or complex square matrix
+      overwrite_a  : if true, allows modification of A which may improve
+                     performance. if false, A is not modified.
+
+    output:
+      Q : an unitary matrix
+      R : an upper right triangular matrix
+
+    return value:   (Q, R)
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> Q, R = mp.schur(A)
+      >>> mp.nprint(R, 3) # doctest:+SKIP
+      [2.0  0.417  -2.53]
+      [0.0    4.0  -4.74]
+      [0.0    0.0    9.0]
+      >>> print(mp.chop(A - Q * R * Q.transpose_conj()))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    warning: The Schur decomposition is not unique.
+    """
+
+    n = A.rows
+
+    if n == 1:
+        return (ctx.matrix([[1]]), A)
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.matrix(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+    Q = A.copy()
+    hessenberg_reduce_1(ctx, Q, T)
+
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            A[y,x] = 0
+
+    hessenberg_qr(ctx, A, Q)
+
+    return Q, A
+
+
+def eig_tr_r(ctx, A):
+    """
+    This routine calculates the right eigenvectors of an upper right triangular matrix.
+
+    input:
+      A      an upper right triangular matrix
+
+    output:
+      ER     a matrix whose columns form the right eigenvectors of A
+
+    return value: ER
+    """
+
+    # this subroutine is inspired by the lapack routines ctrevc.f,clatrs.f
+
+    n = A.rows
+
+    ER = ctx.eye(n)
+
+    eps = ctx.eps
+
+    unfl = ctx.ldexp(ctx.one, -ctx.prec * 30)
+    # since mpmath effectively has no limits on the exponent, we simply scale doubles up
+    # original double has prec*20
+
+    smlnum = unfl * (n / eps)
+    simin = 1 / ctx.sqrt(eps)
+
+    rmax = 1
+
+    for i in xrange(1, n):
+        s = A[i,i]
+
+        smin = max(eps * abs(s), smlnum)
+
+        for j in xrange(i - 1, -1, -1):
+
+            r = 0
+            for k in xrange(j + 1, i + 1):
+                r += A[j,k] * ER[k,i]
+
+            t = A[j,j] - s
+            if abs(t) < smin:
+                t = smin
+
+            r = -r / t
+            ER[j,i] = r
+
+            rmax = max(rmax, abs(r))
+            if rmax > simin:
+                for k in xrange(j, i+1):
+                    ER[k,i] /= rmax
+                rmax = 1
+
+        if rmax != 1:
+            for k in xrange(0, i + 1):
+                ER[k,i] /= rmax
+
+    return ER
+
+def eig_tr_l(ctx, A):
+    """
+    This routine calculates the left eigenvectors of an upper right triangular matrix.
+
+    input:
+      A      an upper right triangular matrix
+
+    output:
+      EL     a matrix whose rows form the left eigenvectors of A
+
+    return value:  EL
+    """
+
+    n = A.rows
+
+    EL = ctx.eye(n)
+
+    eps = ctx.eps
+
+    unfl = ctx.ldexp(ctx.one, -ctx.prec * 30)
+    # since mpmath effectively has no limits on the exponent, we simply scale doubles up
+    # original double has prec*20
+
+    smlnum = unfl * (n / eps)
+    simin = 1 / ctx.sqrt(eps)
+
+    rmax = 1
+
+    for i in xrange(0, n - 1):
+        s = A[i,i]
+
+        smin = max(eps * abs(s), smlnum)
+
+        for j in xrange(i + 1, n):
+
+            r = 0
+            for k in xrange(i, j):
+                r += EL[i,k] * A[k,j]
+
+            t = A[j,j] - s
+            if abs(t) < smin:
+                t = smin
+
+            r = -r / t
+            EL[i,j] = r
+
+            rmax = max(rmax, abs(r))
+            if rmax > simin:
+                for k in xrange(i, j + 1):
+                    EL[i,k] /= rmax
+                rmax = 1
+
+        if rmax != 1:
+            for k in xrange(i, n):
+                EL[i,k] /= rmax
+
+    return EL
+
+@defun
+def eig(ctx, A, left = False, right = True, overwrite_a = False):
+    """
+    This routine computes the eigenvalues and optionally the left and right
+    eigenvectors of a square matrix A. Given A, a vector E and matrices ER
+    and EL are calculated such that
+
+                        A ER[:,i] =         E[i] ER[:,i]
+                EL[i,:] A         = EL[i,:] E[i]
+
+    E contains the eigenvalues of A. The columns of ER contain the right eigenvectors
+    of A whereas the rows of EL contain the left eigenvectors.
+
+
+    input:
+      A           : a real or complex square matrix of shape (n, n)
+      left        : if true, the left eigenvectors are calculated.
+      right       : if true, the right eigenvectors are calculated.
+      overwrite_a : if true, allows modification of A which may improve
+                    performance. if false, A is not modified.
+
+    output:
+      E    : a list of length n containing the eigenvalues of A.
+      ER   : a matrix whose columns contain the right eigenvectors of A.
+      EL   : a matrix whose rows contain the left eigenvectors of A.
+
+    return values:
+       E            if left and right are both false.
+      (E, ER)       if right is true and left is false.
+      (E, EL)       if left is true and right is false.
+      (E, EL, ER)   if left and right are true.
+
+
+    examples:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> E, ER = mp.eig(A)
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+
+      >>> E, EL, ER = mp.eig(A,left = True, right = True)
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER)
+      >>> mp.nprint(E)
+      [2.0, 4.0, 9.0]
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+      >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0]))
+      [0.0  0.0  0.0]
+
+    warning:
+     - If there are multiple eigenvalues, the eigenvectors do not necessarily
+       span the whole vectorspace, i.e. ER and EL may have not full rank.
+       Furthermore in that case the eigenvectors are numerical ill-conditioned.
+     - In the general case the eigenvalues have no natural order.
+
+    see also:
+      - eigh (or eigsy, eighe) for the symmetric eigenvalue problem.
+      - eig_sort for sorting of eigenvalues and eigenvectors
+    """
+
+    n = A.rows
+
+    if n == 1:
+        if left and (not right):
+            return ([A[0]], ctx.matrix([[1]]))
+
+        if right and (not left):
+            return ([A[0]], ctx.matrix([[1]]))
+
+        return ([A[0]], ctx.matrix([[1]]), ctx.matrix([[1]]))
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.zeros(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+
+    if left or right:
+        Q = A.copy()
+        hessenberg_reduce_1(ctx, Q, T)
+    else:
+        Q = False
+
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            A[y,x] = 0
+
+    hessenberg_qr(ctx, A, Q)
+
+    E = [0 for i in xrange(n)]
+    for i in xrange(n):
+        E[i] = A[i,i]
+
+    if not (left or right):
+        return E
+
+    if left:
+        EL = eig_tr_l(ctx, A)
+        EL = EL * Q.transpose_conj()
+
+    if right:
+        ER = eig_tr_r(ctx, A)
+        ER = Q * ER
+
+    if left and (not right):
+        return (E, EL)
+
+    if right and (not left):
+        return (E, ER)
+
+    return (E, EL, ER)
+
+@defun
+def eig_sort(ctx, E, EL = False, ER = False, f = "real"):
+    """
+    This routine sorts the eigenvalues and eigenvectors delivered by ``eig``.
+
+    parameters:
+      E  : the eigenvalues as delivered by eig
+      EL : the left  eigenvectors as delivered by eig, or false
+      ER : the right eigenvectors as delivered by eig, or false
+      f  : either a string ("real" sort by increasing real part, "imag" sort by
+           increasing imag part, "abs" sort by absolute value) or a function
+           mapping complexs to the reals, i.e. ``f = lambda x: -mp.re(x) ``
+           would sort the eigenvalues by decreasing real part.
+
+    return values:
+       E            if EL and ER are both false.
+      (E, ER)       if ER is not false and left is false.
+      (E, EL)       if EL is not false and right is false.
+      (E, EL, ER)   if EL and ER are not false.
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> E, EL, ER = mp.eig(A,left = True, right = True)
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER)
+      >>> mp.nprint(E)
+      [2.0, 4.0, 9.0]
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER,f = lambda x: -mp.re(x))
+      >>> mp.nprint(E)
+      [9.0, 4.0, 2.0]
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+      >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0]))
+      [0.0  0.0  0.0]
+    """
+
+    if isinstance(f, str):
+        if f == "real":
+            f = ctx.re
+        elif f == "imag":
+            f = ctx.im
+        elif f == "abs":
+            f = abs
+        else:
+            raise RuntimeError("unknown function %s" % f)
+
+    n = len(E)
+
+    # Sort eigenvalues (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = f(E[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = f(E[j])
+            if c < s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap eigenvalues
+
+            z = E[i]
+            E[i] = E[imax]
+            E[imax] = z
+
+            if not isinstance(EL, bool):
+                for j in xrange(n):
+                    z = EL[i,j]
+                    EL[i,j] = EL[imax,j]
+                    EL[imax,j] = z
+
+            if not isinstance(ER, bool):
+                for j in xrange(n):
+                    z = ER[j,i]
+                    ER[j,i] = ER[j,imax]
+                    ER[j,imax] = z
+
+    if isinstance(EL, bool) and isinstance(ER, bool):
+        return E
+
+    if isinstance(EL, bool) and not(isinstance(ER, bool)):
+        return (E, ER)
+
+    if isinstance(ER, bool) and not(isinstance(EL, bool)):
+        return (E, EL)
+
+    return (E, EL, ER)
diff --git a/lib/python3.11/site-packages/mpmath/matrices/eigen_symmetric.py b/lib/python3.11/site-packages/mpmath/matrices/eigen_symmetric.py
new file mode 100644
index 0000000000000000000000000000000000000000..c82c0bb061d22c37a89f82a0b9bdab3e9ba7ddde
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/matrices/eigen_symmetric.py
@@ -0,0 +1,1807 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+#     module for the symmetric eigenvalue problem
+#       Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+#
+# todo:
+#  - implement balancing
+#
+##################################################################################################
+
+"""
+The symmetric eigenvalue problem.
+---------------------------------
+
+This file contains routines for the symmetric eigenvalue problem.
+
+high level routines:
+
+  eigsy : real symmetric (ordinary) eigenvalue problem
+  eighe : complex hermitian (ordinary) eigenvalue problem
+  eigh  : unified interface for eigsy and eighe
+  svd_r : singular value decomposition for real matrices
+  svd_c : singular value decomposition for complex matrices
+  svd   : unified interface for svd_r and svd_c
+
+
+low level routines:
+
+  r_sy_tridiag : reduction of real symmetric matrix to real symmetric tridiagonal matrix
+  c_he_tridiag_0 : reduction of complex hermitian matrix to real symmetric tridiagonal matrix
+  c_he_tridiag_1 : auxiliary routine to c_he_tridiag_0
+  c_he_tridiag_2 : auxiliary routine to c_he_tridiag_0
+  tridiag_eigen : solves the real symmetric tridiagonal matrix eigenvalue problem
+  svd_r_raw : raw singular value decomposition for real matrices
+  svd_c_raw : raw singular value decomposition for complex matrices
+"""
+
+from ..libmp.backend import xrange
+from .eigen import defun
+
+
+def r_sy_tridiag(ctx, A, D, E, calc_ev = True):
+    """
+    This routine transforms a real symmetric matrix A to a real symmetric
+    tridiagonal matrix T using an orthogonal similarity transformation:
+          Q' * A * Q = T     (here ' denotes the matrix transpose).
+    The orthogonal matrix Q is build up from Householder reflectors.
+
+    parameters:
+      A         (input/output) On input, A contains the real symmetric matrix of
+                dimension (n,n). On output, if calc_ev is true, A contains the
+                orthogonal matrix Q, otherwise A is destroyed.
+
+      D         (output) real array of length n, contains the diagonal elements
+                of the tridiagonal matrix
+
+      E         (output) real array of length n, contains the offdiagonal elements
+                of the tridiagonal matrix in E[0:(n-1)] where is the dimension of
+                the matrix A. E[n-1] is undefined.
+
+      calc_ev   (input) If calc_ev is true, this routine explicitly calculates the
+                orthogonal matrix Q which is then returned in A. If calc_ev is
+                false, Q is not explicitly calculated resulting in a shorter run time.
+
+    This routine is a python translation of the fortran routine tred2.f in the
+    software library EISPACK (see netlib.org) which itself is based on the algol
+    procedure tred2 described in:
+      - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson
+      - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971)
+
+    For a good introduction to Householder reflections, see also
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+    """
+
+    # note : the vector v of the i-th houshoulder reflector is stored in a[(i+1):,i]
+    #        whereas v/<v,v> is stored in a[i,(i+1):]
+
+    n = A.rows
+    for i in xrange(n - 1, 0, -1):
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(A[k,i])
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1/scale
+
+        # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+
+        if i == 1 or scale == 0 or ctx.isinf(scale_inv):
+            E[i] = A[i-1,i]        # nothing to do
+            D[i] = 0
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[k,i] *= scale_inv
+            H += A[k,i] * A[k,i]
+
+        F = A[i-1,i]
+        G = ctx.sqrt(H)
+        if F > 0:
+            G = -G
+        E[i] = scale * G
+        H -= F * G
+        A[i-1,i] = F - G
+        F = 0
+
+        # apply housholder transformation
+
+        for j in xrange(0, i):
+            if calc_ev:
+                A[i,j] = A[j,i] / H
+
+            G = 0                  # calculate A*U
+            for k in xrange(0, j + 1):
+                G += A[k,j] * A[k,i]
+            for k in xrange(j + 1, i):
+                G += A[j,k] * A[k,i]
+
+            E[j] = G / H           # calculate P
+            F += E[j] * A[j,i]
+
+        HH = F / (2 * H)
+
+        for j in xrange(0, i):     # calculate reduced A
+            F = A[j,i]
+            G = E[j] - HH * F      # calculate Q
+            E[j] = G
+
+            for k in xrange(0, j + 1):
+                A[k,j] -= F * E[k] + G * A[k,i]
+
+        D[i] = H
+
+    for i in xrange(1, n):         # better for compatibility
+        E[i-1] = E[i]
+    E[n-1] = 0
+
+    if calc_ev:
+        D[0] = 0
+        for i in xrange(0, n):
+            if D[i] != 0:
+                for j in xrange(0, i):     # accumulate transformation matrices
+                    G = 0
+                    for k in xrange(0, i):
+                        G += A[i,k] * A[k,j]
+                    for k in xrange(0, i):
+                        A[k,j] -= G * A[k,i]
+
+            D[i] = A[i,i]
+            A[i,i] = 1
+
+            for j in xrange(0, i):
+                A[j,i] = A[i,j] = 0
+    else:
+        for i in xrange(0, n):
+            D[i] = A[i,i]
+
+
+
+
+
+def c_he_tridiag_0(ctx, A, D, E, T):
+    """
+    This routine transforms a complex hermitian matrix A to a real symmetric
+    tridiagonal matrix T using an unitary similarity transformation:
+          Q' * A * Q = T     (here ' denotes the hermitian matrix transpose,
+                              i.e. transposition und conjugation).
+    The unitary matrix Q is build up from Householder reflectors and
+    an unitary diagonal matrix.
+
+    parameters:
+      A         (input/output) On input, A contains the complex hermitian matrix
+                of dimension (n,n). On output, A contains the unitary matrix Q
+                in compressed form.
+
+      D         (output) real array of length n, contains the diagonal elements
+                of the tridiagonal matrix.
+
+      E         (output) real array of length n, contains the offdiagonal elements
+                of the tridiagonal matrix in E[0:(n-1)] where is the dimension of
+                the matrix A. E[n-1] is undefined.
+
+      T         (output) complex array of length n, contains a unitary diagonal
+                matrix.
+
+    This routine is a python translation (in slightly modified form) of the fortran
+    routine htridi.f in the software library EISPACK (see netlib.org) which itself
+    is a complex version of the algol procedure tred1 described in:
+      - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson
+      - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971)
+
+    For a good introduction to Householder reflections, see also
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+    """
+
+    n = A.rows
+    T[n-1] = 1
+    for i in xrange(n - 1, 0, -1):
+
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(ctx.re(A[k,i])) + abs(ctx.im(A[k,i]))
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1 / scale
+
+        # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+
+        if scale == 0 or ctx.isinf(scale_inv):
+            E[i] = 0
+            D[i] = 0
+            T[i-1] = 1
+            continue
+
+        if i == 1:
+            F = A[i-1,i]
+            f = abs(F)
+            E[i] = f
+            D[i] = 0
+            if f != 0:
+                T[i-1] = T[i] * F / f
+            else:
+                T[i-1] = T[i]
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[k,i] *= scale_inv
+            rr = ctx.re(A[k,i])
+            ii = ctx.im(A[k,i])
+            H += rr * rr + ii * ii
+
+        F = A[i-1,i]
+        f = abs(F)
+        G = ctx.sqrt(H)
+        H += G * f
+        E[i] = scale * G
+        if f != 0:
+            F = F / f
+            TZ = - T[i] * F              # T[i-1]=-T[i]*F, but we need T[i-1] as temporary storage
+            G *= F
+        else:
+            TZ = -T[i]                   # T[i-1]=-T[i]
+        A[i-1,i] += G
+        F = 0
+
+        # apply housholder transformation
+
+        for j in xrange(0, i):
+            A[i,j] = A[j,i] / H
+
+            G = 0                        # calculate A*U
+            for k in xrange(0, j + 1):
+                G += ctx.conj(A[k,j]) * A[k,i]
+            for k in xrange(j + 1, i):
+                G += A[j,k] * A[k,i]
+
+            T[j] = G / H                 # calculate P
+            F += ctx.conj(T[j]) * A[j,i]
+
+        HH = F / (2 * H)
+
+        for j in xrange(0, i):           # calculate reduced A
+            F = A[j,i]
+            G = T[j] - HH * F            # calculate Q
+            T[j] = G
+
+            for k in xrange(0, j + 1):
+                A[k,j] -= ctx.conj(F) * T[k] + ctx.conj(G) * A[k,i]
+                # as we use the lower left part for storage
+                # we have to use the transpose of the normal formula
+
+        T[i-1] = TZ
+        D[i] = H
+
+    for i in xrange(1, n):                # better for compatibility
+        E[i-1] = E[i]
+    E[n-1] = 0
+
+    D[0] = 0
+    for i in xrange(0, n):
+        zw = D[i]
+        D[i] = ctx.re(A[i,i])
+        A[i,i] = zw
+
+
+
+
+
+
+
+def c_he_tridiag_1(ctx, A, T):
+    """
+    This routine forms the unitary matrix Q described in c_he_tridiag_0.
+
+    parameters:
+      A    (input/output) On input, A is the same matrix as delivered by
+           c_he_tridiag_0. On output, A is set to Q.
+
+      T    (input) On input, T is the same array as delivered by c_he_tridiag_0.
+
+    """
+
+    n = A.rows
+
+    for i in xrange(0, n):
+        if A[i,i] != 0:
+            for j in xrange(0, i):
+                G = 0
+                for k in xrange(0, i):
+                    G += ctx.conj(A[i,k]) * A[k,j]
+                for k in xrange(0, i):
+                    A[k,j] -= G * A[k,i]
+
+        A[i,i] = 1
+
+        for j in xrange(0, i):
+            A[j,i] = A[i,j] = 0
+
+    for i in xrange(0, n):
+        for k in xrange(0, n):
+            A[i,k] *= T[k]
+
+
+
+
+def c_he_tridiag_2(ctx, A, T, B):
+    """
+    This routine applied the unitary matrix Q described in c_he_tridiag_0
+    onto the the matrix B, i.e. it forms Q*B.
+
+    parameters:
+      A    (input) On input, A is the same matrix as delivered by c_he_tridiag_0.
+
+      T    (input) On input, T is the same array as delivered by c_he_tridiag_0.
+
+      B    (input/output) On input, B is a complex matrix. On output B is replaced
+           by Q*B.
+
+    This routine is a python translation of the fortran routine htribk.f in the
+    software library EISPACK (see netlib.org). See c_he_tridiag_0 for more
+    references.
+    """
+
+    n = A.rows
+
+    for i in xrange(0, n):
+        for k in xrange(0, n):
+            B[k,i] *= T[k]
+
+    for i in xrange(0, n):
+        if A[i,i] != 0:
+            for j in xrange(0, n):
+                G = 0
+                for k in xrange(0, i):
+                    G += ctx.conj(A[i,k]) * B[k,j]
+                for k in xrange(0, i):
+                    B[k,j] -= G * A[k,i]
+
+
+
+
+
+def tridiag_eigen(ctx, d, e, z = False):
+    """
+    This subroutine find the eigenvalues and the first components of the
+    eigenvectors of a real symmetric tridiagonal matrix using the implicit
+    QL method.
+
+    parameters:
+
+      d (input/output) real array of length n. on input, d contains the diagonal
+        elements of the input matrix. on output, d contains the eigenvalues in
+        ascending order.
+
+      e (input) real array of length n. on input, e contains the offdiagonal
+        elements of the input matrix in e[0:(n-1)]. On output, e has been
+        destroyed.
+
+      z (input/output) If z is equal to False, no eigenvectors will be computed.
+        Otherwise on input z should have the format z[0:m,0:n] (i.e. a real or
+        complex matrix of dimension (m,n) ). On output this matrix will be
+        multiplied by the matrix of the eigenvectors (i.e. the columns of this
+        matrix are the eigenvectors): z --> z*EV
+        That means if z[i,j]={1 if j==j; 0 otherwise} on input, then on output
+        z will contain the first m components of the eigenvectors. That means
+        if m is equal to n, the i-th eigenvector will be z[:,i].
+
+    This routine is a python translation (in slightly modified form) of the
+    fortran routine imtql2.f in the software library EISPACK (see netlib.org)
+    which itself is based on the algol procudure imtql2 desribed in:
+     - num. math. 12, p. 377-383(1968) by matrin and wilkinson
+     - modified in num. math. 15, p. 450(1970) by dubrulle
+     - handbook for auto. comp., vol. II-linear algebra, p. 241-248 (1971)
+    See also the routine gaussq.f in netlog.org or acm algorithm 726.
+    """
+
+    n = len(d)
+    e[n-1] = 0
+    iterlim = 2 * ctx.dps
+
+    for l in xrange(n):
+        j = 0
+        while 1:
+            m = l
+            while 1:
+                # look for a small subdiagonal element
+                if m + 1 == n:
+                    break
+                if abs(e[m]) <= ctx.eps * (abs(d[m]) + abs(d[m + 1])):
+                    break
+                m = m + 1
+            if m == l:
+                break
+
+            if j >= iterlim:
+                raise RuntimeError("tridiag_eigen: no convergence to an eigenvalue after %d iterations" % iterlim)
+
+            j += 1
+
+            # form shift
+
+            p = d[l]
+            g = (d[l + 1] - p) / (2 * e[l])
+            r = ctx.hypot(g, 1)
+
+            if g < 0:
+                s = g - r
+            else:
+                s = g + r
+
+            g = d[m] - p + e[l] / s
+
+            s, c, p = 1, 1, 0
+
+            for i in xrange(m - 1, l - 1, -1):
+                f = s * e[i]
+                b = c * e[i]
+                if abs(f) > abs(g):             # this here is a slight improvement also used in gaussq.f or acm algorithm 726.
+                    c = g / f
+                    r = ctx.hypot(c, 1)
+                    e[i + 1] = f * r
+                    s = 1 / r
+                    c = c * s
+                else:
+                    s = f / g
+                    r = ctx.hypot(s, 1)
+                    e[i + 1] = g * r
+                    c = 1 / r
+                    s = s * c
+                g = d[i + 1] - p
+                r = (d[i] - g) * s + 2 * c * b
+                p = s * r
+                d[i + 1] = g + p
+                g = c * r - b
+
+                if not isinstance(z, bool):
+                    # calculate eigenvectors
+                    for w in xrange(z.rows):
+                        f = z[w,i+1]
+                        z[w,i+1] = s * z[w,i] + c * f
+                        z[w,i  ] = c * z[w,i] - s * f
+
+            d[l] = d[l] - p
+            e[l] = g
+            e[m] = 0
+
+    for ii in xrange(1, n):
+        # sort eigenvalues and eigenvectors (bubble-sort)
+        i = ii - 1
+        k = i
+        p = d[i]
+        for j in xrange(ii, n):
+            if d[j] >= p:
+                continue
+            k = j
+            p = d[k]
+        if k == i:
+            continue
+        d[k] = d[i]
+        d[i] = p
+
+        if not isinstance(z, bool):
+            for w in xrange(z.rows):
+                p = z[w,i]
+                z[w,i] = z[w,k]
+                z[w,k] = p
+
+########################################################################################
+
+@defun
+def eigsy(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    This routine solves the (ordinary) eigenvalue problem for a real symmetric
+    square matrix A. Given A, an orthogonal matrix Q is calculated which
+    diagonalizes A:
+
+          Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) is a diagonal matrix whose diagonal is E.
+    ' denotes the transpose.
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+          A Q[:,i] = E[i] Q[:,i]
+
+
+    input:
+
+      A: real matrix of format (n,n) which is symmetric
+         (i.e. A=A' or A[i,j]=A[j,i])
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: orthogonal matrix of format (n,n). contains the eigenvectors
+         of A as columns.
+
+    return value:
+
+          E          if eigvals_only is true
+         (E, Q)      if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, 2], [2, 0]])
+      >>> E = mp.eigsy(A, eigvals_only = True)
+      >>> print(E)
+      [-1.0]
+      [ 4.0]
+
+      >>> A = mp.matrix([[1, 2], [2, 3]])
+      >>> E, Q = mp.eigsy(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eighe, eigh, eig
+    """
+
+    if not overwrite_a:
+        A = A.copy()
+
+    d = ctx.zeros(A.rows, 1)
+    e = ctx.zeros(A.rows, 1)
+
+    if eigvals_only:
+        r_sy_tridiag(ctx, A, d, e, calc_ev = False)
+        tridiag_eigen(ctx, d, e, False)
+        return d
+    else:
+        r_sy_tridiag(ctx, A, d, e, calc_ev = True)
+        tridiag_eigen(ctx, d, e, A)
+        return (d, A)
+
+
+@defun
+def eighe(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    This routine solves the (ordinary) eigenvalue problem for a complex
+    hermitian square matrix A. Given A, an unitary matrix Q is calculated which
+    diagonalizes A:
+
+        Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) a is diagonal matrix whose diagonal is E.
+    ' denotes the hermitian transpose (i.e. ordinary transposition and
+    complex conjugation).
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+        A Q[:,i] = E[i] Q[:,i]
+
+
+    input:
+
+      A: complex matrix of format (n,n) which is hermitian
+         (i.e. A=A' or A[i,j]=conj(A[j,i]))
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: unitary matrix of format (n,n). contains the eigenvectors
+         of A as columns.
+
+    return value:
+
+           E         if eigvals_only is true
+          (E, Q)     if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[1, -3 - 1j], [-3 + 1j, -2]])
+      >>> E = mp.eighe(A, eigvals_only = True)
+      >>> print(E)
+      [-4.0]
+      [ 3.0]
+
+      >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]])
+      >>> E, Q = mp.eighe(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eigsy, eigh, eig
+    """
+
+    if not overwrite_a:
+        A = A.copy()
+
+    d = ctx.zeros(A.rows, 1)
+    e = ctx.zeros(A.rows, 1)
+    t = ctx.zeros(A.rows, 1)
+
+    if eigvals_only:
+        c_he_tridiag_0(ctx, A, d, e, t)
+        tridiag_eigen(ctx, d, e, False)
+        return d
+    else:
+        c_he_tridiag_0(ctx, A, d, e, t)
+        B = ctx.eye(A.rows)
+        tridiag_eigen(ctx, d, e, B)
+        c_he_tridiag_2(ctx, A, t, B)
+        return (d, B)
+
+@defun
+def eigh(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    "eigh" is a unified interface for "eigsy" and "eighe". Depending on
+    whether A is real or complex the appropriate function is called.
+
+    This routine solves the (ordinary) eigenvalue problem for a real symmetric
+    or complex hermitian square matrix A. Given A, an orthogonal (A real) or
+    unitary (A complex) matrix Q is calculated which diagonalizes A:
+
+        Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) a is diagonal matrix whose diagonal is E.
+    ' denotes the hermitian transpose (i.e. ordinary transposition and
+    complex conjugation).
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+        A Q[:,i] = E[i] Q[:,i]
+
+    input:
+
+      A: a real or complex square matrix of format (n,n) which is symmetric
+         (i.e. A[i,j]=A[j,i]) or hermitian (i.e. A[i,j]=conj(A[j,i])).
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: an orthogonal or unitary matrix of format (n,n). contains the
+         eigenvectors of A as columns.
+
+    return value:
+
+          E         if eigvals_only is true
+         (E, Q)     if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, 2], [2, 0]])
+      >>> E = mp.eigh(A, eigvals_only = True)
+      >>> print(E)
+      [-1.0]
+      [ 4.0]
+
+      >>> A = mp.matrix([[1, 2], [2, 3]])
+      >>> E, Q = mp.eigh(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+      >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]])
+      >>> E, Q = mp.eigh(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eigsy, eighe, eig
+    """
+
+    iscomplex = any(type(x) is ctx.mpc for x in A)
+
+    if iscomplex:
+        return ctx.eighe(A, eigvals_only = eigvals_only, overwrite_a = overwrite_a)
+    else:
+        return ctx.eigsy(A, eigvals_only = eigvals_only, overwrite_a = overwrite_a)
+
+
+@defun
+def gauss_quadrature(ctx, n, qtype = "legendre", alpha = 0, beta = 0):
+    """
+    This routine calulates gaussian quadrature rules for different
+    families of orthogonal polynomials. Let (a, b) be an interval,
+    W(x) a positive weight function and n a positive integer.
+    Then the purpose of this routine is to calculate pairs (x_k, w_k)
+    for k=0, 1, 2, ... (n-1) which give
+
+      int(W(x) * F(x), x = a..b) = sum(w_k * F(x_k),k = 0..(n-1))
+
+    exact for all polynomials F(x) of degree (strictly) less than 2*n. For all
+    integrable functions F(x) the sum is a (more or less) good approximation to
+    the integral. The x_k are called nodes (which are the zeros of the
+    related orthogonal polynomials) and the w_k are called the weights.
+
+    parameters
+       n        (input) The degree of the quadrature rule, i.e. its number of
+                nodes.
+
+       qtype    (input) The family of orthogonal polynmomials for which to
+                compute the quadrature rule. See the list below.
+
+       alpha    (input) real number, used as parameter for some orthogonal
+                polynomials
+
+       beta     (input) real number, used as parameter for some orthogonal
+                polynomials.
+
+    return value
+
+      (X, W)    a pair of two real arrays where x_k = X[k] and w_k = W[k].
+
+
+    orthogonal polynomials:
+
+      qtype           polynomial
+      -----           ----------
+
+      "legendre"      Legendre polynomials, W(x)=1 on the interval (-1, +1)
+      "legendre01"    shifted Legendre polynomials, W(x)=1 on the interval (0, +1)
+      "hermite"       Hermite polynomials, W(x)=exp(-x*x) on (-infinity,+infinity)
+      "laguerre"      Laguerre polynomials, W(x)=exp(-x) on (0,+infinity)
+      "glaguerre"     generalized Laguerre polynomials, W(x)=exp(-x)*x**alpha
+                      on (0, +infinity)
+      "chebyshev1"    Chebyshev polynomials of the first kind, W(x)=1/sqrt(1-x*x)
+                      on (-1, +1)
+      "chebyshev2"    Chebyshev polynomials of the second kind, W(x)=sqrt(1-x*x)
+                      on (-1, +1)
+      "jacobi"        Jacobi polynomials, W(x)=(1-x)**alpha * (1+x)**beta on (-1, +1)
+                      with alpha>-1 and beta>-1
+
+    examples:
+      >>> from mpmath import mp
+      >>> f = lambda x: x**8 + 2 * x**6 - 3 * x**4 + 5 * x**2 - 7
+      >>> X, W = mp.gauss_quadrature(5, "hermite")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> B = mp.sqrt(mp.pi) * 57 / 16
+      >>> C = mp.quad(lambda x: mp.exp(- x * x) * f(x), [-mp.inf, +mp.inf])
+      >>> mp.nprint((mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10)))
+      (0.0, 0.0)
+
+      >>> f = lambda x: x**5 - 2 * x**4 + 3 * x**3 - 5 * x**2 + 7 * x - 11
+      >>> X, W = mp.gauss_quadrature(3, "laguerre")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> B = 76
+      >>> C = mp.quad(lambda x: mp.exp(-x) * f(x), [0, +mp.inf])
+      >>> mp.nprint(mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10))
+      .0
+
+      # orthogonality of the chebyshev polynomials:
+      >>> f = lambda x: mp.chebyt(3, x) * mp.chebyt(2, x)
+      >>> X, W = mp.gauss_quadrature(3, "chebyshev1")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> print(mp.chop(A, tol = 1e-10))
+      0.0
+
+    references:
+      - golub and welsch, "calculations of gaussian quadrature rules", mathematics of
+        computation 23, p. 221-230 (1969)
+      - golub, "some modified matrix eigenvalue problems", siam review 15, p. 318-334 (1973)
+      - stroud and secrest, "gaussian quadrature formulas", prentice-hall (1966)
+
+    See also the routine gaussq.f in netlog.org or ACM Transactions on
+    Mathematical Software algorithm 726.
+    """
+
+    d = ctx.zeros(n, 1)
+    e = ctx.zeros(n, 1)
+    z = ctx.zeros(1, n)
+
+    z[0,0] = 1
+
+    if qtype == "legendre":
+        # legendre on the range -1 +1 , abramowitz, table 25.4, p.916
+        w = 2
+        for i in xrange(n):
+            j = i + 1
+            e[i] = ctx.sqrt(j * j / (4 * j * j - ctx.mpf(1)))
+    elif qtype == "legendre01":
+        # legendre shifted to 0 1        , abramowitz, table 25.8, p.921
+        w = 1
+        for i in xrange(n):
+            d[i] = 1 / ctx.mpf(2)
+            j = i + 1
+            e[i] = ctx.sqrt(j * j / (16 * j * j - ctx.mpf(4)))
+    elif qtype == "hermite":
+        # hermite on the range -inf +inf , abramowitz, table 25.10,p.924
+        w = ctx.sqrt(ctx.pi)
+        for i in xrange(n):
+            j = i + 1
+            e[i] = ctx.sqrt(j / ctx.mpf(2))
+    elif qtype == "laguerre":
+        # laguerre on the range 0 +inf , abramowitz, table 25.9, p. 923
+        w = 1
+        for i in xrange(n):
+            j = i + 1
+            d[i] = 2 * j - 1
+            e[i] = j
+    elif qtype=="chebyshev1":
+        # chebyshev polynimials of the first kind
+        w = ctx.pi
+        for i in xrange(n):
+            e[i] = 1 / ctx.mpf(2)
+        e[0] = ctx.sqrt(1 / ctx.mpf(2))
+    elif qtype == "chebyshev2":
+        # chebyshev polynimials of the second kind
+        w = ctx.pi / 2
+        for i in xrange(n):
+            e[i] = 1 / ctx.mpf(2)
+    elif qtype == "glaguerre":
+        # generalized laguerre on the range 0 +inf
+        w = ctx.gamma(1 + alpha)
+        for i in xrange(n):
+            j = i + 1
+            d[i] = 2 * j - 1 + alpha
+            e[i] = ctx.sqrt(j * (j + alpha))
+    elif qtype == "jacobi":
+        # jacobi polynomials
+        alpha = ctx.mpf(alpha)
+        beta = ctx.mpf(beta)
+        ab = alpha + beta
+        abi = ab + 2
+        w = (2**(ab+1)) * ctx.gamma(alpha + 1) * ctx.gamma(beta + 1) / ctx.gamma(abi)
+        d[0] = (beta - alpha) / abi
+        e[0] = ctx.sqrt(4 * (1 + alpha) * (1 + beta) / ((abi + 1) * (abi * abi)))
+        a2b2 = beta * beta - alpha * alpha
+        for i in xrange(1, n):
+            j = i + 1
+            abi = 2 * j + ab
+            d[i] = a2b2 / ((abi - 2) * abi)
+            e[i] = ctx.sqrt(4 * j * (j + alpha) * (j + beta) * (j + ab) / ((abi * abi - 1) * abi * abi))
+    elif isinstance(qtype, str):
+        raise ValueError("unknown quadrature rule \"%s\"" % qtype)
+    elif not isinstance(qtype, str):
+        w = qtype(d, e)
+    else:
+        assert 0
+
+    tridiag_eigen(ctx, d, e, z)
+
+    for i in xrange(len(z)):
+        z[i] *= z[i]
+
+    z = z.transpose()
+    return (d, w * z)
+
+##################################################################################################
+##################################################################################################
+##################################################################################################
+
+def svd_r_raw(ctx, A, V = False, calc_u = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal matrices U and V are calculated such that
+
+                    A = U S V
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    The diagonal elements of S are the singular values of A, i.e. the
+    squareroots of the eigenvalues of A' A or A A'. Here ' denotes the transpose.
+    Householder bidiagonalization and a variant of the QR algorithm is used.
+
+    overview of the matrices :
+
+      A : m*n       A gets replaced by U
+      U : m*n       U replaces A. If n>m then only the first m*m block of U is
+                    non-zero. column-orthogonal: U' U = B
+                    here B is a n*n matrix whose first min(m,n) diagonal
+                    elements are 1 and all other elements are zero.
+      S : n*n       diagonal matrix, only the diagonal elements are stored in
+                    the array S. only the first min(m,n) diagonal elements are non-zero.
+      V : n*n       orthogonal: V V' = V' V = 1
+
+    parameters:
+      A        (input/output) On input, A contains a real matrix of shape m*n.
+               On output, if calc_u is true A contains the column-orthogonal
+               matrix U; otherwise A is simply used as workspace and thus destroyed.
+
+      V        (input/output) if false, the matrix V is not calculated. otherwise
+               V must be a matrix of shape n*n.
+
+      calc_u   (input) If true, the matrix U is calculated and replaces A.
+               if false, U is not calculated and A is simply destroyed
+
+    return value:
+      S        an array of length n containing the singular values of A sorted by
+               decreasing magnitude. only the first min(m,n) elements are non-zero.
+
+    This routine is a python translation of the fortran routine svd.f in the
+    software library EISPACK (see netlib.org) which itself is based on the
+    algol procedure svd described in:
+      - num. math. 14, 403-420(1970) by golub and reinsch.
+      - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).
+
+    """
+
+    m, n = A.rows, A.cols
+
+    S = ctx.zeros(n, 1)
+
+    # work is a temporary array of size n
+    work = ctx.zeros(n, 1)
+
+    g = scale = anorm = 0
+    maxits = 3 * ctx.dps
+
+    for i in xrange(n):     # householder reduction to bidiagonal form
+        work[i] = scale*g
+        g = s = scale = 0
+        if i < m:
+            for k in xrange(i, m):
+                scale += ctx.fabs(A[k,i])
+            if scale != 0:
+                for k in xrange(i, m):
+                    A[k,i] /= scale
+                    s += A[k,i] * A[k,i]
+                f = A[i,i]
+                g = -ctx.sqrt(s)
+                if f < 0:
+                    g = -g
+                h = f * g - s
+                A[i,i] = f - g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i, m):
+                        s += A[k,i] * A[k,j]
+                    f = s / h
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for k in xrange(i,m):
+                    A[k,i] *= scale
+
+        S[i] = scale * g
+        g = s = scale = 0
+
+        if i < m and i != n - 1:
+            for k in xrange(i+1, n):
+                scale += ctx.fabs(A[i,k])
+            if scale:
+                for k in xrange(i+1, n):
+                    A[i,k] /= scale
+                    s += A[i,k] * A[i,k]
+                f = A[i,i+1]
+                g = -ctx.sqrt(s)
+                if f < 0:
+                    g = -g
+                h = f * g - s
+                A[i,i+1] = f - g
+
+                for k in xrange(i+1, n):
+                    work[k] = A[i,k] / h
+
+                for j in xrange(i+1, m):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += A[j,k] * A[i,k]
+                    for k in xrange(i+1, n):
+                        A[j,k] += s * work[k]
+
+                for k in xrange(i+1, n):
+                    A[i,k] *= scale
+
+        anorm = max(anorm, ctx.fabs(S[i]) + ctx.fabs(work[i]))
+
+    if not isinstance(V, bool):
+        for i in xrange(n-2, -1, -1):     # accumulation of right hand transformations
+            V[i+1,i+1] = 1
+
+            if work[i+1] != 0:
+                for j in xrange(i+1, n):
+                    V[i,j] = (A[i,j] / A[i,i+1]) / work[i+1]
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += A[i,k] * V[j,k]
+                    for k in xrange(i+1, n):
+                        V[j,k] += s * V[i,k]
+
+            for j in xrange(i+1, n):
+                V[j,i] = V[i,j] = 0
+
+        V[0,0] = 1
+
+    if m<n : minnm = m
+    else   : minnm = n
+
+    if calc_u:
+        for i in xrange(minnm-1, -1, -1): # accumulation of left hand transformations
+            g = S[i]
+            for j in xrange(i+1, n):
+                A[i,j] = 0
+            if g != 0:
+                g = 1 / g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, m):
+                        s += A[k,i] * A[k,j]
+                    f = (s / A[i,i]) * g
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for j in xrange(i, m):
+                    A[j,i] *= g
+            else:
+                for j in xrange(i, m):
+                    A[j,i] = 0
+            A[i,i] += 1
+
+    for k in xrange(n - 1, -1, -1):
+        # diagonalization of the bidiagonal form:
+        #   loop over singular values, and over allowed itations
+
+        its = 0
+        while 1:
+            its += 1
+            flag = True
+
+            for l in xrange(k, -1, -1):
+                nm = l-1
+
+                if ctx.fabs(work[l]) + anorm == anorm:
+                    flag = False
+                    break
+
+                if ctx.fabs(S[nm]) + anorm == anorm:
+                    break
+
+            if flag:
+                c = 0
+                s = 1
+                for i in xrange(l, k + 1):
+                    f = s * work[i]
+                    work[i] *= c
+                    if ctx.fabs(f) + anorm == anorm:
+                        break
+                    g = S[i]
+                    h = ctx.hypot(f, g)
+                    S[i] = h
+                    h = 1 / h
+                    c = g * h
+                    s = - f * h
+
+                    if calc_u:
+                        for j in xrange(m):
+                            y = A[j,nm]
+                            z = A[j,i]
+                            A[j,nm] = y * c + z * s
+                            A[j,i]  = z * c - y * s
+
+            z = S[k]
+
+            if l == k:               # convergence
+                if z < 0:            # singular value is made nonnegative
+                    S[k] = -z
+                    if not isinstance(V, bool):
+                        for j in xrange(n):
+                            V[k,j] = -V[k,j]
+                break
+
+            if its >= maxits:
+                raise RuntimeError("svd: no convergence to an eigenvalue after %d iterations" % its)
+
+            x = S[l]         # shift from bottom 2 by 2 minor
+            nm = k-1
+            y = S[nm]
+            g = work[nm]
+            h = work[k]
+            f = ((y - z) * (y + z) + (g - h) * (g + h))/(2 * h * y)
+            g = ctx.hypot(f, 1)
+            if f >= 0: f = ((x - z) * (x + z) + h * ((y / (f + g)) - h)) / x
+            else:      f = ((x - z) * (x + z) + h * ((y / (f - g)) - h)) / x
+
+            c = s = 1         # next qt transformation
+
+            for j in xrange(l, nm + 1):
+                g = work[j+1]
+                y = S[j+1]
+                h = s * g
+                g = c * g
+                z = ctx.hypot(f, h)
+                work[j] = z
+                c = f / z
+                s = h / z
+                f = x * c + g * s
+                g = g * c - x * s
+                h = y * s
+                y *= c
+                if not isinstance(V, bool):
+                    for jj in xrange(n):
+                        x = V[j  ,jj]
+                        z = V[j+1,jj]
+                        V[j    ,jj]= x * c + z * s
+                        V[j+1  ,jj]= z * c - x * s
+                z = ctx.hypot(f, h)
+                S[j] = z
+                if z != 0:            # rotation can be arbitray if z=0
+                    z = 1 / z
+                    c = f * z
+                    s = h * z
+                f = c * g + s * y
+                x = c * y - s * g
+
+                if calc_u:
+                    for jj in xrange(m):
+                        y = A[jj,j  ]
+                        z = A[jj,j+1]
+                        A[jj,j    ] = y * c + z * s
+                        A[jj,j+1  ] = z * c - y * s
+
+            work[l] = 0
+            work[k] = f
+            S[k] = x
+
+    ##########################
+
+    # Sort singular values into decreasing order (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = ctx.fabs(S[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = ctx.fabs(S[j])
+            if c > s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap singular values
+
+            z = S[i]
+            S[i] = S[imax]
+            S[imax] = z
+
+            if calc_u:
+                for j in xrange(m):
+                    z = A[j,i]
+                    A[j,i] = A[j,imax]
+                    A[j,imax] = z
+
+            if not isinstance(V, bool):
+                for j in xrange(n):
+                    z = V[i,j]
+                    V[i,j] = V[imax,j]
+                    V[imax,j] = z
+
+    return S
+
+#######################
+
+def svd_c_raw(ctx, A, V = False, calc_u = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two unitary matrices U and V are calculated such that
+
+                    A = U S V
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    The diagonal elements of S are the singular values of A, i.e. the
+    squareroots of the eigenvalues of A' A or A A'. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation). Householder bidiagonalization
+    and a variant of the QR algorithm is used.
+
+    overview of the matrices :
+
+      A : m*n       A gets replaced by U
+      U : m*n       U replaces A. If n>m then only the first m*m block of U is
+                    non-zero. column-unitary: U' U = B
+                    here B is a n*n matrix whose first min(m,n) diagonal
+                    elements are 1 and all other elements are zero.
+      S : n*n       diagonal matrix, only the diagonal elements are stored in
+                    the array S. only the first min(m,n) diagonal elements are non-zero.
+      V : n*n       unitary: V V' = V' V = 1
+
+    parameters:
+      A        (input/output) On input, A contains a complex matrix of shape m*n.
+               On output, if calc_u is true A contains the column-unitary
+               matrix U; otherwise A is simply used as workspace and thus destroyed.
+
+      V        (input/output) if false, the matrix V is not calculated. otherwise
+               V must be a matrix of shape n*n.
+
+      calc_u   (input) If true, the matrix U is calculated and replaces A.
+               if false, U is not calculated and A is simply destroyed
+
+    return value:
+      S        an array of length n containing the singular values of A sorted by
+               decreasing magnitude. only the first min(m,n) elements are non-zero.
+
+    This routine is a python translation of the fortran routine svd.f in the
+    software library EISPACK (see netlib.org) which itself is based on the
+    algol procedure svd described in:
+      - num. math. 14, 403-420(1970) by golub and reinsch.
+      - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).
+
+    """
+
+    m, n = A.rows, A.cols
+
+    S = ctx.zeros(n, 1)
+
+    # work is a temporary array of size n
+    work  = ctx.zeros(n, 1)
+    lbeta = ctx.zeros(n, 1)
+    rbeta = ctx.zeros(n, 1)
+    dwork = ctx.zeros(n, 1)
+
+    g = scale = anorm = 0
+    maxits = 3 * ctx.dps
+
+    for i in xrange(n):         # householder reduction to bidiagonal form
+        dwork[i] = scale * g    # dwork are the side-diagonal elements
+        g = s = scale = 0
+        if i < m:
+            for k in xrange(i, m):
+                scale += ctx.fabs(ctx.re(A[k,i])) + ctx.fabs(ctx.im(A[k,i]))
+            if scale != 0:
+                for k in xrange(i, m):
+                    A[k,i] /= scale
+                    ar = ctx.re(A[k,i])
+                    ai = ctx.im(A[k,i])
+                    s += ar * ar + ai * ai
+                f = A[i,i]
+                g = -ctx.sqrt(s)
+                if ctx.re(f) < 0:
+                    beta = -g - ctx.conj(f)
+                    g = -g
+                else:
+                    beta = -g + ctx.conj(f)
+                beta /= ctx.conj(beta)
+                beta += 1
+                h = 2 * (ctx.re(f) * g - s)
+                A[i,i] = f - g
+                beta /= h
+                lbeta[i] = (beta / scale) / scale
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i, m):
+                        s += ctx.conj(A[k,i]) * A[k,j]
+                    f = beta * s
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for k in xrange(i, m):
+                    A[k,i] *= scale
+
+        S[i] = scale * g     # S are the diagonal elements
+        g = s = scale = 0
+
+        if i < m and i != n - 1:
+            for k in xrange(i+1, n):
+                scale += ctx.fabs(ctx.re(A[i,k])) + ctx.fabs(ctx.im(A[i,k]))
+            if scale:
+                for k in xrange(i+1, n):
+                    A[i,k] /= scale
+                    ar = ctx.re(A[i,k])
+                    ai = ctx.im(A[i,k])
+                    s += ar * ar + ai * ai
+                f = A[i,i+1]
+                g = -ctx.sqrt(s)
+                if ctx.re(f) < 0:
+                    beta = -g - ctx.conj(f)
+                    g = -g
+                else:
+                    beta = -g + ctx.conj(f)
+
+                beta /= ctx.conj(beta)
+                beta += 1
+
+                h = 2 * (ctx.re(f) * g - s)
+                A[i,i+1] = f - g
+
+                beta /= h
+                rbeta[i] = (beta / scale) / scale
+
+                for k in xrange(i+1, n):
+                    work[k] = A[i, k]
+
+                for j in xrange(i+1, m):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += ctx.conj(A[i,k]) * A[j,k]
+                    f = s * beta
+                    for k in xrange(i+1,n):
+                        A[j,k] += f * work[k]
+
+                for k in xrange(i+1, n):
+                    A[i,k] *= scale
+
+        anorm = max(anorm,ctx.fabs(S[i]) + ctx.fabs(dwork[i]))
+
+    if not isinstance(V, bool):
+        for i in xrange(n-2, -1, -1):     # accumulation of right hand transformations
+            V[i+1,i+1] = 1
+
+            if dwork[i+1] != 0:
+                f = ctx.conj(rbeta[i])
+                for j in xrange(i+1, n):
+                    V[i,j] = A[i,j] * f
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += ctx.conj(A[i,k]) * V[j,k]
+                    for k in xrange(i+1, n):
+                        V[j,k] += s * V[i,k]
+
+            for j in xrange(i+1,n):
+                V[j,i] = V[i,j] = 0
+
+        V[0,0] = 1
+
+    if m < n : minnm = m
+    else     : minnm = n
+
+    if calc_u:
+        for i in xrange(minnm-1, -1, -1): # accumulation of left hand transformations
+            g = S[i]
+            for j in xrange(i+1, n):
+                A[i,j] = 0
+            if g != 0:
+                g = 1 / g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, m):
+                        s += ctx.conj(A[k,i]) * A[k,j]
+                    f = s * ctx.conj(lbeta[i])
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for j in xrange(i, m):
+                    A[j,i] *= g
+            else:
+                for j in xrange(i, m):
+                    A[j,i] = 0
+            A[i,i] += 1
+
+    for k in xrange(n-1, -1, -1):
+        # diagonalization of the bidiagonal form:
+        #   loop over singular values, and over allowed itations
+
+        its = 0
+        while 1:
+            its += 1
+            flag = True
+
+            for l in xrange(k, -1, -1):
+                nm = l - 1
+
+                if ctx.fabs(dwork[l]) + anorm == anorm:
+                    flag = False
+                    break
+
+                if ctx.fabs(S[nm]) + anorm == anorm:
+                    break
+
+            if flag:
+                c = 0
+                s = 1
+                for i in xrange(l, k+1):
+                    f = s * dwork[i]
+                    dwork[i] *= c
+                    if ctx.fabs(f) + anorm == anorm:
+                        break
+                    g = S[i]
+                    h = ctx.hypot(f, g)
+                    S[i] = h
+                    h = 1 / h
+                    c = g * h
+                    s = -f * h
+
+                    if calc_u:
+                        for j in xrange(m):
+                            y = A[j,nm]
+                            z = A[j,i]
+                            A[j,nm]= y * c + z * s
+                            A[j,i] = z * c - y * s
+
+            z = S[k]
+
+            if l == k:         # convergence
+                if z < 0:    # singular value is made nonnegative
+                    S[k] = -z
+                    if not isinstance(V, bool):
+                        for j in xrange(n):
+                            V[k,j] = -V[k,j]
+                break
+
+            if its >= maxits:
+                raise RuntimeError("svd: no convergence to an eigenvalue after %d iterations" % its)
+
+            x = S[l]         # shift from bottom 2 by 2 minor
+            nm = k-1
+            y = S[nm]
+            g = dwork[nm]
+            h = dwork[k]
+            f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2 * h * y)
+            g = ctx.hypot(f, 1)
+            if f >=0: f = (( x - z) *( x + z) + h *((y / (f + g)) - h)) / x
+            else:     f = (( x - z) *( x + z) + h *((y / (f - g)) - h)) / x
+
+            c = s = 1         # next qt transformation
+
+            for j in xrange(l, nm + 1):
+                g = dwork[j+1]
+                y = S[j+1]
+                h = s * g
+                g = c * g
+                z = ctx.hypot(f, h)
+                dwork[j] = z
+                c = f / z
+                s = h / z
+                f = x * c + g * s
+                g = g * c - x * s
+                h = y * s
+                y *= c
+                if not isinstance(V, bool):
+                    for jj in xrange(n):
+                        x = V[j  ,jj]
+                        z = V[j+1,jj]
+                        V[j    ,jj]= x * c + z * s
+                        V[j+1,jj  ]= z * c - x * s
+                z = ctx.hypot(f, h)
+                S[j] = z
+                if z != 0:            # rotation can be arbitray if z=0
+                    z = 1 / z
+                    c = f * z
+                    s = h * z
+                f = c * g + s * y
+                x = c * y - s * g
+                if calc_u:
+                    for jj in xrange(m):
+                        y = A[jj,j  ]
+                        z = A[jj,j+1]
+                        A[jj,j    ]= y * c + z * s
+                        A[jj,j+1  ]= z * c - y * s
+
+            dwork[l] = 0
+            dwork[k] = f
+            S[k] = x
+
+    ##########################
+
+    # Sort singular values into decreasing order (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = ctx.fabs(S[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = ctx.fabs(S[j])
+            if c > s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap singular values
+
+            z = S[i]
+            S[i] = S[imax]
+            S[imax] = z
+
+            if calc_u:
+                for j in xrange(m):
+                    z = A[j,i]
+                    A[j,i] = A[j,imax]
+                    A[j,imax] = z
+
+            if not isinstance(V, bool):
+                for j in xrange(n):
+                    z = V[i,j]
+                    V[i,j] = V[imax,j]
+                    V[imax,j] = z
+
+    return S
+
+##################################################################################################
+
+@defun
+def svd_r(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal matrices U and V are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the transpose. The diagonal elements of S are the singular
+    values of A, i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a real matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an orthogonal matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an orthogonal matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    examples:
+
+       >>> from mpmath import mp
+       >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]])
+       >>> S = mp.svd_r(A, compute_uv = False)
+       >>> print(S)
+       [6.0]
+       [3.0]
+       [1.0]
+
+       >>> U, S, V = mp.svd_r(A)
+       >>> print(mp.chop(A - U * mp.diag(S) * V))
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+
+
+    see also: svd, svd_c
+    """
+
+    m, n = A.rows, A.cols
+
+    if not compute_uv:
+        if not overwrite_a:
+            A = A.copy()
+        S = svd_r_raw(ctx, A, V = False, calc_u = False)
+        S = S[:min(m,n)]
+        return S
+
+    if full_matrices and n < m:
+        V = ctx.zeros(m, m)
+        A0 = ctx.zeros(m, m)
+        A0[:,:n] = A
+        S = svd_r_raw(ctx, A0, V, calc_u = True)
+
+        S = S[:n]
+        V = V[:n,:n]
+
+        return (A0, S, V)
+    else:
+        if not overwrite_a:
+            A = A.copy()
+        V = ctx.zeros(n, n)
+        S = svd_r_raw(ctx, A, V, calc_u = True)
+
+        if n > m:
+            if full_matrices == False:
+                V = V[:m,:]
+
+            S = S[:m]
+            A = A[:,:m]
+
+        return (A, S, V)
+
+##############################
+
+@defun
+def svd_c(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two unitary matrices U and V are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the hermitian transpose (i.e. transposition and complex
+    conjugation). The diagonal elements of S are the singular values of A,
+    i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a complex matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an unitary matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an unitary matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[-2j, -1-3j, -2+2j], [2-2j, -1-3j, 1], [-3+1j,-2j,0]])
+      >>> S = mp.svd_c(A, compute_uv = False)
+      >>> print(mp.chop(S - mp.matrix([mp.sqrt(34), mp.sqrt(15), mp.sqrt(6)])))
+      [0.0]
+      [0.0]
+      [0.0]
+
+      >>> U, S, V = mp.svd_c(A)
+      >>> print(mp.chop(A - U * mp.diag(S) * V))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    see also: svd, svd_r
+    """
+
+    m, n = A.rows, A.cols
+
+    if not compute_uv:
+        if not overwrite_a:
+            A = A.copy()
+        S = svd_c_raw(ctx, A, V = False, calc_u = False)
+        S = S[:min(m,n)]
+        return S
+
+    if full_matrices and n < m:
+        V = ctx.zeros(m, m)
+        A0 = ctx.zeros(m, m)
+        A0[:,:n] = A
+        S = svd_c_raw(ctx, A0, V, calc_u = True)
+
+        S = S[:n]
+        V = V[:n,:n]
+
+        return (A0, S, V)
+    else:
+        if not overwrite_a:
+            A = A.copy()
+        V = ctx.zeros(n, n)
+        S = svd_c_raw(ctx, A, V, calc_u = True)
+
+        if n > m:
+            if full_matrices == False:
+                V = V[:m,:]
+
+            S = S[:m]
+            A = A[:,:m]
+
+        return (A, S, V)
+
+@defun
+def svd(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    "svd" is a unified interface for "svd_r" and "svd_c". Depending on
+    whether A is real or complex the appropriate function is called.
+
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal (A real) or unitary (A complex) matrices U and V
+    are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the hermitian transpose (i.e. transposition and complex
+    conjugation). The diagonal elements of S are the singular values of A,
+    i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a real or complex matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an orthogonal or unitary matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an orthogonal or unitary matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    examples:
+
+       >>> from mpmath import mp
+       >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]])
+       >>> S = mp.svd(A, compute_uv = False)
+       >>> print(S)
+       [6.0]
+       [3.0]
+       [1.0]
+
+       >>> U, S, V = mp.svd(A)
+       >>> print(mp.chop(A - U * mp.diag(S) * V))
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+
+    see also: svd_r, svd_c
+    """
+
+    iscomplex = any(type(x) is ctx.mpc for x in A)
+
+    if iscomplex:
+        return ctx.svd_c(A, full_matrices = full_matrices, compute_uv = compute_uv, overwrite_a = overwrite_a)
+    else:
+        return ctx.svd_r(A, full_matrices = full_matrices, compute_uv = compute_uv, overwrite_a = overwrite_a)
diff --git a/lib/python3.11/site-packages/mpmath/matrices/linalg.py b/lib/python3.11/site-packages/mpmath/matrices/linalg.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2fe643e809822e3d05a52b73c965edb622f9af9
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/matrices/linalg.py
@@ -0,0 +1,790 @@
+"""
+Linear algebra
+--------------
+
+Linear equations
+................
+
+Basic linear algebra is implemented; you can for example solve the linear
+equation system::
+
+      x + 2*y = -10
+    3*x + 4*y =  10
+
+using ``lu_solve``::
+
+    >>> from mpmath import *
+    >>> mp.pretty = False
+    >>> A = matrix([[1, 2], [3, 4]])
+    >>> b = matrix([-10, 10])
+    >>> x = lu_solve(A, b)
+    >>> x
+    matrix(
+    [['30.0'],
+     ['-20.0']])
+
+If you don't trust the result, use ``residual`` to calculate the residual ||A*x-b||::
+
+    >>> residual(A, x, b)
+    matrix(
+    [['3.46944695195361e-18'],
+     ['3.46944695195361e-18']])
+    >>> str(eps)
+    '2.22044604925031e-16'
+
+As you can see, the solution is quite accurate. The error is caused by the
+inaccuracy of the internal floating point arithmetic. Though, it's even smaller
+than the current machine epsilon, which basically means you can trust the
+result.
+
+If you need more speed, use NumPy, or ``fp.lu_solve`` for a floating-point computation.
+
+    >>> fp.lu_solve(A, b)   # doctest: +ELLIPSIS
+    matrix(...)
+
+``lu_solve`` accepts overdetermined systems. It is usually not possible to solve
+such systems, so the residual is minimized instead. Internally this is done
+using Cholesky decomposition to compute a least squares approximation. This means
+that that ``lu_solve`` will square the errors. If you can't afford this, use
+``qr_solve`` instead. It is twice as slow but more accurate, and it calculates
+the residual automatically.
+
+
+Matrix factorization
+....................
+
+The function ``lu`` computes an explicit LU factorization of a matrix::
+
+    >>> P, L, U = lu(matrix([[0,2,3],[4,5,6],[7,8,9]]))
+    >>> print(P)
+    [0.0  0.0  1.0]
+    [1.0  0.0  0.0]
+    [0.0  1.0  0.0]
+    >>> print(L)
+    [              1.0                0.0  0.0]
+    [              0.0                1.0  0.0]
+    [0.571428571428571  0.214285714285714  1.0]
+    >>> print(U)
+    [7.0  8.0                9.0]
+    [0.0  2.0                3.0]
+    [0.0  0.0  0.214285714285714]
+    >>> print(P.T*L*U)
+    [0.0  2.0  3.0]
+    [4.0  5.0  6.0]
+    [7.0  8.0  9.0]
+
+Interval matrices
+-----------------
+
+Matrices may contain interval elements. This allows one to perform
+basic linear algebra operations such as matrix multiplication
+and equation solving with rigorous error bounds::
+
+    >>> a = iv.matrix([['0.1','0.3','1.0'],
+    ...             ['7.1','5.5','4.8'],
+    ...             ['3.2','4.4','5.6']])
+    >>>
+    >>> b = iv.matrix(['4','0.6','0.5'])
+    >>> c = iv.lu_solve(a, b)
+    >>> print(c)
+    [   [5.2582327113062568605927528666, 5.25823271130625686059275702219]]
+    [[-13.1550493962678375411635581388, -13.1550493962678375411635540152]]
+    [  [7.42069154774972557628979076189, 7.42069154774972557628979190734]]
+    >>> print(a*c)
+    [  [3.99999999999999999999999844904, 4.00000000000000000000000155096]]
+    [[0.599999999999999999999968898009, 0.600000000000000000000031763736]]
+    [[0.499999999999999999999979320485, 0.500000000000000000000020679515]]
+"""
+
+# TODO:
+# *implement high-level qr()
+# *test unitvector
+# *iterative solving
+
+from copy import copy
+
+from ..libmp.backend import xrange
+
+class LinearAlgebraMethods(object):
+
+    def LU_decomp(ctx, A, overwrite=False, use_cache=True):
+        """
+        LU-factorization of a n*n matrix using the Gauss algorithm.
+        Returns L and U in one matrix and the pivot indices.
+
+        Use overwrite to specify whether A will be overwritten with L and U.
+        """
+        if not A.rows == A.cols:
+            raise ValueError('need n*n matrix')
+        # get from cache if possible
+        if use_cache and isinstance(A, ctx.matrix) and A._LU:
+            return A._LU
+        if not overwrite:
+            orig = A
+            A = A.copy()
+        tol = ctx.absmin(ctx.mnorm(A,1) * ctx.eps) # each pivot element has to be bigger
+        n = A.rows
+        p = [None]*(n - 1)
+        for j in xrange(n - 1):
+            # pivoting, choose max(abs(reciprocal row sum)*abs(pivot element))
+            biggest = 0
+            for k in xrange(j, n):
+                s = ctx.fsum([ctx.absmin(A[k,l]) for l in xrange(j, n)])
+                if ctx.absmin(s) <= tol:
+                    raise ZeroDivisionError('matrix is numerically singular')
+                current = 1/s * ctx.absmin(A[k,j])
+                if current > biggest: # TODO: what if equal?
+                    biggest = current
+                    p[j] = k
+            # swap rows according to p
+            ctx.swap_row(A, j, p[j])
+            if ctx.absmin(A[j,j]) <= tol:
+                raise ZeroDivisionError('matrix is numerically singular')
+            # calculate elimination factors and add rows
+            for i in xrange(j + 1, n):
+                A[i,j] /= A[j,j]
+                for k in xrange(j + 1, n):
+                    A[i,k] -= A[i,j]*A[j,k]
+        if ctx.absmin(A[n - 1,n - 1]) <= tol:
+            raise ZeroDivisionError('matrix is numerically singular')
+        # cache decomposition
+        if not overwrite and isinstance(orig, ctx.matrix):
+            orig._LU = (A, p)
+        return A, p
+
+    def L_solve(ctx, L, b, p=None):
+        """
+        Solve the lower part of a LU factorized matrix for y.
+        """
+        if L.rows != L.cols:
+            raise RuntimeError("need n*n matrix")
+        n = L.rows
+        if len(b) != n:
+            raise ValueError("Value should be equal to n")
+        b = copy(b)
+        if p: # swap b according to p
+            for k in xrange(0, len(p)):
+                ctx.swap_row(b, k, p[k])
+        # solve
+        for i in xrange(1, n):
+            for j in xrange(i):
+                b[i] -= L[i,j] * b[j]
+        return b
+
+    def U_solve(ctx, U, y):
+        """
+        Solve the upper part of a LU factorized matrix for x.
+        """
+        if U.rows != U.cols:
+            raise RuntimeError("need n*n matrix")
+        n = U.rows
+        if len(y) != n:
+            raise ValueError("Value should be equal to n")
+        x = copy(y)
+        for i in xrange(n - 1, -1, -1):
+            for j in xrange(i + 1, n):
+                x[i] -= U[i,j] * x[j]
+            x[i] /= U[i,i]
+        return x
+
+    def lu_solve(ctx, A, b, **kwargs):
+        """
+        Ax = b => x
+
+        Solve a determined or overdetermined linear equations system.
+        Fast LU decomposition is used, which is less accurate than QR decomposition
+        (especially for overdetermined systems), but it's twice as efficient.
+        Use qr_solve if you want more precision or have to solve a very ill-
+        conditioned system.
+
+        If you specify real=True, it does not check for overdeterminded complex
+        systems.
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows < A.cols:
+                raise ValueError('cannot solve underdetermined system')
+            if A.rows > A.cols:
+                # use least-squares method if overdetermined
+                # (this increases errors)
+                AH = A.H
+                A = AH * A
+                b = AH * b
+                if (kwargs.get('real', False) or
+                    not sum(type(i) is ctx.mpc for i in A)):
+                    # TODO: necessary to check also b?
+                    x = ctx.cholesky_solve(A, b)
+                else:
+                    x = ctx.lu_solve(A, b)
+            else:
+                # LU factorization
+                A, p = ctx.LU_decomp(A)
+                b = ctx.L_solve(A, b, p)
+                x = ctx.U_solve(A, b)
+        finally:
+            ctx.prec = prec
+        return x
+
+    def improve_solution(ctx, A, x, b, maxsteps=1):
+        """
+        Improve a solution to a linear equation system iteratively.
+
+        This re-uses the LU decomposition and is thus cheap.
+        Usually 3 up to 4 iterations are giving the maximal improvement.
+        """
+        if A.rows != A.cols:
+            raise RuntimeError("need n*n matrix") # TODO: really?
+        for _ in xrange(maxsteps):
+            r = ctx.residual(A, x, b)
+            if ctx.norm(r, 2) < 10*ctx.eps:
+                break
+            # this uses cached LU decomposition and is thus cheap
+            dx = ctx.lu_solve(A, -r)
+            x += dx
+        return x
+
+    def lu(ctx, A):
+        """
+        A -> P, L, U
+
+        LU factorisation of a square matrix A. L is the lower, U the upper part.
+        P is the permutation matrix indicating the row swaps.
+
+        P*A = L*U
+
+        If you need efficiency, use the low-level method LU_decomp instead, it's
+        much more memory efficient.
+        """
+        # get factorization
+        A, p = ctx.LU_decomp(A)
+        n = A.rows
+        L = ctx.matrix(n)
+        U = ctx.matrix(n)
+        for i in xrange(n):
+            for j in xrange(n):
+                if i > j:
+                    L[i,j] = A[i,j]
+                elif i == j:
+                    L[i,j] = 1
+                    U[i,j] = A[i,j]
+                else:
+                    U[i,j] = A[i,j]
+        # calculate permutation matrix
+        P = ctx.eye(n)
+        for k in xrange(len(p)):
+            ctx.swap_row(P, k, p[k])
+        return P, L, U
+
+    def unitvector(ctx, n, i):
+        """
+        Return the i-th n-dimensional unit vector.
+        """
+        assert 0 < i <= n, 'this unit vector does not exist'
+        return [ctx.zero]*(i-1) + [ctx.one] + [ctx.zero]*(n-i)
+
+    def inverse(ctx, A, **kwargs):
+        """
+        Calculate the inverse of a matrix.
+
+        If you want to solve an equation system Ax = b, it's recommended to use
+        solve(A, b) instead, it's about 3 times more efficient.
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A
+            A = ctx.matrix(A, **kwargs).copy()
+            n = A.rows
+            # get LU factorisation
+            A, p = ctx.LU_decomp(A)
+            cols = []
+            # calculate unit vectors and solve corresponding system to get columns
+            for i in xrange(1, n + 1):
+                e = ctx.unitvector(n, i)
+                y = ctx.L_solve(A, e, p)
+                cols.append(ctx.U_solve(A, y))
+            # convert columns to matrix
+            inv = []
+            for i in xrange(n):
+                row = []
+                for j in xrange(n):
+                    row.append(cols[j][i])
+                inv.append(row)
+            result = ctx.matrix(inv, **kwargs)
+        finally:
+            ctx.prec = prec
+        return result
+
+    def householder(ctx, A):
+        """
+        (A|b) -> H, p, x, res
+
+        (A|b) is the coefficient matrix with left hand side of an optionally
+        overdetermined linear equation system.
+        H and p contain all information about the transformation matrices.
+        x is the solution, res the residual.
+        """
+        if not isinstance(A, ctx.matrix):
+            raise TypeError("A should be a type of ctx.matrix")
+        m = A.rows
+        n = A.cols
+        if m < n - 1:
+            raise RuntimeError("Columns should not be less than rows")
+        # calculate Householder matrix
+        p = []
+        for j in xrange(0, n - 1):
+            s = ctx.fsum(abs(A[i,j])**2 for i in xrange(j, m))
+            if not abs(s) > ctx.eps:
+                raise ValueError('matrix is numerically singular')
+            p.append(-ctx.sign(ctx.re(A[j,j])) * ctx.sqrt(s))
+            kappa = ctx.one / (s - p[j] * A[j,j])
+            A[j,j] -= p[j]
+            for k in xrange(j+1, n):
+                y = ctx.fsum(ctx.conj(A[i,j]) * A[i,k] for i in xrange(j, m)) * kappa
+                for i in xrange(j, m):
+                    A[i,k] -= A[i,j] * y
+        # solve Rx = c1
+        x = [A[i,n - 1] for i in xrange(n - 1)]
+        for i in xrange(n - 2, -1, -1):
+            x[i] -= ctx.fsum(A[i,j] * x[j] for j in xrange(i + 1, n - 1))
+            x[i] /= p[i]
+        # calculate residual
+        if not m == n - 1:
+            r = [A[m-1-i, n-1] for i in xrange(m - n + 1)]
+        else:
+            # determined system, residual should be 0
+            r = [0]*m # maybe a bad idea, changing r[i] will change all elements
+        return A, p, x, r
+
+    #def qr(ctx, A):
+    #    """
+    #    A -> Q, R
+    #
+    #    QR factorisation of a square matrix A using Householder decomposition.
+    #    Q is orthogonal, this leads to very few numerical errors.
+    #
+    #    A = Q*R
+    #    """
+    #    H, p, x, res = householder(A)
+    # TODO: implement this
+
+    def residual(ctx, A, x, b, **kwargs):
+        """
+        Calculate the residual of a solution to a linear equation system.
+
+        r = A*x - b for A*x = b
+        """
+        oldprec = ctx.prec
+        try:
+            ctx.prec *= 2
+            A, x, b = ctx.matrix(A, **kwargs), ctx.matrix(x, **kwargs), ctx.matrix(b, **kwargs)
+            return A*x - b
+        finally:
+            ctx.prec = oldprec
+
+    def qr_solve(ctx, A, b, norm=None, **kwargs):
+        """
+        Ax = b => x, ||Ax - b||
+
+        Solve a determined or overdetermined linear equations system and
+        calculate the norm of the residual (error).
+        QR decomposition using Householder factorization is applied, which gives very
+        accurate results even for ill-conditioned matrices. qr_solve is twice as
+        efficient.
+        """
+        if norm is None:
+            norm = ctx.norm
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows < A.cols:
+                raise ValueError('cannot solve underdetermined system')
+            H, p, x, r = ctx.householder(ctx.extend(A, b))
+            res = ctx.norm(r)
+            # calculate residual "manually" for determined systems
+            if res == 0:
+                res = ctx.norm(ctx.residual(A, x, b))
+            return ctx.matrix(x, **kwargs), res
+        finally:
+            ctx.prec = prec
+
+    def cholesky(ctx, A, tol=None):
+        r"""
+        Cholesky decomposition of a symmetric positive-definite matrix `A`.
+        Returns a lower triangular matrix `L` such that `A = L \times L^T`.
+        More generally, for a complex Hermitian positive-definite matrix,
+        a Cholesky decomposition satisfying `A = L \times L^H` is returned.
+
+        The Cholesky decomposition can be used to solve linear equation
+        systems twice as efficiently as LU decomposition, or to
+        test whether `A` is positive-definite.
+
+        The optional parameter ``tol`` determines the tolerance for
+        verifying positive-definiteness.
+
+        **Examples**
+
+        Cholesky decomposition of a positive-definite symmetric matrix::
+
+            >>> from mpmath import *
+            >>> mp.dps = 25; mp.pretty = True
+            >>> A = eye(3) + hilbert(3)
+            >>> nprint(A)
+            [     2.0      0.5  0.333333]
+            [     0.5  1.33333      0.25]
+            [0.333333     0.25       1.2]
+            >>> L = cholesky(A)
+            >>> nprint(L)
+            [ 1.41421      0.0      0.0]
+            [0.353553  1.09924      0.0]
+            [0.235702  0.15162  1.05899]
+            >>> chop(A - L*L.T)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+
+        Cholesky decomposition of a Hermitian matrix::
+
+            >>> A = eye(3) + matrix([[0,0.25j,-0.5j],[-0.25j,0,0],[0.5j,0,0]])
+            >>> L = cholesky(A)
+            >>> nprint(L)
+            [          1.0                0.0                0.0]
+            [(0.0 - 0.25j)  (0.968246 + 0.0j)                0.0]
+            [ (0.0 + 0.5j)  (0.129099 + 0.0j)  (0.856349 + 0.0j)]
+            >>> chop(A - L*L.H)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+
+        Attempted Cholesky decomposition of a matrix that is not positive
+        definite::
+
+            >>> A = -eye(3) + hilbert(3)
+            >>> L = cholesky(A)
+            Traceback (most recent call last):
+              ...
+            ValueError: matrix is not positive-definite
+
+        **References**
+
+        1. [Wikipedia]_ http://en.wikipedia.org/wiki/Cholesky_decomposition
+
+        """
+        if not isinstance(A, ctx.matrix):
+            raise RuntimeError("A should be a type of ctx.matrix")
+        if not A.rows == A.cols:
+            raise ValueError('need n*n matrix')
+        if tol is None:
+            tol = +ctx.eps
+        n = A.rows
+        L = ctx.matrix(n)
+        for j in xrange(n):
+            c = ctx.re(A[j,j])
+            if abs(c-A[j,j]) > tol:
+                raise ValueError('matrix is not Hermitian')
+            s = c - ctx.fsum((L[j,k] for k in xrange(j)),
+                absolute=True, squared=True)
+            if s < tol:
+                raise ValueError('matrix is not positive-definite')
+            L[j,j] = ctx.sqrt(s)
+            for i in xrange(j, n):
+                it1 = (L[i,k] for k in xrange(j))
+                it2 = (L[j,k] for k in xrange(j))
+                t = ctx.fdot(it1, it2, conjugate=True)
+                L[i,j] = (A[i,j] - t) / L[j,j]
+        return L
+
+    def cholesky_solve(ctx, A, b, **kwargs):
+        """
+        Ax = b => x
+
+        Solve a symmetric positive-definite linear equation system.
+        This is twice as efficient as lu_solve.
+
+        Typical use cases:
+        * A.T*A
+        * Hessian matrix
+        * differential equations
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows !=  A.cols:
+                raise ValueError('can only solve determined system')
+            # Cholesky factorization
+            L = ctx.cholesky(A)
+            # solve
+            n = L.rows
+            if len(b) != n:
+                raise ValueError("Value should be equal to n")
+            for i in xrange(n):
+                b[i] -= ctx.fsum(L[i,j] * b[j] for j in xrange(i))
+                b[i] /= L[i,i]
+            x = ctx.U_solve(L.T, b)
+            return x
+        finally:
+            ctx.prec = prec
+
+    def det(ctx, A):
+        """
+        Calculate the determinant of a matrix.
+        """
+        prec = ctx.prec
+        try:
+            # do not overwrite A
+            A = ctx.matrix(A).copy()
+            # use LU factorization to calculate determinant
+            try:
+                R, p = ctx.LU_decomp(A)
+            except ZeroDivisionError:
+                return 0
+            z = 1
+            for i, e in enumerate(p):
+                if i != e:
+                    z *= -1
+            for i in xrange(A.rows):
+                z *= R[i,i]
+            return z
+        finally:
+            ctx.prec = prec
+
+    def cond(ctx, A, norm=None):
+        """
+        Calculate the condition number of a matrix using a specified matrix norm.
+
+        The condition number estimates the sensitivity of a matrix to errors.
+        Example: small input errors for ill-conditioned coefficient matrices
+        alter the solution of the system dramatically.
+
+        For ill-conditioned matrices it's recommended to use qr_solve() instead
+        of lu_solve(). This does not help with input errors however, it just avoids
+        to add additional errors.
+
+        Definition:    cond(A) = ||A|| * ||A**-1||
+        """
+        if norm is None:
+            norm = lambda x: ctx.mnorm(x,1)
+        return norm(A) * norm(ctx.inverse(A))
+
+    def lu_solve_mat(ctx, a, b):
+        """Solve a * x = b  where a and b are matrices."""
+        r = ctx.matrix(a.rows, b.cols)
+        for i in range(b.cols):
+            c = ctx.lu_solve(a, b.column(i))
+            for j in range(len(c)):
+                r[j, i] = c[j]
+        return r
+
+    def qr(ctx, A, mode = 'full', edps = 10):
+        """
+        Compute a QR factorization $A = QR$ where
+        A is an m x n matrix of real or complex numbers where m >= n
+
+        mode has following meanings:
+        (1) mode = 'raw' returns two matrixes (A, tau) in the
+            internal format used by LAPACK
+        (2) mode = 'skinny' returns the leading n columns of Q
+            and n rows of R
+        (3) Any other value returns the leading m columns of Q
+            and m rows of R
+
+        edps is the increase in mp precision used for calculations
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> mp.pretty = True
+            >>> A = matrix([[1, 2], [3, 4], [1, 1]])
+            >>> Q, R = qr(A)
+            >>> Q
+            [-0.301511344577764   0.861640436855329   0.408248290463863]
+            [-0.904534033733291  -0.123091490979333  -0.408248290463863]
+            [-0.301511344577764  -0.492365963917331   0.816496580927726]
+            >>> R
+            [-3.3166247903554  -4.52267016866645]
+            [             0.0  0.738548945875996]
+            [             0.0                0.0]
+            >>> Q * R
+            [1.0  2.0]
+            [3.0  4.0]
+            [1.0  1.0]
+            >>> chop(Q.T * Q)
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+            >>> B = matrix([[1+0j, 2-3j], [3+j, 4+5j]])
+            >>> Q, R = qr(B)
+            >>> nprint(Q)
+            [     (-0.301511 + 0.0j)   (0.0695795 - 0.95092j)]
+            [(-0.904534 - 0.301511j)  (-0.115966 + 0.278318j)]
+            >>> nprint(R)
+            [(-3.31662 + 0.0j)  (-5.72872 - 2.41209j)]
+            [              0.0       (3.91965 + 0.0j)]
+            >>> Q * R
+            [(1.0 + 0.0j)  (2.0 - 3.0j)]
+            [(3.0 + 1.0j)  (4.0 + 5.0j)]
+            >>> chop(Q.T * Q.conjugate())
+            [1.0  0.0]
+            [0.0  1.0]
+
+        """
+
+        # check values before continuing
+        assert isinstance(A, ctx.matrix)
+        m = A.rows
+        n = A.cols
+        assert n >= 0
+        assert m >= n
+        assert edps >= 0
+
+        # check for complex data type
+        cmplx = any(type(x) is ctx.mpc for x in A)
+
+        # temporarily increase the precision and initialize
+        with ctx.extradps(edps):
+            tau = ctx.matrix(n,1)
+            A = A.copy()
+
+            # ---------------
+            # FACTOR MATRIX A
+            # ---------------
+            if cmplx:
+                one = ctx.mpc('1.0', '0.0')
+                zero = ctx.mpc('0.0', '0.0')
+                rzero = ctx.mpf('0.0')
+
+                # main loop to factor A (complex)
+                for j in xrange(0, n):
+                    alpha = A[j,j]
+                    alphr = ctx.re(alpha)
+                    alphi = ctx.im(alpha)
+
+                    if (m-j) >= 2:
+                        xnorm = ctx.fsum( A[i,j]*ctx.conj(A[i,j]) for i in xrange(j+1, m) )
+                        xnorm = ctx.re( ctx.sqrt(xnorm) )
+                    else:
+                        xnorm = rzero
+
+                    if (xnorm == rzero) and (alphi == rzero):
+                        tau[j] = zero
+                        continue
+
+                    if alphr < rzero:
+                        beta = ctx.sqrt(alphr**2 + alphi**2 + xnorm**2)
+                    else:
+                        beta = -ctx.sqrt(alphr**2 + alphi**2 + xnorm**2)
+
+                    tau[j] = ctx.mpc( (beta - alphr) / beta, -alphi / beta )
+                    t = -ctx.conj(tau[j])
+                    za = one / (alpha - beta)
+
+                    for i in xrange(j+1, m):
+                        A[i,j] *= za
+
+                    A[j,j] = one
+                    for k in xrange(j+1, n):
+                        y = ctx.fsum(A[i,j] * ctx.conj(A[i,k]) for i in xrange(j, m))
+                        temp = t * ctx.conj(y)
+                        for i in xrange(j, m):
+                            A[i,k] += A[i,j] * temp
+
+                    A[j,j] = ctx.mpc(beta, '0.0')
+            else:
+                one = ctx.mpf('1.0')
+                zero = ctx.mpf('0.0')
+
+                # main loop to factor A (real)
+                for j in xrange(0, n):
+                    alpha = A[j,j]
+
+                    if (m-j) > 2:
+                        xnorm = ctx.fsum( (A[i,j])**2 for i in xrange(j+1, m) )
+                        xnorm = ctx.sqrt(xnorm)
+                    elif (m-j) == 2:
+                        xnorm = abs( A[m-1,j] )
+                    else:
+                        xnorm = zero
+
+                    if xnorm == zero:
+                        tau[j] = zero
+                        continue
+
+                    if alpha < zero:
+                        beta = ctx.sqrt(alpha**2 + xnorm**2)
+                    else:
+                        beta = -ctx.sqrt(alpha**2 + xnorm**2)
+
+                    tau[j] = (beta - alpha) / beta
+                    t = -tau[j]
+                    da = one / (alpha - beta)
+
+                    for i in xrange(j+1, m):
+                        A[i,j] *= da
+
+                    A[j,j] = one
+                    for k in xrange(j+1, n):
+                        y = ctx.fsum( A[i,j] * A[i,k] for i in xrange(j, m) )
+                        temp = t * y
+                        for i in xrange(j,m):
+                            A[i,k] += A[i,j] * temp
+
+                    A[j,j] = beta
+
+            # return factorization in same internal format as LAPACK
+            if (mode == 'raw') or (mode == 'RAW'):
+                return A, tau
+
+            # ----------------------------------
+            # FORM Q USING BACKWARD ACCUMULATION
+            # ----------------------------------
+
+            # form R before the values are overwritten
+            R = A.copy()
+            for j in xrange(0, n):
+                for i in xrange(j+1, m):
+                    R[i,j] = zero
+
+            # set the value of p (number of columns of Q to return)
+            p = m
+            if (mode == 'skinny') or (mode == 'SKINNY'):
+                p = n
+
+            # add columns to A if needed and initialize
+            A.cols += (p-n)
+            for j in xrange(0, p):
+                A[j,j] = one
+                for i in xrange(0, j):
+                    A[i,j] = zero
+
+            # main loop to form Q
+            for j in xrange(n-1, -1, -1):
+                t = -tau[j]
+                A[j,j] += t
+
+                for k in xrange(j+1, p):
+                    if cmplx:
+                        y = ctx.fsum(A[i,j] * ctx.conj(A[i,k]) for i in xrange(j+1, m))
+                        temp = t * ctx.conj(y)
+                    else:
+                        y = ctx.fsum(A[i,j] * A[i,k] for i in xrange(j+1, m))
+                        temp = t * y
+                    A[j,k] = temp
+                    for i in xrange(j+1, m):
+                        A[i,k] += A[i,j] * temp
+
+                for i in xrange(j+1, m):
+                    A[i, j] *= t
+
+            return A, R[0:p,0:n]
+
+        # ------------------
+        # END OF FUNCTION QR
+        # ------------------
diff --git a/lib/python3.11/site-packages/mpmath/matrices/matrices.py b/lib/python3.11/site-packages/mpmath/matrices/matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..a97d5a9ca7e173195386dc7cb60860a826ab6a97
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/matrices/matrices.py
@@ -0,0 +1,1005 @@
+from ..libmp.backend import xrange
+import warnings
+
+# TODO: interpret list as vectors (for multiplication)
+
+rowsep = '\n'
+colsep = '  '
+
+class _matrix(object):
+    """
+    Numerical matrix.
+
+    Specify the dimensions or the data as a nested list.
+    Elements default to zero.
+    Use a flat list to create a column vector easily.
+
+    The datatype of the context (mpf for mp, mpi for iv, and float for fp) is used to store the data.
+
+    Creating matrices
+    -----------------
+
+    Matrices in mpmath are implemented using dictionaries. Only non-zero values
+    are stored, so it is cheap to represent sparse matrices.
+
+    The most basic way to create one is to use the ``matrix`` class directly.
+    You can create an empty matrix specifying the dimensions:
+
+        >>> from mpmath import *
+        >>> mp.dps = 15
+        >>> matrix(2)
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> matrix(2, 3)
+        matrix(
+        [['0.0', '0.0', '0.0'],
+         ['0.0', '0.0', '0.0']])
+
+    Calling ``matrix`` with one dimension will create a square matrix.
+
+    To access the dimensions of a matrix, use the ``rows`` or ``cols`` keyword:
+
+        >>> A = matrix(3, 2)
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> A.rows
+        3
+        >>> A.cols
+        2
+
+    You can also change the dimension of an existing matrix. This will set the
+    new elements to 0. If the new dimension is smaller than before, the
+    concerning elements are discarded:
+
+        >>> A.rows = 2
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+
+    Internally ``mpmathify`` is used every time an element is set. This
+    is done using the syntax A[row,column], counting from 0:
+
+        >>> A = matrix(2)
+        >>> A[1,1] = 1 + 1j
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', mpc(real='1.0', imag='1.0')]])
+
+    A more comfortable way to create a matrix lets you use nested lists:
+
+        >>> matrix([[1, 2], [3, 4]])
+        matrix(
+        [['1.0', '2.0'],
+         ['3.0', '4.0']])
+
+    Convenient advanced functions are available for creating various standard
+    matrices, see ``zeros``, ``ones``, ``diag``, ``eye``, ``randmatrix`` and
+    ``hilbert``.
+
+    Vectors
+    .......
+
+    Vectors may also be represented by the ``matrix`` class (with rows = 1 or cols = 1).
+    For vectors there are some things which make life easier. A column vector can
+    be created using a flat list, a row vectors using an almost flat nested list::
+
+        >>> matrix([1, 2, 3])
+        matrix(
+        [['1.0'],
+         ['2.0'],
+         ['3.0']])
+        >>> matrix([[1, 2, 3]])
+        matrix(
+        [['1.0', '2.0', '3.0']])
+
+    Optionally vectors can be accessed like lists, using only a single index::
+
+        >>> x = matrix([1, 2, 3])
+        >>> x[1]
+        mpf('2.0')
+        >>> x[1,0]
+        mpf('2.0')
+
+    Other
+    .....
+
+    Like you probably expected, matrices can be printed::
+
+        >>> print randmatrix(3) # doctest:+SKIP
+        [ 0.782963853573023  0.802057689719883  0.427895717335467]
+        [0.0541876859348597  0.708243266653103  0.615134039977379]
+        [ 0.856151514955773  0.544759264818486  0.686210904770947]
+
+    Use ``nstr`` or ``nprint`` to specify the number of digits to print::
+
+        >>> nprint(randmatrix(5), 3) # doctest:+SKIP
+        [2.07e-1  1.66e-1  5.06e-1  1.89e-1  8.29e-1]
+        [6.62e-1  6.55e-1  4.47e-1  4.82e-1  2.06e-2]
+        [4.33e-1  7.75e-1  6.93e-2  2.86e-1  5.71e-1]
+        [1.01e-1  2.53e-1  6.13e-1  3.32e-1  2.59e-1]
+        [1.56e-1  7.27e-2  6.05e-1  6.67e-2  2.79e-1]
+
+    As matrices are mutable, you will need to copy them sometimes::
+
+        >>> A = matrix(2)
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> B = A.copy()
+        >>> B[0,0] = 1
+        >>> B
+        matrix(
+        [['1.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+
+    Finally, it is possible to convert a matrix to a nested list. This is very useful,
+    as most Python libraries involving matrices or arrays (namely NumPy or SymPy)
+    support this format::
+
+        >>> B.tolist()
+        [[mpf('1.0'), mpf('0.0')], [mpf('0.0'), mpf('0.0')]]
+
+
+    Matrix operations
+    -----------------
+
+    You can add and subtract matrices of compatible dimensions::
+
+        >>> A = matrix([[1, 2], [3, 4]])
+        >>> B = matrix([[-2, 4], [5, 9]])
+        >>> A + B
+        matrix(
+        [['-1.0', '6.0'],
+         ['8.0', '13.0']])
+        >>> A - B
+        matrix(
+        [['3.0', '-2.0'],
+         ['-2.0', '-5.0']])
+        >>> A + ones(3) # doctest:+ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: incompatible dimensions for addition
+
+    It is possible to multiply or add matrices and scalars. In the latter case the
+    operation will be done element-wise::
+
+        >>> A * 2
+        matrix(
+        [['2.0', '4.0'],
+         ['6.0', '8.0']])
+        >>> A / 4
+        matrix(
+        [['0.25', '0.5'],
+         ['0.75', '1.0']])
+        >>> A - 1
+        matrix(
+        [['0.0', '1.0'],
+         ['2.0', '3.0']])
+
+    Of course you can perform matrix multiplication, if the dimensions are
+    compatible, using ``@`` (for Python >= 3.5) or ``*``. For clarity, ``@`` is
+    recommended (`PEP 465 <https://www.python.org/dev/peps/pep-0465/>`), because
+    the meaning of ``*`` is different in many other Python libraries such as NumPy.
+
+        >>> A @ B # doctest:+SKIP
+        matrix(
+        [['8.0', '22.0'],
+         ['14.0', '48.0']])
+        >>> A * B # same as A @ B
+        matrix(
+        [['8.0', '22.0'],
+         ['14.0', '48.0']])
+        >>> matrix([[1, 2, 3]]) * matrix([[-6], [7], [-2]])
+        matrix(
+        [['2.0']])
+
+    ..
+        COMMENT: TODO: the above "doctest:+SKIP" may be removed as soon as we
+        have dropped support for Python 3.5 and below.
+
+    You can raise powers of square matrices::
+
+        >>> A**2
+        matrix(
+        [['7.0', '10.0'],
+         ['15.0', '22.0']])
+
+    Negative powers will calculate the inverse::
+
+        >>> A**-1
+        matrix(
+        [['-2.0', '1.0'],
+         ['1.5', '-0.5']])
+        >>> A * A**-1
+        matrix(
+        [['1.0', '1.0842021724855e-19'],
+         ['-2.16840434497101e-19', '1.0']])
+
+
+
+    Matrix transposition is straightforward::
+
+        >>> A = ones(2, 3)
+        >>> A
+        matrix(
+        [['1.0', '1.0', '1.0'],
+         ['1.0', '1.0', '1.0']])
+        >>> A.T
+        matrix(
+        [['1.0', '1.0'],
+         ['1.0', '1.0'],
+         ['1.0', '1.0']])
+
+    Norms
+    .....
+
+    Sometimes you need to know how "large" a matrix or vector is. Due to their
+    multidimensional nature it's not possible to compare them, but there are
+    several functions to map a matrix or a vector to a positive real number, the
+    so called norms.
+
+    For vectors the p-norm is intended, usually the 1-, the 2- and the oo-norm are
+    used.
+
+        >>> x = matrix([-10, 2, 100])
+        >>> norm(x, 1)
+        mpf('112.0')
+        >>> norm(x, 2)
+        mpf('100.5186549850325')
+        >>> norm(x, inf)
+        mpf('100.0')
+
+    Please note that the 2-norm is the most used one, though it is more expensive
+    to calculate than the 1- or oo-norm.
+
+    It is possible to generalize some vector norms to matrix norm::
+
+        >>> A = matrix([[1, -1000], [100, 50]])
+        >>> mnorm(A, 1)
+        mpf('1050.0')
+        >>> mnorm(A, inf)
+        mpf('1001.0')
+        >>> mnorm(A, 'F')
+        mpf('1006.2310867787777')
+
+    The last norm (the "Frobenius-norm") is an approximation for the 2-norm, which
+    is hard to calculate and not available. The Frobenius-norm lacks some
+    mathematical properties you might expect from a norm.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.__data = {}
+        # LU decompostion cache, this is useful when solving the same system
+        # multiple times, when calculating the inverse and when calculating the
+        # determinant
+        self._LU = None
+        if "force_type" in kwargs:
+            warnings.warn("The force_type argument was removed, it did not work"
+                " properly anyway. If you want to force floating-point or"
+                " interval computations, use the respective methods from `fp`"
+                " or `mp` instead, e.g., `fp.matrix()` or `iv.matrix()`."
+                " If you want to truncate values to integer, use .apply(int) instead.")
+        if isinstance(args[0], (list, tuple)):
+            if isinstance(args[0][0], (list, tuple)):
+                # interpret nested list as matrix
+                A = args[0]
+                self.__rows = len(A)
+                self.__cols = len(A[0])
+                for i, row in enumerate(A):
+                    for j, a in enumerate(row):
+                        # note: this will call __setitem__ which will call self.ctx.convert() to convert the datatype.
+                        self[i, j] = a
+            else:
+                # interpret list as row vector
+                v = args[0]
+                self.__rows = len(v)
+                self.__cols = 1
+                for i, e in enumerate(v):
+                    self[i, 0] = e
+        elif isinstance(args[0], int):
+            # create empty matrix of given dimensions
+            if len(args) == 1:
+                self.__rows = self.__cols = args[0]
+            else:
+                if not isinstance(args[1], int):
+                    raise TypeError("expected int")
+                self.__rows = args[0]
+                self.__cols = args[1]
+        elif isinstance(args[0], _matrix):
+            A = args[0]
+            self.__rows = A._matrix__rows
+            self.__cols = A._matrix__cols
+            for i in xrange(A.__rows):
+                for j in xrange(A.__cols):
+                    self[i, j] = A[i, j]
+        elif hasattr(args[0], 'tolist'):
+            A = self.ctx.matrix(args[0].tolist())
+            self.__data = A._matrix__data
+            self.__rows = A._matrix__rows
+            self.__cols = A._matrix__cols
+        else:
+            raise TypeError('could not interpret given arguments')
+
+    def apply(self, f):
+        """
+        Return a copy of self with the function `f` applied elementwise.
+        """
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[i,j] = f(self[i,j])
+        return new
+
+    def __nstr__(self, n=None, **kwargs):
+        # Build table of string representations of the elements
+        res = []
+        # Track per-column max lengths for pretty alignment
+        maxlen = [0] * self.cols
+        for i in range(self.rows):
+            res.append([])
+            for j in range(self.cols):
+                if n:
+                    string = self.ctx.nstr(self[i,j], n, **kwargs)
+                else:
+                    string = str(self[i,j])
+                res[-1].append(string)
+                maxlen[j] = max(len(string), maxlen[j])
+        # Patch strings together
+        for i, row in enumerate(res):
+            for j, elem in enumerate(row):
+                # Pad each element up to maxlen so the columns line up
+                row[j] = elem.rjust(maxlen[j])
+            res[i] = "[" + colsep.join(row) + "]"
+        return rowsep.join(res)
+
+    def __str__(self):
+        return self.__nstr__()
+
+    def _toliststr(self, avoid_type=False):
+        """
+        Create a list string from a matrix.
+
+        If avoid_type: avoid multiple 'mpf's.
+        """
+        # XXX: should be something like self.ctx._types
+        typ = self.ctx.mpf
+        s = '['
+        for i in xrange(self.__rows):
+            s += '['
+            for j in xrange(self.__cols):
+                if not avoid_type or not isinstance(self[i,j], typ):
+                    a = repr(self[i,j])
+                else:
+                    a = "'" + str(self[i,j]) + "'"
+                s += a + ', '
+            s = s[:-2]
+            s += '],\n '
+        s = s[:-3]
+        s += ']'
+        return s
+
+    def tolist(self):
+        """
+        Convert the matrix to a nested list.
+        """
+        return [[self[i,j] for j in range(self.__cols)] for i in range(self.__rows)]
+
+    def __repr__(self):
+        if self.ctx.pretty:
+            return self.__str__()
+        s = 'matrix(\n'
+        s += self._toliststr(avoid_type=True) + ')'
+        return s
+
+    def __get_element(self, key):
+        '''
+        Fast extraction of the i,j element from the matrix
+            This function is for private use only because is unsafe:
+                1. Does not check on the value of key it expects key to be a integer tuple (i,j)
+                2. Does not check bounds
+        '''
+        if key in self.__data:
+            return self.__data[key]
+        else:
+            return self.ctx.zero
+
+    def __set_element(self, key, value):
+        '''
+        Fast assignment of the i,j element in the matrix
+            This function is unsafe:
+                1. Does not check on the value of key it expects key to be a integer tuple (i,j)
+                2. Does not check bounds
+                3. Does not check the value type
+                4. Does not reset the LU cache
+        '''
+        if value: # only store non-zeros
+            self.__data[key] = value
+        elif key in self.__data:
+            del self.__data[key]
+
+
+    def __getitem__(self, key):
+        '''
+            Getitem function for mp matrix class with slice index enabled
+            it allows the following assingments
+            scalar to a slice of the matrix
+         B = A[:,2:6]
+        '''
+        # Convert vector to matrix indexing
+        if isinstance(key, int) or isinstance(key,slice):
+            # only sufficent for vectors
+            if self.__rows == 1:
+                key = (0, key)
+            elif self.__cols == 1:
+                key = (key, 0)
+            else:
+                raise IndexError('insufficient indices for matrix')
+
+        if isinstance(key[0],slice) or isinstance(key[1],slice):
+
+            #Rows
+            if isinstance(key[0],slice):
+                #Check bounds
+                if (key[0].start is None or key[0].start >= 0) and \
+                    (key[0].stop is None or key[0].stop <= self.__rows+1):
+                    # Generate indices
+                    rows = xrange(*key[0].indices(self.__rows))
+                else:
+                    raise IndexError('Row index out of bounds')
+            else:
+                # Single row
+                rows = [key[0]]
+
+            # Columns
+            if isinstance(key[1],slice):
+                # Check bounds
+                if (key[1].start is None or key[1].start >= 0) and \
+                    (key[1].stop is None or key[1].stop <= self.__cols+1):
+                    # Generate indices
+                    columns = xrange(*key[1].indices(self.__cols))
+                else:
+                    raise IndexError('Column index out of bounds')
+
+            else:
+                # Single column
+                columns = [key[1]]
+
+            # Create matrix slice
+            m = self.ctx.matrix(len(rows),len(columns))
+
+            # Assign elements to the output matrix
+            for i,x in enumerate(rows):
+                for j,y in enumerate(columns):
+                    m.__set_element((i,j),self.__get_element((x,y)))
+
+            return m
+
+        else:
+            # single element extraction
+            if key[0] >= self.__rows or key[1] >= self.__cols:
+                raise IndexError('matrix index out of range')
+            if key in self.__data:
+                return self.__data[key]
+            else:
+                return self.ctx.zero
+
+    def __setitem__(self, key, value):
+        # setitem function for mp matrix class with slice index enabled
+        # it allows the following assingments
+        #  scalar to a slice of the matrix
+        # A[:,2:6] = 2.5
+        #  submatrix to matrix (the value matrix should be the same size as the slice size)
+        # A[3,:] = B   where A is n x m  and B is n x 1
+        # Convert vector to matrix indexing
+        if isinstance(key, int) or isinstance(key,slice):
+            # only sufficent for vectors
+            if self.__rows == 1:
+                key = (0, key)
+            elif self.__cols == 1:
+                key = (key, 0)
+            else:
+                raise IndexError('insufficient indices for matrix')
+        # Slice indexing
+        if isinstance(key[0],slice) or isinstance(key[1],slice):
+            # Rows
+            if isinstance(key[0],slice):
+                # Check bounds
+                if (key[0].start is None or key[0].start >= 0) and \
+                    (key[0].stop is None or key[0].stop <= self.__rows+1):
+                    # generate row indices
+                    rows = xrange(*key[0].indices(self.__rows))
+                else:
+                    raise IndexError('Row index out of bounds')
+            else:
+                # Single row
+                rows = [key[0]]
+            # Columns
+            if isinstance(key[1],slice):
+                # Check bounds
+                if (key[1].start is None or key[1].start >= 0) and \
+                    (key[1].stop is None or key[1].stop <= self.__cols+1):
+                    # Generate column indices
+                    columns = xrange(*key[1].indices(self.__cols))
+                else:
+                    raise IndexError('Column index out of bounds')
+            else:
+                # Single column
+                columns = [key[1]]
+            # Assign slice with a scalar
+            if isinstance(value,self.ctx.matrix):
+                # Assign elements to matrix if input and output dimensions match
+                if len(rows) == value.rows and len(columns) == value.cols:
+                    for i,x in enumerate(rows):
+                        for j,y in enumerate(columns):
+                            self.__set_element((x,y), value.__get_element((i,j)))
+                else:
+                    raise ValueError('Dimensions do not match')
+            else:
+                # Assign slice with scalars
+                value = self.ctx.convert(value)
+                for i in rows:
+                    for j in columns:
+                        self.__set_element((i,j), value)
+        else:
+            # Single element assingment
+            # Check bounds
+            if key[0] >= self.__rows or key[1] >= self.__cols:
+                raise IndexError('matrix index out of range')
+            # Convert and store value
+            value = self.ctx.convert(value)
+            if value: # only store non-zeros
+                self.__data[key] = value
+            elif key in self.__data:
+                del self.__data[key]
+
+        if self._LU:
+            self._LU = None
+        return
+
+    def __iter__(self):
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                yield self[i,j]
+
+    def __mul__(self, other):
+        if isinstance(other, self.ctx.matrix):
+            # dot multiplication
+            if self.__cols != other.__rows:
+                raise ValueError('dimensions not compatible for multiplication')
+            new = self.ctx.matrix(self.__rows, other.__cols)
+            self_zero = self.ctx.zero
+            self_get = self.__data.get
+            other_zero = other.ctx.zero
+            other_get = other.__data.get
+            for i in xrange(self.__rows):
+                for j in xrange(other.__cols):
+                    new[i, j] = self.ctx.fdot((self_get((i,k), self_zero), other_get((k,j), other_zero))
+                                     for k in xrange(other.__rows))
+            return new
+        else:
+            # try scalar multiplication
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i, j] = other * self[i, j]
+            return new
+
+    def __matmul__(self, other):
+        return self.__mul__(other)
+
+    def __rmul__(self, other):
+        # assume other is scalar and thus commutative
+        if isinstance(other, self.ctx.matrix):
+            raise TypeError("other should not be type of ctx.matrix")
+        return self.__mul__(other)
+
+    def __pow__(self, other):
+        # avoid cyclic import problems
+        #from linalg import inverse
+        if not isinstance(other, int):
+            raise ValueError('only integer exponents are supported')
+        if not self.__rows == self.__cols:
+            raise ValueError('only powers of square matrices are defined')
+        n = other
+        if n == 0:
+            return self.ctx.eye(self.__rows)
+        if n < 0:
+            n = -n
+            neg = True
+        else:
+            neg = False
+        i = n
+        y = 1
+        z = self.copy()
+        while i != 0:
+            if i % 2 == 1:
+                y = y * z
+            z = z*z
+            i = i // 2
+        if neg:
+            y = self.ctx.inverse(y)
+        return y
+
+    def __div__(self, other):
+        # assume other is scalar and do element-wise divison
+        assert not isinstance(other, self.ctx.matrix)
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[i,j] = self[i,j] / other
+        return new
+
+    __truediv__ = __div__
+
+    def __add__(self, other):
+        if isinstance(other, self.ctx.matrix):
+            if not (self.__rows == other.__rows and self.__cols == other.__cols):
+                raise ValueError('incompatible dimensions for addition')
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i,j] = self[i,j] + other[i,j]
+            return new
+        else:
+            # assume other is scalar and add element-wise
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i,j] += self[i,j] + other
+            return new
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        if isinstance(other, self.ctx.matrix) and not (self.__rows == other.__rows
+                                              and self.__cols == other.__cols):
+            raise ValueError('incompatible dimensions for subtraction')
+        return self.__add__(other * (-1))
+
+    def __pos__(self):
+        """
+        +M returns a copy of M, rounded to current working precision.
+        """
+        return (+1) * self
+
+    def __neg__(self):
+        return (-1) * self
+
+    def __rsub__(self, other):
+        return -self + other
+
+    def __eq__(self, other):
+        return self.__rows == other.__rows and self.__cols == other.__cols \
+               and self.__data == other.__data
+
+    def __len__(self):
+        if self.rows == 1:
+            return self.cols
+        elif self.cols == 1:
+            return self.rows
+        else:
+            return self.rows # do it like numpy
+
+    def __getrows(self):
+        return self.__rows
+
+    def __setrows(self, value):
+        for key in self.__data.copy():
+            if key[0] >= value:
+                del self.__data[key]
+        self.__rows = value
+
+    rows = property(__getrows, __setrows, doc='number of rows')
+
+    def __getcols(self):
+        return self.__cols
+
+    def __setcols(self, value):
+        for key in self.__data.copy():
+            if key[1] >= value:
+                del self.__data[key]
+        self.__cols = value
+
+    cols = property(__getcols, __setcols, doc='number of columns')
+
+    def transpose(self):
+        new = self.ctx.matrix(self.__cols, self.__rows)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[j,i] = self[i,j]
+        return new
+
+    T = property(transpose)
+
+    def conjugate(self):
+        return self.apply(self.ctx.conj)
+
+    def transpose_conj(self):
+        return self.conjugate().transpose()
+
+    H = property(transpose_conj)
+
+    def copy(self):
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        new.__data = self.__data.copy()
+        return new
+
+    __copy__ = copy
+
+    def column(self, n):
+        m = self.ctx.matrix(self.rows, 1)
+        for i in range(self.rows):
+            m[i] = self[i,n]
+        return m
+
+class MatrixMethods(object):
+
+    def __init__(ctx):
+        # XXX: subclass
+        ctx.matrix = type('matrix', (_matrix,), {})
+        ctx.matrix.ctx = ctx
+        ctx.matrix.convert = ctx.convert
+
+    def eye(ctx, n, **kwargs):
+        """
+        Create square identity matrix n x n.
+        """
+        A = ctx.matrix(n, **kwargs)
+        for i in xrange(n):
+            A[i,i] = 1
+        return A
+
+    def diag(ctx, diagonal, **kwargs):
+        """
+        Create square diagonal matrix using given list.
+
+        Example:
+        >>> from mpmath import diag, mp
+        >>> mp.pretty = False
+        >>> diag([1, 2, 3])
+        matrix(
+        [['1.0', '0.0', '0.0'],
+         ['0.0', '2.0', '0.0'],
+         ['0.0', '0.0', '3.0']])
+        """
+        A = ctx.matrix(len(diagonal), **kwargs)
+        for i in xrange(len(diagonal)):
+            A[i,i] = diagonal[i]
+        return A
+
+    def zeros(ctx, *args, **kwargs):
+        """
+        Create matrix m x n filled with zeros.
+        One given dimension will create square matrix n x n.
+
+        Example:
+        >>> from mpmath import zeros, mp
+        >>> mp.pretty = False
+        >>> zeros(2)
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        """
+        if len(args) == 1:
+            m = n = args[0]
+        elif len(args) == 2:
+            m = args[0]
+            n = args[1]
+        else:
+            raise TypeError('zeros expected at most 2 arguments, got %i' % len(args))
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = 0
+        return A
+
+    def ones(ctx, *args, **kwargs):
+        """
+        Create matrix m x n filled with ones.
+        One given dimension will create square matrix n x n.
+
+        Example:
+        >>> from mpmath import ones, mp
+        >>> mp.pretty = False
+        >>> ones(2)
+        matrix(
+        [['1.0', '1.0'],
+         ['1.0', '1.0']])
+        """
+        if len(args) == 1:
+            m = n = args[0]
+        elif len(args) == 2:
+            m = args[0]
+            n = args[1]
+        else:
+            raise TypeError('ones expected at most 2 arguments, got %i' % len(args))
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = 1
+        return A
+
+    def hilbert(ctx, m, n=None):
+        """
+        Create (pseudo) hilbert matrix m x n.
+        One given dimension will create hilbert matrix n x n.
+
+        The matrix is very ill-conditioned and symmetric, positive definite if
+        square.
+        """
+        if n is None:
+            n = m
+        A = ctx.matrix(m, n)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = ctx.one / (i + j + 1)
+        return A
+
+    def randmatrix(ctx, m, n=None, min=0, max=1, **kwargs):
+        """
+        Create a random m x n matrix.
+
+        All values are >= min and <max.
+        n defaults to m.
+
+        Example:
+        >>> from mpmath import randmatrix
+        >>> randmatrix(2) # doctest:+SKIP
+        matrix(
+        [['0.53491598236191806', '0.57195669543302752'],
+         ['0.85589992269513615', '0.82444367501382143']])
+        """
+        if not n:
+            n = m
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = ctx.rand() * (max - min) + min
+        return A
+
+    def swap_row(ctx, A, i, j):
+        """
+        Swap row i with row j.
+        """
+        if i == j:
+            return
+        if isinstance(A, ctx.matrix):
+            for k in xrange(A.cols):
+                A[i,k], A[j,k] = A[j,k], A[i,k]
+        elif isinstance(A, list):
+            A[i], A[j] = A[j], A[i]
+        else:
+            raise TypeError('could not interpret type')
+
+    def extend(ctx, A, b):
+        """
+        Extend matrix A with column b and return result.
+        """
+        if not isinstance(A, ctx.matrix):
+            raise TypeError("A should be a type of ctx.matrix")
+        if A.rows != len(b):
+            raise ValueError("Value should be equal to len(b)")
+        A = A.copy()
+        A.cols += 1
+        for i in xrange(A.rows):
+            A[i, A.cols-1] = b[i]
+        return A
+
+    def norm(ctx, x, p=2):
+        r"""
+        Gives the entrywise `p`-norm of an iterable *x*, i.e. the vector norm
+        `\left(\sum_k |x_k|^p\right)^{1/p}`, for any given `1 \le p \le \infty`.
+
+        Special cases:
+
+        If *x* is not iterable, this just returns ``absmax(x)``.
+
+        ``p=1`` gives the sum of absolute values.
+
+        ``p=2`` is the standard Euclidean vector norm.
+
+        ``p=inf`` gives the magnitude of the largest element.
+
+        For *x* a matrix, ``p=2`` is the Frobenius norm.
+        For operator matrix norms, use :func:`~mpmath.mnorm` instead.
+
+        You can use the string 'inf' as well as float('inf') or mpf('inf')
+        to specify the infinity norm.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> x = matrix([-10, 2, 100])
+            >>> norm(x, 1)
+            mpf('112.0')
+            >>> norm(x, 2)
+            mpf('100.5186549850325')
+            >>> norm(x, inf)
+            mpf('100.0')
+
+        """
+        try:
+            iter(x)
+        except TypeError:
+            return ctx.absmax(x)
+        if type(p) is not int:
+            p = ctx.convert(p)
+        if p == ctx.inf:
+            return max(ctx.absmax(i) for i in x)
+        elif p == 1:
+            return ctx.fsum(x, absolute=1)
+        elif p == 2:
+            return ctx.sqrt(ctx.fsum(x, absolute=1, squared=1))
+        elif p > 1:
+            return ctx.nthroot(ctx.fsum(abs(i)**p for i in x), p)
+        else:
+            raise ValueError('p has to be >= 1')
+
+    def mnorm(ctx, A, p=1):
+        r"""
+        Gives the matrix (operator) `p`-norm of A. Currently ``p=1`` and ``p=inf``
+        are supported:
+
+        ``p=1`` gives the 1-norm (maximal column sum)
+
+        ``p=inf`` gives the `\infty`-norm (maximal row sum).
+        You can use the string 'inf' as well as float('inf') or mpf('inf')
+
+        ``p=2`` (not implemented) for a square matrix is the usual spectral
+        matrix norm, i.e. the largest singular value.
+
+        ``p='f'`` (or 'F', 'fro', 'Frobenius, 'frobenius') gives the
+        Frobenius norm, which is the elementwise 2-norm. The Frobenius norm is an
+        approximation of the spectral norm and satisfies
+
+        .. math ::
+
+            \frac{1}{\sqrt{\mathrm{rank}(A)}} \|A\|_F \le \|A\|_2 \le \|A\|_F
+
+        The Frobenius norm lacks some mathematical properties that might
+        be expected of a norm.
+
+        For general elementwise `p`-norms, use :func:`~mpmath.norm` instead.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> A = matrix([[1, -1000], [100, 50]])
+            >>> mnorm(A, 1)
+            mpf('1050.0')
+            >>> mnorm(A, inf)
+            mpf('1001.0')
+            >>> mnorm(A, 'F')
+            mpf('1006.2310867787777')
+
+        """
+        A = ctx.matrix(A)
+        if type(p) is not int:
+            if type(p) is str and 'frobenius'.startswith(p.lower()):
+                return ctx.norm(A, 2)
+            p = ctx.convert(p)
+        m, n = A.rows, A.cols
+        if p == 1:
+            return max(ctx.fsum((A[i,j] for i in xrange(m)), absolute=1) for j in xrange(n))
+        elif p == ctx.inf:
+            return max(ctx.fsum((A[i,j] for j in xrange(n)), absolute=1) for i in xrange(m))
+        else:
+            raise NotImplementedError("matrix p-norm for arbitrary p")
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
diff --git a/lib/python3.11/site-packages/mpmath/rational.py b/lib/python3.11/site-packages/mpmath/rational.py
new file mode 100644
index 0000000000000000000000000000000000000000..58745205319ac3548ad5feb49371d2d154b2d3c8
--- /dev/null
+++ b/lib/python3.11/site-packages/mpmath/rational.py
@@ -0,0 +1,240 @@
+import operator
+import sys
+from .libmp import int_types, mpf_hash, bitcount, from_man_exp, HASH_MODULUS
+
+new = object.__new__
+
+def create_reduced(p, q, _cache={}):
+    key = p, q
+    if key in _cache:
+        return _cache[key]
+    x, y = p, q
+    while y:
+        x, y = y, x % y
+    if x != 1:
+        p //= x
+        q //= x
+    v = new(mpq)
+    v._mpq_ = p, q
+    # Speedup integers, half-integers and other small fractions
+    if q <= 4 and abs(key[0]) < 100:
+        _cache[key] = v
+    return v
+
+class mpq(object):
+    """
+    Exact rational type, currently only intended for internal use.
+    """
+
+    __slots__ = ["_mpq_"]
+
+    def __new__(cls, p, q=1):
+        if type(p) is tuple:
+            p, q = p
+        elif hasattr(p, '_mpq_'):
+            p, q = p._mpq_
+        return create_reduced(p, q)
+
+    def __repr__(s):
+        return "mpq(%s,%s)" % s._mpq_
+
+    def __str__(s):
+        return "(%s/%s)" % s._mpq_
+
+    def __int__(s):
+        a, b = s._mpq_
+        return a // b
+
+    def __nonzero__(s):
+        return bool(s._mpq_[0])
+
+    __bool__ = __nonzero__
+
+    def __hash__(s):
+        a, b = s._mpq_
+        if sys.version_info >= (3, 2):
+            inverse = pow(b, HASH_MODULUS-2, HASH_MODULUS)
+            if not inverse:
+                h = sys.hash_info.inf
+            else:
+                h = (abs(a) * inverse) % HASH_MODULUS
+            if a < 0: h = -h
+            if h == -1: h = -2
+            return h
+        else:
+            if b == 1:
+                return hash(a)
+            # Power of two: mpf compatible hash
+            if not (b & (b-1)):
+                return mpf_hash(from_man_exp(a, 1-bitcount(b)))
+            return hash((a,b))
+
+    def __eq__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            return s._mpq_ == t._mpq_
+        if ttype in int_types:
+            a, b = s._mpq_
+            if b != 1:
+                return False
+            return a == t
+        return NotImplemented
+
+    def __ne__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            return s._mpq_ != t._mpq_
+        if ttype in int_types:
+            a, b = s._mpq_
+            if b != 1:
+                return True
+            return a != t
+        return NotImplemented
+
+    def _cmp(s, t, op):
+        ttype = type(t)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return op(a, t*b)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return op(a*d, b*c)
+        return NotImplementedError
+
+    def __lt__(s, t): return s._cmp(t, operator.lt)
+    def __le__(s, t): return s._cmp(t, operator.le)
+    def __gt__(s, t): return s._cmp(t, operator.gt)
+    def __ge__(s, t): return s._cmp(t, operator.ge)
+
+    def __abs__(s):
+        a, b = s._mpq_
+        if a >= 0:
+            return s
+        v = new(mpq)
+        v._mpq_ = -a, b
+        return v
+
+    def __neg__(s):
+        a, b = s._mpq_
+        v = new(mpq)
+        v._mpq_ = -a, b
+        return v
+
+    def __pos__(s):
+        return s
+
+    def __add__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d+b*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = a+b*t, b
+            return v
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d-b*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = a-b*t, b
+            return v
+        return NotImplemented
+
+    def __rsub__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(b*c-a*d, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = b*t-a, b
+            return v
+        return NotImplemented
+
+    def __mul__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(a*t, b)
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __div__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d, b*c)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(a, b*t)
+        return NotImplemented
+
+    def __rdiv__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(b*c, a*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(b*t, a)
+        return NotImplemented
+
+    def __pow__(s, t):
+        ttype = type(t)
+        if ttype in int_types:
+            a, b = s._mpq_
+            if t:
+                if t < 0:
+                    a, b, t = b, a, -t
+                v = new(mpq)
+                v._mpq_ = a**t, b**t
+                return v
+            raise ZeroDivisionError
+        return NotImplemented
+
+
+mpq_1 = mpq((1,1))
+mpq_0 = mpq((0,1))
+mpq_1_2 = mpq((1,2))
+mpq_3_2 = mpq((3,2))
+mpq_1_4 = mpq((1,4))
+mpq_1_16 = mpq((1,16))
+mpq_3_16 = mpq((3,16))
+mpq_5_2 = mpq((5,2))
+mpq_3_4 = mpq((3,4))
+mpq_7_4 = mpq((7,4))
+mpq_5_4 = mpq((5,4))
+
+
+# Register with "numbers" ABC
+#     We do not subclass, hence we do not use the @abstractmethod checks. While
+#     this is less invasive it may turn out that we do not actually support
+#     parts of the expected interfaces.  See
+#     http://docs.python.org/2/library/numbers.html for list of abstract
+#     methods.
+try:
+    import numbers
+    numbers.Rational.register(mpq)
+except ImportError:
+    pass
diff --git a/lib/python3.11/site-packages/mpmath/tests/__init__.py b/lib/python3.11/site-packages/mpmath/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.11/site-packages/mpmath/tests/__pycache__/__init__.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/tests/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d46abaa86841db4995b36a0c14246de457d3a0c0
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/tests/__pycache__/__init__.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/tests/__pycache__/extratest_gamma.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/tests/__pycache__/extratest_gamma.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..93da5dfb9633407a489872ad3d05ecaeeb685a5e
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/tests/__pycache__/extratest_gamma.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/tests/__pycache__/extratest_zeta.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/tests/__pycache__/extratest_zeta.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..18de43a4b98901aade940f4d51a914c925789dc4
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/tests/__pycache__/extratest_zeta.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/tests/__pycache__/runtests.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/tests/__pycache__/runtests.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da6fea9ceb74dc0b19d20c96a95eaedefe601f33
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/tests/__pycache__/runtests.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_basic_ops.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_basic_ops.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4c65adc5f8230be24167fd8a04679accabdcb9f
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_basic_ops.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_bitwise.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_bitwise.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..175f765b0185070c6e6b4aa4b4fb391318865832
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_bitwise.cpython-311.pyc differ
diff --git a/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_calculus.cpython-311.pyc b/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_calculus.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..166a0fcd412778ea057e3b0a6661ade8b40b3c71
Binary files /dev/null and b/lib/python3.11/site-packages/mpmath/tests/__pycache__/test_calculus.cpython-311.pyc differ